Jeff referenced "normalization", which is the key to answering your question.
Simply put, normalization involves building your database to a specific
value only once. There are entire books written on the subject but I will
give you a very basic example.
Imagine a baseball league with 4 teams and ten players per team. You could
build a a one table database with the following fields:
Player Name
Team Name
Simple yes, but you would need to add the team name to each player. It is
not just an issue of extra typing - but suppose you mispelled the team name
"Reds" as "Red" for one player. If you were to need to build a query to
search for all members of the Team "Reds", you would miss the player in team
"Red".
Now, imagine that the "Reds" change their name to "Blues". You would need
to change each record. Sure, this could be done with an Update query, but it
would still miss the mispelled player with team "Red".
A normalized database would have a table of Players and a table of Teams.
In the Players table would be the following fields:
Player_ID
PlayerName
Team_ID (foreign key) FK
The Team table would have the following following fields:
Team_ID (primary key) PK
TeamName
Join your tables on the Team_ID as a one to many.
Now, if you need to change the team name, you change it once, in the Teams
table, because of the relationship it will be changed for each player on the
team. Also, you only have to type it once.
This is the basis of a relational database - otherwise, you simply have a
spreadsheet. As your database grow in complexity, normalization becomes more
and more important.
Finally, to continue to build a better database, you would split the
PlayerName field into PlayerFirstName and PlayerSecondName. Then you could
sort of the last name, something you could not do with the original
PlayerName field.
The opportunites go on and on, but this should show you what Jeff was
referring to.
Let me know if this helps,
Randy