Database
A database is an organized collection of persistent data managed by software for storage, retrieval, querying, and modification.
A Pythonic Adventure: From Python basics to a working web app
A database is a program or organized persistent system that stores data and performs operations such as searching and summarizing it.
- How it is used
- Stores coffee-shop orders so a Flask application can save submissions and later display an order list.
- How deep it goes
- Works through SQLite table creation, INSERT, commit, SELECT, fetched rows, and template display without detailing database internals.
- Examples
- Uses coffee-shop order forms, an orders table, save_order(), get_orders(), and an HTML table listing names and menu choices.
- What you can do after
- Apply it via SQLite and Flask to create a table, save submitted orders, retrieve rows, and render an order list.
Read how A Pythonic Adventure: From Python basics to a working web app explains database →
Coding with AI
A database is a system that stores organized information and retrieves records matching explicit queries.
- How it is used
- Stores question pools and task records that applications retrieve for selection, display, grading, and CRUD operations.
- How deep it goes
- Walks through CSV import, table setup, primary-key configuration, and visual inspection, while deferring application connection code.
- Examples
- Uses a HAM radio question pool and a TODO application with task name, description, due date, and completion status.
- What you can do after
- Operate/configure it by importing CSV data into SQLite, setting a unique primary key, and inspecting the resulting table.
Data Analysis with LLMs
A structured collection of data organized for storage, retrieval, and management by computer software.
- How it is used
- Stores tabular data for efficient analysis while a language model translates plain-language questions into SQL.
- How deep it goes
- Defines relational tables and walks through SQLite setup and CSV import, without explaining database storage internals.
- Examples
- Uses a video-game table and SQLite file, plus a query for the highest-selling game in 2016.
- What you can do after
- Build it from scratch in SQLite by creating a table, importing CSV data, and checking its row count.
Apache Kafka in Action
A database is a software system that durably stores, organizes, and supports querying of data.
- How it is used
- Positions relational databases as stores for service-specific current state, contrasted with Kafka’s role in exchanging event history.
- How deep it goes
- Explains queries, ACID guarantees, normalization, joins, and commit logs, but does not walk through database setup or SQL commands.
- Examples
- Uses customer and order tables to illustrate denormalization and a shared-database diagram to illustrate service coupling.
- What you can do after
- Evaluate/understand when to retain service-specific state in a relational database and use Kafka instead of a shared database for exchange.
Build Python Web Apps with Streamlit
A database is an organized system for storing, managing, and retrieving structured or unstructured data.
- How it is used
- Stores and retrieves users’ haikus persistently for a Streamlit CRUD app.
- How deep it goes
- Defines relational tables and schemas, walks through entity modeling, and introduces PostgreSQL setup and SQL operations.
- Examples
- Models users and private haikus as related tables, then uses PostgreSQL and psql for local development.
- What you can do after
- Build it from scratch: model related tables and set up PostgreSQL storage for a Streamlit CRUD app.
Read how Build Python Web Apps with Streamlit explains database →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A database is a system that stores and manages persistent structured data for retrieval and modification.
- How it is used
- Stores updated video metadata for a microservice while external file storage holds video files.
- How deep it goes
- Works through MongoDB integration in a containerized application but defers database design and data engineering.
- Examples
- Uses a MongoDB container, a Node.js connection, and a JSON record containing a video path.
- What you can do after
- Apply it via Docker Compose and the mongodb driver to store video metadata for a Node.js microservice.
The Quick Python Book, Fourth Edition
A database is an organized collection of persistent data managed for storage, retrieval, and modification.
- How it is used
- Stores cleaned data for later retrieval and modification when managing growing collections of files becomes impractical.
- How deep it goes
- Works through SQLite connections, cursors, parameter binding, queries, and commits; defers database-specific details and comprehensive treatment.
- Examples
- Demonstrates a SQLite people table and MongoDB document operations.
- What you can do after
- Build it from scratch: choose a database for a dataset, load its data, and retrieve single or multiple matching records.
Read how The Quick Python Book, Fourth Edition explains database →
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
A database system is software that manages persistent data storage, querying, and updates.
- How it is used
- Stores and queries application data for web shops, WordPress, and enterprise applications running on AWS.
- How deep it goes
- Explains relational database purpose and RDS operating choices, but defers database-system-specific user administration.
- Examples
- Uses a product-and-order web shop, a WordPress MySQL database, and an enterprise SQL application.
- What you can do after
- Operate/configure a relational database with Amazon RDS, including access controls, recovery, availability, and monitoring.
Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains database →
Investing for Programmers
A database is an organized system for storing, retrieving, and managing structured or semi-structured data.
- How it is used
- Organizes reusable prompts and external financial context for retrieval-augmented generation and LLM analysis.
- How deep it goes
- Demonstrates relational DDL and an in-memory vector retrieval workflow, but does not develop database administration or production persistence.
- Examples
- Uses prompt schemas, company placeholders, earnings-call transcripts, filings, document chunks, and similarity-search results.
- What you can do after
- Build it from scratch as a tagged prompt repository or in-memory vector store supporting retrieved context for LLM answers.
Building Web APIs with ASP.NET Core
A database is an organized repository that stores structured data for retrieval and modification.
- How it is used
- Feeds websites, mobile applications, management tools, and analysis services through a web API without exposing the database directly.
- How deep it goes
- Defines DBMS benefits and demonstrates SQL Server creation, credentials, users, and deployment, but defers detailed schema design.
- Examples
- Uses a board-game catalog, the MyBGList database, SQL Server Management Studio, instance logins, and database users.
- What you can do after
- Operate/configure SQL Server by creating databases, logins, users, roles, and separate development and production credentials.
Read how Building Web APIs with ASP.NET Core explains database →
Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
A database is an organized repository that persistently stores data and supports structured access and management.
- How it is used
- Uses structured storage to replace spreadsheet-based data handling in PowerShell automation and support repeatable reporting.
- How deep it goes
- Explains connections, database creation, table design, typed columns, and module reuse, but defers administration, backups, and report production.
- Examples
- Demonstrates SQL Server Express setup and a disk-inventory table populated from PowerShell-generated objects.
- What you can do after
- Operate/configure a SQL Server database from PowerShell and organize inventory data for automated reporting.
MongoDB 8.0 in Action, Third Edition
A database is a logical container that organizes related collections or tables and their stored data.
- How it is used
- Organizes MongoDB collections and their documents within a deployment.
- How deep it goes
- Defines the data hierarchy and works through shell selection, first-write creation, naming limits, and reserved databases.
- Examples
- Uses a mongosh insertion that creates a database and an Atlas CLI job that populates test databases.
- What you can do after
- Operate/configure it with mongosh to select a database and create it on first insertion.
Read how MongoDB 8.0 in Action, Third Edition explains database →
Platform Engineering on Kubernetes
A database is an organized data store that supports persistent storage and retrieval of application data.
- How it is used
- Supports persistent, shared application state while services scale across Kubernetes replicas.
- How deep it goes
- Explains persistence, replica sharing, database selection, provisioning, and connection limits, but not database internals.
- Examples
- Uses Redis for Agenda items, PostgreSQL for proposals, and a PostgreSQL Helm Chart deployed inside a Kubernetes cluster.
- What you can do after
- Operate/configure persistent stores with Helm Charts and account for database connection limits when scaling services.
Read how Platform Engineering on Kubernetes explains database →
Microsoft Azure in Action
A database is an organized logical store within a Cosmos DB account that contains collections or containers of data.
- How it is used
- Organizes containers or collections within a Cosmos DB account so applications can group and manage stored documents.
- How deep it goes
- Defines the account-database-container-document hierarchy and demonstrates database creation, but defers broader Cosmos DB scaling details.
- Examples
- Uses alpacacosmosdbaccount, alpacacosmosdb, and alpacacontainer in Azure CLI commands and a hierarchy diagram.
- What you can do after
- Operate/configure a MongoDB database and collection under a Cosmos DB account using Azure CLI.
Just Use Postgres!
A database is a named collection of database objects such as schemas, tables, views, and indexes.
- How it is used
- Organizes application data and workloads into isolated, queryable collections of schemas and database objects.
- How deep it goes
- Defines databases through schemas, tables, and object boundaries, but stops short of detailed administration or deployment guidance.
- Examples
- Uses the default postgres database, a Postgres container, and psql commands for connection and object inspection.
- What you can do after
- Operate/configure it by connecting with psql and recognize the scope of queries across databases and schemas.
Road to Kubernetes
A database is a system that persistently stores and manages structured or semi-structured data for applications.
- How it is used
- Frames databases as stateful dependencies that make otherwise independent web applications practical.
- How deep it goes
- Explains database deployment through volumes, StatefulSets, Secrets, initialization, and Services, but defers clustered-database construction.
- Examples
- Uses PostgreSQL manifests with credentials, a 20Gi volume claim, an init container, and a ClusterIP Service.
- What you can do after
- Operate/configure PostgreSQL on Kubernetes with persistent storage, Secret-backed credentials, and internal Service connectivity.
Functional Design and Architecture: Examples in Haskell
A database is an organized system for storing, managing, and retrieving structured data.
- How it is used
- Provides an external persistence subsystem for application data and a boundary between storage technology and application logic.
- How deep it goes
- Descends from architectural placement to relational schemas, normalization, indexes, SQL, and ORM challenges.
- Examples
- Uses relational storage in the Andromeda architecture and a raw, then type-safe, key–value database subsystem.
- What you can do after
- Evaluate requirements, storage technologies, schemas, access libraries, and abstraction boundaries for application persistence.
Read how Functional Design and Architecture: Examples in Haskell explains database →
Rust Servers, Services, and Apps
Database persistence is the storage of application data in a database so that it survives process termination and can be retrieved later.
- How it is used
- Backs Rust web APIs and frontend handlers with stored course data and user credentials.
- How deep it goes
- Builds from an async PostgreSQL connection and query to service-level persistence and CRUD, while leaving distributed errors for later treatment.
- Examples
- Uses course creation and retrieval, tutor credential lookup, and database container packaging as examples.
- What you can do after
- Build a Rust web service that stores and retrieves course data through a PostgreSQL-backed API.
Read how Rust Servers, Services, and Apps explains database →
Simple Object-Oriented Design: Create clean, maintainable applications
A database is a system that persistently stores and retrieves structured application information.
- How it is used
- Anchors backend operations that retrieve, insert, update, and delete application information.
- How deep it goes
- Defines the database’s architectural role and access boundary but defers storage technology and implementation details.
- Examples
- Uses training courses, employees, trainers, enrollments, reports, and notifications as stored application information.
- What you can do after
- Understand how a database fits into a backend and how repositories isolate persistence logic.
Read how Simple Object-Oriented Design: Create clean, maintainable applications explains database →
ASP.NET Core in Action, 3e
A database is an organized collection of data managed for storage, retrieval, and processing.
- How it is used
- Organizes application data for storage, retrieval, and processing through object-relational mapping.
- How deep it goes
- Defines relational mapping and surveys production concerns without detailing migration or concurrency implementations.
- Examples
- Uses SQL Server, SQLite, MySQL, PostgreSQL, Cosmos DB, and temporary in-memory databases as concrete technology examples.
- What you can do after
- Evaluate database options and understand how EF Core maps .NET classes to relational tables and rows.
Code Like a Pro in Rust
A database is an organized system for persistently storing, retrieving, and modifying structured data.
- How it is used
- Provides persistent state for a REST API implementing todo-item CRUD operations.
- How deep it goes
- Explains database placement, configuration, typed query mapping, CRUD methods, binding order, and error conversion.
- Examples
- Uses a todo table, Todo struct, SQLite queries, connection pools, and create, read, update, delete, and list methods.
- What you can do after
- Apply it via Rust and SQLx to implement typed asynchronous CRUD access for a web service.
Digital Twins in Action
A data store is a software system or repository that persists and retrieves data.
- How it is used
- Positions databases as stores for digital-twin data that must remain accessible for modeling, monitoring, and analysis.
- How deep it goes
- Explains relational schemas and ACID tradeoffs, then compares storage choices by workload without detailing database internals.
- Examples
- Uses linked assets, work orders, and maintenance tasks in a SQLite query, plus a table of digital-twin storage options.
- What you can do after
- Apply it via SQLite to query linked maintenance records and evaluate storage options against workload constraints.
Python How-To
A database is an organized collection of data managed for storage, retrieval, and modification by software.
- How it is used
- Hosts task-management application data while the project moves from individual techniques to a working application.
- How deep it goes
- Explains SQLite setup, parameterized insertion, batch insertion, guarded updates, and data-type limitations, but stops short of broader database administration.
- Examples
- Uses task records such as Laundry, Homework, and Museum to demonstrate single-record, batch, and conditional updates.
- What you can do after
- Operate/configure SQLite to insert individual or multiple records and safely update an existing application record.
Learn Haskell by Example
A database is an organized system for storing, retrieving, and managing structured data.
- How it is used
- Deploys a database layer to persist todo entries behind a module used by a server API.
- How deep it goes
- Explains schema setup, queries, transactions, parameter binding, generated identifiers, and error handling through implementation listings.
- Examples
- Uses a todo-entry table, SELECT retrieval, id lookup, transactional insertion, and checked-field updates.
- What you can do after
- Apply it via Database.SQLite.Simple to build a small transactional persistence layer for a todo API.
Related concepts
- SQLused by · SQL is a standardized declarative language for defining, querying, and manipulating data and structures in relational database systems.
- PostgreSQLincludes · PostgreSQL is an open-source object-relational database management system that implements SQL and supports transactional data storage and extensibility.
- Entity Framework Coreused by · Entity Framework Core is a cross-platform object-relational mapping framework for .NET that enables applications to query and persist data through .NET objects and APIs.
- ScyllaDBincludes · ScyllaDB is a distributed wide-column database compatible with Cassandra’s data model and protocol, designed for high scalability and availability.
- document databasecontrasts with · A document database is a nonrelational database that stores and retrieves records as self-contained documents, often with flexible or nested structures.
- Apache Kafkacontrasts with · Apache Kafka is a distributed event-streaming platform for publishing, storing, processing, and consuming streams of records.
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.