Record
A record is a structured representation of related fields or components, either as one data entry or as a type defining such entries.
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 structured data while distinguishing C# records from F# records used for everyday domain modeling.
- How deep it goes
- Contrasts C# inheritance, initialization, and immutability with F# records, but develops declaration and updating only for F#.
- Examples
- Uses person and address records, customer and supplier models, and a copy-and-update address example.
- What you can do after
- Evaluate/understand it: distinguish C# records from F# records and choose F# records for defined data models.
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
- Uses records to organize related fields in text files, class instances, and structured binary data.
- How deep it goes
- Explains field access, row filtering, and binary packing and unpacking, while referring readers to documentation for further struct formats.
- Examples
- Uses Cook County weather rows, a Circle instance with a radius field, and a packed integer, float, and byte string.
- What you can do after
- Diagnose row-filtering errors by distinguishing whole-field membership from a substring test on a selected field.
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.
Also covered in
- Data-Oriented Programming in JavaIn early access (MEAP)
- Building User-Friendly DSLs
- The Art of Code
- Practices of the Python Pro
- Microservices Patterns, Second EditionIn early access (MEAP)
- Functional Programming in C#, Second Edition
- Logs and Telemetry
- Healthcare ITIn early access (MEAP)
- Optimization Algorithms: AI techniques for design, planning, and control problems
- D3.js in Action, Third Edition
- .NET in Action, Second Edition
- Python Workout: 50 ten-minute exercises
What to know first
- listA list is an ordered collection of elements arranged in a sequence.
- tupleA tuple is a finite, ordered collection of values grouped as a single composite value, often with elements of different types.
- attributeAn attribute is a named property or piece of information associated with an entity, object, or structured data item.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
Related concepts
- commandincludes · A command is an instruction or representation of a requested operation that a system can execute, often with parameters and potentially changing state.
- 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.
- queryincludes · A query is a request or operation that retrieves information from a system or data source.
- contractimplements · A contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- anonymous recordincludes · An anonymous record is an F# record value with named fields whose record type is inferred without an explicit named type declaration.
Questions about record
What is record?
A record is a structured representation of related fields or components, either as one data entry or as a type defining such entries.
Which Manning books explain record?
Data-Oriented Programming: Reduce software complexity, F# in Action: A Revised Edition of Get Programming with F#, Clojure: The Essential Reference, Learn Haskell by Example, The Quick Python Book, Fourth Edition, Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI, Learn SQL in a Month of Lunches, Build Python Web Apps with Streamlit and 4 more.
What should I know before learning record?
Manning books that teach record usually introduce list, tuple, attribute and JSON first.
What kinds of record are there?
Kinds of record include command, query and anonymous record.
What is record a kind of?
Record is a kind of heterogeneous string map. A heterogeneous string map is a mapping structure that associates string keys with values of different types or shapes through a common interface.
What are the parts of record?
Record includes field.
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.











