Schema
A data schema is a formal specification of the structure, fields, types, relationships, and constraints of data.
Kafka Streams in Action, Second Edition
A schema is a formal description of the structure and meaning of data records exchanged between software components, expressed in Apache Avro's schema format.
- How it is used
- Defines explicit event contracts so independent Kafka producers and consumers serialize and deserialize compatible records.
- How deep it goes
- Works through definition, Avro, Protobuf, and JSON Schema forms, registration, generated objects, and serializer configuration.
- Examples
- Uses Person, Avenger records, generated Java Avenger objects, and related package-tracking events on one topic.
- What you can do after
- Operate/configure schema registration, code generation, and Avro serializer or deserializer settings for Kafka event records.
Read how Kafka Streams in Action, Second Edition explains schema →
Kafka for Architects
A data schema is a formal definition of the fields, types, and structure of a particular data or message type.
- How it is used
- Structures Kafka event payloads as producer-consumer data contracts when brokers treat messages as opaque bytes.
- How deep it goes
- Defines fields, types, and constraints and works through Avro, Protobuf, and JSON Schema examples rather than serializer internals.
- Examples
- Contrasts full-state profile and phone-number delta events and shows a Client schema with optional fields and a nested address.
- What you can do after
- Apply it via Schema Registry to version event contracts and check compatibility as producers and consumers evolve.
Designing Deep Learning Systems: A guide for software engineers
A data schema that imposes explicit data types and structural constraints on its fields and values.
- How it is used
- Establishes contracts between data collection and model training so teams can exchange datasets safely.
- How deep it goes
- Details two-schema validation, transformation, compatibility rules, and transformer implementation rather than type-system internals.
- Examples
- Uses TEXT_INTENT CSV inputs and label manifests, plus IMAGE_CLASS image directories and zipped training artifacts.
- What you can do after
- Build it from scratch by defining ingestion and training formats and implementing a DatasetTransformer for a new dataset type.
Read how Designing Deep Learning Systems: A guide for software engineers explains schema →
Knowledge Graphs and LLMs in Action
A schema is a formal specification of the structure, types, and relationships permitted in a data representation.
- How it is used
- Guides knowledge-graph construction, data integration, ingestion, normalization, analysis, and natural-language query translation.
- How deep it goes
- Explains schema design through node and relationship models, mappings, provenance, normalization, and constrained traversals, while deferring implementation syntax.
- Examples
- Uses healthcare ontology mappings, document-to-entity graphs, Rockefeller Archive influence networks, and red-Camaro query traversals.
- What you can do after
- Build it from scratch by defining graph structures, mapping source data, resolving entities, and writing schema-constrained queries.
Read how Knowledge Graphs and LLMs in Action explains schema →
The Well-Grounded Data Analyst
A schema is a specification of the fields, structure, and expected organization of data in a dataset or table.
- How it is used
- Shapes multiple customer sources into a combined, one-row-per-customer data model.
- How deep it goes
- Works through selecting fields, handling missing values, standardizing records, adding lineage flags, and merging sources.
- Examples
- Uses purchases, CRM, and customer databases to build a customer schema with guest and source-presence fields.
- What you can do after
- Apply it to transform disparate customer datasets into a common structure ready for combination and deduplication.
Building Web APIs with ASP.NET Core
A GraphQL schema is a typed definition of the data and operations that a GraphQL API exposes to clients.
- How it is used
- Defines the board-game API’s client-facing data access and CRUD operations.
- How deep it goes
- Defines root operation types and implements Query and Mutation classes and registration, while deferring Subscription implementation.
- Examples
- Uses board-game, domain, and mechanic retrieval methods, authorized mutations, and GraphQL server registration.
- What you can do after
- Build it from scratch with HotChocolate Query and Mutation types and map a GraphQL endpoint.
Read how Building Web APIs with ASP.NET Core explains schema →
Data-Oriented Programming: Reduce software complexity
A data schema is a formal description of the structure, constraints, and types that valid data must satisfy.
- How it is used
- Uses schemas to validate data at system boundaries and clarify generic function inputs during development.
- How deep it goes
- Defines types, required fields, nested structures, enumerations, and runtime checks, while deferring validation details beyond supplied JSON Schema examples.
- Examples
- Demonstrates book-search requests, catalog records, author and book schemas, homogeneous maps, tuples, and validated function arguments.
- What you can do after
- Apply JSON Schema with a validation library to reject malformed data and document expected function argument shapes.
Read how Data-Oriented Programming: Reduce software complexity explains schema →
ScyllaDB in Action
A database schema is the formal structure that defines a database's data entities, fields, relationships, and constraints.
- How it is used
- Guides ScyllaDB data modeling from application requirements and query patterns to tables and partitions.
- How deep it goes
- Explains schema creation, table keys, partitioning trade-offs, and an iterative query-first design checklist.
- Examples
- Uses a restaurant-review table with restaurant, time, food, review, and a composite primary key.
- What you can do after
- Build it from scratch by translating requirements into query-oriented ScyllaDB tables, partitions, and fields.
DuckDB in Action
A schema is a formal description of data fields, types, and structural organization.
- How it is used
- Organizes relational tables and helps inspect, transform, and query external JSON and Parquet data.
- How deep it goes
- Defines tables, types, keys, nested structures, and Parquet metadata, then stops short of exhaustive constraint management.
- Examples
- Uses energy tables, nested football-shot JSON, ATP rankings Parquet, DESCRIBE, ALTER TABLE, unnest, casting, and schema diagrams.
- What you can do after
- Operate/configure DuckDB to inspect inferred schemas, evolve tables, flatten nested data, and query Parquet metadata.
Graph Neural Networks in Action
A schema is a formal specification of the classes, attributes, relationships, constraints, and other structure permitted in a data model.
- How it is used
- Organizes nongraph data into a testable graph structure for recruitment queries and downstream GNN pipelines.
- How deep it goes
- Develops schema design through instance-model construction, validation, and refactoring, without prescribing a database-specific schema language.
- Examples
- Uses recruitment data, progressively varied node-and-edge schemas, and an instance model populated with candidate data.
- What you can do after
- Build it from scratch by defining graph structure, testing a populated instance, and refactoring the schema before downstream analysis.
Authorization in Action
A schema is a formal description of the structure, types, and constraints of data stored or exchanged by a system, including Cedar entity types, attributes, actions, and context.
- How it is used
- Establishes the authorization vocabulary that policies, requests, and entity data must share.
- How deep it goes
- Explains typed Cedar modeling, validation, evolution, and OpenFGA relationship schemas without detailing compiler internals.
- Examples
- Uses a collaboration platform with employees, customers, teams, documents, device context, and doc:view, doc:edit, and doc:share actions.
- What you can do after
- Build it from scratch by defining typed authorization entities, actions, attributes, relationships, and context before writing policies.
Secure APIs
A schema is a formal structure that defines the shape and permitted content of data in requests or responses.
- How it is used
- Defines acceptable API request and response data while supporting validation, sanitization, and secure-by-design decisions.
- How deep it goes
- Explains schema constraints through attack scenarios and YAML examples, but does not descend into validator implementation internals.
- Examples
- Uses book reviews, product pagination and sorting, model formats, third-party responses, and corrupted database data as concrete cases.
- What you can do after
- Build constrained schemas that reject invalid ranges, oversized strings, arbitrary fields, and unsafe model choices.
Snowflake Data Engineering
A data schema is the structural specification of the fields, types, and organization of a dataset.
- How it is used
- Defines CSV fields and types so Snowpark can read staged files and load a typed staging table.
- How deep it goes
- Explains field-level Python definitions and their application during loading, while contrasting them with schema-flexible JSON ingestion.
- Examples
- Uses an orders CSV schema with customer, dates, baked-good type, and quantity fields, then contrasts it with nested JSON stored in VARIANT.
- What you can do after
- Build it from scratch by defining Snowpark fields and types, applying the schema to staged CSV data, and loading a staging table.
LLMs in Production
A schema is a formal specification of the structure, fields, types, and constraints of data.
- How it is used
- Organizes dataset features before cleaning and preparation for LLM training.
- How deep it goes
- Places schema selection in a preparation sequence but does not detail how to construct data pipelines.
- Examples
- Uses a pile of data needing a feature schema and identifies the instruct schema as a fine-tuning option.
- What you can do after
- Practice/perform selecting a feature schema before cleaning and converting data for model ingestion.
ASP.NET Core in Action, 3e
A database schema is the structural definition of a database's tables, columns, keys, relationships, and related objects.
- How it is used
- Structures application data and coordinates database changes with Entity Framework Core.
- How deep it goes
- Defines tables, columns, and relationships, then explains versioning through migrations without exploring schema design in great depth.
- Examples
- Uses SQLite, SQL Server LocalDB, EF Core migrations, and the ASP.NET Core Identity tables as concrete examples.
- What you can do after
- Apply it via EF Core migrations to create a database and update its schema as the application data model changes.
Quarkus in Action
A schema definition is a formal specification of a data structure's fields, types, names, and ordering.
- How it is used
- Defines a client-facing GraphQL contract and a Protocol Buffers message structure for exchanging inventory data.
- How deep it goes
- Works through generated GraphQL types and notation, then shows proto field declarations and compilation without detailing generated-code internals.
- Examples
- Uses an inventory service’s generated GraphQL schema, field-selecting query, and proto message declaration.
- What you can do after
- Apply it via SmallRye GraphQL to expose a Java model, or compile a proto file into message and serialization code.
Data Analysis with LLMs
A database schema is the defined structure of a database, including its tables, columns, data types, and relationships.
- How it is used
- Uses schemas to give language models the database structure needed to translate natural-language questions into SQL or Cypher.
- How deep it goes
- Shows hardcoded definitions and automatic SQLite table extraction, while hardcoding rather than extracting the graph description.
- Examples
- Uses a video-game sales table and a movie graph’s node labels, relationship types, and properties.
- What you can do after
- Build it from scratch by extracting SQLite table definitions with sqlite3 and inserting them into reusable question-to-SQL prompts.
Elasticsearch in Action, Second Edition
A schema is a formal specification of the structure, fields, types, and constraints that data must follow.
- How it is used
- Defines document fields and types so Elasticsearch can index, search, sort, filter, and aggregate data appropriately.
- How deep it goes
- Explains field-level mapping, dynamic versus explicit definitions, storage implications, and reindexing for prohibited type changes.
- Examples
- Uses movie documents, cars with a formatted registration date, electrical products, and orders migrated through the reindex API.
- What you can do after
- Build it from scratch by declaring index mappings and migrating to a new index when an existing field type must change.
Read how Elasticsearch in Action, Second Edition explains schema →
Apache Kafka in Action
A schema is a formal blueprint that defines the structure, fields, types, and rules of data.
- How it is used
- Defines the data contract between Kafka producers and consumers so topic messages can be interpreted consistently.
- How deep it goes
- Explains implicit schemas, field-level changes, compatibility concerns, and Avro schema IDs; stops short of a schema-registry configuration procedure.
- Examples
- Uses supermarket product records, proposed field changes, and a typed Avro product schema with an optional field.
- What you can do after
- Evaluate/understand schema changes against consumer compatibility and choose whether documented schemas and a registry address topic needs.
Just Use Postgres!
A database schema is a named logical namespace within a database that contains database objects such as tables.
- How it is used
- Organizes database objects around application modules, microservices, or other logical boundaries.
- How deep it goes
- Explains namespaces, defaults, qualification, search_path, and cross-schema queries, but defers detailed permissions and administration.
- Examples
- Uses products, customers, and sales schemas plus products.catalog and products.reviews tables for an eCommerce platform.
- What you can do after
- Build it from scratch with CREATE SCHEMA, qualified object names, psql inspection, and SET search_path.
100 SQL Server Mistakes and How to Avoid Them
A schema is a named namespace in a database that contains and organizes securable objects.
- How it is used
- Guides database modeling by organizing entities, attributes, relationships, and normalization decisions before implementation.
- How deep it goes
- Explains ERDs, atomic values, duplication, normalization, and naming consequences, but does not detail complete normalization procedures.
- Examples
- Uses customer names, product categories and subcategories, ERDs, T-SQL name extraction, and MagicChoc stored procedures.
- What you can do after
- Builds and evaluates schemas with ERDs, atomic values, normalization rules, and descriptive object names.
Read how 100 SQL Server Mistakes and How to Avoid Them explains schema →
Functional Design and Architecture: Examples in Haskell
A database schema is the structure defining the data types, fields, and relationships represented in a database.
- How it is used
- Structures database-facing entities so storage, access, relationships, and queries can be designed against explicit requirements.
- How deep it goes
- Defines fields, column types, table names, primary keys, and database declarations, while deferring broader relational theory and implementation choices.
- Examples
- Uses meteor records with typed fields, JSON key–value entities, primary-key declarations, and size-filtered queries as concrete schema examples.
- What you can do after
- Build it from scratch by declaring typed tables, primary keys, database settings, and conversions between stored entities and domain values.
Read how Functional Design and Architecture: Examples in Haskell explains schema →
Build Python Web Apps with Streamlit
A database schema is the formal definition of a database's tables, fields, relationships, and constraints.
- How it is used
- Designs persistent tables and relationships for CRUD applications.
- How deep it goes
- Explains modeling steps and PostgreSQL constraints, but stops short of comprehensive production schema design.
- Examples
- Models users and haikus with PostgreSQL tables, sample records, queries, updates, and deletions.
- What you can do after
- Build a small relational schema and operate it with PostgreSQL SQL commands.
Read how Build Python Web Apps with Streamlit explains schema →
Effective Data Analysis
A schema is a logical organization of related database objects such as tables.
- How it is used
- Organizes warehouse tables into reusable structures for analysis, stakeholder reporting, dashboards, and recurring business workflows.
- How deep it goes
- Defines schemas briefly, then details joins, data quality, aggregation, and denormalization without specifying a vendor implementation.
- Examples
- Uses weather history, forecasts, timestamps, foreign keys, weekly aggregates, dashboards, and cross-language population queries.
- What you can do after
- Build analytics schemas by standardizing fields, validating joins, combining sources, and aggregating information for faster querying.
Delivering Machine Learning Projects: From design to deployment
A schema is a formal specification of the structure, fields, types, and relationships of data.
- How it is used
- Uses schema inspection to scope data preparation, ETL effort, access requirements, and delivery risk before project work begins.
- How deep it goes
- Explains schema as an investigation checkpoint and stops short of specifying field-level notation or implementation syntax.
- Examples
- Uses large flat sample tables joined from underlying databases as the concrete schema example.
- What you can do after
- Evaluate source structure and turn schema findings into ETL, access, security, privacy, and resourcing actions.
Read how Delivering Machine Learning Projects: From design to deployment explains schema →
The Design of Web APIs, Second Edition
A schema is a formal description of the structure, properties, and constraints of data exchanged by an API.
- How it is used
- Describes API request, response, and header data for design, documentation, mocking, testing, and validation.
- How deep it goes
- Explains types, properties, required fields, arrays, references, and inline schemas, while focusing on OpenAPI essentials.
- Examples
- Uses product resources, POST and PUT bodies, JSON media types, error responses, and a string-valued Location header.
- What you can do after
- Build it from scratch by defining JSON schemas, placing them in OpenAPI, and reusing them through components.schemas and $ref.
Read how The Design of Web APIs, Second Edition explains schema →
Build an AI Agent (From Scratch)
A schema is a formal specification of the fields, types, and constraints that valid structured data must satisfy.
- How it is used
- Defines validated contracts for LLM responses, tool arguments, final answers, and stored agent memories.
- How deep it goes
- Works through Pydantic fields and tool-parameter design, then integrates a final-answer tool; defers graph-schema construction.
- Examples
- Uses contact extraction, a restaurant reservation tool, a light-state enum, and problem-solving memory records.
- What you can do after
- Apply it via Pydantic to validate structured responses and design clearer, more constrained tool arguments.
Automating API Delivery
A schema is a formal description of the structure, data types, properties, and constraints of data exchanged by an API.
- How it is used
- Defines API request and response structure, then supports validation, conformance testing, and security-oriented linting.
- How deep it goes
- Explains types, properties, formats, lengths, required fields, and additionalProperties, then notes evolution trade-offs without covering unevaluatedProperties in detail.
- Examples
- Uses a Product response with UUID and string-length constraints, plus lint findings for undocumented and potentially sensitive response fields.
- What you can do after
- Apply OpenAPI schemas to validate client data, test API responses, and identify undocumented response properties.
Contract Testing in Action
A formal description of the structure, fields, data types, rules, and constraints permitted for data or an interface.
- How it is used
- Defines permitted data structures and validates API inputs or queries before consumers and providers exchange them.
- How deep it goes
- Explains structure, constraints, GraphQL types, queries, and resolvers, but defers consumer usage and breaking-change detection to contract testing.
- Examples
- Uses a Pact login interaction and a GraphQL Movie type with movie and movies queries.
- What you can do after
- Build it from scratch by defining JSON or GraphQL data shapes, constraints, queries, and their separate resolver behavior.
Generative AI in Action
A schema is a formal specification of the structure and permitted content of a data representation.
- How it is used
- Structures searchable enterprise data and constrains AI-generated JSON outputs.
- How deep it goes
- Defines concrete fields, types, vector parameters, and permitted JSON keys through implementation examples.
- Examples
- Uses a blog-post Redis index and a pet-salon entity-extraction prompt with controlled JSON fields.
- What you can do after
- Apply it via Redis index creation or prompt instructions to organize searchable records and shape extracted JSON.
The Art of AI Product Development
A specification of the entity types, relationship types, and structural rules in a graph.
- How it is used
- Structures language-model outputs and knowledge graphs so applications can automate reliably or retrieve connected domain information.
- How deep it goes
- Defines fields, entities, and relationships, then names enforcement approaches; stops short of detailed schema design or implementation code.
- Examples
- Uses predefined LM output formats and finance graphs linking regulations, companies, and market events.
- What you can do after
- Apply it via function calling, constrained generation, Pydantic validation, or GraphRAG to produce more reliable structured results.
Read how The Art of AI Product Development explains schema →
Microsoft Azure in Action
A schema is a prescribed structure and set of rules that defines and validates the organization of data.
- How it is used
- Structures relational data so applications can store, retrieve, query, and manage it efficiently.
- How deep it goes
- Explains tables, keys, relationship types, SQL creation, and normalization trade-offs, but stops short of exhaustive database theory.
- Examples
- Uses a Banning Books ordering system, relationship definitions, a schema diagram, and SQL CREATE TABLE statements.
- What you can do after
- Build it from scratch by modeling tables and relationships, then generating them with SQL primary and foreign keys.
Learn Docker in a Month of Lunches, Second Edition
A database schema is the formal definition of a database's tables, relationships, constraints, indexes, and other structural objects.
- How it is used
- Packages database structure as a repeatable artifact for development, testing, upgrades, and production deployment.
- How deep it goes
- Defines schema deployment through DACPAC creation and application, but does not detail individual database objects or migration internals.
- Examples
- Uses a multi-stage Dockerfile, a NerdDinner DACPAC, initialize.ps1, and SQL Server containers.
- What you can do after
- Apply it via DACPAC and Docker to create or upgrade SQL Server databases consistently.
Read how Learn Docker in a Month of Lunches, Second Edition explains schema →
Kubernetes in Action, Second Edition
A schema is a formal description of the fields and structure used to represent an object.
- How it is used
- Describes Kubernetes objects so manifests and API responses can represent their fields and structure.
- How deep it goes
- Explains schemas through apiVersion, object sections, alternate API representations, and JSON/YAML, without detailing validation rules.
- Examples
- Uses a Node manifest retrieved with kubectl and contrasts Deployment representations across API versions.
- What you can do after
- Evaluate Kubernetes object representations by reading apiVersion and separating metadata, spec, and status.
Read how Kubernetes in Action, Second Edition explains schema →
Building Distributed Applications that Work
A database schema is the structure and organization of a database, including its tables and fields.
- How it is used
- Uses schema changes as a deployment concern for a SQL-backed Aspire application.
- How deep it goes
- Works through migration generation and startup application, while leaving manual conversion of EnsureCreated databases unspecified.
- Examples
- Shows an order address property becoming a nullable column through a generated migration.
- What you can do after
- Apply it via Entity Framework migrations to update a SQL schema when deploying an Aspire application.
Read how Building Distributed Applications that Work explains schema →
MongoDB 8.0 in Action, Third Edition
A schema is a specification of the fields, structures, and data types that an application's stored documents may contain.
- How it is used
- Guides MongoDB document modeling, validation, SQL integration, and ongoing performance improvement.
- How deep it goes
- Explains flexible structures, validation examples, generated JSON schemas, and performance recommendations without detailing validation syntax or query execution internals.
- Examples
- Uses user passwords, flight routes, airport totals, federated collections, nested fields, arrays, data types, and frequently queried fields.
- What you can do after
- Evaluate and improve MongoDB document structures, enforce selected data rules, and interpret Atlas recommendations for application workloads.
Read how MongoDB 8.0 in Action, Third Edition explains schema →
PostgreSQL Mistakes and How to Avoid Them
A database schema is a named namespace within a database that contains objects such as tables, views, and functions.
- How it is used
- Uses schema inspection to assess inherited PostgreSQL databases before diagnosing problems or planning incremental improvements.
- How deep it goes
- Explains practical inspection and documentation, but stops short of detailed schema-definition syntax or object-level internals.
- Examples
- Uses a retail schema containing branches, stock, customers, suppliers, products, orders, payments, and payment types.
- What you can do after
- Diagnose schema and database problems with pg_dump, pgAdmin, DBeaver, exploratory queries, logs, and PostgreSQL statistics views.
Read how PostgreSQL Mistakes and How to Avoid Them explains schema →
Data Pipelines with Apache Airflow, Second Edition
A database schema is the structural definition of a database's tables, columns, relationships, and other database objects.
- How it is used
- Defines fields for Weaviate collections and supports initialization or migration of Airflow's metastore.
- How deep it goes
- Explains properties, data types, vectorization, existence checks, and migrations, but does not detail relational schema internals.
- Examples
- Uses recipe UUID, recipe name, chunk UUID, and chunk fields alongside Airflow metastore migration commands.
- What you can do after
- Build it from scratch by defining Weaviate properties and initialize or upgrade an Airflow metastore with migration commands.
Read how Data Pipelines with Apache Airflow, Second Edition explains schema →
F# in Action: A Revised Edition of Get Programming with F#
A schema is a formal description of the fields, structure, and types expected in a data resource.
- How it is used
- Uses representative data to define external-resource structure and reduce manual type creation in F# applications and scripts.
- How deep it goes
- Explains sample-based inference, edit-time type creation, runtime loading, optional fields, and schema-maintenance trade-offs.
- Examples
- Uses guitar JSON samples, local files, remote HTTP resources, optional fields, and larger runtime inventory files.
- What you can do after
- Apply it via F# type providers to create types from samples and load matching runtime data.
Read how F# in Action: A Revised Edition of Get Programming with F# explains schema →
Digital Twins in Action
A schema is a formal specification of the concepts, relationships, properties, or structures that organize information in a domain or system.
- How it is used
- Defines the query contract and physical-system model for a digital twin, giving sensor readings context through their relationships.
- How deep it goes
- Defines the contract, shows home-twin types and a small working API, then addresses compatibility; it does not specify a migration procedure.
- Examples
- Uses a home-twin query schema and a city-weather query that combines geocoding with forecast data.
- What you can do after
- Build it from scratch as a small GraphQL API, and evaluate schema changes for downstream compatibility.
AI Agents in Action, Second Edition
- How it is used
- Keeps multi-agent workflows stable with typed input/output data and specifies the parameters, description, and result shape of MCP tools.
- How deep it goes
- Maps MCP function signatures, docstrings, and return annotations to tool parameters, descriptions, and expected result shapes.
- Examples
- Uses a Python `get_research_sources` tool returning a list of strings, alongside typed input/output schemas built with Pydantic.
- What you can do after
- Apply it via Pydantic types and the MCP `@mcp.tool()` decorator to structure agent data and expose a function's callable interface.
Read how AI Agents in Action, Second Edition explains schema →
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A schema is a data structure that defines the parameters, attributes, configuration values, types, requirements, computed status, defaults, and documentation associated with a Terraform component.
- How it is used
- Defines the configuration and attribute interface for Terraform providers, resources, and data sources.
- How deep it goes
- Explains types, required or computed status, defaults, and documentation, while leaving field-specific functionality to further treatment.
- Examples
- Uses Mastodon provider settings and an account data source with computed account attributes.
- What you can do after
- Build schemas for provider configuration and data source parameters and attributes.
Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains schema →
API Design Patterns
A schema is a formal specification of the structure, allowed contents, and constraints of data.
- How it is used
- Organizes known resource fields into predictable structures while distinguishing them from arbitrary dynamic data.
- How deep it goes
- Explains predefined keys, value types, grouping decisions, and dynamic-map trade-offs through API-shaped examples.
- Examples
- Uses ChatRoom security configuration and GroceryItem ingredient amounts to contrast typed structures with maps.
- What you can do after
- Evaluate whether API data needs a predefined schema, grouped structure, separate sub-resource, or dynamic map.
The Quick Python Book, Fourth Edition
A database schema is the formal definition of a database's tables, fields, data types, relationships, and other structural constraints.
- How it is used
- Coordinates application code, ORM definitions, and relational database structure as the application evolves.
- How deep it goes
- Explains schema change management through reversible migrations, stopping short of a broad treatment of structural design.
- Examples
- Demonstrates an address table, revision metadata, Alembic upgrades and downgrades, and table listings before and after migration.
- What you can do after
- Operate Alembic to create, apply, inspect, and reverse versioned relational schema changes.
Read how The Quick Python Book, Fourth Edition explains schema →
Related concepts
- MCPused by · The Model Context Protocol is an open standard protocol that defines how AI applications connect with external tools, data sources, and other contextual resources.
- structured dataused by · Structured data is information organized according to an explicit schema or predictable fields, types, records, or relationships for consistent machine processing.
- data representationcontrasts with · A data representation is a form or encoding in which information is structured for storage, processing, transmission, or interpretation.
- databasepart of · A database is an organized collection of persistent data managed by software for storage, retrieval, querying, and modification.
- SQLused by · SQL is a standardized declarative language for defining, querying, and manipulating data and structures in relational database systems.
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.