How to use handle collisions in hashtables using glib - c

Question

I'm trying to store some data using hashtables and I decided to use glib.
So I could use the g_str_hash to generate the key, but there are equal strings. Basically, the data comes from a csv file and there are multiple lines for the same id, for example. And I wanted to use the ids as keys and still have the lines separately.
So I was trying to implement a similar algorithm from g_str_hash but that when there is already something attached to the key, it would go to the next space available. But I have difficulties because of some issues regarding the types and how to do it.
guint hash(char * key, GHashTable *hasht ) {
unsigned int hash = 5381;
int c;
while ((c = *(key++))) {
hash = ((hash << 5) + hash) + c;
}
//this is where i get lost on how to check if there is alreay something stored using the hash I generated before
while (g_hash_table_contains(hasht, hash))
{
hash++;
}
return hash;
}
Soo I would really appreciate some help on how to do it! Thank you so much!

Answer 1

If you're just trying to learn, implementing a custom hash table for this would be a good experience. However, if you just want to get some working code you're over-complicating this. Just use a GHashTable of GPtrArrays. Something like (untested, largely from memory and I haven't really used GLib from C in years):
/* create hash table */
GHashTable* ht = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_ptr_array_unref);
for (/* each record in CSV */) {
GPtrArray* arr = g_hash_table_lookup(ht, record->id);
if (arr == NULL) {
/* We don't have an entry for that ID yet */
arr = g_ptr_array_new_full(1, g_free);
g_hash_table_insert(ht, g_strdup(record->id), arr);
}
g_ptr_array_add(arr, g_strdup(record->value));
}
Unless you're in a very performance-critical loop, this should be fine.

Answer 2

A hash table works by using an array where each element of the array is a 'bucket'. The bucket (array index) for a particular key or element in the hashtable is computed from the hash value for that element. Each bucket contains a linked list of elements which have the same hash value (hash collisions), or NULL if the bucket is empty.
Therefore it is required that your hash function always return the same value for a given key/element. Otherwise, you'll never be able to find/lookup the given key. Note that your hash function is called both when inserting into the hash table, as well when trying to look up a given key. With this hash function, you could insert a key "key1" and then when you later try to lookup "key1", you will increment the hash value because it is already present in the hashtable, and it will not be found. You must not increment the hash value based on if the key is already present in the hash table.
A hash table also requires a way to determine if two keys are equal or not. This is used, for example, to find the particular element you are looking for in a lookup. In short, a lookup involves finding the bucket for the given key using the hash function, and then using the 'key_equal' function to find the specific, given key among all the other keys in that bucket. Something similar happens on an insert, depending if the hashtable allows multiple identical keys or not, and what it does when an equal key already exists in the hash table (e.g., fail or replace the existing key.)
I've not used GLib before, but looking at the docs, GLib.HashTable is implementing a hash map of key/value pairs. The keys are hashed, and each key has an associated value. It does not allow duplicate keys. Inserting a duplicate key results in the old one being replaced.
So, with that background, whether or not this data structure is appropriate depends on your requirements and what you need to do with the data later. It sounds like you want to associate all the lines with their id, storing all of the lines individually, and that you'll need to lookup some or all lines with a given id later. In that case, with GLib.HashTable, I would recommend using the id as the key, and a collection (perhaps a linked list) of lines as the HashTable value. And correcting your hash function to remove this part:
while (g_hash_table_contains(hasht, hash))
{
hash++;
}