Unit 06 Flashcards
abort
Deliberately stop something that has started.
Aborted (transaction state)
The state a transaction is in after it has been rolled back to undo any partially completed actions of the transaction.
ACID properties
The desirable properties of a transaction: Atomicity,
Consistency,
Isolation and
Durability.
acquire phase
The phase in two-phase locking in which the locks are gradually acquired, and in which no locks can be released.
See also release phase
Active (transaction state)
The state a transaction is in as soon as it has started, and in which it remains while executing.
after image
In logging, the name given to the value of a variable after an update is made.
asymmetric replication
A style of ownership of data in schemes for replication of data where data is owned by the master site, and only the master site is allowed to make updates to the data.
See also master–slave ownership.
asynchronous replication
A strategy for replication of data, in which a replicated part is updated some time after the source database is updated.
before image
In logging, the name given to the value of a variable before an update is made.
cache manager (in a transaction processing system)
The part of the transaction processing system that organises the objects in main memory and interfaces with the persistent storage.
cascade of aborts
The situation where a transaction has had to be aborted, and this in turn leads to many other transactions having to abort.
commit protocol
A protocol to commit transactions.
See two-phase commit (2PC) protocol.
Committed (transaction state)
The state a transaction is in after the transaction has completed successfully and all the updates to the data have been made permanent (persistent).
conflicting operations
Two operations A and B are said to be conflicting if, starting from some initial state, the result of executing A then B is not the same as the result of executing B then A. Also known as non-commutative operations.
coordinator
In the two-phase commit protocol for distributed transactions, the process that oversees the activities of other participating processes, each of which is dealing with only part of a transaction.
crash resilience
The extent to which an application is supported in recovering from system crashes.
data replication
Holding multiple copies of data items in different locations.
database
In computing, a structured collection of records or data that is stored in a computer so that a program can consult it to answer queries.
database driver
The implementation details of a particular database are handled by the database driver for that database.
database management system (DBMS)
The computer program used to manage and query a database.
database metadata
Literally, data about data. For example, data about the vendor of the database system and data about the way the database records are stored.
directed acyclic graph (DAG)
In graph theory, a graph with nodes and edges, where each edge has a definite direction (going from one node to another). The graph has no cycles, meaning that there is no path from a node that leads back to itself.
dirty read
A dirty read occurs if a transaction reads values that are written by another transaction that has not committed yet.
exclusive lock
A lock that needs to be acquired by a writer process. Only one process can hold a write lock at the same time.
Also referred to as a write lock.
externally visible effect
Any communication that an operation may have with another process, user or storage device.
Failed (transaction state)
The state a transaction is in when the discovery is made that normal execution cannot proceed.
failure atomicity
A form of atomicity, also known as all-or-nothing atomicity, which is one of the properties of a transaction. It refers to the fact that if there is some kind of failure which causes a part of the transaction not to be completed, then the entire transaction should be rolled back.
failure transparency
Another term for crash resilience, referring to a system’s ability to create the illusion that a failure never happened.
fragmentation
Slicing a database into different fragments, such that each part is stored in different physical areas of storage.
global transaction
A transaction that accesses and updates data in several databases
(contrast with local transaction).
granularity of a lock
A design consideration for algorithms based on locks, regarding the size of the object that needs to be locked.
intermediate state
The state that a system is in while it is in the middle of executing an operation. In transaction processing it is desirable that other concurrent transactions avoid seeing the intermediate state of a given transaction.
Java Transaction API (JTA)
A standard Java interface for demarcating transactions.
JDBC
An API for the Java programming language that defines how a client may access a database.
local transaction
A transaction that accesses and updates data in a single local database
(contrast with global transaction).
log
The place in which logging information is recorded. The log is stored in stable storage.
logging
The process of recording the new value and the old value and the name of a transaction so that the persistent store can be rolled back to the previous state.
A log will also contain information indicating the start of a new transaction, the number of update records and the fact that the transaction has committed.
Log information must be written before the data in permanent store is changed.
lost update problem
The situation where, during the execution of a transaction, intermediate results (i.e. results of sub-operations) become accessible to other operations, with the potential danger that a previous update becomes lost.
master–slave ownership
A style of ownership of data in schemes for replication of data where data is owned by the master site, and only the master site is allowed to make updates to the data.
Also referred to as asymmetric replication.
non-repeatable read
A non-repeatable read occurs if a transaction reads the same object twice during execution and finds a different value the second time, although the transaction has not changed the value in the meantime.
Open Database Connectivity (ODBC)
An interface to SQL-based databases, which aids the communication with a database and the access to the database metadata. The aim of ODBC is to enable access to a great number of databases, independent of the programming language of the application that seeks access to a database, and independent of the database systems and operating systems.
optimistic algorithm
In concurrency control for transactions, an algorithm that assumes that conflicts will occur rarely, and that takes measures after the event.
Example: optimistic concurrency control.
optimistic concurrency control
A concurrency control algorithm (optimistic) that works with the assumption that there is not much concurrency contention between transactions. It allows transactions to proceed without locking or time-stamping, and only just before it commits does it perform a validation check.
It has three phases: working phase, validation phase and update phase.
Partially Committed (transaction state)
The state a transaction is in after the final part of the transaction has taken place, but before the transaction has committed.
persistent storage
A form of storage of data which outlives the execution of the program that created it, e.g. a database or a file.
pessimistic algorithm
In concurrency control for transactions, an algorithm that assumes that there are likely to be many conflicts and that takes measures to avoid them.
Examples: two-phase (2PL) locking and time-stamp ordering (TSO).
phantom read
A phantom read occurs when a transaction re-executes a query, returning a set of data that satisfies the condition in the query, and finds that the set of data has changed as a result of another recently committed transaction.
precedence graph
A way of representing the order constraints among a collection of transactions (or other statements). The nodes of the graph represent the transactions, and there is a directed edge from node A to node B if transaction A must be executed before transaction B.
prepare phase
In the two-phase commit protocol for distributed transactions, the phase in which each process involved with dealing with part of the transaction has to send a message to the coordinator to indicate whether it intends to commit.
See also resolution phase.
query language
The language that is used with a relational database in order to query the database and retrieve information.
read lock
A lock that needs to be taken out if a process needs to read from a data resource. Several processes can hold a read lock.
Also referred to as a shareable lock.
record
In a relational database, a record is a set of values for one entry into a database.
recovery manager (in a transaction processing system)
The part of a transaction processing system that deals with the recovery from crashes.
redundant array of independent disks (RAID)
A redundant array of independent drives (or disks), also known as a redundant array of inexpensive drives (or disks). RAID is an umbrella term for data storage schemes that divide and/or replicate data among multiple hard drives. They offer, depending on the scheme, increased data reliability and/or I/O performance.
relation
In a relational database, a relation is also known as a table. The table has a fixed number of uniquely named columns, and each row represents a record for an entry into the database.
relational database
A database model, where the data is conceptually modelled as a relation. It uses a collection of tables to represent both the data and the relationships between the data.
release phase
The phase in two-phase locking in which the locks are released, and in which no more locks are acquired.
See also acquire phase
resolution phase
In the two-phase commit protocol for distributed transactions, the phase in which the coordinator decides on whether or not the transaction as a whole can commit or not, based on the responses received from the processes involved in carrying out parts of the transaction.
See also prepare phase.
rolling back
Restoring the state of the persistent store to the one that existed before the start of an atomic operation that was aborted due to a system crash.
schedule (for transactions)
A sequence of operations that specifies the chronological order in which the operations of concurrent transactions are executed.
scheduler (in a transaction processing system)
The part of the transaction processing system that puts together serialisable schedules for the operations of transactions.
serial schedule
A schedule for the operations of concurrent transactions, in which the operations of one transaction all occur before the operations of the next transaction, such that the transactions execute in a strictly serial fashion. There is no interleaving.
serialisability
A schedule for a group of concurrent transactions is serialisable if, and only if, it produces the same result as if the transactions had executed in some serial order. Serialisability is also referred to as serial equivalence.
shadowing
Where the results of a transaction are built up in a structure that mirrors the persistent store but the persistent store is not updated until the transaction commits. Once the transaction has committed, the shadow structure replaces the persistent store.
shareable lock
A lock that needs to be taken out if a process needs to read from a data resource. Several processes can hold a read lock.
Also referred to as a read lock.
stable storage
An abstraction which means that the results of an atomic operation are written to two independent places in a persistent store.
strict two-phase locking (strict 2PL)
A form of two-phase locking in which all locks are released on commit.
Structured Query Language (SQL)
The most widely used and standardised query language for relational databases.
synchronous replication
A strategy for replication of data, where all copies are updated at the same time.
time-stamp ordering (TSO)
An algorithm for concurrency control for transactions based on time-stamps. A time (such as the time at which the transaction started) is associated with each transaction and is recorded by every object involved with each operation invoked by the transaction. This time-stamp is used to serially order transactions.
topological sorting
In graph theory, a topological sort of a directed acyclic graph is a linear ordering of its nodes such that each node comes before all nodes to which it has edges. Every directed acyclic graph has one or more topological sorts.
transaction
A sequence of atomic actions, with the property that either the entire sequence is performed, or no part of the sequence is performed at all.
transaction isolation level
The levels that allow fine-tuning of transactions, based on different reads: dirty reads, non-repeatable reads and phantom reads.
transaction manager (in a transaction processing system)
The part of a transaction processing system that provides an interface between the clients and the system, and which passes on requests for transaction processing to the scheduler.
transaction processing (TP) system
A layer of middleware to manage the correct and efficient execution of transactions. Also known as a transaction processing (TP) monitor.
two-phase commit (2PC) protocol
A protocol for distributed transactions, where one process acts as the coordinator for several parts of a transaction. All parts of the transaction must agree to commit in order for the transaction to commit as a whole.
There are two phases: the prepare phase and a resolution phase.
two-phase locking (2PL)
An algorithm for concurrency control for transactions based on locking. Locks are acquired for a transaction as they are needed (acquire phase), and no lock can be released until all locks have been acquired. When locks are released, no more locks can be acquired (release phase).
update anywhere ownership
A style of ownership for data in schemes for replication of data, where anyone is allowed to update. Often used in the peer-to-peer environment of open source projects.
update phase (in optimistic concurrency control)
The phase in which a transaction has been validated, and can now commit.
validation phase (in optimistic concurrency control)
The phase in which a transaction gets validated. If validation succeeds, the transaction can commit.
workflow ownership
A style of ownership of data in schemes for replication of data, where the right to make updates to replicated parts moves from site to site.
working phase (in optimistic concurrency control)
The phase in which a transaction works with a tentative version of the objects.
write lock
A lock that needs to be acquired by a writer process. Only one process can hold a write lock at the same time.
Also referred to as an exclusive lock.
write-ahead log
In logging, a log must be written ahead of the actual update made to the data, in case a crash occurs just after an update is made, and before this update could be recorded in the log.
