Record
A record is a structured data unit or type that groups related values into fields or properties, typically to represent one item, entity, or observation.
Data-Oriented Programming: Reduce software complexity
A record is a data structure that groups related fields, potentially containing values of different data types.
- How it is used
- Represents data entities as flexible generic structures that code can query and manipulate through field keys.
- How deep it goes
- Defines fields, map representation, information paths, type handling, and flexibility-safety tradeoffs, while deferring state changes.
- Examples
- Demonstrates Book, Catalog, UserManagement, librarian, member, and nested book-item records through maps and Lodash operations.
- What you can do after
- Apply via generic functions by modeling entities as maps, navigating information paths, and querying fields without class-specific code.
Read how Data-Oriented Programming: Reduce software complexity explains record →
F# in Action: A Revised Edition of Get Programming with F#
A C# record is a reference or value type designed primarily for modeling data with compiler-supported value-based equality and concise initialization syntax.
- How it is used
- Models named domain data and public API shapes where tuples would obscure field meaning.
- How deep it goes
- Explains declaration, construction, inference, updates, equality, pattern matching, composition, and .NET representation; defers uncommon recursive-record use.
- Examples
- Demonstrates Person and Address values, customer and supplier composition, loan eligibility matching, and raw JSON validation records.
- What you can do after
- Build it from scratch as typed, immutable domain data, then update, compare, match, compose, and expose it to C#.
Read how F# in Action: A Revised Edition of Get Programming with F# explains record →
Clojure: The Essential Reference
A database row is one record in a relational table, containing a value for each applicable column.
- How it is used
- Uses records for small, map-like values that need a generated type and potentially protocol-based behavior.
- How deep it goes
- Explains construction, lookup, map semantics, interfaces, and an `empty` exception without detailing generated-class internals.
- Examples
- Demonstrates a point with keyword and field access, a sortable point implementing `Comparable`, and an address rejected by `empty`.
- What you can do after
- Build it from scratch with `defrecord`, access its fields, and recognize when a record differs from a map or struct.
Learn Haskell by Example
A record is a structured value whose fields are identified by names and for which field-access functions can be generated automatically.
- How it is used
- Models CSV tables as named header and column fields for parsing and table operations.
- How deep it goes
- Explains declaration, generated selectors, construction, updates, patterns, and extensions; later identifies partial selectors and safer replacements.
- Examples
- Uses Csv headers and columns, row and column counting, parsing options, and Tone or Silence events.
- What you can do after
- Apply it via Haskell record syntax to model structured values, select or update fields, and avoid unsafe partial selectors.
The Quick Python Book, Fourth Edition
A row is a horizontally aligned record of related values in a tabular data structure.
- How it is used
- Organizes delimited file data into rows whose fields can be selected, cleaned, and written as output.
- How deep it goes
- Defines rows as delimited records and works through field indexing and cleaning, without specifying a general record schema.
- Examples
- Uses Illinois weather rows to demonstrate county filtering, missing-value replacement, percentage conversion, and a field-selection bug.
- What you can do after
- Apply it via Python csv.reader and csv.writer to filter, clean, and write tabular records.
Read how The Quick Python Book, Fourth Edition explains record →
Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI
A record in tabular data that represents one observation or data point.
- How it is used
- Represents one autonomous observation or data point within a tabular dataset.
- How deep it goes
- Defines records through row autonomy, attributes, and data types, but does not detail storage or implementation internals.
- Examples
- Uses currency rows, DNA samples, industrial products, and property listings as concrete records.
- What you can do after
- Apply it by assembling feature values into a new data point for model prediction.
Read how Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI explains record →
Learn SQL in a Month of Lunches
A row is a horizontal record in a table containing values for a related set of attributes.
- How it is used
- Frames table data as complete records for reading, inserting, and updating information in an RDBMS.
- How deep it goes
- Defines row structure, values, identifiers, missing data, and modification boundaries without descending into implementation internals.
- Examples
- Uses spreadsheet book records, The Sum Also Rises, vegetable-table queries, and missing middle-name values.
- What you can do after
- Evaluate/understand how records hold column values and distinguish inserting new rows from updating existing values.
Build Python Web Apps with Streamlit
A database row is a single record in a table containing values for that table's columns.
- How it is used
- Represents one persistent entity or entry within a relational database table.
- How deep it goes
- Explains rows through columns, data types, keys, defaults, relationships, and CRUD queries without covering database engine internals.
- Examples
- Uses user and haiku rows, SELECT results, inserted records, identifier-based updates, and deletions.
- What you can do after
- Operate PostgreSQL records by inserting, selecting, updating, deleting, and identifying rows with SQL.
Read how Build Python Web Apps with Streamlit explains record →
The Well-Grounded Python Developer: How the pros use Python and Flask
A database record is a stored row representing one set of related field values in a database table.
- How it is used
- Organizes related values into stored table rows for persistent application data.
- How deep it goes
- Defines records, typed fields, primary keys, foreign keys, and persistence, then demonstrates creation through SQLAlchemy.
- Examples
- Uses online-store customers, addresses, products, orders, CSV rows, ERD diagrams, and SQLAlchemy-created model instances.
- What you can do after
- Apply it via SQLAlchemy by converting parsed CSV data into model instances and committing persistent records with related identifiers.
Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains record →
Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
A row is a table record containing values for the table's columns.
- How it is used
- Uses rows to store PowerShell-generated disk-inventory records in a SQL Server table.
- How deep it goes
- Defines rows through table structure and typed fields, stopping short of detailed reporting implementation.
- Examples
- Uses disk-inventory objects containing computer, size, drive, free-space, drive-type, and date-added values.
- What you can do after
- Build it from scratch by mapping command output properties to typed SQL table columns.
Grokking Relational Database Design
A table record containing values for the columns of one represented entity or relationship.
- How it is used
- Uses records to represent individual entities or relationships inside relational database tables.
- How deep it goes
- Defines records, columns, and primary-key identification, while deferring deeper primary-key discussion.
- Examples
- Uses product records for fictional sci-fi merchandise, including an Atomic Nose Hair Trimmer and a Selfie Toaster.
- What you can do after
- Build and insert complete product records by matching values with a table's named columns.
Read how Grokking Relational Database Design explains record →
React in Depth
Record is a built-in TypeScript utility type that constructs an object type with a specified set of property keys and a uniform property value type.
- How it is used
- Types React state that maps user identifiers to uniform visibility flags.
- How deep it goes
- Defines the object-map pattern and demonstrates its use in useState, without exploring advanced key constraints or mapped-type internals.
- Examples
- Uses a user-visibility map typed as Record<string, boolean> and initialized with an empty object.
- What you can do after
- Apply it via TypeScript and useState to type object maps initialized without entries.
Related concepts
- heterogeneous string mapkind of · A heterogeneous string map is a mapping structure that associates string keys with values of different types or shapes through a common interface.
- datasetpart of · A dataset is a collection of related data items organized or treated as a unit for storage, processing, analysis, or computation.
- database tablepart of · A database table is a relational database structure that organizes records into rows and defined columns.
- attributehas part · An attribute is a named property, value, or piece of information associated with an entity, object, or program element.
- insertproduced by · An insertion is an operation that adds an element, record, or key-value association to a collection or data store, with placement and replacement behavior determined by the target.
- primary keyuses · A primary key is a designated column or attribute, or combination of them, that uniquely identifies each row or item in a table or data store.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.