Join
A join is an operation that combines records or rows from multiple data sources according to specified matching conditions or relationships.
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 profiles with transaction histories before creating personalized customer descriptions.
- How deep it goes
- Defines shared-key matching and illustrates how inclusion choices change the resulting rows.
- Examples
- Uses customer master data, transaction history, CUST002 purchases, CUST003 without purchases, and CUST085 without a master record.
- What you can do after
- Operate/configure it by matching customer and transaction tables on CustomerID while retaining customers without purchases.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Related concepts
- inner joinincludes · An inner join is a relational operation that returns combinations of rows only when the join condition matches records in both input relations.
- DynamoDBcontrasts with · Amazon DynamoDB is a fully managed AWS NoSQL database service for storing and retrieving key-value and document data at scale.
- asof joinincludes · An ASOF join matches rows from two relations according to temporal validity or another inequality condition.
- left outer joinincludes · A left outer join returns every row from the left relation and matching rows from the right relation, representing unmatched right-side values as nulls.
- SQLused by · SQL is a standardized declarative language for defining, querying, and manipulating data and structures in relational database systems.
- outer joinincludes · An outer join combines matching rows while preserving unmatched rows from one or both inputs and representing missing counterparts with null values.
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.