Future users of large data banks must be protected from having to know how the data is organized in the machine (the internal representation). A prompting service which supplies such information is not a satisfactory solution. Activities of users at terminals and most application programs should remain unaffected when the internal representation of data is changed and even when some aspects of the external representation are changed. Changes in data representation will often be needed as a result of changes in query, update, and report traffic and natural growth in the types of stored information. Existing noninferential, formatted data systems provide users with tree-structured files or slightly more general network models of the data. In Section 1, inadequacies of these models are discussed. A model based on n -ary relations, a normal form for data base relations, and the concept of a universal data sublanguage are introduced. In Section 2, certain operations on relations (other than logical inference) are discussed and applied to the problems of redundancy and consistency in the user's model.
Metadata: Crossref. Abstracts retain their original authors’ rights.
In the conversation
Original HN comments, with labels from simple text rules. A label describes the whole comment and may miss context or irony. Read the discussion to make up your own mind. About the labels
In his seminal paper A Relational Model of Data for
Large Shared Data Banks, Codd explicitly mentions first-order predicate calculus as a suitable formalism for the sub-language. Quoting from https://dl.acm.org/doi/pdf/10.1145/362384.362685:
"The adoption of a relational model of data, as described above, permits the development of a universal data sub-language based on an applied predicate calculus. A first-order predicate calculus suffices if the collection of relationships is in normal form."
One great advantage of using Prolog is that queries themselves are so readily amenable to analysis and reasoning with the same mechanism, and it becomes very easy to optimize them by reordering goals.
As much as I love relational databases, I have not actually ever ventured outside of SQL for describing queries. Its dominance is near-total. I've never even thought that there might exist something else. But of course, SQL didn't exist since time immemorial, and there must have been things before that.
Thanks for the link. I actually do like the syntax of SQUARE a little, and I'll definitely look into the predicate logic-based query languages like DSL ALPHA that came before that!
If anyone is interested in the Codd paper on predicate logic-based language: https://dl.acm.org/doi/pdf/10.1145/1734714.1734718
And more on SQUARE:…
Read the full comment
https://dl.acm.org/doi/pdf/10.1145/361219.361221
Edit: This is a treasure trove of literature that's gone me by. I'm very grateful for OP bringing it to my attention. Relational data and SQL are things that are basically part of my fabric of existence and I've never questioned them or investigated why they were invented in the first place. It's definitely enlightening to do so. Here's the background to why relational data in the first place: https://dl.acm.org/doi/pdf/10.1145/362384.362685
Second edit: I love the parallels you can draw to how one might query in-memory data in a general purpose language, ranging from iterative loops (low-level) through list comprehensions (predicate logic) into functional looping pipelines like LINQ or Java Streams (calculus-based).
So some people already posted now-accessible papers that worth a look.
Here is my random pick: "A relational model of data for large shared data banks" [1]
It's a defining paper for RDB data model. I think it's not a exaggeration to say
all the RDB history starts here. (The history itself is covered not by acm but by ieee [2]).
[1] https://dl.acm.org/doi/10.1145/362384.362685
[2] https://scholar.google.com/scholar?cluster=16074372884446179...
This is almost exactly the motivational example that Codd used when originally describing relational algebra. He described 5 different data organization schemes for a single problem and designed relational algebra to work with all of them. This ability for the same program logic to work with many different data storage layouts should make changes like you describe less painful to implement.
(see page 2)
E. F. Codd. 1970. A relational model of data for large shared data banks. Commun. ACM 13, 6 (June 1970), 377–387. DOI:https://doi.org/10.1145/362384.362685
PDF: https://www.seas.upenn.edu/~zives/03f/cis550/codd.pdf
Indexes are models: a B-Tree-Index can be seen as a model to map a key to the position of a record within a sorted array, a Hash-Index as a model to map a key to a position of a record within an unsorted array, and a BitMap-Index as a model to indicate if a data record exists or not.
Fast compilation is important when compilation occurs at runtime, such as query compilers in modern database systems and WebAssembly virtual machines in modern browsers.