Access-control group 2026-11-05
An access-control group collects security principals so that a permission can be assigned to the collection rather than copied separately for every member. A file might grant read access to a laboratory group while withholding write access. Changing membership then changes who obtains the group's applicable permissions.
In Unix-style systems, process credentials include group identifiers, including supplementary groups, and file permission checks use the relevant identity information.[ref] The membership considered for an already running process need not change immediately when an account database is edited. Group names, account membership and the credentials used for a particular access check are therefore related but distinct pieces of state. Grouping users for permissions also does not imply that their processes are one scheduling job.
Database Created 2026-10-31 Updated 2026-11-05
A database is an organized collection of data maintained for queries and updates. A database management system manages that collection, enforcing access rules and database integrity constraints. A relational database represents it through database relations, rather than exposing only an arbitrary collection of bytes in files.
For example, a laboratory can store biological sample identifiers, measurement values and scientific instrument identifiers as database tuples. A database query can select measurements above a threshold and join them to scientific instrument records. A foreign key can require every recorded scientific instrument identifier to name an existing scientific instrument. This makes the connection a maintained rule rather than a convention that every application must remember.
The logical relational schema and actual storage are distinct. A database query plan may use an index or scan database pages while returning the same specified result. Database transactions coordinate related updates, and database integrity constraints restrict the permitted states. PostgreSQL's documentation gives a concrete implementation in which named tables contain rows with named, typed columns and databases group tables.[ref]
A database management system is software that defines, stores, queries and updates databases while managing access, integrity and concurrent use. Its components can include a query parser, optimizer, storage manager, transaction manager and recovery mechanism. A database is the managed collection; the database management system supplies the mechanisms and interfaces used to operate on it.
For example, evaluating SELECT name FROM Person WHERE id = 7 requires interpreting the query, choosing an access path, retrieving visible records and returning the selected field. An index can speed the lookup without changing its logical result. Concurrent updates may require locks or versions, and a crash may require log replay. Merely writing records to a file does not supply those guarantees. PostgreSQL's tutorial illustrates the distinction between client applications, the server process managing database files and connections, and the databases accessed through that server.[ref]
Database query language Created 2026-10-31 Updated 2026-11-05
A database query language expresses requests over a database using a defined syntax and semantics. A declarative language describes the desired result while allowing a query optimizer to choose its evaluation. SQL is a prominent example for relational databases; relational algebra supplies operations useful for representing and transforming query plans. Expressive power, treatment of duplicates and null values, and the ability to update data vary by language. A query that is syntactically accepted is not automatically safe or efficient on arbitrary datasets.
Database transaction Created 2026-10-31 Updated 2026-11-05
A database transaction groups database operations into a unit that can be committed or rolled back. Transaction atomicity means that its updates take effect together or not at all. Transaction durability concerns retaining an acknowledged committed result after a failure; transaction isolation controls which effects concurrent database transactions may observe.[ref]
For example, transferring seven units from an account with balance twenty to one with balance five should produce balances thirteen and twelve. A failure after only the debit must not leave thirteen and five as a completed transfer. In SQL, a transaction block uses BEGIN, then the related updates, then COMMIT; ROLLBACK abandons the uncommitted changes.[ref]
Isolation is a separate question from grouping statements. Two concurrent transfers can each read an old balance before either writes. A correct application must select suitable transaction isolation or locking and handle possible conflicts; merely putting the statements in a database transaction does not establish every desired invariant. The corresponding database schedule records their interleaving.
Data independence 2026-11-05
Data independence separates the logical meaning of stored data from details that an application need not know. Physical independence permits changing indexes, page layout or access paths without changing a query's meaning. Logical independence permits some changes in the database's logical organization while preserving the interface exposed to existing applications, often through views.
For example, a query asking for an employee's department should return the same answer after the database replaces a table scan with a B-tree index. An application that follows stored record addresses directly would instead depend on that representation. E. F. Codd's1970 relational model explicitly argued against dependencies on ordering, indexes and access paths.[ref] Independence does not mean every schema change is invisible: removing a field an application needs changes its contract unless another representation supplies equivalent information.
Entity-relationship model Created 2026-10-31 Updated 2026-11-05
An entity-relationship model describes identifiable entities, their database attributes and the relationships between them before committing to a physical database layout. Entity types classify the objects being recorded; relationship types describe associations, possibly with their own database attributes. Peter Pin-Shan Chen developed the model as a way to retain the meaning of data while relating several existing database models.[ref]
For example, a laboratory records scientific instrument entities and measurement entities, with a relationship saying which scientific instrument produced each measurement. An scientific instrument's serial number is an identifying database attribute. A calibration date can describe an scientific instrument, while a usage duration can describe a particular relationship occurrence. Distinguishing these placements prevents unrelated facts from being conflated.
Cardinality and participation constraints add rules: every measurement might require exactly one scientific instrument, while an scientific instrument can produce zero or many measurements. An entity-relationship diagram records these choices. Translating the design to a relational schema introduces database relations, identifiers and appropriate foreign keys; the diagram itself does not require a particular index or file structure.
Lexical database 2026-11-05
A lexical database organizes information about the lexemes of a language. It can record forms, part of speech, definitions, word senses, examples and relationships among entries. A database representation makes these items separately identifiable and queryable rather than treating an entire entry as one unstructured string.[ref]
For a toy design, an entry for bank can link to distinct word sense records for a financial institution and a river margin, each with an example sentence. A form record for banks can refer to the relevant entry without requiring duplicated definitions. Spelling is consequently an inadequate unique identifier: different lexical analyses can involve the same written form.
A lexical database can also connect entries to attested uses in a text corpus, as in FieldWorks Language Explorer. The stored relations support searches and revision, but the linguistic annotation still represents an analysis whose evidence must be retained.
Multi-tenancy 2026-11-05
Multi-tenancy lets distinct consumers share a software service or computing infrastructure while retaining separate data and permitted operations. A tenant is the consumer or administrative grouping treated as one isolated customer. Resource pooling commonly assigns shared physical resources dynamically among tenants.[ref]
For example, two laboratories can use one hosted database application. Each laboratory's users must access only their permitted records, even when both laboratories' records occupy the same database relation. Checks on each database query and limits on resource use serve different purposes: data isolation does not prevent one tenant's expensive work from delaying another. Separate virtual machines are one possible implementation boundary, rather than a requirement of multi-tenancy.
Assume the two database queries have compatible output database attributes. Then
For a finite input database, the result of the relational difference is a subset of the finite result of , so it is finite and introduces no new values. For the usual domain independence of a database query, let be the input database and let be two ambient value domains containing its data and the query constants. Database query safety gives
and therefore
Although a domain relational calculus expression for the relational difference uses negation, its positive membership requirement in supplies the necessary range restriction. Negation is not by itself a reason for failure of database query safety.
An individual can have any number of children, so use a rose tree, with one list of child trees at each root:
data DescendantTree = Desc Person [DescendantTree]
  deriving Show

descendants :: Database -> Person -> DescendantTree
descendants db p = Desc p (map (descendants db) (children db p))
The root records p, its immediate child trees record children db p, and recursion repeats the same construction at each generation. An individual with no recorded children produces Desc p []. For a finite database whose parent-child directed graph is acyclic, every recursive descent advances along a path that cannot revisit a vertex, so the construction terminates. On inconsistent cyclic records it can unfold indefinitely; finiteness of the database alone is insufficient for termination.
Two branches may contain the same descendant, as happens when relatives have a child. This is appropriate for the requested tree unfolding; it preserves both lines of descent rather than silently choosing one. The concise constructor equation is
A string data type suffices for a name, an algebraic data type for the recorded sex, and a triple of integers for a date. Use a constructor for Person so that selectors are unambiguous in Haskell:
type Name = String
data Sex = Female | Male deriving (Eq, Show)
data Date = Date { day :: Int, month :: Int, year :: Int }
  deriving (Eq, Show)
data Person = Person { name :: Name, sex :: Sex, born :: Date }
  deriving (Eq, Show)
type BirthCertificate = (Person, Person, Person)
type Database = [BirthCertificate]
Dates have the precondition that their fields form a valid calendar date. This simple database representation assumes the triple of identifying fields distinguishes the recorded individuals; a production database would normally add a stable identifier to distinguish namesakes. The two constructors for Sex model the two recorded values used by this exercise. In mathematical notation,
Rapid elasticity 2026-11-05
Rapid elasticity is the ability to provision and release computing capacity quickly in response to demand, often automatically. The consumer may experience capacity as readily available even though the provider operates finite physical resources.[ref]
For example, a service can add workers when its queue grows and remove them after the backlog clears. A control rule needs an observation signal, a scaling policy and time for new workers to become ready. Elastic capacity does not make every program parallel: a serial bottleneck, shared database or slow startup can prevent additional workers from increasing throughput. Releasing capacity also requires preserving needed state outside workers that may disappear.
Relational model Created 2026-10-31 Updated 2026-11-05
The relational model represents data as database relations, which are sets of database tuples over specified value domains. A relational schema names the database attributes and states database integrity constraints; an instance supplies their current values. Relational algebra describes operations on this logical data, while storage order, indexes and access paths belong to its implementation.
For example, the database relation Reading(sample, value) can contain . A relational selection for values above five followed by relational projection onto sample identifiers returns . Changing the underlying file layout or adding an index need not change that query's meaning. Mathematical database relations have set semantics; SQL often uses bag semantics and has additional SQL NULL behavior.
In his 1970 paper, E. F. Codd argued for data independence: application logic should not rely on particular stored orderings, indexes or navigational paths. His relational formulation made that separation central to database design.[ref]
Threat model 2026-11-05
A threat model states what is being protected, which adversarial actions are considered, which assumptions are trusted and which security properties must hold. A trust boundary marks where data or authority crosses between differently trusted parts. The model guides design and evaluation rather than treating every possible failure as equally relevant.[ref]
For example, encrypting a database backup protects its contents from someone who obtains only the stored backup. That mechanism does not by itself stop a logged-in administrator from replacing live records, or an endpoint from disclosing data after decryption. Adding those capabilities to the attacker changes the model and may require authorization checks, integrity protection and audit evidence. An explicit model makes the scope of a security claim inspectable.
Transaction atomicity 2026-11-05
Transaction atomicity gives a database transaction an all-or-nothing effect: either its committed updates take effect together or its partial updates do not remain as a completed result. This can be implemented with undo information, version visibility, recovery logging or combinations of these mechanisms. It does not require every physical write to happen at the same instant.
For example, transferring five units between accounts requires a debit and a credit. If an error occurs after the debit, aborting the transaction must not leave only that debit as the final database result. SQL transaction blocks use BEGIN, COMMIT and ROLLBACK to express the boundary.[ref] Atomicity alone does not say how transactions interact before completion; transaction isolation governs that. Nor does it make a committed result survive a crash; that is transaction durability. External effects such as a sent email require coordination beyond rolling back the database changes.
Transaction durability 2026-11-05
Transaction durability means that an acknowledged committed transaction survives failures covered by the database's durability model. A successful statement that has not committed is not yet such a promise. The failure model and storage configuration matter: surviving a process crash does not automatically mean surviving destruction of every storage replica.
Write-ahead logging provides one mechanism. Before reporting a durable commit, persist the required log records. Modified data pages can be written later because recovery can replay their committed changes from the log. The log-before-data rule also prevents a page from reaching persistent storage without the recovery information needed to interpret it.[ref] Durability therefore concerns persistence of the committed result, whereas transaction atomicity concerns which parts of a transaction may take effect. Faster asynchronous commit settings can deliberately weaken the interval covered by the acknowledgment.
Trust boundary 2026-11-05
A trust boundary separates components or actors to which a threat model assigns different trust or authority. Data crossing it must be checked under the receiving side's rules. A boundary can exist between a browser and server, between two operating-system processes, or inside one application.[ref]
For example, a browser sends a requested record identifier to a database-backed service. The service must check both its format and the requester's authorization to access that record. Hiding the identifier in a GUI widget does not establish either property: an attacker can send a different request. Identifying the trust boundary makes the required checks visible before choosing a security mechanism.
Tuple relational calculus 2026-11-05
Tuple relational calculus describes query answers by predicates over database tuples rather than a sequence of storage operations. A set-builder expression returns tuples satisfying a formula built from relation membership, attribute comparisons, logical connectives and quantifiers. For example,
selects employee tuples whose salary exceeds100. A join can be expressed using existentially quantified tuples from two relations and equality of their shared identifying attribute.
The formula needs a safety restriction. Over an unrestricted infinite value universe, a query such as can demand infinitely many absent tuples. Safe tuple relational calculus restricts results to information grounded in the input and explicit constants. Under the usual finite-relation assumptions, its expressive power agrees with relational algebra. This gives a declarative query language while leaving the database system free to choose an efficient query plan.