The invention was not tables, it was "data independence" which means data is decoupled from specific applications.
Tables was indeed nothing new. They are just a representation of a set of records with the same structure. This have existed as long as electronic data processing (and in physical form probably as long as organized bookkeeping has existed)
As long as records are independent it is simple. The question arises when records have relationships to other records. In hierarchical databases, records are stored inside other records. In network databases, related records are linked by storing pointers from one record to another along with the data.
These models are simple and fast, but have the fundamental limitation that the database schema determines which queries are possible, since queries work by navigating the existing structure - traversing the hierarchy or following the stored pointers. In other words, the database schema has to be designed based on how it is expected that the application logic will use it. We have a tight coupling between data and application logic.
One fundamental insight in the relational model is that relationships in themselves can be represented as data: The idea of the "foreign key". This decouples the representation of the relationships from implementation details like how data is stored physically and the mechanism of queries.
You can now write queries independently of what the designers of the database initially expected. This is incredibly important when you have long-living data stores. Applications tend to come and go, while data lives forever.
Of course you still need optimizations. The difference is that the optimizations in a relational database (indexes, materialized queries etc.) are not tightly coupled with the data itself. You can change or add new optimizations ad-hoc as new requirements arises. Since the data model is decoupled from its physical representation you can do stuff like changing from row-stored to column-storage, implement sharding and so on without breaking any existing application.
The idea of "data independence" did probably not in itself warrant a Turing Award. What E.F. Codd did in his seminal paper https://cs.uwaterloo.ca/~david/cs848s14/codd-relational.pdf was not only to advocate data independence, but also to device a theoretical model including a full query language (relational algebra) which can be used to perform any query over a relational database.
This query language is itself decoupled from the physical storage model. It only represent the logical query, and then a query engine will device a query plan for how to physically retrieve the data in an optimal way. This is an incredibly powerful abstraction.
What prevented pioneers from inventing the relational model earlier? I'm not sure this can be answered. It is possible that the limitations of the previous models first needed to become apparent.