Changeset 3290

Timestamp:

04/27/08 14:48:53 (5 months ago)

Author:

dgollub

Message:

Introduce new osync_hashltable API

* The hashtable is now restricted to one object type/table.
* Instead of performing single SQL queries an internal

hashtable data structure is used for temporary store.

* The persistent store of the hashtable is done by the

function osync_hashtable_save(), which
is using SQL transaction. Call this function in your
syncdone() plugin sink function.

* Hashtable needs to be loaded with function osync_hashtable_load()
* Added reference counting for hashtable object
* osync_hashtable_num_entries() return value changed from int to unsigned int
* osync_hashtable_nth_entry() got replaced by osync_hashtable_foreach(),

which is more performant to iterate through the hashtable

* osync_hashtable_get_deleted() return value changed from char* Array to OSyncList
* osync_hashtable_update_hash() got by replaced osync_hashtable_update_change()

which allows to use the OSyncChange object, since this contains changetype
and UID. Depending on the changetype more specific SQL query get prepared.

* osync_hashtable_write()/osync_hashtable_delete() got dropped. No need - right?
* osync_hashtable_reset() and osync_hashtable_report() are gone - everything is done

with osync_hashtable_update_change()

* It's FAST now (seriously)!

Files:

• trunk/opensync/helper/opensync_hashtable.c (modified) (11 diffs)
• trunk/opensync/helper/opensync_hashtable.h (modified) (2 diffs)
• trunk/opensync/helper/opensync_hashtable_internals.h (modified) (1 diff)

trunk/opensync/helper/opensync_hashtable.c

@@ -39 +39 @@
- * 
- * @param table The hashtable
-objtype the object type of the hashtable
+ame The name of the hastable inside the database 
- * @param error An error struct
- * @returns TRUE on success, or FALSE if an error occurred.
@@ -45 +45 @@
- */
-
-
-
-
-
-
+
+
+
+
+
+
-        if (!osync_db_query(table->dbhandle, query, error)) {
-                osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
@@ -61 +62 @@
-}
-
-/*@}*/
-
-/**
- * @defgroup OSyncHashtableAPI OpenSync Hashtables
- * @ingroup OSyncPublic
- * @brief A Hashtable can be used to detect changes
- * 
- * Hashtables can be used to detect changes since the last invocation. They do this
- * by keeping track of all reported uids and the hashes of the objects.
- * 
- * A hash is a string that changes when an object is updated or when the content of
- * the object changes. So hashes can either be a real hash like an MD5, or something 
- * like a timestamp. The only important thing is that the hash changes when the item
- * gets updated.
- * 
- * The hashtable is created or loaded from a .db file using the osync_hashtable_new()
- * function.
- * 
- * Now you can query and alter the table. You can ask if a item has changed by doing:
- * - osync_hashtable_get_changetype() to get the changetype of a certain uid and hash
- * - or the convience function osync_hashtable_detect_change() which calls 
- * osync_hashtable_get_changetype() and sets this changetype on the change object and then
- * automatically calls osync_hashtable_report()
- * After you reported all objects you can query the table for the deleted objects using
- * osync_hashtable_get_deleted() or osync_hashtable_report_deleted()
- * 
- * After you are finished using the hashtable, call:
- * - osync_hashtable_free()
- * 
- * The hashtable works like this:
- * 
- * First the items are reported with a certain uid or hash. If the uid does not yet
- * exist in the database it is reported as ADDED. If the uid exists and the hash is different
- * it is reported as MODIFIED. If the uid exists but the hash is the same it means that the
- * object is UNMODIFIED.
- * 
- * To be able to report deleted objects the hashtables keeps track of the uids you reported.
- * After you are done with asking the hashtable for changes you can ask it for deleted objects.
- * All items that are in the hashtable but where not reported by you have to be DELETED.
- * 
- */
-/*@{*/
-
-/*! @brief Loads or creates a hashtable
- * 
- * Hashtables can be used to detect what has been changed since
- * the last sync
- * 
- * @param path the full path and file name of the hashtable .db file to load from or create
- * @param objtype the object type of the hashtable
- * @param error An error struct
- * @returns A new hashtable, or NULL if an error occurred.
- * 
- */
-OSyncHashTable *osync_hashtable_new(const char *path, const char *objtype, OSyncError **error)
-{
-        osync_trace(TRACE_ENTRY, "%s(%s, %s, %p)", __func__, path, objtype, error);
-        
-        OSyncHashTable *table = osync_try_malloc0(sizeof(OSyncHashTable), error);
-        if (!table) {
-                osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
-                return NULL;
-        }
-        
-        table->used_entries = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
-
-        table->dbhandle = osync_db_new(error);
-        if (!table->dbhandle)
-                goto error;
-
-        if (!osync_db_open(table->dbhandle, path, error))
-                goto error_and_free;
-
-        table->tablename = g_strdup_printf("tbl_hash_%s", objtype);
-
-        int ret = osync_db_exists(table->dbhandle, table->tablename, error);
-        if (ret > 0) {
-                goto end;
-        } else if (ret < 0) {
-                goto error_and_free;
-        }
-        /* if ret == 0 then table does not exist yet. contiune and create one. */
-
-        if (!osync_hashtable_create(table, objtype, error))
-                goto error_and_free;
-
-end:
-        osync_trace(TRACE_EXIT, "%s: %p", __func__, table);
-        return table;
-
-error_and_free: 
-        g_free(table->dbhandle);
-        g_free(table);
-error:  
-        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
-        return FALSE;
-
-}
-
-/*! @brief Frees a hashtable
- * 
- * @param table The hashtable to free
- * 
- */
-void osync_hashtable_free(OSyncHashTable *table)
-{
-        osync_trace(TRACE_ENTRY, "%s(%p)", __func__, table);
-        osync_assert(table);
-        
-        if (!osync_db_close(table->dbhandle, NULL))
-                osync_trace(TRACE_INTERNAL, "Can't close database");
-
-                
-        g_hash_table_destroy(table->used_entries);
-
-        g_free(table->tablename);
-        g_free(table->dbhandle);
-        g_free(table);
-        
-        osync_trace(TRACE_EXIT, "%s", __func__);
-}
-
-/*! @brief Prepares the hashtable for a slowsync and flush the entire hashtable
- * 
- * This function should be called to prepare the hashtable for a slowsync.
- * The entire database, which stores the values of the hashtable beyond the
- * synchronization, gets flushed.
- * 
- * @param table The hashtable
- * @param error An error struct
- * @returns TRUE on success, or FALSE if an error occurred.
- * 
- */
-osync_bool osync_hashtable_slowsync(OSyncHashTable *table, OSyncError **error)
-{
-        osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, table, error);
-        osync_assert(table);
-        osync_assert(table->dbhandle);
-
-        if (!osync_db_reset(table->dbhandle, table->tablename, error)) {
-                osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
-                return FALSE;
-        }
-        
-        osync_trace(TRACE_EXIT, "%s", __func__);
-        return TRUE;
-}
-
-#if !GLIB_CHECK_VERSION(2,12,0)
-/*! \brief g_hash_table_foreach_remove foreach function
@@ -218 +71 @@
-#endif
-
-
+ reported entries
- * 
- * You can ask the hashtable to detect the changes. In the end you can
@@ -229 +82 @@
- * 
- */
-
+static 
-{
-        osync_trace(TRACE_ENTRY, "%s(%p)", __func__, table);
@@ -238 +91 @@
-           Don't flush the real database. */
-#if GLIB_CHECK_VERSION(2,12,0)
-us
+report
-#else
-us
+report
-#endif
-        
@@ -246 +99 @@
-}
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-{
-        osync_trace(TRACE_ENTRY, "%s(%p)", __func__, table);
-        osync_assert(table);
-        osync_assert(table->dbhandle);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-/*! @brief Report a item
@@ -444 +129 @@
- * 
- * @param table The hashtable
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        osync_trace(TRACE_ENTRY, "%s(%p)", __func__, table);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-        }
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
- * 
- * This function does not report the object so if you only use this function then
@@ -504 +526 @@
- * @param table The hashtable
- * @param uid The uid to lookup
-hash The hash to compare
+newhash The new hash to compare with the stored hash
- * @returns The changetype
- * 
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        
-        if (orighash) {
-
+new
-                        retval = OSYNC_CHANGE_TYPE_UNMODIFIED;
-                else
@@ -534 +553 @@
-                retval = OSYNC_CHANGE_TYPE_ADDED;
-
-        g_free(orighash);
-        
-        osync_trace(TRACE_EXIT, "%s: %i", __func__, retval);
@@ -540 +558 @@
-}
-
+unsigned int osync_hashtable_num_entries(OSyncHashTable *table)
+{
+        osync_assert(table);
+        return g_hash_table_size(table->db_entries);
+}
+
+void osync_hashtable_foreach(OSyncHashTable *table, OSyncHashtableForEach func, void *user_data)
+{
+        osync_assert(table);
+        g_hash_table_foreach(table->db_entries, (GHFunc) func, user_data);
+}
+
+const char *osync_hashtable_get_hash(OSyncHashTable *table, const char *uid)
+{
+        osync_assert(table);
+        osync_assert(uid);
+
+        return (const char *)  g_hash_table_lookup(table->db_entries, uid);
+}
+
-/*@}*/

trunk/opensync/helper/opensync_hashtable.h

@@ -2 +2 @@
- * libopensync - A synchronization framework
- * Copyright (C) 2004-2005  Armin Bauer <armin.bauer@opensync.org>
+ * Copyright (C) 2008  Daniel Gollub <dgollub@suse.de>
- * 
- * This library is free software; you can redistribute it and/or
@@ -22 +23 @@
-#define OPENSYNC_HASHTABLE_H_
-
+typedef void (*OSyncHashtableForEach) (const char *uid, const char *hash, void *user_data);
+
-OSYNC_EXPORT OSyncHashTable *osync_hashtable_new(const char *path, const char *objtype, OSyncError **error);
-
+
+
+
+
+
+
-
-OSYNC_EXPORT osync_bool osync_hashtable_slowsync(OSyncHashTable *table, OSyncError **error);
-
-
-
-
-
-
+
+
-
-
-
+
-
-
-
-
+
+
+
+
+
+
-
-#endif /* OPENSYNC_HASHTABLE_H_ */

trunk/opensync/helper/opensync_hashtable_internals.h

@@ -23 +23 @@
-#define _OPENSYNC_HASHTABLE_INTERNALS_H_
-
+#define OSYNC_HASHTABLE_DB_PREFIX "tbl_hash_"
+
-/*! @brief Represent a hashtable which can be used to check if changes have been modifed or deleted */
-struct OSyncHashTable {
+        int ref_count;
-        OSyncDB *dbhandle;
-
-
+
+
+
+
+
+
+
+
+
-};
-