Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Head First SQL

Head First SQL

Build a database that answers real questions, without losing track of what a change might break.
by Lynn Beighley 2007 607 pages
4.01
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Start with the question your data must answer, then build its tables.

Model the information first. A database holds related structures, especially tables. A table organizes one kind of thing into columns, which name categories such as a contact’s email or birthday, and rows, each describing one record. Greg’s scattered notes about friends become useful once he groups the details into categories and gives each a suitable data type. Text, dates, and numbers should not be treated as interchangeable: numeric types support arithmetic, while text does not.

Build for your purpose. Before creating a table, decide what it describes, what information matters, and how that information will be queried. SQL commands create the database and table, add records, and inspect the table’s structure. The book teaches a practical subset of SQL, using MySQL examples while warning that syntax and data types can vary across database systems.

Analysis

A table is not just a container. It is a claim about which facts belong together and what each fact means. That makes the first design decision partly semantic: a price stored as text may look right on screen but fail when someone tries to calculate revenue. The book’s purpose-first approach helps prevent that mismatch. Its useful restraint is equally important: database design is not improved by splitting every value into the smallest imaginable pieces. A field should be as detailed as its actual uses require.

Replace table-wide scans with SELECT queries that name exactly what you need.

Make the database search. Greg initially reads through a long contact list to find women named Anne in San Francisco. A `SELECT` query with a `WHERE` condition lets the database return only matching rows, while listing specific columns keeps the result focused. Use `AND` when every condition must hold, and `OR` when any one can match. Comparison operators, `BETWEEN`, and `IN` handle numeric ranges, ordered comparisons, and sets of possible values.

Search text carefully. `LIKE` uses `%` for any number of characters and ` ` for one character. Text values are usually enclosed in single quotes, and apostrophes inside text need escaping. `NULL` means unknown or undefined, not zero or an empty string, so test it with `IS NULL` rather than equality. Selecting only needed columns can also reduce needless retrieval.

Analysis

A query is a compact, testable statement of what counts as a match. That makes it more than a shortcut for searching: it forces the questioner to define the conditions precisely. The distinction between AND and OR is a small piece of syntax with large consequences, since a misplaced condition can change a result set dramatically. NULL deserves special care because ordinary comparisons do not behave as they do for known values. Narrow queries are clearer, but a wildcard search can still match unintended text, so returned rows need sensible validation.

Preview every destructive filter before you UPDATE or DELETE.

A condition can erase too much. `DELETE` removes entire rows that match its `WHERE` clause. Without that clause, it can remove every row in the table. `UPDATE` changes the selected columns in every matching row, and without a `WHERE` clause it can change every row. The clown-tracking example shows why a vague filter is dangerous: deleting records based only on a location or activity can remove sightings belonging to several clowns.

Check before changing. Run a `SELECT` with the exact condition first, inspect the returned rows, and only then use the same condition in the change. When replacing a row with `INSERT` and `DELETE`, verify the deletion target before removing anything. Also, a table’s displayed row order is not a reliable timeline. If a history matters, store the time of each event explicitly.

Analysis

The suggested preview is a useful form of a dry run: it makes the consequence of a command visible before it becomes permanent. That habit also reveals a deeper operational risk. A preview and a later update are separate actions, so data can change between them in a busy database. For high-stakes changes, a preview should be paired with safeguards appropriate to the system, such as a transaction or a more specific key. The clown example is memorable because it exposes two different errors: broad filters and treating storage order as evidence of chronology.

Make row order explicit, and group records before drawing conclusions.

Stored order proves nothing. Use `ORDER BY` to request a deliberate sort, such as movie titles alphabetically within category, or purchase dates with titles as a tie-breaker. SQL sorts in ascending order by default; `DESC` reverses it. `LIMIT` can restrict the number of returned rows or select a portion of an ordered result. Without an explicit sort, a result’s apparent order should not be treated as meaningful.

Summarize with functions. In the cookie-sales example, `SUM` totals each Girl Sprout’s sales when paired with `GROUP BY first name`. `AVG`, `MIN`, and `MAX` calculate group statistics, while `COUNT` counts rows or values. `DISTINCT` removes repeated values, so counting distinct sale dates reveals how many different days appear in the records. These tools turn a pile of rows into a comparison, ranking, or summary.

Analysis

Sorting and aggregation make databases useful for decisions, but a summary is only as sound as the unit being counted. Counting sales records is not the same as counting days with sales, which is why distinct dates matter in the cookie example. Averages can also conceal uneven results: two people can share the same average while having very different daily patterns. The chapter’s functions are best understood as tools for asking sharper questions, not as automatic guarantees that the chosen measure captures the whole situation.

Normalize repeated facts before they turn into query headaches.

Keep fields usefully atomic. Atomic data is divided into pieces that the table’s real queries need to handle independently. A contact’s several interests stored in one comma-separated field are hard to match reliably. Splitting that field into a fixed set of interest columns does not solve the problem; it creates repeated columns and imposes an arbitrary limit. In contrast, a delivery worker may reasonably keep a street number and street name together if they are never searched separately.

Give each row an identity. First Normal Form requires atomic values and a unique identifier for each row. Second Normal Form removes partial dependencies on part of a composite key, and Third Normal Form removes dependencies between non-key columns. The book’s toy-store example shows the cost of repeated store addresses: a changed address must be corrected in many rows, creating opportunities for inconsistency.

Analysis

Normalization is a strategy for reducing contradictory copies of the same fact. If an address appears in twenty inventory rows, a single correction can leave the database disagreeing with itself. Separating facts makes updates more dependable, though it means queries may need to reconnect the tables. The useful standard is not maximal fragmentation but a design in which each fact has a clear home and can be changed consistently. That balance matters because a design optimized only for tidy theory can become awkward for the work people actually need to do.

Use stable identifiers. A primary key uniquely identifies a row and should not be missing or duplicated. An `AUTO INCREMENT` identifier is one practical option. A foreign key stores a reference to a key in another table, linking related records and, when constrained, enforcing referential integrity: a reference must point to an existing row.

Match the relationship. One-to-many data can place the parent’s key in the child table. For many-to-many data, such as contacts and interests, neither table can safely hold the other’s key as a single value. A junction table stores a contact key and an interest key for each association. This avoids repeating contact or interest details and lets one interest belong to many contacts. A schema diagrams the tables and their connections so the design can be understood before writing multi-table queries.

Analysis

Keys separate identity from description. A person’s name may change or be shared by two people, while a dedicated identifier provides a dependable link. The junction-table pattern is especially powerful because it represents relationships as data in their own right: a contact has an interest, and that association can be queried without packing lists into a field. Referential constraints make the model more robust, though they also force deliberate choices about deletion and updates. Those rules are not obstacles; they make the consequences of changing related records visible.

Join tables on keys, and use subqueries when a question has stages.

Bring related records together. An inner join returns rows that satisfy a matching condition between tables. An outer join also preserves rows from one chosen table when no match exists, showing missing counterparts as `NULL`. A self-join uses two aliases for one table, as in the clown hierarchy where each clown’s boss is another clown in the same table. `UNION` combines compatible query results and removes duplicates; `UNION ALL` keeps them.

Break complex questions apart. A subquery places one query inside another. Greg can first retrieve job titles from current listings, then use that result to find matching contacts with `IN`. A noncorrelated subquery can run independently; a correlated one depends on a value from the outer query. Joins and subqueries often answer similar questions, so readability and performance on the actual database should guide the choice.

Analysis

Joins express relationships directly, while subqueries can mirror the stages of a question. That distinction is useful for human reasoning even when the database can produce the same answer either way. Outer joins are particularly valuable because they make absence inspectable, rather than silently dropping unmatched records. The book presents joins as generally efficient and subqueries as sometimes slower, but performance depends on the database system, data, and query. Treat that comparison as a reason to measure real workloads, not as a universal rule that overrides clarity.

Put routine rules and repeated queries inside the database.

Make invalid data harder to enter. Constraints express rules such as requiring a value, making a key unique, or ensuring a foreign-key reference exists. A `CHECK` constraint can restrict allowed values, such as limiting a gender field to specified codes, but the book warns that the MySQL version it discusses ignores `CHECK` constraints. System behavior varies, so verify support in the database being used.

Give complex queries a simple name. A view is a named query that behaves like a virtual table when selected. Greg’s employee Frank can save a recurring job-search query as a view rather than retype a long join each day. Views can simplify access, preserve an interface when underlying tables change, and hide columns a user should not see. Some views can also accept changes, but their behavior and restrictions depend on how they are defined and on the database system.

Analysis

Rules enforced at the data layer protect records no matter which person or application writes them. This is stronger than relying on every user interface to remember the same validation. Views complement constraints by shaping what users see and by giving complicated queries stable names. Together, they function as both guardrails and interfaces. The caveat is portability: a command that appears accepted may not actually be enforced, as the book’s MySQL CHECK warning illustrates. Database rules should be tested, not inferred from syntax alone.

Make multi-step writes atomic, and grant each worker only needed access.

Keep related changes together. A transaction groups SQL statements into one unit of work. The ATM story makes the risk concrete: a transfer that subtracts money but fails before adding it leaves the accounts inconsistent. ACID names four properties expected of transactions: atomicity, consistency, isolation, and durability. In the book’s MySQL examples, `START TRANSACTION` begins the unit, `COMMIT` makes it permanent, and `ROLLBACK` undoes it. Transactions require a storage engine that supports them.

Limit permissions. The clown-tracking team needs to look up records, but new employees should not automatically be able to alter or delete them. `GRANT` and `REVOKE` assign and remove privileges for users, tables, or columns. Protect the administrator account, give individual workers only the access their jobs require, and use roles to manage groups when the database supports them. The book notes that its MySQL version does not support roles.

Analysis

Transactions address failures that ordinary command-by-command thinking misses: a workflow can be correct in each step and still be wrong if interrupted halfway through or interleaved with another user’s work. Permissions address a different risk, limiting the damage a mistake or compromised account can cause. These are complementary controls, not substitutes. Transaction support depends on storage engines and configuration, and role features vary by product. The durable lesson is to design for failure and varied skill levels instead of assuming every operator will always act correctly.

Learn SQL by predicting results, running queries, and explaining errors.

Practice is part of the lesson. The book is designed as a learning experience, not a reference catalog. Its exercises ask readers to predict a query’s output, write commands, inspect results, and diagnose errors. Greg’s examples, from searching contacts to rebuilding a recruiting database, give each new command a concrete purpose. Repeatedly seeing an idea in a different form is intentional, and the book includes more than 80 activities.

Make the learner do the work. Pause before looking at an answer, type the query, and compare the actual result with the prediction. Keep notes, try examples in a text editor, and explain a concept aloud. If attention fades or the material stops making sense, take a break rather than pushing through passively. The book also favors diagrams, conversational explanations, and humor to make technical ideas more memorable.

Analysis

Predicting an output before running a query exposes the learner’s mental model; a mismatch then becomes useful evidence rather than mere failure. This resembles retrieval practice, in which recalling information strengthens learning more effectively than simply rereading it. SQL is especially suited to this approach because each claim can be tested against a database. Humor and diagrams can sustain attention, but they cannot replace doing the work. The book’s strongest teaching choice is making the reader construct and inspect queries instead of presenting SQL as a list of commands to memorize.

Analysis

Head First SQL is a beginner’s programming primer organized around a growing problem: Greg begins with contact details on scattered notes, then expands his database into a matchmaking and recruiting business. The narrative gives technical concepts a reason to exist. A badly structured interests field makes queries awkward; duplicated clown sightings show why data needs identifiers and timestamps; employees introduce the need for validation, transactions, and permissions. The result is a progression from basic table creation to relational design and operational safeguards.

The book’s central teaching idea is that SQL is learned by asking questions of data, predicting results, and running the commands, not by memorizing a catalog of syntax. Its strongest technical lesson is similarly practical: structure data around how it will be queried, then use keys and constraints to preserve the relationships that design implies. This connects the mechanics of SELECT and JOIN to the more consequential work of keeping records coherent as a database grows.

Its scope is intentionally introductory. The text prioritizes frequently used commands and teaches Standard SQL through MySQL examples, while repeatedly noting dialect differences. That makes its mental models more durable than some command details. The book dates from 2007, and specific MySQL features, transaction engines, syntax, and security capabilities should be checked against current documentation. Some claims about query speed are best treated as guidance to test rather than universal laws. Even with those limits, the sequence remains effective: model the information, query it, change it cautiously, relate tables deliberately, and protect shared data. The playful examples are not decoration alone. They turn abstract database failures into memorable design problems.

Summary in 30 Seconds
A useful database starts with the questions it must answer, then organizes information into tables with suitable data types and relationships. Queries filter, sort, join, and summarize records. Keys connect tables, while normalization reduces duplicated facts and update errors. Preview the exact rows affected before changing or deleting data. Transactions keep related writes consistent, and permissions limit who can alter records. Practice by predicting query results, running them, and diagnosing errors.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.01 out of 5
Average of 500+ ratings from Goodreads and Amazon.

Head First SQL receives mostly positive reviews, praised for its beginner-friendly approach and entertaining style. Readers appreciate its clear explanations and practical examples. Some criticize outdated syntax and technical errors. The book is highly recommended for SQL novices but may not suit those seeking advanced content. Many readers find it enjoyable and effective for learning basic SQL concepts. Some suggest it's best for MySQL users and advise checking documentation for other database systems. Overall, it's considered a good starting point for SQL beginners.

Your rating:
4.53
165 ratings
Want to read the full book?

Glossary

Atomic data

Values split for useful queries

Data is atomic when a column stores values in pieces suitable for the ways the table will be queried. A contact’s city and state may need separate columns if searches target them independently. Atomicity does not mean splitting every value as far as possible; the needed level depends on the table’s purpose.

Primary key

Unique row identifier

A primary key is a column, or set of columns, that uniquely identifies each row in a table. It must have a value and cannot repeat. The book often uses a dedicated integer identifier with AUTO_INCREMENT, avoiding reliance on descriptive data such as names that can change or be duplicated.

Foreign key

Reference to another table

A foreign key is a column whose values refer to a key in another table. When defined as a constraint, it helps enforce referential integrity by preventing references to nonexistent rows. Foreign keys commonly connect a parent table to related child records and may repeat when several child rows refer to one parent.

Schema

Map of database structures

A schema describes a database’s tables, columns, and the relationships among them. It can be drawn as a diagram or represented in text. A schema separates the design of the database from the particular records stored inside it, making it easier to plan and understand queries across multiple tables.

Junction table

Link for many-to-many data

A junction table connects two tables when each record on either side may relate to multiple records on the other. It typically stores the key from each related table in a separate row. For example, a contact-interest junction table can associate many contacts with many interests without storing lists in a single field.

First Normal Form (1NF)

Atomic rows with unique identity

In the book’s presentation, a table is in First Normal Form when each row contains atomic values and each row has a unique identifier. A column containing a list of interests violates the atomic-values rule. A primary key provides the unique identity needed to distinguish records, including records whose descriptive details happen to match.

Second Normal Form (2NF)

No partial key dependencies

A table in Second Normal Form is already in First Normal Form and has no partial functional dependencies. A partial dependency occurs when a non-key column depends on only part of a composite primary key rather than the whole key. Separating that fact into its own table reduces repeated information and update errors.

Third Normal Form (3NF)

No transitive dependencies

A table in Third Normal Form is in Second Normal Form and has no transitive dependencies among non-key columns. A transitive dependency occurs when one non-key value determines another non-key value. For example, if an instructor determines a phone number, storing both instructor and phone details with course data can duplicate facts unnecessarily.

Subquery

Query nested inside another

A subquery is a SQL query placed inside another query. Its result supplies a value or set of values to the containing query. A noncorrelated subquery can run independently, while a correlated subquery refers to a value from the outer query and depends on it. The appropriate form depends on the question and database.

ACID

Four transaction reliability properties

ACID names atomicity, consistency, isolation, and durability, properties used to describe reliable transactions. Atomicity means all steps succeed or none do. Consistency means the transaction preserves valid database state. Isolation limits interference among concurrent transactions. Durability means committed changes persist. The book illustrates these principles through interrupted and overlapping bank transfers.

View

Named query used like a table

A view is a named query that can be selected from as though it were a table. The view definition persists, while its result is generated from the underlying data when used. Views can simplify recurring queries or expose only selected information. Whether a view can also be updated depends on its definition and database system.

FAQ

1. What’s "A Game Plan for Success in Data Analytics" by Fru Nde about?

  • Beginner’s Guide to Data Analytics: The book provides a high-level overview of the essential tools, concepts, and skills needed to start a career in data analytics, especially for beginners.
  • 5-Point Game Plan: It introduces a structured five-step approach: Master Excel, Conquer SQL, Tame Data Warehousing, Pick Up Coding, and Continue Adapting.
  • Focus on Practical Skills: Rather than deep technical tutorials, the book offers practical advice, industry context, and curated resources for self-study.
  • Career Orientation: It targets aspiring data professionals (Data Ninjas), helping them understand roles, required skills, and industry expectations.

2. Why should I read "A Game Plan for Success in Data Analytics" by Fru Nde?

  • Entry-Level Friendly: The book is designed for newcomers with little or no experience in data analytics, making it accessible and unintimidating.
  • Career Advancement: It provides actionable steps and resources to help readers land their first job, make a career change, or progress in their current roles.
  • Comprehensive Overview: Readers gain a broad understanding of the data analytics landscape, including tools, roles, and industry trends.
  • Resource-Rich: Each chapter ends with curated resources for further learning, making it a practical guide for self-driven learners.

3. Who is the ideal reader for "A Game Plan for Success in Data Analytics" by Fru Nde?

  • Aspiring Data Professionals: The book is aimed at those interested in starting a career in data analytics, regardless of technical background.
  • Career Changers: Individuals looking to transition into data roles from other fields will find the guidance and resources especially helpful.
  • Curious Learners: Anyone seeking to understand the basics of data analytics, tools, and industry expectations will benefit.
  • Entry-Level Candidates: The content is tailored for those at the beginning of their data journey, not for advanced practitioners.

4. What is the "5-Point Game Plan" outlined in "A Game Plan for Success in Data Analytics" by Fru Nde?

  • Master Excel: Learn to use Excel for data manipulation, analysis, and presentation, as it remains a foundational tool in analytics.
  • Conquer SQL: Gain proficiency in SQL to query, manage, and analyze data stored in relational databases.
  • Tame Data Warehousing: Understand the basics of data warehousing, including architecture, dimensional modeling, and its role in consolidating data.
  • Pick Up Coding: Develop basic programming skills to automate tasks, analyze data, and solve business problems.
  • Continue Adapting: Embrace continuous learning and adaptability to keep up with evolving technologies and industry trends.

5. How does "A Game Plan for Success in Data Analytics" by Fru Nde define a "Data Ninja" and what roles do they play?

  • Definition of Data Ninja: A Data Ninja is an entry-level, unspecialized individual who works with data to collect, organize, and interpret it for actionable insights.
  • Versatile Skill Set: Data Ninjas are expected to be multi-skilled, using various tools and techniques to transform raw data into information.
  • Industry Roles: They can work in diverse industries (healthcare, finance, retail, government, etc.) and perform roles such as data analyst, report writer, or business intelligence professional.
  • Interpreter of Data: Data Ninjas act as interpreters, ensuring that data is accurately analyzed and communicated to support business decisions.

6. What are the key skills and tools recommended in "A Game Plan for Success in Data Analytics" by Fru Nde?

  • Technical Skills: Proficiency in Excel, SQL, understanding of data warehousing concepts, and basic programming are emphasized.
  • Soft Skills: Communication, critical thinking, business acumen, and attention to detail are highlighted as essential for success.
  • Recommended Tools: The book suggests starting with Excel, SQL Server, and learning about data warehousing and programming languages.
  • Continuous Learning: Emphasis is placed on ongoing training and practice, with resources provided for self-study.

7. How does "A Game Plan for Success in Data Analytics" by Fru Nde explain the importance of Excel for data professionals?

  • Ubiquity and Versatility: Excel is widely used for data manipulation, analysis, and presentation, making it a must-know tool for data professionals.
  • Core Functionalities: Features like sorting, filtering, pivot tables, charts, and the Analysis ToolPak are essential for analyzing and visualizing data.
  • Limitations Acknowledged: The book discusses Excel’s drawbacks (e.g., collaboration, scalability, data integrity) and when to consider other tools.
  • Integration with Power BI: It introduces Power BI as an extension of Excel’s capabilities for more advanced analytics and visualization.

8. What is SQL and why is it essential according to "A Game Plan for Success in Data Analytics" by Fru Nde?

  • Definition and Ubiquity: SQL (Structured Query Language) is the standard language for querying and managing data in relational databases, used across industries and applications.
  • Key Benefits: SQL enables efficient data retrieval, updates, and reporting, supports large datasets, and allows for concurrent multi-user access.
  • Core Concepts: The book covers DML (Data Manipulation Language), DDL (Data Definition Language), DCL (Data Control Language), and TCL (Transaction Control Language).
  • Relevance: Mastery of SQL is crucial for data professionals, as most organizational data resides in relational databases.

9. What is data warehousing and why should data professionals understand it, according to "A Game Plan for Success in Data Analytics" by Fru Nde?

  • Centralized Data Repository: A data warehouse consolidates data from multiple sources, providing a single version of the truth for analysis and reporting.
  • Architecture and ETL: Understanding the flow of data from source systems through ETL (Extract, Transform, Load) processes into the warehouse is key.
  • Dimensional Modeling: The book introduces fact and dimension tables, explaining how dimensional modeling supports efficient querying and analysis.
  • Business Impact: Data warehousing standardizes data, improves data quality, and enables historical analysis, making it vital for decision support.

10. Why does "A Game Plan for Success in Data Analytics" by Fru Nde emphasize learning programming for data analysis?

  • Problem-Solving Tool: Programming enables automation, data manipulation, and the creation of custom solutions for complex business problems.
  • Gateway to Advanced Analytics: As data tasks become more complex (e.g., big data, data science), programming skills become increasingly important.
  • Recommended Approach: Start with beginner-friendly languages (e.g., VB.NET, Python), focus on concepts, and practice regularly to build competence.
  • Broader Learning: Programming fosters computational thinking, creativity, and adaptability—skills valuable beyond just coding.

11. How does "A Game Plan for Success in Data Analytics" by Fru Nde address the need for continuous adaptation in the data field?

  • Rapid Technological Change: The book highlights the fast pace of change in data tools, technologies, and methodologies.
  • Predictive Analytics and Emerging Trends: It discusses the rise of predictive analytics, big data, and the importance of staying current with industry developments.
  • Evolutionary vs. Revolutionary Change: Readers are encouraged to adapt to both incremental (evolutionary) and disruptive (revolutionary) changes in the field.
  • Lifelong Learning: Emphasis is placed on curiosity, flexibility, and ongoing education to remain relevant and successful as a data professional.

12. What are the key takeaways, best quotes, and resources from "A Game Plan for Success in Data Analytics" by Fru Nde?

  • Key Takeaways: Master foundational tools (Excel, SQL), understand data warehousing, learn programming, and commit to continuous learning and adaptation.
  • Best Quotes: Notable quotes include “Numbers have an important story to tell. They rely on you to give them a clear and convincing voice.” (Stephen Few) and “It is not the strongest of the species that survives, nor the most intelligent that survives. It is the one that is most adaptable to change.” (Charles Darwin).
  • Resource Lists: Each chapter ends with curated resources—websites, tutorials, books—for further study in Excel, SQL, data warehousing, and programming.
  • Practical Advice: The book stresses the importance of communication, business understanding, and the ability to translate data into actionable insights.

About the Author

Lynn Beighley is a prolific tech author with numerous books and articles to her credit. She works as an editor for Manning Publications and is currently writing a young adult novel aimed at encouraging girls to explore computer programming. Beighley holds an MFA degree and has published many short stories in various outlets. Her expertise spans multiple technical subjects, and she has a particular focus on making complex topics accessible to beginners. Beighley is active on Twitter under the handle @lynnbeighley, where she welcomes interaction with her readers and followers.

Download PDF

To save this Head First SQL summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.45 MB     Pages: 22

Download EPUB

To read this Head First SQL summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.46 MB     Pages: 28
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...