A database table is a structured collection of related data organised into rows and columns within a database, particularly in a relational database management system. A table normally represents a type of entity, relationship or logical subject, such as customers, products, orders, employees or invoices. Columns define attributes of the information being stored, while rows represent individual records or instances.
For example, a Customers table might contain columns such as customer_id, name, email and registration_date, with each row representing one customer. The table abstraction provides a structured way to store, retrieve, modify and relate data. Tables are central to the relational model introduced by Edgar F. Codd in the early 1970s, although practical database systems implement the relational concepts with additional features and constraints.
A table's columns describe the structure or attributes that can occur in its rows. A column normally has a name and data type, such as integer, decimal, character string, date, timestamp or Boolean, although exact types vary between database systems. Constraints can further restrict permissible values. A NOT NULL constraint can require a value to be present, a UNIQUE constraint can require values to be distinct, and a CHECK constraint can enforce a condition.
A primary key identifies rows, while foreign keys can establish relationships between tables. These definitions collectively provide part of the database's schema. A table can therefore be viewed not simply as a spreadsheet-like grid but as a formally defined database object whose columns, constraints, indexes, permissions and relationships determine how its data is represented and manipulated.
Rows in a table represent individual records, although relational theory more precisely describes them as tuples. A row contains one value, or a null where permitted, for each applicable column. For example, a Products table might contain one row representing a particular product, with values for its identifier, name, price and stock quantity. Rows are not inherently ordered in the relational model.
If an application requests rows without specifying an ORDER BY clause in SQL, the database is generally free to return them in an implementation-dependent order. This differs from a spreadsheet, where users may perceive the physical sequence of rows as meaningful. Database applications should therefore explicitly specify ordering when the order of results matters.
Tables can be related to one another through keys. A Customers table might have customer_id as its primary key, while an Orders table can contain customer_id as a foreign key referring to the customer. This permits the database to represent one-to-many relationships without duplicating the customer's complete information in every order row. Junction tables can represent many-to-many relationships, such as students enrolled in courses. Referential integrity constraints can ensure that a foreign-key value corresponds to an appropriate referenced row. This relational structure allows complex information to be represented as multiple related tables rather than as one enormous denormalised collection containing repeated information.
Tables can be physically implemented in many different ways even though their logical representation appears as rows and columns. A database engine may store table data in heap structures, clustered indexes, columnar structures, partitions or other internal formats. Some systems can partition a large table by date, range, list or hash so that operations can work with relevant portions of the data. Indexes can provide separate structures for locating rows efficiently. The logical table seen by SQL users therefore does not necessarily correspond to one contiguous physical file. Database engines are free to optimise storage and access while preserving the logical behaviour expected by applications.
A table can be manipulated using database operations such as INSERT, SELECT, UPDATE and DELETE. INSERT adds rows, SELECT retrieves data, UPDATE modifies existing rows and DELETE removes rows. SQL allows these operations to be combined with filtering, joins, aggregation, grouping and ordering. Transactions can group multiple modifications into an atomic unit so that related changes succeed or fail together. For example, transferring money between accounts may require updating two rows or sets of rows consistently. The table structure, constraints and transaction mechanisms work together to protect data integrity while allowing applications to perform concurrent operations.
Tables differ from views, which are generally logical query definitions that present data derived from one or more underlying tables. A view can appear table-like to users and applications but may not independently store all of the data it presents. Temporary tables are another variation, existing only for a limited session or transaction depending on the database system. Materialised views can store the result of a query physically and refresh it periodically or according to database-specific mechanisms. These distinctions matter because the word table can sometimes be used informally for anything that appears as tabular data, whereas a database table is a specific database object with defined semantics and storage behaviour.
Database tables provide a durable and structured foundation for relational information management, but they are not always the appropriate representation for every workload. Relational tables are well suited to structured data with relationships, constraints and transactional requirements. Other database models use documents, key-value pairs, graphs, wide-column structures or other representations. Within relational systems, good table design considers data types, keys, constraints, normalisation, indexing and expected query patterns. A table is therefore more than a rectangular data display: it is a logical structure that defines how a particular category of information is represented and how that information can participate in relationships, integrity rules and database operations.
