liveBook · Manning

Join

Also called joining

A join is an operation that combines records or data elements from multiple inputs according to matching or related values or conditions.

How 18 Manning books explain it

Pandas Workout: 200 exercises to make you a stronger data analyst

Joining combines rows from separate tabular data structures by matching values in a common key or index.

How it is used
Combines specific data frames so analysts can answer questions requiring fields stored in separate tables.
How deep it goes
Explains index preparation, default matching, grouped follow-up analysis, multiple joins, join types, and missing-value interpretation.
Examples
Uses product and sales frames, product-level summaries, daily totals, two-level grouping, and country-level wine and tourism data.
What you can do after
Apply it via pandas DataFrame.join, then analyze the combined rows with groupby, sums, sorting, and correlation.

Read how Pandas Workout: 200 exercises to make you a stronger data analyst explains join →

Grokking AI Applications

A relational data operation that combines rows from two tables using matching values in one or more key columns.

How it is used
Combines customer and transaction data to prepare customer-level descriptions for personalized emails.
How deep it goes
Defines shared keys and works through matching, repeated matches, and unmatched rows using a left-table-preserving join.
Examples
Uses customer master data and transaction history keyed by CustomerID, including customers without purchases and a transaction without a master record.
What you can do after
Evaluate and understand how a join choice affects matching and unmatched customer records.

Read how Grokking AI Applications explains join →

DuckDB in Action

A JOIN clause combines rows from two or more relations according to matching or other join conditions.

How it is used
Combines related relations for filtering, aggregation, readings analysis, and multi-file data workflows.
How deep it goes
Demonstrates inner, left outer, and full outer joins with runnable results, duplicate-key behavior, CTEs, and recursive SQL.
Examples
Uses VALUES relations, readings and systems, timestamped CSV files, duplicate keys, maximum readings, and recursive parent-child data.
What you can do after
Apply it via DuckDB SQL or the relational API to combine relations, retain unmatched rows, and build staged analyses.

Read how DuckDB in Action explains join →

Apache Kafka in Action

A join is a query operation that combines related records from multiple data sources according to matching or related fields.

How it is used
Enriches streaming records with current table values or correlates related events as they arrive.
How deep it goes
Works through three join pairings, their triggers, keyed matching, and a time-windowed implementation; does not detail state-store internals.
Examples
Uses product sales and prices, customer loyalty cards, and notifications joined to aggregated active-device lists.
What you can do after
Apply it via Kafka Streams or Flink SQL to enrich keyed events and correlate streams within a time window.

Read how Apache Kafka in Action explains join →

Kafka Streams in Action, Second Edition

A join is an operation that combines records from two data streams or related data sources according to matching criteria.

How it is used
Combines related event records or enriches streams when isolated events cannot provide the needed context.
How deep it goes
Explains join windows, co-partitioning, joiner logic, Serdes, and state stores; defers detailed join state-store usage.
Examples
Uses cafe and retail purchases to create customer rewards, then enriches rewards with membership information.
What you can do after
Build it from scratch with Kafka Streams or ksqlDB by keying inputs, selecting a window, and combining matching records.

Read how Kafka Streams in Action, Second Edition explains join →

Learn SQL in a Month of Lunches

A join is an SQL operation that combines rows from multiple tables according to a specified relationship or predicate.

How it is used
Retrieves related customer, order, item, and title values in a single SQL query.
How deep it goes
Explains JOIN and ON through two- and four-table queries, while deferring more-inclusive join types.
Examples
Uses an order 1001 lookup, Chris Dixon’s orders, 2015 customers, and The Sum Also Rises purchases.
What you can do after
Apply it to write readable SQL queries that retrieve related data across several tables.

Read how Learn SQL in a Month of Lunches explains join →

AI-Powered Search

A join is an operation that combines records or documents by matching a shared identifier, attribute, or resolved entity.

How it is used
Relates structured rows, unstructured documents, or retrieved question-answer records into composite data for search and modeling.
How deep it goes
Progresses from foreign-key definition to fuzzy entity matching and a retrieval workflow, while deferring detailed join algorithms.
Examples
Uses employee-company tables, Haystack documents, fuzzy person references, and question-answer contexts.
What you can do after
Apply joins via SQL-style keys, resolved document entities, or separate Solr retrievals combined into a dataframe.

Read how AI-Powered Search explains join →

Grokking Software Architecture

A relational query operation that combines rows from tables according to a specified relationship or matching condition.

How it is used
Combines related rows across tables for complex or unpredictable multi-table queries.
How deep it goes
Names JOIN as a SQL fundamental and connects it to multi-table queries, but gives no syntax or execution details.
Examples
Uses a cross-table orders-and-payments request and contrasts it with collecting blog data from separate services.
What you can do after
Evaluate whether complex multi-table queries suit a relational database or require aggregation across services.

Read how Grokking Software Architecture explains join →

Java Persistence with Spring Data and Hibernate epub

A join is an SQL relational operation that combines rows from multiple tables according to a matching or other join condition.

How it is used
Improves relational data access by retrieving related rows in fewer SQL queries.
How deep it goes
Explains SQL joins, ORM fetch-depth limits, eager-loading behavior, Cartesian products, and Querydsl join predicates.
Examples
Uses User, BillingDetails, Item, User seller, Bid, and Image tables, plus Querydsl predicates and generated SQL.
What you can do after
Apply it via SQL, Hibernate fetch plans, or Querydsl to retrieve related entities and constrain joined rows.

Read how Java Persistence with Spring Data and Hibernate epub explains join →

Kafka for Architects

A stream join is a stream-processing operation that combines records from multiple streams or tables when their keys or other join conditions match.

How it is used
Moves enrichment and aggregation into an intermediate streaming service so downstream services consume reusable results.
How deep it goes
Explains matching, copartitioning, task assignment, and arrival-order challenges, but does not provide implementation code.
Examples
Uses order-payment enrichment and Customer 360 joins between transactions and customer profiles.
What you can do after
Evaluate join designs by checking match conditions, partition alignment, key distribution, and downstream aggregation needs.

Read how Kafka for Architects explains join →

Event Processing in Action

An operation that matches records or events from two inputs according to a condition and combines matching pairs.

How it is used
Uses joins as a stateful transformation to match events arriving on two streams.
How deep it goes
Explains input filtering, event routing, pairwise matching, condition testing, and output derivation.
Examples
Uses camera-recorded vehicle arrivals and departures, matched by registration mark to estimate time on a highway section.
What you can do after
Understand how matching arrival and departure events can reveal a vehicle’s time on a road section.

Read how Event Processing in Action explains join →

ScyllaDB in Action

A join is a database operation that combines related rows from two or more relations according to a matching condition.

How it is used
Contrasts relational data access with ScyllaDB's query-first modeling and explains why schemas avoid cross-table reads.
How deep it goes
Defines joins, demonstrates their relational use, and stops at their performance implications and schema alternatives in ScyllaDB.
Examples
Uses restaurant reviews, article authors, and store items with prices to contrast joins, duplication, and multiple queries.
What you can do after
Evaluate when a relational join must become denormalized data or multiple queries in a ScyllaDB schema.

Read how ScyllaDB in Action explains join →

Machine Learning System Design

Data joining is the technique of combining records or collections from multiple data sources into a connected dataset.

How it is used
Uses joining to enrich datasets, connect proprietary and public information, and create marketing opportunities.
How deep it goes
Defines SQL-style, cross-business, and multimodal joining but stops short of implementation details.
Examples
Uses game-payer and ad-profile matching plus product images paired with text descriptions.
What you can do after
Apply it to enrich datasets and identify marketing opportunities from complementary information.

Read how Machine Learning System Design explains join →

Financial AI in Practice

A join operation combines records from separate data sources according to a relationship between their fields.

How it is used
Unifies financial snapshots and behavioral aggregates to create contextual features for customer profiles and model training.
How deep it goes
Defines the join’s role and illustrates its value, but does not specify join keys or implementation syntax.
Examples
Combines daily P&L of −5% with 10 logins to illustrate a feature suggesting panic.
What you can do after
Evaluate how joining financial and behavioral data can reveal context unavailable from either source alone.

Read how Financial AI in Practice explains join →

Troubleshooting Java, Second Edition

An SQL JOIN is a relational query operation that combines rows from multiple tables according to a matching condition.

How it is used
Uses JOIN to diagnose and remove repeated database queries caused by fetching related records in application code.
How deep it goes
Demonstrates the optimization rationale and investigation path but stops short of showing the replacement JOIN syntax.
Examples
Uses a PurchaseService loop, repeated findProduct calls, ten query executions, and profiler-intercepted JDBC traffic.
What you can do after
Diagnose repeated SQL with VisualVM and identify when related lookups should become one JOIN query.

Read how Troubleshooting Java, Second Edition explains join →

The Well-Grounded Python Developer: How the pros use Python and Flask

A join operation combines rows from related database tables according to a matching relationship between them.

How it is used
Connects normalized database tables when an application needs related customer, order, address, product, or item data together.
How deep it goes
Explains aliases, key matching, ON conditions, grouping, and multi-table reconstruction, without detailing join variants or query optimization.
Examples
Uses customer-address counts, invoice reconstruction, and a blog post query joined with user information.
What you can do after
Apply it via SQL to retrieve related records and assemble application views from normalized tables.

Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains join →

Statistics Slam Dunk

A join operation combines rows from two tabular datasets according to matching values in one or more key variables.

How it is used
Combines related data sets so records can support later analysis, statistical tests, models, and visualizations.
How deep it goes
Defines four join types and demonstrates shared-key behavior, but does not develop join internals or unmatched-record diagnostics.
Examples
Uses NBA team-season data, the Team and season keys, playoffs conversion, dplyr joins, and head() output.
What you can do after
Apply it via dplyr to merge NBA and statistics data by multiple shared variables.

Read how Statistics Slam Dunk explains join →

Everyday Data Visualization

A join is an operation that combines rows from tables according to matching or related fields.

How it is used
Supports reporting weekly work by product area when related records reside in separate systems.
How deep it goes
Explains table linkage and mapping keys, but stops short of implementation details.
Examples
Uses team names, assigned people, weekly work, and product areas across two systems.
What you can do after
Evaluate whether available fields can support a join and identify when a mapping key is required.

Read how Everyday Data Visualization explains join →

Also covered in

What to know first

Related concepts

Questions about join

What is join?

A join is an operation that combines records or data elements from multiple inputs according to matching or related values or conditions.

Which Manning books explain join?

Pandas Workout: 200 exercises to make you a stronger data analyst, Grokking AI Applications, DuckDB in Action, Apache Kafka in Action, Kafka Streams in Action, Second Edition, Learn SQL in a Month of Lunches, AI-Powered Search, Grokking Software Architecture and 10 more.

What should I know before learning join?

Manning books that teach join usually introduce SQL, database table, ACID and foreign key first.

What is the difference between join and DynamoDB?

A join is an operation that combines records or data elements from multiple inputs according to matching or related values or conditions. Amazon DynamoDB is a fully managed AWS NoSQL database service for storing and retrieving key-value and document data at scale.

What kinds of join are there?

Kinds of join include inner join, asof join, in-memory join and two-way join.

What is join also called?

Join is also called joining.

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.