Suppose there are two databases $A$ and $B$. $A$ stores a random salt $salt1$ and a bunch of hashes of the form $h(salt1||password)$ for each password $A$ was submitted with. $B$ stores a random salt $salt2$ and another bunch of hashes of the form $h(salt2||password)$ for each password $B$ was submitted with.
Now imagine there is an attacker who steals the contents(e.g. the unique salt and the hashes) of both databases $A$ and $B$ and wants to learn the passwords. What he is going to do is an attack called dictionary attack. For the database $A$, he is going to build a table containing hashes of the form $(h(salt1||guess), guess)$, for every possible guess he makes. After he is done with that, he is going to take each single hash of database A and compare it with the first element in each entry of the hash table he just built. When he hits a match, he has cracked the password, which is simply going to be the second element of the matching entry.
Now the usefulness of salt is clear: the dictionary he just computed is not applicable to an attack to the database $B$, because the two databases use different salts to create their hashes. So he should build a completely new dictionary, using this time $salt2$ during his computations. This is time consuming and makes the life of the attacker more difficult.
Applying the same argument, you can see that if a database uses a new random salt for each hashed password it stores, then the attacker should build a new dictionary for each password he wants to crack. In other words, in the best case, a database should generate a new random salt for every new password it is submitted with and store pairs of $(salt_i,h(salt_i||password_i)$.