The Origins of SQL: The Language That Refused to Die

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