The Origins of SQL: The Language That Refused to Die

Matt George

Fractional CTO · Founder of Injuria.ai

Technology rarely lasts. The tools, languages, and frameworks that dominate one decade are often footnotes in the next. SQL is a striking exception. It was designed in the 1970s, built on a theory from 1970, and it still sits underneath the data layer of nearly every web application running today. It has been written off repeatedly, most loudly during the NoSQL movement, and each time it came back. The story of why SQL refuses to die is really a story about getting the fundamentals right the first time, and then being carried by a market that made the right thing also the available thing.

It started with a theory

SQL begins not with code but with a paper. In 1970 a researcher at IBM named Edgar F. Codd published "A Relational Model of Data for Large Shared Data Banks," though he had circulated the core idea in an internal IBM report the year before.[1] At the time, databases stored information in rigid structures that tied the data tightly to the programs that used it, which made them brittle. Codd proposed something more abstract: organize data into relations, which we now call tables, and query it using the mathematics of relational algebra and relational calculus rather than by hand-navigating pointers and physical layouts.[4]

The key insight was separating the logical shape of the data from how it was physically stored. You could ask questions about the data without knowing or caring how it sat on disk. That one idea was powerful enough to define an entire industry.

From SEQUEL to SQL

Codd's model needed a practical way to express queries. In the mid-1970s two IBM researchers, Donald Chamberlin and Raymond Boyce, designed one as part of a prototype database called System R. They called it SEQUEL, for Structured English Query Language, because the goal was something readable enough that people who were not career programmers could use it.[2]

The name had to change. SEQUEL was already a trademark, held by the British aviation firm Hawker Siddeley, so it was shortened to SQL. Many people still pronounce it "sequel" out of habit, a small living fossil of the original name. System R mattered for a second reason beyond the language: it proved Codd's relational theory could be built into a real, high-performance database, with transactions and a query optimizer, not just described on paper.[3]

The rival you never heard of, and the startup that won

The clean story is a straight line from System R to Oracle and DB2. The real story had a serious competitor. At the University of California, Berkeley, a team led by Michael Stonebraker built Ingres, a relational database with its own query language called QUEL, which many researchers considered more elegant than SQL.[5] SQL did not win because it was the better language. It won because IBM's weight was behind it and because a startup commercialized it ruthlessly.

That startup was Relational Software, led by Larry Ellison, founded in 1977 as Software Development Laboratories. It read IBM's published research, saw the commercial opening, and shipped a SQL database in 1979, ahead of IBM's own, under the product name Oracle (there was never a version 1, the first release was called version 2 to seem less risky to buyers).[6] The company later took its product's name. It is one of the clearest cases in tech history of a small firm turning a larger one's published research into a market before the larger one could. SQL was standardized by ANSI in 1986 and ISO in 1987, which locked in its win over QUEL for good.[3][7]

Declarative by design, and durable because of it

Part of SQL's staying power comes from a design decision that still feels modern. SQL is declarative. You describe the result you want, and the database decides how to produce it.

SELECT name, email
FROM users
WHERE created_at > '2026-01-01'
ORDER BY created_at DESC;

You never told the database which index to use, in what order to read rows, or how to sort them. A component called the query optimizer decides all of that, and it can change strategy as your data grows without you touching the query. The other half of SQL's durability is less glamorous and just as important: ACID transactions, the guarantees of atomicity, consistency, isolation, and durability that let a bank move money without ever landing in a half-finished state.[4] Declarative querying made SQL pleasant. ACID made it trustworthy with money, and that is what welded it into the enterprise.

The NoSQL challenge and the return

In the late 2000s and early 2010s, as web companies hit enormous scale, a movement called NoSQL argued that SQL and the relational model were the wrong fit for the modern web. Part of the frustration was real and specific: the object-relational impedance mismatch, the friction of mapping rows and columns onto the objects in application code, had developers leaning on heavy ORM layers and wishing their database just stored data in the shape their program used. NoSQL systems offered flexible schemas and easier spreading across many machines, and for a while it looked like SQL might be relegated to legacy systems.[8]

What actually happened is more interesting. NoSQL found real niches, but SQL did not go away. The relational model proved more adaptable than its critics claimed, many NoSQL systems bolted SQL-like query languages back on because developers kept asking, and a category called NewSQL emerged offering the relational model and SQL at the scale NoSQL had promised. The challenge made SQL better rather than killing it.[3]

A sound foundation outlasts fashion

SQL is everywhere a web application stores structured data. PostgreSQL and MySQL run countless back ends, SQLite is embedded in phones, browsers, and apps by the billions, and every major cloud offers managed SQL as a core service.[9] There is one real asterisk on all of it: standard SQL is more of an aspiration than a reality, because each engine speaks its own dialect, T-SQL, PL/pgSQL, PL/SQL, and moving between them is painful enough to lock companies in for decades. That fragmentation is not a bug in the SQL story, it is part of why specific engines survive so long.

The deeper lesson is that a sound foundation outlasts fashion, but it needs a push to win. Codd got the model right in 1970 and Chamberlin and Boyce gave it a usable language a few years later, and that was necessary but not sufficient. QUEL was arguably just as sound and is a museum piece. SQL endures because the right idea happened to arrive with IBM's research weight and Oracle's commercial hunger behind it, and more than fifty years on, when you ask a website for your order history, the request almost certainly still ends in SQL.

Sources (9)
  1. E. F. Codd, "A Relational Model of Data for Large Shared Data Banks" (CACM, 1970)
  2. Chamberlin & Boyce, "SEQUEL: A Structured English Query Language" (1974)
  3. SQL (Wikipedia)
  4. Relational model (Wikipedia)
  5. Ingres (database) (Wikipedia)
  6. Oracle Corporation (Wikipedia)
  7. Rick F. van der Lans, The SQL Standard (Prentice Hall, 1989)
  8. Michael Kaufmann, Andreas Meier, SQL and NoSQL Databases (Springer Nature, 2023)
  9. Robert Sheldon, Geoff Moes, Beginning MySQL (John Wiley & Sons, 2005)

Recommended reading

The Origins of TypeScript: Adding a Type System to JavaScript7 min readJavaScript's flexibility is a gift on a small page and a liability in a large codebase. TypeScript was Microsoft's answer: keep the language, add a type system on top. Here is where it came from and why it won when every earlier attempt failed.The Origins of Go: Simplicity as a Feature8 min readGo was a reaction. Three veteran engineers at Google, frustrated by slow builds and growing complexity, built a language that left features out on purpose. That restraint made it the language of modern cloud infrastructure.The Origins of Java: Write Once, Run Anywhere7 min readJava was built to run on television set-top boxes. That market never arrived, but the idea underneath it, code that runs anywhere without changes, made Java the language of enterprise software and Android. Here is the story.The Origins of PHP: The Accidental Language That Runs Much of the Web6 min readPHP was never meant to be a programming language. It started as a few tools one developer wrote to track visits to his resume, survived an existential threat from Facebook, and still runs a large share of the web. Here is how.The Origins of Ruby: A Language Designed for Programmer Happiness6 min readMost languages optimize for the machine or the problem. Ruby set out to optimize for the person writing the code. That unusual goal, plus one framework, turned it into the language behind a generation of startups.The Origins of C#: Microsoft's Answer to Java5 min readC# was born out of a lawsuit. Blocked from extending Java, Microsoft built its own modern language, had it standardized so no one could call it a cage, and spent two decades turning it into a fast, open, cross-platform tool.