Merge lp:~aauzi/midori/fix-1179200 into lp:midori

[André Auzi]

[Cris Dywan (kalikiana)]

- if (item->parent)
- katze_array_update ((KatzeArray*)item->parent);
+ if (item->parent && g_strcmp0(icon, picon))
+ katze_array_update_item ((KatzeArray*)item->parent, item);

katze_array_update_item replaces katze_array_update if I see correctly, so that should be mentioned by marking the old one as Deprecated for clarity.

The checks like g_strcmp0(icon, picon) seem to avoid updating if nothing changed - in that case, why not do this for all values in each function?

[Cris Dywan (kalikiana)]

A side note on the comment "panels/midori-bookmarks seems to be a view": yes, historically the code is badly mixed, in an ideal world both the panel and the toolbar should be independent views. Much like the Transfers extension these days.

[André Auzi (aauzi)]

> - if (item->parent)
> - katze_array_update ((KatzeArray*)item->parent);
> + if (item->parent && g_strcmp0(icon, picon))
> + katze_array_update_item ((KatzeArray*)item->parent, item);
>
> katze_array_update_item replaces katze_array_update if I see correctly, so
> that should be mentioned by marking the old one as Deprecated for clarity.

Not exactly... I kept the update for one purpose, the update of the whole data structure.

Basically here, the update in the bookmark panel, clears the whole tree and reloads it.

It thought this use case was still needed for features like bookmark imports, especially the way it is still designed.

Basically, the array_tree is a container. update is signal signaling an item and its containees, update_item only the item.

You probably have noticed that the update_item in the panel basically:
* finds the item in the tree
* unlinks it from where it is
* finds its new parent
* and relinks the item at its new position.

It doesn't do much if the item and its new parent is not visible.

So far, the bookmark bar does not implement such behaviour, it only refresh the whol bar on item change. This would probablye have to be changed for correct DND reordering of the bookmark bar.

> The checks like g_strcmp0(icon, picon) seem to avoid updating if nothing
> changed - in that case, why not do this for all values in each function?

Well, I didn't do it because it would most probably generate a lot of useless signal traffic.
The design I choose make midori/midori-bookmarks robust to poor design that would do multiple updates of the items but I wouldn't not encourage it. I like the speed of midori as it is.

I therefore just kept the automatic signal of the container on containee change where it was in place (I believe it's due to site title and favicon update after page load, isn't it?)

[André Auzi (aauzi)]

> A side note on the comment "panels/midori-bookmarks seems to be a view": yes,
> historically the code is badly mixed, in an ideal world both the panel and the
> toolbar should be independent views. Much like the Transfers extension these
> days.

Yes, I've identified the Model-View-Controller design pattern in the way the code is organised:
* the data base is the Model
* the midori/midori-bookmarks is the Controller
* and bookmarkbar and bookmarkpanel are Views of this model.

With this design pattern actions on the model should go through the controller and that's what I've implemented for delete and update.
I did not do it for insert for two reasons:
1. I didn't intend to change the whole design. I believe there are historical reasons to designs decision that may not be obvious on quick examination. The less I touch the better everybody is :)
2. I do not have a satisfying solution for the provision of the parentid on the insert of a child item I've seen in the file import. No solution => no change.

[Cris Dywan (kalikiana)]

> > The checks like g_strcmp0(icon, picon) seem to avoid updating if nothing
> > changed - in that case, why not do this for all values in each function?

> Well, I didn't do it because it would most probably generate a lot of useless signal traffic.
> The design I choose make midori/midori-bookmarks robust to poor design that would do multiple updates of the > items but I wouldn't not encourage it. I like the speed of midori as it is.

> I therefore just kept the automatic signal of the container on containee change where it was in place
> (I believe it's due to site title and favicon update after page load, isn't it?)

What I meant was to wrap the whole of the values that change, for example:

{
     gchar* pname;
     g_return_if_fail (KATZE_IS_ITEM (item));
     pname = item->name;
     if (item->parent && g_strcmp0(name, pname))
     {
         katze_assign (item->name, g_strdup (name));
         katze_array_update((KatzeArray*)item->parent);
         g_object_notify (G_OBJECT (item), "name");
     }
}

I also realize you're doing "pname = item->name" before g_return_if_fail - don't, it will crash if the assertion is hit. Do it as I do above to be on the safe side.

[André Auzi (aauzi)]

> What I meant was to wrap the whole of the values that change, for example:
>
> {
> gchar* pname;
> g_return_if_fail (KATZE_IS_ITEM (item));
> pname = item->name;
> if (item->parent && g_strcmp0(name, pname))
> {
> katze_assign (item->name, g_strdup (name));
> katze_array_update((KatzeArray*)item->parent);
> g_object_notify (G_OBJECT (item), "name");
> }
> }
>
> I also realize you're doing "pname = item->name" before g_return_if_fail -
> don't, it will crash if the assertion is hit. Do it as I do above to be on the
> safe side.

OK, understood and agreed.
I will change that.

[André Auzi (aauzi)]

> > A side note on the comment "panels/midori-bookmarks seems to be a view":
> yes,
> > historically the code is badly mixed, in an ideal world both the panel and
> the
> > toolbar should be independent views. Much like the Transfers extension these
> > days.
>
> Yes, I've identified the Model-View-Controller design pattern in the way the
> code is organised:
> * the data base is the Model
> * the midori/midori-bookmarks is the Controller
> * and bookmarkbar and bookmarkpanel are Views of this model.
>
> With this design pattern actions on the model should go through the controller
> and that's what I've implemented for delete and update.
> I did not do it for insert for two reasons:

Let's do a little follow up on this topic.

Thanks to your remark in Bug #1185595 I felt encouraged to investigate the way bookmarks are retrieved from the database.

My investigations led me to two observations:
 1- katze_array_query_recursive is specialized to "bookmarks" table query due to the fact that the bookmarks table name is hard encoded in it
 2- katze_array_query_recursize lacks the feature of identifying folders item and populate them as katze_array of type KATZE_TYPE_ITEM.

My conclusions are the following:
 1- katze_array_query_recursive should be replaced by something like midori_bookmarks_query_recursive
 2- midori_bookmarks_query_recursive should allways select the column 'uri' of bookmarks in order to identify a folder item
 3- it should then parse the result rows for 'uri' value in order to determine if it can populate a katze_item or a katze_array of type KATZE_TYPE_ITEM

The connection with this bug fix proposal is the following.

The new function midori_bookmarks_query_recursive should be implemented in what I identify as the data base controller: midory/midory-bookmarks.c.

This would allow us to implement one additional steps forward in the direction of convergence of the bookmarks data and fix a concern pfor and I share, the triplication of data between bookmarks menu, bookmarkbar item and bookmarks side panel.

The hash table I used to implement packing of updates, or something similar, can also be used for items retrieval, before populating new items, midori_bookmarks_query_recursive should search the bookmarks array for their existence and only populate a new one a last resort.

Of course, the rows data should be inserted in an existing item, different client view may need different metadata.

To integrate well with the existing fix proposal, midori_bookmarks_query_recursive should flush the pending updates.

pfor, again, tipped me on how this flush could be sped up further: updates should be enclosed into SQLite transactions.

Finally, I was mentioning I did not have a solution for the insert, I think it is not the case anymore.

The katze_array_add_item callback of midori/midori-bookmarks.c should actually process the item added in order to make them available in the bookmarks array hash table.

This callback should change a folder implemented in katze_item into an empty katze_array of type
 KATZE_ARRAY_ITEM before inserting it in the database

It should also go through a katze_array of type KATZE_ARRAY:
 1- insert all child bookm...

[André Auzi (aauzi)]

> The consequences on the client views are the following:
> 1- they should ignore add_item of katze_array which are not type
> KATZE_TYPE_ITEM
> 2- they should ignore add_item of katze_item of a folder
>

Additional note:

The consequence on client side may be totally removed if midori_bookmarks derives from katze_array and implements the preprocessing of folders (convert in katze_array of type KATZE_ARRAY_ITEM) and the population of the content of a katze_array is done in a specialization of katze_array_add_item.

By doing so we could ensure that *valid* items would be signaled to the client views.

[André Auzi (aauzi)]

Ok, I've prototyped the ideas shared in the previous comment.

Now, all the database operations are implemented in midori/midori-bookmarks.c using transactions.

The result is impressive, my 883 bookmarks are now imported in #500ms where it was previously taking more than 6s.

The katze_array_query(_recursive) are now replaced by a fixed midori_bookmarks_query_recursive which ensures that the items are not duplicated between the different views.

Well, this is not clean code yet (far from it) but I was so excited by the impressive improvement that I wanted to share it for maybe some stress test feedback.

I therefore resubmit it as it is and will implement suggested changes in a clean update.

review: Needs Resubmitting

[André Auzi (aauzi)]

Well, this is now clean enough.

[lp:~aauzi/midori/fix-1179200]

6179. By André Auzi on 2013-06-11

implement complete derivation from KatzeArray for proper database interaction.
midori/midori-bookmarks.[ch] -> midori/midori-bookmarks-db.[ch]
class MidoriBookmarksDb created.

6180. By André Auzi on 2013-06-11

merge lp:midori
move midori_array_count_recursive into midori_bookmarks_db_count_recursive

6181. By André Auzi on 2013-06-15

fix relay method selection

6182. By André Auzi on 2013-06-18

revert changes in katze-item and katze-array,
localize them in midori-bookmarks-db

6183. By André Auzi on 2013-06-18

merge lp:midori

6184. By André Auzi on 2013-06-18

insert change 6208 from lp:midori

6185. By André Auzi on 2013-06-18

cosmetics coding style

6186. By André Auzi on 2013-06-18

adapt bookmarks unit tests and fix add item issue

6187. By André Auzi on 2013-06-18

cleanup update_item implementation

6188. By André Auzi on 2013-07-09

merge lp:midori

6189. By André Auzi on 2013-08-05

merge lp:midori

6190. By André Auzi on 2013-08-05

fix potential memory leak

Unmerged revisions

6190. By André Auzi on 2013-08-05

fix potential memory leak

6189. By André Auzi on 2013-08-05

merge lp:midori

6188. By André Auzi on 2013-07-09

merge lp:midori

6187. By André Auzi on 2013-06-18

cleanup update_item implementation

6186. By André Auzi on 2013-06-18

adapt bookmarks unit tests and fix add item issue

6185. By André Auzi on 2013-06-18

cosmetics coding style

6184. By André Auzi on 2013-06-18

insert change 6208 from lp:midori

6183. By André Auzi on 2013-06-18

merge lp:midori

6182. By André Auzi on 2013-06-18

revert changes in katze-item and katze-array,
localize them in midori-bookmarks-db

6181. By André Auzi on 2013-06-15

fix relay method selection

=== modified file 'katze/katze-array.c'
--- katze/katze-array.c	2012-08-08 23:02:56 +0000
+++ katze/katze-array.c	2013-06-11 20:53:24 +0000
@@ -25,40 +25,11 @@
  * #KatzeArray is a type aware container for items.
  */
 
-struct _KatzeArray
-{
-    KatzeItem parent_instance;
-
-    GType type;
-    GList* items;
-};
-
-struct _KatzeArrayClass
-{
-    KatzeItemClass parent_class;
-
-    /* Signals */
-    void
-    (*add_item)               (KatzeArray* array,
-                               gpointer    item);
-    void
-    (*remove_item)            (KatzeArray* array,
-                               gpointer    item);
-    void
-    (*move_item)              (KatzeArray* array,
-                               gpointer    item,
-                               gint        index);
-    void
-    (*clear)                  (KatzeArray* array);
-
-    void
-    (*update)                 (KatzeArray* array);
-};
-
 G_DEFINE_TYPE (KatzeArray, katze_array, KATZE_TYPE_ITEM);
 
 enum {
     ADD_ITEM,
+    UPDATE_ITEM,
     REMOVE_ITEM,
     MOVE_ITEM,
     CLEAR,
@@ -95,6 +66,13 @@
 }
 
 static void
+_katze_array_update_item (KatzeArray* array,
+			  gpointer    item)
+{
+    _katze_array_update (array);
+}
+
+static void
 _katze_array_remove_item (KatzeArray* array,
                           gpointer   item)
 {
@@ -147,6 +125,17 @@
         G_TYPE_NONE, 1,
         G_TYPE_POINTER);
 
+    signals[UPDATE_ITEM] = g_signal_new (
+        "update-item",
+        G_TYPE_FROM_CLASS (class),
+        (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+        G_STRUCT_OFFSET (KatzeArrayClass, update_item),
+        0,
+        NULL,
+        g_cclosure_marshal_VOID__POINTER,
+        G_TYPE_NONE, 1,
+        G_TYPE_POINTER);
+
     signals[REMOVE_ITEM] = g_signal_new (
         "remove-item",
         G_TYPE_FROM_CLASS (class),
@@ -213,6 +202,7 @@
     gobject_class->finalize = katze_array_finalize;
 
     class->add_item = _katze_array_add_item;
+    class->update_item = _katze_array_update_item;
     class->remove_item = _katze_array_remove_item;
     class->move_item = _katze_array_move_item;
     class->clear = _katze_array_clear;
@@ -301,6 +291,23 @@
 }
 
 /**
+ * katze_array_update_item:
+ * @array: a #KatzeArray
+ * @item: an item
+ *
+ * Notify an update of the item of the array.
+ *
+ **/
+void
+katze_array_update_item (KatzeArray* array,
+                      gpointer    item)
+{
+    g_return_if_fail (KATZE_IS_ARRAY (array));
+
+    g_signal_emit (array, signals[UPDATE_ITEM], 0, item);
+}
+
+/**
  * katze_array_remove_item:
  * @array: a #KatzeArray
  * @item: an item

=== modified file 'katze/katze-array.h'
--- katze/katze-array.h	2011-01-19 20:58:26 +0000
+++ katze/katze-array.h	2013-06-11 20:53:24 +0000
@@ -32,6 +32,39 @@
 typedef struct _KatzeArray                       KatzeArray;
 typedef struct _KatzeArrayClass                  KatzeArrayClass;
 
+struct _KatzeArray
+{
+    KatzeItem parent_instance;
+
+    GType type;
+    GList* items;
+};
+
+struct _KatzeArrayClass
+{
+    KatzeItemClass parent_class;
+
+    /* Signals */
+    void
+    (*add_item)               (KatzeArray* array,
+                               gpointer    item);
+    void
+    (*update_item)            (KatzeArray* array,
+                               gpointer    item);
+    void
+    (*remove_item)            (KatzeArray* array,
+                               gpointer    item);
+    void
+    (*move_item)              (KatzeArray* array,
+                               gpointer    item,
+                               gint        index);
+    void
+    (*clear)                  (KatzeArray* array);
+
+    void
+    (*update)                 (KatzeArray* array);
+};
+
 GType
 katze_array_get_type               (void) G_GNUC_CONST;
 
@@ -47,6 +80,10 @@
                                     gpointer      item);
 
 void
+katze_array_update_item            (KatzeArray*   array,
+                                    gpointer      item);
+
+void
 katze_array_remove_item            (KatzeArray*   array,
                                     gpointer      item);
 

=== modified file 'katze/katze-item.c'
--- katze/katze-item.c	2013-05-31 22:00:38 +0000
+++ katze/katze-item.c	2013-06-11 20:53:24 +0000
@@ -316,9 +316,12 @@
 {
     g_return_if_fail (KATZE_IS_ITEM (item));
 
+    if (!g_strcmp0 (item->name, name))
+        return;
+
     katze_assign (item->name, g_strdup (name));
     if (item->parent)
-        katze_array_update ((KatzeArray*)item->parent);
+        katze_array_update_item ((KatzeArray*)item->parent, item);
     g_object_notify (G_OBJECT (item), "name");
 }
 
@@ -420,9 +423,12 @@
 {
     g_return_if_fail (KATZE_IS_ITEM (item));
 
+    if (!g_strcmp0 (katze_item_get_meta_string (item, "icon"), icon))
+        return;
+
     katze_item_set_meta_string (item, "icon", icon);
     if (item->parent)
-        katze_array_update ((KatzeArray*)item->parent);
+        katze_array_update_item ((KatzeArray*)item->parent, item);
     g_object_notify (G_OBJECT (item), "icon");
 }
 

=== modified file 'midori/midori-array.c'
--- midori/midori-array.c	2013-05-30 21:57:04 +0000
+++ midori/midori-array.c	2013-06-11 20:53:24 +0000
@@ -97,15 +97,15 @@
         if (katze_str_equal ((gchar*)cur->name, "title"))
         {
             gchar* value = g_strstrip ((gchar*)xmlNodeGetContent (cur));
+            katze_item_set_name (KATZE_ITEM (array), value);
+            xmlFree (value);
+        }
+        else if (katze_str_equal ((gchar*)cur->name, "desc"))
+        {
+            gchar* value = g_strstrip ((gchar*)xmlNodeGetContent (cur));
             katze_item_set_text (KATZE_ITEM (array), value);
             xmlFree (value);
         }
-        else if (katze_str_equal ((gchar*)cur->name, "desc"))
-        {
-            gchar* value = g_strstrip ((gchar*)xmlNodeGetContent (cur));
-            katze_item_set_name (KATZE_ITEM (array), value);
-            xmlFree (value);
-        }
         else if (katze_str_equal ((gchar*)cur->name, "info"))
             katze_xbel_parse_info ((KatzeItem*)array, cur);
         else if (katze_str_equal ((gchar*)cur->name, "folder"))
@@ -986,7 +986,17 @@
     return FALSE;
 }
 
-static void
+/**
+ * katze_item_set_value_from_columne:
+ * @stmt: prepared statement
+ * @column: column to read
+ * @item: #KatzeItem to populate
+ *
+ * Stores the column in the given #KatzeItem.
+ *
+ * Since: 0.2.7
+ **/
+void
 katze_item_set_value_from_column (sqlite3_stmt* stmt,
                                   gint          column,
                                   KatzeItem*    item)
@@ -1103,244 +1113,3 @@
     return katze_array_from_statement (stmt);
 }
 
-/**
- * midori_array_query_recursive:
- * @array: the main bookmark array
- * @fields: comma separated list of fields
- * @condition: condition, like "folder = '%q'"
- * @value: a value to be inserted if @condition contains %q
- * @recursive: if %TRUE include children
- *
- * Stores the result in a #KatzeArray.
- *
- * Return value: a #KatzeArray on success, %NULL otherwise
- *
- * Since: 0.4.4
- **/
-KatzeArray*
-midori_array_query_recursive (KatzeArray*  bookmarks,
-                              const gchar* fields,
-                              const gchar* condition,
-                              const gchar* value,
-                              gboolean     recursive)
-{
-    sqlite3* db;
-    gchar* sqlcmd;
-    char* sqlcmd_value;
-    KatzeArray* array;
-    KatzeItem* item;
-    GList* list;
-
-    g_return_val_if_fail (KATZE_IS_ARRAY (bookmarks), NULL);
-    g_return_val_if_fail (fields, NULL);
-    g_return_val_if_fail (condition, NULL);
-    db = g_object_get_data (G_OBJECT (bookmarks), "db");
-    g_return_val_if_fail (db != NULL, NULL);
-
-    sqlcmd = g_strdup_printf ("SELECT %s FROM bookmarks WHERE %s "
-                              "ORDER BY (uri='') ASC, title DESC", fields, condition);
-    if (strstr (condition, "%q"))
-    {
-        sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
-        array = katze_array_from_sqlite (db, sqlcmd_value);
-        sqlite3_free (sqlcmd_value);
-    }
-    else
-        array = katze_array_from_sqlite (db, sqlcmd);
-    g_free (sqlcmd);
-
-    if (!recursive)
-        return array;
-
-    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
-    {
-        if (KATZE_ITEM_IS_FOLDER (item))
-        {
-            gchar* parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
-                katze_item_get_meta_integer (item, "id"));
-            KatzeArray* subarray = midori_array_query_recursive (bookmarks,
-                fields, "parentid=%q", parentid, TRUE);
-            katze_item_set_name (KATZE_ITEM (subarray), katze_item_get_name (item));
-            katze_array_add_item (array, subarray);
-
-            g_free (parentid);
-        }
-    }
-    g_list_free (list);
-    return array;
-}
-
-/**
- * midori_array_query:
- * @array: the main bookmark array
- * @fields: comma separated list of fields
- * @condition: condition, like "folder = '%q'"
- * @value: a value to be inserted if @condition contains %q
- *
- * Stores the result in a #KatzeArray.
- *
- * Return value: a #KatzeArray on success, %NULL otherwise
- *
- * Since: 0.4.3
- *
- * Deprecated: 0.4.4: Use midori_array_query_recursive() instead.
- **/
-KatzeArray*
-midori_array_query (KatzeArray*  bookmarks,
-                    const gchar* fields,
-                    const gchar* condition,
-                    const gchar* value)
-{
-    return midori_array_query_recursive (bookmarks, fields, condition, value, FALSE);
-}
-
-static gint64
-count_from_sqlite (sqlite3*     db,
-		   const gchar* sqlcmd)
-{
-    gint64 count = -1;
-    sqlite3_stmt* stmt;
-    gint result;
-    
-    result = sqlite3_prepare_v2 (db, sqlcmd, -1, &stmt, NULL);
-    if (result != SQLITE_OK)
-        return -1;
-
-    g_assert (sqlite3_column_count (stmt) == 1);
-    
-    if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
-	count = sqlite3_column_int64(stmt, 0);
-
-    sqlite3_clear_bindings (stmt);
-    sqlite3_reset (stmt);
-
-    return count;
-}
-
-static gint64
-midori_array_count_recursive_by_id (KatzeArray*  bookmarks,
-				    const gchar* condition,
-				    const gchar* value,
-				    gint64       id,
-				    gboolean     recursive)
-{
-    gint64 count = -1;
-    sqlite3* db;
-    gchar* sqlcmd;
-    char* sqlcmd_value;
-    sqlite3_stmt* stmt;
-    gint result;
-    GList* ids;
-    GList* iter_ids;
-
-    g_return_val_if_fail (condition, -1);
-    g_return_val_if_fail (KATZE_IS_ARRAY (bookmarks), -1);
-    db = g_object_get_data (G_OBJECT (bookmarks), "db");
-    g_return_val_if_fail (db != NULL, -1);
-
-    g_assert(!strstr("parentid", condition));
-
-    if (id > 0)
-	sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
-				  "WHERE parentid = %" G_GINT64_FORMAT " AND %s",
-				  id,
-				  condition);
-    else
-	sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
-				  "WHERE parentid IS NULL AND %s ",
-				  condition);
-
-    if (strstr (condition, "%q"))
-    {
-        sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
-        count = count_from_sqlite (db, sqlcmd_value);
-        sqlite3_free (sqlcmd_value);
-    }
-    else
-        count = count_from_sqlite (db, sqlcmd);
-
-    g_free (sqlcmd);
-
-    if (!recursive || (count < 0))
-        return count;
-
-    ids = NULL;
-
-    if (id > 0)
-	sqlcmd_value = sqlite3_mprintf (
-	    "SELECT id FROM bookmarks "
-	    "WHERE parentid = %" G_GINT64_FORMAT " AND uri = ''", id);
-    else
-	sqlcmd_value = sqlite3_mprintf (
-	    "SELECT id FROM bookmarks "
-	    "WHERE parentid IS NULL AND uri = ''");
-
-    if (sqlite3_prepare_v2 (db, sqlcmd_value, -1, &stmt, NULL) == SQLITE_OK)
-    {
-	g_assert (sqlite3_column_count (stmt) == 1);
-    
-	if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
-	{
-	    gint64* pid = g_new (gint64, 1);
-	    
-	    *pid = sqlite3_column_int64(stmt, 0);
-	    ids = g_list_append (ids, pid);
-	}
-	
-	sqlite3_clear_bindings (stmt);
-	sqlite3_reset (stmt);
-    }
-
-    sqlite3_free (sqlcmd_value);
-
-    iter_ids = ids;
-    while (iter_ids)
-    {
-	gint64 sub_count = midori_array_count_recursive_by_id (bookmarks,
-							       condition,
-							       value,
-							       *(gint64*)(iter_ids->data),
-							       recursive);
-	
-	if (sub_count < 0)
-	{
-	    g_list_free_full (ids, g_free);
-	    return -1;
-	}
-	
-	count += sub_count;
-	iter_ids = g_list_next (iter_ids);
-    }
-	
-    g_list_free_full (ids, g_free);
-    return count;
-}
-
-/**
- * midori_array_count_recursive:
- * @array: the main bookmark array
- * @condition: condition, like "folder = '%q'"
- * @value: a value to be inserted if @condition contains %q
- * @recursive: if %TRUE include children
- *
- * Return value: the number of elements on success, -1 otherwise
- *
- * Since: 0.5.2
- **/
-gint64
-midori_array_count_recursive (KatzeArray*  bookmarks,
-			      const gchar* condition,
-                              const gchar* value,
-			      KatzeItem*   folder,
-                              gboolean     recursive)
-{
-    gint64 id = -1;
-
-    g_return_val_if_fail (!folder || KATZE_ITEM_IS_FOLDER (folder), -1);
-    
-    id = folder ? katze_item_get_meta_integer (folder, "id") : 0;
-
-    return midori_array_count_recursive_by_id (bookmarks, condition,
-					       value, id,
-					       recursive);
-}

=== modified file 'midori/midori-array.h'
--- midori/midori-array.h	2013-05-21 21:46:26 +0000
+++ midori/midori-array.h	2013-06-11 20:53:24 +0000
@@ -27,31 +27,16 @@
                         const gchar* format,
                         GError**     error);
 
+void
+katze_item_set_value_from_column (sqlite3_stmt* stmt,
+                                  gint          column,
+                                  KatzeItem*    item);
+
 KatzeArray*
 katze_array_from_statement (sqlite3_stmt* stmt);
 
 KatzeArray*
-midori_array_query     (KatzeArray*  array,
-                        const gchar* fields,
-                        const gchar* condition,
-                        const gchar* value);
-
-KatzeArray*
-midori_array_query_recursive (KatzeArray*  array,
-                              const gchar* fields,
-                              const gchar* condition,
-                              const gchar* value,
-                              gboolean     recursive);
-
-KatzeArray*
 katze_array_from_sqlite (sqlite3*     db,
                          const gchar* sqlcmd);
 
-gint64
-midori_array_count_recursive (KatzeArray*  bookmarks,
-			      const gchar* condition,
-                              const gchar* value,
-			      KatzeItem*   folder,
-                              gboolean     recursive);
-
 #endif /* !__MIDORI_ARRAY_H__ */

=== renamed file 'midori/midori-bookmarks.c' => 'midori/midori-bookmarks-db.c'
--- midori/midori-bookmarks.c	2012-11-25 15:37:41 +0000
+++ midori/midori-bookmarks-db.c	2013-06-11 20:53:24 +0000
@@ -10,8 +10,8 @@
  See the file COPYING for the full license text.
 */
 
-#include "midori-bookmarks.h"
-#include "panels/midori-bookmarks.h"
+#include "midori-bookmarks-db.h"
+
 #include "midori-app.h"
 #include "midori-array.h"
 #include "sokoke.h"
@@ -25,42 +25,818 @@
     #include <unistd.h>
 #endif
 
-void
-midori_bookmarks_dbtracer (void*       dummy,
-                           const char* query)
-{
-    g_printerr ("%s\n", query);
-}
-
-void
-midori_bookmarks_add_item_cb (KatzeArray* array,
-                              KatzeItem*  item,
-                              sqlite3*    db)
-{
-    midori_bookmarks_insert_item_db (db, item,
-        katze_item_get_meta_integer (item, "parentid"));
-}
-
-void
-midori_bookmarks_remove_item_cb (KatzeArray* array,
-                                 KatzeItem*  item,
-                                 sqlite3*    db)
-{
-    gchar* sqlcmd;
-    char* errmsg = NULL;
-
-
-    sqlcmd = sqlite3_mprintf (
-            "DELETE FROM bookmarks WHERE id = %" G_GINT64_FORMAT ";",
+/**
+ * SECTION:midory-bookmarks-db
+ * @short_description: A #KatzeArray connected to a database
+ * @see_also: #KatzeArray
+ *
+ * #MidoriBookmarksDb is a #KatzeArray specialized for database
+ * interraction.
+ */
+
+struct _MidoriBookmarksDb
+{
+    KatzeArray  parent_instance;
+
+    sqlite3*    db;
+    GList*      pending_inserts;
+    GHashTable* pending_updates;
+    GHashTable* pending_deletes;
+    GHashTable* all_items;
+    gboolean    in_idle_func;
+};
+
+struct _MidoriBookmarksDbClass
+{
+    KatzeArrayClass parent_class;
+};
+
+G_DEFINE_TYPE (MidoriBookmarksDb, midori_bookmarks_db, KATZE_TYPE_ARRAY);
+
+static void
+_midori_bookmarks_db_add_item (KatzeArray* array,
+                               gpointer    item);
+
+static void
+_midori_bookmarks_db_update_item (KatzeArray* array,
+                                  gpointer    item);
+
+static void
+_midori_bookmarks_db_remove_item (KatzeArray* array,
+                                  gpointer   item);
+
+static void
+_midori_bookmarks_db_move_item (KatzeArray* array,
+                                gpointer    item,
+                                gint        position);
+
+static void
+_midori_bookmarks_db_clear (KatzeArray* array);
+
+static void
+midori_bookmarks_db_force_idle (MidoriBookmarksDb* bookmarks);
+
+static void
+midori_bookmarks_db_finalize (GObject* object);
+
+static gint64
+midori_bookmarks_db_insert_item_db (sqlite3*   db,
+                                    KatzeItem* item,
+                                    gint64     parentid);
+
+static gboolean
+midori_bookmarks_db_update_item_db (sqlite3*   db,
+                                    KatzeItem* item);
+
+static gboolean
+midori_bookmarks_db_remove_item_db (sqlite3*   db,
+                                    KatzeItem* item);
+
+static guint
+item_hash (gconstpointer item)
+{
+    gint64 id = katze_item_get_meta_integer (KATZE_ITEM (item), "id");
+    return g_int64_hash (&id);
+}
+
+static gboolean
+item_equal (gconstpointer item_a, gconstpointer item_b)
+{
+    gint64 id_a = katze_item_get_meta_integer (KATZE_ITEM (item_a), "id");
+    gint64 id_b = katze_item_get_meta_integer (KATZE_ITEM (item_b), "id");
+    return (id_a == id_b)? TRUE : FALSE;
+}
+
+static void
+midori_bookmarks_db_class_init (MidoriBookmarksDbClass* class)
+{
+    GObjectClass* gobject_class;
+    KatzeArrayClass* katze_array_class;
+
+    gobject_class = G_OBJECT_CLASS (class);
+    gobject_class->finalize = midori_bookmarks_db_finalize;
+
+    katze_array_class = KATZE_ARRAY_CLASS (class);
+
+    katze_array_class->add_item = _midori_bookmarks_db_add_item;
+    katze_array_class->update_item = _midori_bookmarks_db_update_item;
+    katze_array_class->remove_item = _midori_bookmarks_db_remove_item;
+    katze_array_class->move_item = _midori_bookmarks_db_move_item;
+    katze_array_class->clear = _midori_bookmarks_db_clear;
+}
+
+static void
+midori_bookmarks_db_init (MidoriBookmarksDb* bookmarks)
+{
+    bookmarks->db = NULL;
+    bookmarks->pending_inserts = NULL;
+    bookmarks->pending_updates = g_hash_table_new (item_hash, item_equal);
+    bookmarks->pending_deletes = g_hash_table_new (item_hash, item_equal);
+    bookmarks->all_items = g_hash_table_new (item_hash, item_equal);
+
+    bookmarks->in_idle_func = FALSE;
+
+    katze_item_set_meta_integer (KATZE_ITEM (bookmarks), "id", 0);
+    g_hash_table_insert (bookmarks->all_items, bookmarks, bookmarks);
+    /* g_object_ref (bookmarks); */
+}
+
+static void
+midori_bookmarks_db_finalize (GObject* object)
+{
+    MidoriBookmarksDb* bookmarks = MIDORI_BOOKMARKS_DB (object);
+
+    if (bookmarks->db)
+    {
+        midori_bookmarks_db_force_idle (bookmarks);
+        sqlite3_close (bookmarks->db);
+    }
+
+    g_list_free (bookmarks->pending_inserts);
+    g_hash_table_unref (bookmarks->pending_updates);
+    g_hash_table_unref (bookmarks->pending_deletes);
+    g_hash_table_unref (bookmarks->all_items);
+
+    G_OBJECT_CLASS (midori_bookmarks_db_parent_class)->finalize (object);
+}
+
+/**
+ * midori_bookmarks_db_get_item_parent:
+ * @bookmarks: the main bookmarks array
+ * @item: a #KatzeItem
+ *
+ * Internal function that find the parent of the @item thanks to its %parentid
+ **/
+static KatzeArray*
+midori_bookmarks_db_get_item_parent (MidoriBookmarksDb* bookmarks,
+                                     gpointer    item)
+{
+    KatzeArray* parent;
+    gint64 parentid;
+
+    parentid = katze_item_get_meta_integer (KATZE_ITEM (item), "parentid");
+
+    if (parentid == 0)
+    {
+        parent = KATZE_ARRAY (bookmarks);
+    }
+    else
+    {
+        KatzeItem *search = katze_item_new ();
+
+        katze_item_set_meta_integer(search, "id", parentid);
+
+        parent = KATZE_ARRAY (g_hash_table_lookup (bookmarks->all_items, search));
+
+        g_object_unref (search);
+    }
+
+    return parent;
+}
+
+/**
+ * _midori_bookmarks_db_add_item:
+ * @array: the main bookmarks array
+ * @item: a #KatzeItem
+ *
+ * Internal function that overloads the #KatzeArray %katze_array_add_item().
+ * It relays the add item to the appropriate #KatzeArray.
+ **/
+static void
+_midori_bookmarks_db_add_item (KatzeArray* array,
+                               gpointer    item)
+{
+    MidoriBookmarksDb *bookmarks;
+    KatzeArray* parent;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    bookmarks = MIDORI_BOOKMARKS_DB (array);
+    g_return_if_fail (bookmarks->in_idle_func);
+
+    parent = katze_item_get_parent (KATZE_ITEM (item));
+
+    g_return_if_fail (!parent);
+
+    parent = midori_bookmarks_db_get_item_parent (bookmarks, item);
+
+    g_return_if_fail (parent);
+
+    KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->add_item (parent, item);
+}
+
+/**
+ * _midori_bookmarks_db_update_item:
+ * @array: the main bookmarks array
+ * @item: a #KatzeItem
+ *
+ * Internal function that overloads the #KatzeArray %katze_array_update_item().
+ * It relays the update item to the appropriate #KatzeArray.
+ **/
+static void
+_midori_bookmarks_db_update_item (KatzeArray* array,
+			                      gpointer    item)
+{
+    MidoriBookmarksDb *bookmarks;
+    KatzeArray* parent;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    bookmarks = MIDORI_BOOKMARKS_DB (array);
+    g_return_if_fail (bookmarks->in_idle_func);
+
+    parent = katze_item_get_parent (KATZE_ITEM (item));
+
+    g_return_if_fail (parent);
+
+    KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->update_item (parent, item);
+}
+
+/**
+ * _midori_bookmarks_db_remove_item:
+ * @array: the main bookmarks array
+ * @item: a #KatzeItem
+ *
+ * Internal function that overloads the #KatzeArray %katze_array_remove_item().
+ * It relays the remove item to the appropriate #KatzeArray.
+ **/
+static void
+_midori_bookmarks_db_remove_item (KatzeArray* array,
+                                  gpointer   item)
+{
+    MidoriBookmarksDb *bookmarks;
+    KatzeArray* parent;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    bookmarks = MIDORI_BOOKMARKS_DB (array);
+    g_return_if_fail (bookmarks->in_idle_func);
+
+    parent = katze_item_get_parent (KATZE_ITEM (item));
+
+    g_return_if_fail (parent);
+
+    KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->remove_item (parent, item);
+}
+
+/**
+ * _midori_bookmarks_db_move_item:
+ * @array: the main bookmarks array
+ * @item: a #KatzeItem
+ * @position: the new @item position
+ *
+ * Internal function that overloads the #KatzeArray %katze_array_move_item().
+ * It relays the move @item to the appropriate #KatzeArray.
+ **/
+static void
+_midori_bookmarks_db_move_item (KatzeArray* array,
+                                gpointer    item,
+                                gint        position)
+{
+    MidoriBookmarksDb *bookmarks;
+    KatzeArray* parent;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    parent = katze_item_get_parent (KATZE_ITEM (item));
+
+    g_return_if_fail (parent);
+
+    KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->move_item (parent, item, position);
+}
+
+/**
+ * _midori_bookmarks_db_clear:
+ * @array: the main bookmarks array
+ *
+ * Internal function that overloads the #KatzeArray %katze_array_clear().
+ * It deletes the whole bookmarks data.
+ **/
+static void
+_midori_bookmarks_db_clear (KatzeArray* array)
+{
+    MidoriBookmarksDb *bookmarks;
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+
+    bookmarks = MIDORI_BOOKMARKS_DB (array);
+
+    g_critical ("_midori_bookmarks_db_clear: not implemented\n");
+}
+
+/**
+ * midori_bookmarks_db_begin_transaction:
+ * @db: the removed #KatzeItem
+ *
+ * Internal function that starts an SQL transaction.
+ **/
+static gboolean
+midori_bookmarks_db_begin_transaction (sqlite3* db)
+{
+    char* errmsg = NULL;
+
+    if (sqlite3_exec (db, "BEGIN TRANSACTION;", NULL, NULL, &errmsg) != SQLITE_OK)
+    {
+        g_printerr (_("Failed to begin transaction: %s\n"), errmsg);
+        sqlite3_free (errmsg);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/**
+ * midori_bookmarks_db_end_transaction:
+ * @db: the removed #KatzeItem
+ * @commit : boolean
+ *
+ * Internal function that ends an SQL transaction.
+ * If @commit is %TRUE, the transaction is ended by a COMMIT.
+ * It is ended by a ROLLBACK otherwise.
+ **/
+static void
+midori_bookmarks_db_end_transaction (sqlite3* db, gboolean commit)
+{
+    char* errmsg = NULL;
+    if (sqlite3_exec (db, (commit ? "COMMIT;" : "ROLLBACK;"), NULL, NULL, &errmsg) != SQLITE_OK)
+    {
+        if (commit)
+            g_printerr (_("Failed to end transaction: %s\n"), errmsg);
+        else
+            g_printerr (_("Failed to cancel transaction: %s\n"), errmsg);
+        sqlite3_free (errmsg);
+    }
+}
+
+/**
+ * midori_bookmarks_db_add_item_recursive:
+ * @item: the removed #KatzeItem
+ * @bookmarks : the main bookmarks array
+ *
+ * Internal function that creates memory records of the added @item.
+ * If @item is a #KatzeArray, the function recursiveley adds records
+ * of all its childs.
+ **/
+static gint
+midori_bookmarks_db_add_item_recursive (MidoriBookmarksDb* bookmarks,
+                                        KatzeItem* item)
+{
+    GList* list;
+    KatzeArray* array;
+    gint64 id = 0;
+    gint count = 0;
+    gint64 parentid = katze_item_get_meta_integer (item, "parentid");
+
+    id = midori_bookmarks_db_insert_item_db (bookmarks->db, item, parentid);
+    count++;
+
+    g_object_ref (item);
+    g_hash_table_insert (bookmarks->all_items, item, item);
+
+    if (!KATZE_IS_ARRAY (item))
+        return count;
+
+    array = KATZE_ARRAY (item);
+
+    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
+    {
+        katze_item_set_meta_integer (item, "parentid", id);
+        count += midori_bookmarks_db_add_item_recursive (bookmarks, item);
+    }
+
+    g_list_free (list);
+    return count;
+}
+
+/**
+ * midori_bookmarks_db_remove_item_recursive:
+ * @item: the removed #KatzeItem
+ * @bookmarks : the main bookmarks array
+ *
+ * Internal function that removes memory records of the removed @item.
+ * If @item is a #KatzeArray, the function recursiveley removes records
+ * of all its childs.
+ **/
+static void
+midori_bookmarks_db_remove_item_recursive (KatzeItem*  item,
+                                           MidoriBookmarksDb* bookmarks)
+{
+    gint64 id = katze_item_get_meta_integer (item, "id");
+    GHashTableIter hash_iter;
+    gpointer key, value;
+    gpointer found;
+    KatzeArray* array;
+    KatzeItem* child;
+    GList* list;
+
+    if (NULL != (found = g_list_find (bookmarks->pending_inserts, item)))
+    {
+        g_object_unref (((GList*)found)->data);
+        bookmarks->pending_inserts = g_list_delete_link (bookmarks->pending_inserts,
+            ((GList*)found));
+    }
+
+    if (NULL != (found = g_hash_table_lookup (bookmarks->pending_updates, item)))
+    {
+        g_hash_table_remove (bookmarks->pending_updates, found);
+        g_object_unref (found);
+    }
+
+    if (NULL != (found = g_hash_table_lookup (bookmarks->all_items, item)))
+    {
+        g_hash_table_remove (bookmarks->all_items, found);
+        g_object_unref (found);
+    }
+
+    if (!KATZE_IS_ARRAY (item))
+        return;
+
+    array = KATZE_ARRAY (item);
+
+    KATZE_ARRAY_FOREACH_ITEM_L (child, array, list)
+    {
+        midori_bookmarks_db_remove_item_recursive (child, bookmarks);
+    }
+
+    g_list_free (list);
+}
+
+/**
+ * midori_bookmarks_db_idle_func:
+ * @data: the main bookmark array
+ *
+ * Internal function executed during idle time that Packs pending database 
+ * operations in one transaction.
+ *
+ * Pending operations are either:
+ * a. a list of pending add items,
+ *    all child #KatzeItem of a #KatzeArray are recursively added.
+ *    Each added #KatzeItem is memorized for future use.
+ *    (See %midori_bookmarks_db_array_from_statement())
+ * b. a hash table of items to update,
+ * c. or a hash table of items to remove
+ *    the database CASCADE on delete takes care of removal of the childs 
+ *    #KatzeItem of a #KatzeArray in the database 
+ *
+ * When database operations are done, the #KatzeArray equivalent operations
+ * are called to:
+ * 1. update the #KatzeArray tree content
+ * 2. signal the client views of the  #KatzeArray tree content change.
+ **/
+static gboolean
+midori_bookmarks_db_idle_func (gpointer data)
+{
+    GTimer *timer = g_timer_new();
+    gint count = 0;
+    gulong microseconds;
+    gboolean with_transaction;
+    MidoriBookmarksDb* bookmarks = MIDORI_BOOKMARKS_DB (data);
+    GList* list_iter;
+    GHashTableIter hash_iter;
+    gpointer key, value;
+
+    bookmarks->in_idle_func = TRUE;
+
+    g_timer_start (timer);
+
+    with_transaction = midori_bookmarks_db_begin_transaction (bookmarks->db);
+
+    for (list_iter = bookmarks->pending_inserts; list_iter; list_iter = g_list_next (list_iter))
+    {
+        KatzeItem *item = KATZE_ITEM (list_iter->data);
+
+        count += midori_bookmarks_db_add_item_recursive (bookmarks, item);
+        katze_array_add_item (KATZE_ARRAY (bookmarks), item);
+
+        g_object_unref (item);
+    }
+
+    g_hash_table_iter_init (&hash_iter, bookmarks->pending_updates);
+
+    while (g_hash_table_iter_next (&hash_iter, &key, &value))
+    {
+        KatzeItem *item = KATZE_ITEM (value);
+
+        midori_bookmarks_db_update_item_db (bookmarks->db, item);
+        katze_array_update_item (KATZE_ARRAY (bookmarks), item);
+        g_object_unref (item);
+        count++;
+    }
+
+    g_hash_table_iter_init (&hash_iter, bookmarks->pending_deletes);
+
+    while (g_hash_table_iter_next (&hash_iter, &key, &value))
+    {
+        KatzeItem *item = KATZE_ITEM (value);
+
+        midori_bookmarks_db_remove_item_db (bookmarks->db, item);
+        katze_array_remove_item (KATZE_ARRAY (bookmarks), item);
+        g_object_unref (item);
+        count++;
+    }
+
+    if (with_transaction)
+        midori_bookmarks_db_end_transaction (bookmarks->db, TRUE);
+
+    g_timer_elapsed (timer, &microseconds);
+    g_print ("midori_bookmarks_db_idle: %d DB operation(s) in %lu micro-seconds\n",
+        count, microseconds);
+
+    g_timer_destroy (timer);
+
+    g_hash_table_remove_all (bookmarks->pending_deletes);
+    g_hash_table_remove_all (bookmarks->pending_updates);
+    g_list_free (bookmarks->pending_inserts);
+    bookmarks->pending_inserts = NULL;
+
+    bookmarks->in_idle_func = FALSE;
+
+    return FALSE;
+}
+
+/**
+ * midori_bookmarks_db_idle_start:
+ * @bookmarks: the main bookmark array
+ *
+ * Internal function that checks whether idle processing is pending,
+ * if not, add a new one.
+ **/
+static void
+midori_bookmarks_db_idle_start (MidoriBookmarksDb* bookmarks)
+{
+    g_return_if_fail (bookmarks->db != NULL);
+
+    if (bookmarks->pending_inserts
+        || g_hash_table_size (bookmarks->pending_updates)
+        || g_hash_table_size (bookmarks->pending_deletes))
+        return;
+
+    g_idle_add (midori_bookmarks_db_idle_func, bookmarks);
+}
+
+/**
+ * midori_bookmarks_db_insert_item_db:
+ * @db: the #sqlite3
+ * @item: #KatzeItem the item to insert
+ *
+ * Internal function that does the actual SQL INSERT of the @item in @db.
+ *
+ * Since: 0.5.2
+ **/
+static gint64
+midori_bookmarks_db_insert_item_db (sqlite3*   db,
+                                    KatzeItem* item,
+                                    gint64     parentid)
+{
+    gchar* sqlcmd;
+    char* errmsg = NULL;
+    KatzeItem* old_parent;
+    gchar* new_parentid;
+    gchar* id = NULL;
+    const gchar* uri = NULL;
+    const gchar* desc = NULL;
+    gint64 seq = 0;
+
+    /* Bookmarks must have a name, import may produce invalid items */
+    g_return_val_if_fail (katze_item_get_name (item), seq);
+
+    if (!db)
+        return seq;
+
+    if (katze_item_get_meta_integer (item, "id") > 0)
+        id = g_strdup_printf ("%" G_GINT64_FORMAT, katze_item_get_meta_integer(item, "id"));
+    else
+        id = g_strdup_printf ("NULL");
+
+    if (KATZE_ITEM_IS_BOOKMARK (item))
+        uri = katze_item_get_uri (item);
+
+    if (katze_item_get_text (item))
+        desc = katze_item_get_text (item);
+
+    /* Use folder, otherwise fallback to parent folder */
+    old_parent = katze_item_get_parent (item);
+    if (parentid > 0)
+        new_parentid = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
+    else if (old_parent && katze_item_get_meta_integer (old_parent, "id") > 0)
+        new_parentid = g_strdup_printf ("%" G_GINT64_FORMAT, katze_item_get_meta_integer (old_parent, "id"));
+    else
+        new_parentid = g_strdup_printf ("NULL");
+
+    sqlcmd = sqlite3_mprintf (
+            "INSERT INTO bookmarks (id, parentid, title, uri, desc, toolbar, app) "
+            "VALUES (%q, %q, '%q', '%q', '%q', %d, %d)",
+            id,
+            new_parentid,
+            katze_item_get_name (item),
+            katze_str_non_null (uri),
+            katze_str_non_null (desc),
+            katze_item_get_meta_boolean (item, "toolbar"),
+            katze_item_get_meta_boolean (item, "app"));
+
+    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) == SQLITE_OK)
+    {
+        /* Get insert id */
+        if (g_str_equal (id, "NULL"))
+        {
+            KatzeArray* seq_array;
+
+            sqlite3_free (sqlcmd);
+            sqlcmd = sqlite3_mprintf (
+                    "SELECT seq FROM sqlite_sequence WHERE name = 'bookmarks'");
+
+            seq_array = katze_array_from_sqlite (db, sqlcmd);
+            if (katze_array_get_nth_item (seq_array, 0))
+            {
+                KatzeItem* seq_item = katze_array_get_nth_item (seq_array, 0);
+
+                seq = katze_item_get_meta_integer (seq_item, "seq");
+                katze_item_set_meta_integer (item, "id", seq);
+            }
+            g_object_unref (seq_array);
+        }
+    }
+    else
+    {
+        g_printerr (_("Failed to add bookmark item: %s\n"), errmsg);
+        sqlite3_free (errmsg);
+    }
+
+    sqlite3_free (sqlcmd);
+    g_free (new_parentid);
+    g_free (id);
+
+    return seq;
+}
+
+/**
+ * midori_bookmarks_db_update_item_db:
+ * @db: the #sqlite3
+ * @item: #KatzeItem the item to update
+ *
+ * Internal function that does the actual SQL UPDATE of the @item in @db.
+ *
+ * Since: 0.5.2
+ **/
+static gboolean
+midori_bookmarks_db_update_item_db (sqlite3*   db,
+                                 KatzeItem* item)
+{
+    gchar* sqlcmd;
+    char* errmsg = NULL;
+    gchar* parentid;
+    gboolean updated;
+
+    if (katze_item_get_meta_integer (item, "parentid") > 0)
+        parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
+                                    katze_item_get_meta_integer (item, "parentid"));
+    else
+        parentid = g_strdup_printf ("NULL");
+
+    sqlcmd = sqlite3_mprintf (
+            "UPDATE bookmarks SET "
+            "parentid=%q, title='%q', uri='%q', desc='%q', toolbar=%d, app=%d "
+            "WHERE id = %" G_GINT64_FORMAT ";",
+            parentid,
+            katze_item_get_name (item),
+            katze_str_non_null (katze_item_get_uri (item)),
+            katze_str_non_null (katze_item_get_meta_string (item, "desc")),
+            katze_item_get_meta_boolean (item, "toolbar"),
+            katze_item_get_meta_boolean (item, "app"),
             katze_item_get_meta_integer (item, "id"));
 
-    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
-    {
-        g_printerr (_("Failed to remove history item: %s\n"), errmsg);
-        sqlite3_free (errmsg);
-    }
-
-    sqlite3_free (sqlcmd);
+    updated = TRUE;
+    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
+    {
+        updated = FALSE;
+        g_printerr (_("Failed to update bookmark : %s\n"), errmsg);
+        sqlite3_free (errmsg);
+    }
+
+    sqlite3_free (sqlcmd);
+    g_free (parentid);
+
+    return updated;
+}
+
+/**
+ * midori_bookmarks_db_remove_item_db:
+ * @db: the #sqlite3
+ * @item: #KatzeItem the item to delete
+ *
+ * Internal function that does the actual SQL DELETE of the @item in @db.
+ *
+ * Since: 0.5.2
+ **/
+static gboolean
+midori_bookmarks_db_remove_item_db (sqlite3*    db,
+                                    KatzeItem*  item)
+{
+    char* errmsg = NULL;
+    gchar* sqlcmd;
+    gboolean removed = TRUE;
+
+    sqlcmd = sqlite3_mprintf (
+        "DELETE FROM bookmarks WHERE id = %" G_GINT64_FORMAT ";",
+        katze_item_get_meta_integer (item, "id"));
+
+    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
+    {
+        g_printerr (_("Failed to remove bookmark item: %s\n"), errmsg);
+        sqlite3_free (errmsg);
+        removed = FALSE;
+    }
+
+    sqlite3_free (sqlcmd);
+    return removed;
+}
+
+/**
+ * midori_bookmarks_db_add_item:
+ * @bookmarks: the main bookmark array
+ * @item: #KatzeItem the item to update
+ *
+ * Adds the @item in the bookmark data base.
+ *
+ * Since: 0.5.2
+ **/
+void
+midori_bookmarks_db_add_item (MidoriBookmarksDb* bookmarks, KatzeItem* item)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+    g_return_if_fail (NULL == katze_item_get_meta_string (item, "id"));
+
+    gpointer found = g_list_find (bookmarks->pending_inserts, item);
+
+    if (found)
+        return;
+
+    midori_bookmarks_db_idle_start (bookmarks);
+
+    g_object_ref (item);
+    bookmarks->pending_inserts = g_list_append (bookmarks->pending_inserts, item);
+}
+
+/**
+ * midori_bookmarks_db_update_item:
+ * @bookmarks: the main bookmark array
+ * @item: #KatzeItem the item to update
+ *
+ * Updates the @item in the bookmark data base.
+ *
+ * Since: 0.5.2
+ **/
+void
+midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks, KatzeItem* item)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+    g_return_if_fail (katze_item_get_meta_string (item, "id"));
+    g_return_if_fail (0 != katze_item_get_meta_integer (item, "id"));
+
+    gpointer found = g_hash_table_lookup (bookmarks->pending_updates, item);
+
+    if (found)
+        return;
+
+    midori_bookmarks_db_idle_start (bookmarks);
+
+    g_object_ref (item);
+    g_hash_table_insert (bookmarks->pending_updates, item, item);
+}
+
+/**
+ * midori_bookmarks_db_remove_item:
+ * @bookmarks: the main bookmark array
+ * @item: #KatzeItem the item to remove
+ *
+ * Removes the @item from the bookmark data base.
+ *
+ * Since: 0.5.2
+ **/
+void
+midori_bookmarks_db_remove_item (MidoriBookmarksDb* bookmarks, KatzeItem* item)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+    g_return_if_fail (katze_item_get_meta_string (item, "id"));
+    g_return_if_fail (0 != katze_item_get_meta_integer (item, "id"));
+
+    gpointer found = g_hash_table_lookup (bookmarks->pending_deletes, item);
+
+    if (found)
+        return;
+
+    midori_bookmarks_db_idle_start (bookmarks);
+
+    midori_bookmarks_db_remove_item_recursive (item, bookmarks);
+
+    g_object_ref (item);
+    g_hash_table_insert (bookmarks->pending_deletes, item, item);
 }
 
 #define _APPEND_TO_SQL_ERRORMSG(custom_errmsg) \
@@ -74,8 +850,8 @@
             g_string_append (errmsg_str, custom_errmsg); \
     } while (0)
 
-gboolean
-midori_bookmarks_import_from_old_db (sqlite3*     db,
+static gboolean
+midori_bookmarks_db_import_from_old_db (sqlite3*     db,
                                      const gchar* oldfile,
                                      gchar**      errmsg)
 {
@@ -130,8 +906,24 @@
 }
 #undef _APPEND_TO_SQL_ERRORMSG
 
-KatzeArray*
-midori_bookmarks_new (char** errmsg)
+static void
+midori_bookmarks_db_dbtracer (void*       dummy,
+                              const char* query)
+{
+    g_printerr ("%s\n", query);
+}
+
+/**
+ * midori_bookmarks_db_new:
+ *
+ * Initializes the bookmark data base.
+ *
+ * Returns: the main bookmarks array
+ *
+ * Since: 0.5.2
+ **/
+MidoriBookmarksDb*
+midori_bookmarks_db_new (char** errmsg)
 {
     sqlite3* db;
     gchar* oldfile;
@@ -141,6 +933,7 @@
     gchar* sql_errmsg = NULL;
     gchar* import_errmsg = NULL;
     KatzeArray* array;
+    MidoriBookmarksDb* bookmarks;
 
     g_return_val_if_fail (errmsg != NULL, NULL);
 
@@ -158,7 +951,7 @@
     }
 
     if (midori_debug ("bookmarks"))
-        sqlite3_trace (db, midori_bookmarks_dbtracer, NULL);
+        sqlite3_trace (db, midori_bookmarks_db_dbtracer, NULL);
 
     create_stmt =     /* Table structure */
         "CREATE TABLE IF NOT EXISTS bookmarks "
@@ -269,7 +1062,7 @@
 
     if (oldfile_exists)
         /* import from old db */
-        if (!midori_bookmarks_import_from_old_db (db, oldfile, &import_errmsg))
+        if (!midori_bookmarks_db_import_from_old_db (db, oldfile, &import_errmsg))
         {
             *errmsg = g_strdup_printf (_("Couldn't import from old database: %s\n"),
                 import_errmsg ? import_errmsg : "(err = NULL)");
@@ -279,13 +1072,11 @@
     init_success:
         g_free (newfile);
         g_free (oldfile);
-        array = katze_array_new (KATZE_TYPE_ARRAY);
-        g_signal_connect (array, "add-item",
-                          G_CALLBACK (midori_bookmarks_add_item_cb), db);
-        g_signal_connect (array, "remove-item",
-                          G_CALLBACK (midori_bookmarks_remove_item_cb), db);
-        g_object_set_data (G_OBJECT (array), "db", db);
-        return array;
+        bookmarks = MIDORI_BOOKMARKS_DB (g_object_new (TYPE_MIDORI_BOOKMARKS_DB, NULL));
+        bookmarks->db = db;
+
+        g_object_set_data (G_OBJECT (bookmarks), "db", db);
+        return bookmarks;
 
     init_failed:
         g_free (newfile);
@@ -297,31 +1088,384 @@
         return NULL;
 }
 
+/**
+ * midori_bookmarks_db_on_quit:
+ * @bookmarks: the main bookmark array
+ *
+ * Delete the main bookmark array.
+ *
+ * Since: 0.5.2
+ **/
 void
-midori_bookmarks_import (const gchar* filename,
-                         sqlite3*     db)
+midori_bookmarks_db_on_quit (MidoriBookmarksDb* bookmarks)
 {
-    KatzeArray* bookmarks;
-    GError* error = NULL;
-
-    bookmarks = katze_array_new (KATZE_TYPE_ARRAY);
-
-    if (!midori_array_from_file (bookmarks, filename, "xbel", &error))
-    {
-        g_warning (_("The bookmarks couldn't be saved. %s"), error->message);
-        g_error_free (error);
-        return;
-    }
-    midori_bookmarks_import_array_db (db, bookmarks, 0);
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+
+    g_object_unref (bookmarks);
 }
 
+/**
+ * midori_bookmarks_db_import_array:
+ * @array: the main bookmark array
+ * @array: #KatzeArray containing the items to import
+ * @parentid: the id of folder
+ *
+ * Imports the items of @array as childs of the folder
+ * identfied by @parentid.
+ *
+ * Since: 0.5.2
+ **/
 void
-midori_bookmarks_on_quit (KatzeArray* array)
+midori_bookmarks_db_import_array (MidoriBookmarksDb* bookmarks,
+                               KatzeArray* array,
+                               gint64      parentid)
 {
+    GList* list;
+    KatzeItem* item;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
     g_return_if_fail (KATZE_IS_ARRAY (array));
 
-    sqlite3* db = g_object_get_data (G_OBJECT (array), "db");
-    g_return_if_fail (db != NULL);
-    sqlite3_close (db);
-}
-
+    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
+    {
+        katze_item_set_meta_integer (item, "parentid", parentid);
+        midori_bookmarks_db_add_item (bookmarks, item);
+    }
+
+    g_list_free (list);
+}
+
+/**
+ * midori_bookmarks_db_force_idle:
+ * @array: the main bookmark array
+ *
+ * Internal function that checks if idle processing is pending.
+ * If it is the case, removes it from idle time processing and
+ * executes it immediately.
+ **/
+static void
+midori_bookmarks_db_force_idle (MidoriBookmarksDb* bookmarks)
+{
+    if (g_idle_remove_by_data (bookmarks))
+        midori_bookmarks_db_idle_func (bookmarks);
+}
+
+/**
+ * midori_bookmarks_db_array_from_statement:
+ * @stmt: the sqlite returned statement
+ * @bookmarks: the database controller
+ *
+ * Internal function that populate a #KatzeArray by processing the @stmt
+ * rows identifying:
+ * a- if the item is already in memory
+ *    in this case the item data is updated with retreived database content
+ *    and the already existing item is populated in the returned #KatzeArray
+ * b- if the data is a folder
+ *    a new #KatzeArray item is populated in the returned  #KatzeArray and
+ *    memorized for furure use.
+ * c- if the data is a bookmark
+ *    a new #KatzeItem item is populated in the returned  #KatzeArray and
+ *    memorized for furure use.
+ *
+ * Return value: the populated #KatzeArray
+ **/
+static KatzeArray*
+midori_bookmarks_db_array_from_statement (sqlite3_stmt* stmt,
+                                       MidoriBookmarksDb* bookmarks)
+{
+    KatzeArray *array;
+    gint result;
+    gint cols;
+
+    array = katze_array_new (KATZE_TYPE_ITEM);
+    cols = sqlite3_column_count (stmt);
+
+    while ((result = sqlite3_step (stmt)) == SQLITE_ROW)
+    {
+        gint i;
+        KatzeItem* item;
+        KatzeItem* found;
+
+        item = katze_item_new ();
+        for (i = 0; i < cols; i++)
+            katze_item_set_value_from_column (stmt, i, item);
+
+        if (NULL != (found = g_hash_table_lookup (bookmarks->all_items, item)))
+        {
+            for (i = 0; i < cols; i++)
+                katze_item_set_value_from_column (stmt, i, found);
+
+            g_object_unref (item);
+
+            item = found;
+        }
+        else if (KATZE_ITEM_IS_FOLDER (item))
+        {
+            item = KATZE_ITEM (katze_array_new (KATZE_TYPE_ITEM));
+
+            for (i = 0; i < cols; i++)
+                katze_item_set_value_from_column (stmt, i, item);
+
+            g_object_ref (item);
+            g_hash_table_insert (bookmarks->all_items, item, item);
+        }
+        else
+        {
+            g_object_ref (item);
+            g_hash_table_insert (bookmarks->all_items, item, item);
+        }
+
+        katze_array_add_item (array, item);
+    }
+
+    sqlite3_clear_bindings (stmt);
+    sqlite3_reset (stmt);
+    return array;
+}
+
+/**
+ * midori_bookmarks_db_array_from_sqlite:
+ * @array: the main bookmark array
+ * @sqlcmd: the sqlcmd to execute
+ *
+ * Internal function that first forces pending idle processing to update the
+ * database then process the requested @sqlcmd.
+ *
+ * Return value: a #KatzeArray on success, %NULL otherwise
+ **/
+static KatzeArray*
+midori_bookmarks_db_array_from_sqlite (MidoriBookmarksDb* bookmarks,
+                                    const gchar* sqlcmd)
+{
+    sqlite3_stmt* stmt;
+    gint result;
+
+    g_return_val_if_fail (bookmarks->db != NULL, NULL);
+
+    midori_bookmarks_db_force_idle (bookmarks);
+
+    result = sqlite3_prepare_v2 (bookmarks->db, sqlcmd, -1, &stmt, NULL);
+    if (result != SQLITE_OK)
+        return NULL;
+
+    return midori_bookmarks_db_array_from_statement (stmt, bookmarks);
+}
+
+/**
+ * midori_bookmarks_db_query_recursive:
+ * @array: the main bookmark array
+ * @fields: comma separated list of fields
+ * @condition: condition, like "folder = '%q'"
+ * @value: a value to be inserted if @condition contains %q
+ * @recursive: if %TRUE include children
+ *
+ * Stores the result in a #KatzeArray.
+ *
+ * Return value: a #KatzeArray on success, %NULL otherwise
+ *
+ * Since: 0.5.2
+ **/
+KatzeArray*
+midori_bookmarks_db_query_recursive (MidoriBookmarksDb*  bookmarks,
+                                  const gchar* fields,
+                                  const gchar* condition,
+                                  const gchar* value,
+                                  gboolean     recursive)
+{
+    gchar* sqlcmd;
+    char* sqlcmd_value;
+    KatzeArray* array;
+    KatzeItem* item;
+    GList* list;
+
+    g_return_val_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks), NULL);
+    g_return_val_if_fail (fields, NULL);
+    g_return_val_if_fail (condition, NULL);
+
+    sqlcmd = g_strdup_printf ("SELECT %s FROM bookmarks WHERE %s "
+                              "ORDER BY (uri='') ASC, title DESC", fields, condition);
+    if (strstr (condition, "%q"))
+    {
+        sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
+        array = midori_bookmarks_db_array_from_sqlite (bookmarks, sqlcmd_value);
+        sqlite3_free (sqlcmd_value);
+    }
+    else
+        array = midori_bookmarks_db_array_from_sqlite (bookmarks, sqlcmd);
+    g_free (sqlcmd);
+
+    if (!recursive)
+        return array;
+
+    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
+    {
+        if (KATZE_ITEM_IS_FOLDER (item))
+        {
+            gchar* parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
+                katze_item_get_meta_integer (item, "id"));
+            KatzeArray* subarray = midori_bookmarks_db_query_recursive (bookmarks,
+                fields, "parentid=%q", parentid, TRUE);
+            KatzeItem* subitem;
+            GList* sublist;
+
+            KATZE_ARRAY_FOREACH_ITEM_L (subitem, subarray, sublist)
+            {
+                katze_array_add_item (KATZE_ARRAY (item), subitem);
+            }
+
+            g_object_unref (subarray);
+            g_free (parentid);
+        }
+    }
+    g_list_free (list);
+    return array;
+}
+
+static gint64
+midori_bookmarks_db_count_from_sqlite (sqlite3*     db,
+                                       const gchar* sqlcmd)
+{
+    gint64 count = -1;
+    sqlite3_stmt* stmt;
+    gint result;
+
+    result = sqlite3_prepare_v2 (db, sqlcmd, -1, &stmt, NULL);
+    if (result != SQLITE_OK)
+        return -1;
+
+    g_assert (sqlite3_column_count (stmt) == 1);
+
+    if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
+        count = sqlite3_column_int64(stmt, 0);
+
+    sqlite3_clear_bindings (stmt);
+    sqlite3_reset (stmt);
+
+    return count;
+}
+
+static gint64
+midori_bookmarks_db_count_recursive_by_id (MidoriBookmarksDb*  bookmarks,
+				                           const gchar*        condition,
+				                           const gchar*        value,
+				                           gint64              id,
+				                           gboolean            recursive)
+{
+    gint64 count = -1;
+    gchar* sqlcmd;
+    char* sqlcmd_value;
+    sqlite3_stmt* stmt;
+    gint result;
+    GList* ids;
+    GList* iter_ids;
+
+    g_return_val_if_fail (condition, -1);
+    g_return_val_if_fail (MIDORI_BOOKMARKS_DB (bookmarks), -1);
+    g_return_val_if_fail (bookmarks->db != NULL, -1);
+
+    g_assert(!strstr("parentid", condition));
+
+    if (id > 0)
+        sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
+            "WHERE parentid = %" G_GINT64_FORMAT " AND %s",
+            id,
+            condition);
+    else
+        sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
+            "WHERE parentid IS NULL AND %s ",
+            condition);
+
+    if (strstr (condition, "%q"))
+    {
+        sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
+        count = midori_bookmarks_db_count_from_sqlite (bookmarks->db, sqlcmd_value);
+        sqlite3_free (sqlcmd_value);
+    }
+    else
+        count = midori_bookmarks_db_count_from_sqlite (bookmarks->db, sqlcmd);
+
+    g_free (sqlcmd);
+
+    if (!recursive || (count < 0))
+        return count;
+
+    ids = NULL;
+
+    if (id > 0)
+        sqlcmd_value = sqlite3_mprintf (
+            "SELECT id FROM bookmarks "
+            "WHERE parentid = %" G_GINT64_FORMAT " AND uri = ''", id);
+    else
+        sqlcmd_value = sqlite3_mprintf (
+            "SELECT id FROM bookmarks "
+            "WHERE parentid IS NULL AND uri = ''");
+
+    if (sqlite3_prepare_v2 (bookmarks->db, sqlcmd_value, -1, &stmt, NULL) == SQLITE_OK)
+    {
+        g_assert (sqlite3_column_count (stmt) == 1);
+
+        if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
+        {
+            gint64* pid = g_new (gint64, 1);
+
+            *pid = sqlite3_column_int64(stmt, 0);
+            ids = g_list_append (ids, pid);
+        }
+
+        sqlite3_clear_bindings (stmt);
+        sqlite3_reset (stmt);
+    }
+
+    sqlite3_free (sqlcmd_value);
+
+    iter_ids = ids;
+    while (iter_ids)
+    {
+        gint64 sub_count = midori_bookmarks_db_count_recursive_by_id (bookmarks,
+            condition,
+            value,
+            *(gint64*)(iter_ids->data),
+            recursive);
+
+        if (sub_count < 0)
+        {
+            g_list_free_full (ids, g_free);
+            return -1;
+        }
+
+        count += sub_count;
+        iter_ids = g_list_next (iter_ids);
+    }
+
+    g_list_free_full (ids, g_free);
+    return count;
+}
+
+/**
+ * midori_bookmarks_db_count_recursive:
+ * @bookmarks: the main bookmark array
+ * @condition: condition, like "folder = '%q'"
+ * @value: a value to be inserted if @condition contains %q
+ * @recursive: if %TRUE include children
+ *
+ * Return value: the number of elements on success, -1 otherwise
+ *
+ * Since: 0.5.2
+ **/
+gint64
+midori_bookmarks_db_count_recursive (MidoriBookmarksDb*  bookmarks,
+			                         const gchar*        condition,
+                                     const gchar*        value,
+			                         KatzeItem*          folder,
+                                     gboolean            recursive)
+{
+    gint64 id = -1;
+
+    g_return_val_if_fail (!folder || KATZE_ITEM_IS_FOLDER (folder), -1);
+
+    id = folder ? katze_item_get_meta_integer (folder, "id") : 0;
+
+    return midori_bookmarks_db_count_recursive_by_id (bookmarks, condition,
+        value, id,
+        recursive);
+}

=== renamed file 'midori/midori-bookmarks.h' => 'midori/midori-bookmarks-db.h'
--- midori/midori-bookmarks.h	2012-11-25 15:37:41 +0000
+++ midori/midori-bookmarks-db.h	2013-06-11 20:53:24 +0000
@@ -10,31 +10,70 @@
  See the file COPYING for the full license text.
 */
 
-#ifndef __MIDORI_BOOKMARKS_H__
-#define __MIDORI_BOOKMARKS_H__ 1
+#ifndef __MIDORI_BOOKMARKS_DB_H__
+#define __MIDORI_BOOKMARKS_DB_H__ 1
 
 #include <sqlite3.h>
 #include <katze/katze.h>
 
-void
-midori_bookmarks_add_item_cb (KatzeArray* array,
-                              KatzeItem*  item,
-                              sqlite3*    db);
-
-void
-midori_bookmarks_remove_item_cb (KatzeArray* array,
-                                 KatzeItem*  item,
-                                 sqlite3*    db);
+G_BEGIN_DECLS
+
+#define TYPE_MIDORI_BOOKMARKS_DB \
+    (midori_bookmarks_db_get_type ())
+#define MIDORI_BOOKMARKS_DB(obj) \
+    (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MIDORI_BOOKMARKS_DB, MidoriBookmarksDb))
+#define MIDORI_BOOKMARKS_DB_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MIDORI_BOOKMARKS_DB, MidoriBookmarksDbClass))
+#define IS_MIDORI_BOOKMARKS_DB(obj) \
+    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MIDORI_BOOKMARKS_DB))
+#define IS_MIDORI_BOOKMARKS_DB_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MIDORI_BOOKMARKS_DB))
+#define MIDORI_BOOKMARKS_DB_GET_CLASS(obj) \
+    (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MIDORI_BOOKMARKS_DB, MidoriBookmarksDbClass))
+
+typedef struct _MidoriBookmarksDb                       MidoriBookmarksDb;
+typedef struct _MidoriBookmarksDbClass                  MidoriBookmarksDbClass;
+
+GType
+midori_bookmarks_db_get_type               (void) G_GNUC_CONST;
+
+MidoriBookmarksDb*
+midori_bookmarks_db_new (char** errmsg);
+
+void
+midori_bookmarks_db_on_quit (MidoriBookmarksDb* array);
+
+void
+midori_bookmarks_db_add_item (MidoriBookmarksDb* bookmarks, KatzeItem* item);
+
+void
+midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks, KatzeItem* item);
+
+void
+midori_bookmarks_db_remove_item (MidoriBookmarksDb* bookmarks, KatzeItem* item);
+
+void
+midori_bookmarks_db_import_array (MidoriBookmarksDb* bookmarks,
+                                  KatzeArray* array,
+                                  gint64      parentid);
 
 KatzeArray*
-midori_bookmarks_new (char** errmsg);
-
-void
-midori_bookmarks_on_quit (KatzeArray* array);
-
-void
-midori_bookmarks_import (const gchar* filename,
-                         sqlite3*     db);
-
-#endif /* !__MIDORI_BOOKMARKS_H__ */
+midori_bookmarks_db_query_recursive (MidoriBookmarksDb*  bookmarks,
+                                     const gchar* fields,
+                                     const gchar* condition,
+                                     const gchar* value,
+                                     gboolean     recursive);
+
+gint64
+midori_bookmarks_db_count_recursive (MidoriBookmarksDb*  bookmarks,
+			                         const gchar*        condition,
+                                     const gchar*        value,
+			                         KatzeItem*          folder,
+    		                         gboolean            recursive);
+
+void
+midori_bookmarks_db_on_quit (MidoriBookmarksDb* array);
+
+
+#endif /* !__MIDORI_BOOKMARKS_DB_H__ */
 

=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2013-06-02 13:30:16 +0000
+++ midori/midori-browser.c	2013-06-11 20:53:24 +0000
@@ -26,6 +26,7 @@
 #include "midori-privatedata.h"
 #include "midori-core.h"
 #include "midori-privatedata.h"
+#include "midori-bookmarks-db.h"
 
 #include "marshal.h"
 
@@ -85,7 +86,7 @@
 
     MidoriWebSettings* settings;
     KatzeArray* proxy_array;
-    KatzeArray* bookmarks;
+    MidoriBookmarksDb* bookmarks;
     KatzeArray* trash;
     KatzeArray* search_engines;
     KatzeArray* history;
@@ -96,6 +97,8 @@
     gboolean show_statusbar;
     guint maximum_history_age;
     guint last_web_search;
+
+    gboolean bookmarkbar_populate;
 };
 
 G_DEFINE_TYPE (MidoriBrowser, midori_browser, GTK_TYPE_WINDOW)
@@ -162,20 +165,13 @@
                              GParamSpec* pspec);
 
 void
-midori_bookmarks_import_array_db (sqlite3*    db,
-                                  KatzeArray* array,
-                                  gint64      parentid);
-
-gboolean
-midori_bookmarks_update_item_db (sqlite3*   db,
-                                 KatzeItem* item);
-
-void
 midori_browser_open_bookmark (MidoriBrowser* browser,
                               KatzeItem*     item);
 
 static void
 midori_bookmarkbar_populate (MidoriBrowser* browser);
+static void
+midori_bookmarkbar_populate_idle (MidoriBrowser* browser);
 
 static void
 midori_bookmarkbar_clear (GtkWidget* toolbar);
@@ -203,8 +199,8 @@
                                 GtkToolbarStyle style);
 
 static void
-midori_browser_set_bookmarks (MidoriBrowser* browser,
-                              KatzeArray*    bookmarks);
+midori_browser_set_bookmarks (MidoriBrowser*     browser,
+                              MidoriBookmarksDb* bookmarks);
 
 static void
 midori_browser_add_speed_dial (MidoriBrowser* browser);
@@ -484,6 +480,9 @@
         inter = ZEITGEIST_ZG_DELETE_EVENT;
     else
         g_assert_not_reached ();
+    g_assert (KATZE_IS_ITEM (item));
+    if (KATZE_ITEM_IS_FOLDER (item))
+	return;
     zeitgeist_log_insert_events_no_reply (zeitgeist_log_get_default (),
         zeitgeist_event_new_full (inter, ZEITGEIST_ZG_USER_ACTIVITY,
                                   "application://midori.desktop",
@@ -817,7 +816,7 @@
 }
 
 static GtkWidget*
-midori_bookmark_folder_button_new (KatzeArray* array,
+midori_bookmark_folder_button_new (MidoriBookmarksDb* array,
                                    gboolean    new_bookmark,
                                    gint64      selected,
                                    gint64      parentid)
@@ -1059,18 +1058,13 @@
         katze_item_set_meta_integer (bookmark, "parentid", selected);
 
         if (new_bookmark)
-            katze_array_add_item (browser->bookmarks, bookmark);
+            midori_bookmarks_db_add_item (browser->bookmarks, bookmark);
         else
-            midori_bookmarks_update_item_db (db, bookmark);
-        midori_browser_update_history (bookmark, "bookmark", new_bookmark ? "create" : "modify");
+            midori_bookmarks_db_update_item (browser->bookmarks, bookmark);
 
-        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_toolbar)))
-            if (!gtk_widget_get_visible (browser->bookmarkbar))
-                _action_set_active (browser, "Bookmarkbar", TRUE);
         return_status = TRUE;
     }
-    if (gtk_widget_get_visible (browser->bookmarkbar))
-        midori_bookmarkbar_populate (browser);
+
     gtk_widget_destroy (dialog);
     return return_status;
 }
@@ -2321,7 +2315,7 @@
                                      "bookmarks",
                                      "Bookmarks",
                                      "The bookmarks folder, containing all bookmarks",
-                                     KATZE_TYPE_ARRAY,
+                                     TYPE_MIDORI_BOOKMARKS_DB,
                                      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
     /**
@@ -3096,8 +3090,8 @@
     else
         condition = "parentid = %q";
 
-    bookmarks = midori_array_query (browser->bookmarks,
-        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id);
+    bookmarks = midori_bookmarks_db_query_recursive (browser->bookmarks,
+        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, FALSE);
     if (!bookmarks)
         return FALSE;
 
@@ -4227,7 +4221,7 @@
     KatzeItem* item;
 
     item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
-    katze_array_remove_item (browser->bookmarks, item);
+    midori_bookmarks_db_remove_item (browser->bookmarks, item);
 }
 
 static void
@@ -4242,7 +4236,7 @@
     menu = gtk_menu_new ();
     if (KATZE_ITEM_IS_FOLDER (item))
     {
-        gint child_bookmarks_count = midori_array_count_recursive (browser->bookmarks,
+        gint child_bookmarks_count = midori_bookmarks_db_count_recursive (browser->bookmarks,
             "uri <> ''", NULL, item, FALSE);
 
         midori_browser_bookmark_popup_item (menu,
@@ -4497,8 +4491,7 @@
             if (error)
                 g_error_free (error);
         }
-        midori_bookmarks_import_array_db (db, bookmarks, selected);
-        katze_array_update (browser->bookmarks);
+        midori_bookmarks_db_import_array (browser->bookmarks, bookmarks, selected);
         g_object_unref (bookmarks);
         g_free (path);
     }
@@ -4552,7 +4545,7 @@
         return;
 
     error = NULL;
-    bookmarks = midori_array_query_recursive (browser->bookmarks,
+    bookmarks = midori_bookmarks_db_query_recursive (browser->bookmarks,
         "*", "parentid IS NULL", NULL, TRUE);
     if (!midori_array_to_file (bookmarks, path, format, &error))
     {
@@ -5979,6 +5972,21 @@
     }
 }
 
+static gboolean
+midori_browser_idle (gpointer data)
+{
+    MidoriBrowser* browser = MIDORI_BROWSER (data);
+
+    if (browser->bookmarkbar_populate)
+    {
+        midori_bookmarkbar_populate_idle (browser);
+
+        browser->bookmarkbar_populate = FALSE;
+    }
+
+    return FALSE;
+}
+
 static void
 midori_browser_init (MidoriBrowser* browser)
 {
@@ -6459,6 +6467,8 @@
     katze_object_assign (browser->history, NULL);
     katze_object_assign (browser->dial, NULL);
 
+    g_idle_remove_by_data (browser);
+
     G_OBJECT_CLASS (midori_browser_parent_class)->finalize (object);
 }
 
@@ -6973,7 +6983,7 @@
                                 KatzeItem* item)
 {
     MidoriBrowser* browser = midori_browser_get_for_widget (toolbar);
-    GtkAction* action = _action_by_name (browser, "Tools");
+    GtkAction* action = _action_by_name (browser, "Bookmarks");
     GtkToolItem* toolitem = katze_array_action_create_tool_item_for (
         KATZE_ARRAY_ACTION (action), item);
     g_object_set_data (G_OBJECT (toolitem), "KatzeItem", item);
@@ -6994,6 +7004,28 @@
 }
 
 static void
+midori_bookmarkbar_add_item_cb (KatzeArray*    bookmarks,
+				KatzeItem*     item,
+				MidoriBrowser* browser)
+{
+    if (gtk_widget_get_visible (browser->bookmarkbar))
+        midori_bookmarkbar_populate (browser);
+    else if (katze_item_get_meta_boolean (item, "toolbar"))
+	_action_set_active (browser, "Bookmarkbar", TRUE);
+    midori_browser_update_history (item, "bookmark", "created");
+}
+
+static void
+midori_bookmarkbar_update_item_cb (KatzeArray*    bookmarks,
+                                   KatzeItem*     item,
+                                   MidoriBrowser* browser)
+{
+    if (gtk_widget_get_visible (browser->bookmarkbar))
+        midori_bookmarkbar_populate (browser);
+    midori_browser_update_history (item, "bookmark", "modify");
+}
+
+static void
 midori_bookmarkbar_remove_item_cb (KatzeArray*    bookmarks,
                                    KatzeItem*     item,
                                    MidoriBrowser* browser)
@@ -7006,6 +7038,16 @@
 static void
 midori_bookmarkbar_populate (MidoriBrowser* browser)
 {
+    if (browser->bookmarkbar_populate)
+        return;
+    
+    g_idle_add (midori_browser_idle, browser);
+    browser->bookmarkbar_populate = TRUE;
+}
+
+static void
+midori_bookmarkbar_populate_idle (MidoriBrowser* browser)
+{
     KatzeArray* array;
     KatzeItem* item;
 
@@ -7015,8 +7057,8 @@
     gtk_toolbar_insert (GTK_TOOLBAR (browser->bookmarkbar),
                         gtk_separator_tool_item_new (), -1);
 
-    array = midori_array_query (browser->bookmarks,
-        "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL);
+    array = midori_bookmarks_db_query_recursive (browser->bookmarks,
+        "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL, FALSE);
     if (!array)
     {
         _action_set_sensitive (browser, "BookmarkAdd", FALSE);
@@ -7026,21 +7068,7 @@
 
     KATZE_ARRAY_FOREACH_ITEM (item, array)
     {
-        if (KATZE_ITEM_IS_BOOKMARK (item))
-            midori_bookmarkbar_insert_item (browser->bookmarkbar, item);
-        else
-        {
-            gint64 id = katze_item_get_meta_integer (item, "id");
-            gchar* parentid = g_strdup_printf ("%" G_GINT64_FORMAT, id);
-            KatzeArray* subfolder = midori_array_query (browser->bookmarks,
-                "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q AND uri != ''",
-                parentid);
-
-                katze_item_set_name (KATZE_ITEM (subfolder), katze_item_get_name (item));
-                katze_item_set_meta_integer (KATZE_ITEM (subfolder), "id", id);
-                midori_bookmarkbar_insert_item (browser->bookmarkbar, KATZE_ITEM (subfolder));
-            g_free (parentid);
-        }
+        midori_bookmarkbar_insert_item (browser->bookmarkbar, item);
     }
     _action_set_sensitive (browser, "BookmarkAdd", TRUE);
     _action_set_sensitive (browser, "BookmarkFolderAdd", TRUE);
@@ -7070,13 +7098,20 @@
 
 static void
 midori_browser_set_bookmarks (MidoriBrowser* browser,
-                              KatzeArray*    bookmarks)
+                              MidoriBookmarksDb*    bookmarks)
 {
     MidoriWebSettings* settings;
 
     if (browser->bookmarks != NULL)
+    {
+        g_signal_handlers_disconnect_by_func (browser->bookmarks,
+            midori_bookmarkbar_add_item_cb, browser);
+        g_signal_handlers_disconnect_by_func (browser->bookmarks,
+            midori_bookmarkbar_update_item_cb, browser);
         g_signal_handlers_disconnect_by_func (browser->bookmarks,
             midori_bookmarkbar_remove_item_cb, browser);
+    }
+    
     settings = midori_browser_get_settings (browser);
     g_signal_handlers_disconnect_by_func (settings,
         midori_browser_show_bookmarkbar_notify_value_cb, browser);
@@ -7105,6 +7140,10 @@
     g_signal_connect (settings, "notify::show-bookmarkbar",
         G_CALLBACK (midori_browser_show_bookmarkbar_notify_value_cb), browser);
     g_object_notify (G_OBJECT (settings), "show-bookmarkbar");
+    g_signal_connect_after (bookmarks, "add-item",
+        G_CALLBACK (midori_bookmarkbar_add_item_cb), browser);
+    g_signal_connect_after (bookmarks, "update-item",
+        G_CALLBACK (midori_bookmarkbar_update_item_cb), browser);
     g_signal_connect_after (bookmarks, "remove-item",
         G_CALLBACK (midori_bookmarkbar_remove_item_cb), browser);
 }

=== modified file 'midori/midori-frontend.c'
--- midori/midori-frontend.c	2013-05-23 22:15:27 +0000
+++ midori/midori-frontend.c	2013-06-11 20:53:24 +0000
@@ -10,7 +10,7 @@
 */
 
 #include "midori-array.h"
-#include "midori-bookmarks.h"
+#include "midori-bookmarks-db.h"
 #include "midori-history.h"
 #include "midori-preferences.h"
 #include "midori-privatedata.h"
@@ -487,9 +487,9 @@
     }
     g_free (uri);
 
-    KatzeArray* bookmarks;
+    MidoriBookmarksDb* bookmarks;
     gchar* errmsg = NULL;
-    if (!(bookmarks = midori_bookmarks_new (&errmsg)))
+    if (!(bookmarks = midori_bookmarks_db_new (&errmsg)))
     {
         g_string_append_printf (error_messages,
             _("Bookmarks couldn't be loaded: %s\n"), errmsg);
@@ -594,11 +594,11 @@
 midori_normal_app_on_quit (MidoriApp* app)
 {
     MidoriWebSettings* settings = katze_object_get_object (app, "settings");
-    KatzeArray* bookmarks = katze_object_get_object (app, "bookmarks");
+    MidoriBookmarksDb* bookmarks = katze_object_get_object (app, "bookmarks");
     KatzeArray* history = katze_object_get_object (app, "history");
 
     g_object_notify (G_OBJECT (settings), "load-on-startup");
-    midori_bookmarks_on_quit (bookmarks);
+    midori_bookmarks_db_on_quit (bookmarks);
     midori_history_on_quit (history, settings);
     midori_private_data_on_quit (settings);
     /* Removing KatzeHttpCookies makes it save outstanding changes */

=== modified file 'midori/midori.h'
--- midori/midori.h	2012-12-02 15:32:20 +0000
+++ midori/midori.h	2013-06-11 20:53:24 +0000
@@ -14,7 +14,7 @@
 
 #include "midori-app.h"
 #include "midori-array.h"
-#include "midori-bookmarks.h"
+#include "midori-bookmarks-db.h"
 #include "midori-browser.h"
 #include "midori-extension.h"
 #include "midori-frontend.h"

=== modified file 'panels/midori-bookmarks.c'
--- panels/midori-bookmarks.c	2013-06-04 17:28:05 +0000
+++ panels/midori-bookmarks.c	2013-06-11 20:53:24 +0000
@@ -17,6 +17,7 @@
 #include "midori-platform.h"
 #include "midori-view.h"
 #include "midori-core.h"
+#include "midori-bookmarks-db.h"
 
 #include <glib/gi18n.h>
 #include <string.h>
@@ -25,6 +26,111 @@
 
 #define COMPLETION_DELAY 200
 
+G_BEGIN_DECLS
+
+#define MIDORI_BOOKMARKS_TREE_STORE_TYPE \
+    (midori_bookmarks_tree_store_get_type ())
+#define MIDORI_BOOKMARKS_TREE_STORE(obj) \
+    (G_TYPE_CHECK_INSTANCE_CAST ((obj), MIDORI_BOOKMARKS_TREE_STORE_TYPE, MidoriBookmarksTreeStore))
+#define MIDORI_BOOKMARKS_TREE_STORE_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_CAST ((klass), MIDORI_BOOKMARKS_TREE_STORE_TYPE, MidoriBookmarksTreeStoreClass))
+
+static gboolean
+midori_bookmarks_tree_store_row_drop_possible (GtkTreeDragDest   *drag_dest,
+					      GtkTreePath       *dest_path,
+					      GtkSelectionData  *selection_data);
+
+typedef struct _MidoriBookmarksTreeStore                MidoriBookmarksTreeStore;
+typedef struct _MidoriBookmarksTreeStoreClass           MidoriBookmarksTreeStoreClass;
+
+struct _MidoriBookmarksTreeStore
+{
+    GtkTreeStore parent_instance;
+};
+
+struct _MidoriBookmarksTreeStoreClass
+{
+    GtkTreeStoreClass parent_class;
+};
+
+static GtkTreeDragDestIface *
+gtk_tree_store_gtk_tree_drag_dest_iface = NULL;
+
+static void
+midori_bookmarks_tree_store_drag_dest_init (GtkTreeDragDestIface *iface)
+{
+    gtk_tree_store_gtk_tree_drag_dest_iface = g_type_interface_peek_parent (iface);
+
+    iface->row_drop_possible = midori_bookmarks_tree_store_row_drop_possible;
+}
+
+static void
+midori_bookmarks_tree_store_init (MidoriBookmarksTreeStore* item)
+{
+}
+
+static void
+midori_bookmarks_tree_store_class_init (MidoriBookmarksTreeStoreClass *class)
+{
+}
+
+G_DEFINE_TYPE_WITH_CODE (MidoriBookmarksTreeStore,
+			 midori_bookmarks_tree_store,
+			 GTK_TYPE_TREE_STORE,
+			 G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_DEST,
+						midori_bookmarks_tree_store_drag_dest_init));
+
+
+GtkTreeStore*
+midori_bookmarks_tree_store_new (gint n_columns, ...)
+{
+    GtkTreeStore* tree_store = GTK_TREE_STORE (g_object_new (MIDORI_BOOKMARKS_TREE_STORE_TYPE, NULL));
+    va_list ap;
+    GType* types;
+    gint n;
+
+    if (!tree_store)
+        return NULL;
+
+    types = g_new (GType, n_columns);
+
+    if (!types)
+    {
+        g_object_unref(tree_store);
+        return NULL;
+    }
+
+    va_start(ap, n_columns);
+    for (n = 0; n < n_columns; n++)
+    {
+        types[n] = va_arg(ap, GType);
+    }
+    va_end(ap);
+
+    gtk_tree_store_set_column_types (tree_store,
+        n_columns,
+        types);
+
+    g_free (types);
+    return tree_store;
+}
+
+
+GtkTreeStore*
+midori_bookmarks_tree_store_newv (gint n_columns, GType *types)
+{
+    GtkTreeStore* tree_store = GTK_TREE_STORE (g_object_new (MIDORI_BOOKMARKS_TREE_STORE_TYPE, NULL));
+
+    if (!tree_store)
+	return NULL;
+
+    gtk_tree_store_set_column_types (tree_store,
+				     n_columns,
+				     types);
+
+    return tree_store;
+}
+
 gboolean
 midori_browser_edit_bookmark_dialog_new (MidoriBrowser* browser,
                                          KatzeItem*     bookmark,
@@ -36,6 +142,12 @@
 midori_browser_open_bookmark (MidoriBrowser* browser,
                               KatzeItem*     item);
 
+static void
+midori_bookmarks_row_changed_cb (GtkTreeModel*    model,
+                                 GtkTreePath*     path,
+                                 GtkTreeIter*     iter,
+                                 MidoriBookmarks* bookmarks);
+
 struct _MidoriBookmarks
 {
     GtkVBox parent_instance;
@@ -44,11 +156,12 @@
     GtkWidget* delete;
     GtkWidget* treeview;
     MidoriApp* app;
-    KatzeArray* array;
+    MidoriBookmarksDb* bookmarks_db;
 
     gint filter_timeout;
     gchar* filter;
 
+    GList* pending_inserts;
     KatzeItem* hovering_item;
 };
 
@@ -87,7 +200,12 @@
                                GParamSpec* pspec);
 
 static void
-midori_bookmarks_statusbar_update (MidoriBookmarks *bookmarks);
+midori_bookmarks_add_item_cb (KatzeArray*      array,
+                              KatzeItem*       item,
+                              MidoriBookmarks* bookmarks);
+static void
+midori_bookmarks_update_cb (KatzeArray*      array,
+                            MidoriBookmarks* bookmarks);
 
 static void
 midori_bookmarks_class_init (MidoriBookmarksClass* class)
@@ -124,6 +242,7 @@
     return STOCK_BOOKMARKS;
 }
 
+#if 0
 /* TODO: Function never used */
 void
 midori_bookmarks_export_array_db (sqlite3*    db,
@@ -137,7 +256,7 @@
     gchar* parent_id;
 
     parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
-    if (!(root_array = midori_array_query (array, "*", "parentid = %q", parent_id)))
+    if (!(root_array = midori_bookmarks_db_query_recursive (array, "*", "parentid = %q", parent_id, FALSE)))
     {
         g_free (parent_id);
         return;
@@ -159,27 +278,7 @@
     g_free (parent_id);
     g_list_free (list);
 }
-
-void
-midori_bookmarks_import_array_db (sqlite3*    db,
-                                  KatzeArray* array,
-                                  gint64      parentid)
-{
-    GList* list;
-    KatzeItem* item;
-    gint64 id;
-
-    if (!db)
-        return;
-
-    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
-    {
-        id = midori_bookmarks_insert_item_db (db, item, parentid);
-        if (KATZE_IS_ARRAY (item))
-            midori_bookmarks_import_array_db (db, KATZE_ARRAY (item), id);
-    }
-    g_list_free (list);
-}
+#endif
 
 static KatzeArray*
 midori_bookmarks_read_from_db (MidoriBookmarks* bookmarks,
@@ -189,21 +288,21 @@
     KatzeArray* array;
 
     if (keyword && *keyword)
-        array = midori_array_query (bookmarks->array,
-           "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword);
+        array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
+            "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, FALSE);
     else
     {
         if (parentid > 0)
         {
             gchar* parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
-            array = midori_array_query (bookmarks->array,
-               "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id);
+            array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
+                "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, FALSE);
 
             g_free (parent_id);
         }
         else
-            array = midori_array_query (bookmarks->array,
-               "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL);
+            array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
+                "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, FALSE);
     }
     return array ? array : katze_array_new (KATZE_TYPE_ITEM);
 }
@@ -234,90 +333,133 @@
         g_object_unref (item);
 }
 
-gint64
-midori_bookmarks_insert_item_db (sqlite3*   db,
-                                 KatzeItem* item,
-                                 gint64     parentid)
+static gboolean
+midori_bookmarks_reach_item_recurse (GtkTreeModel* model,
+				     GtkTreeIter* iter,
+				     gint64 id)
 {
-    gchar* sqlcmd;
-    char* errmsg = NULL;
-    KatzeItem* old_parent;
-    gchar* new_parentid;
-    gchar* id = NULL;
-    const gchar* uri = NULL;
-    const gchar* desc = NULL;
-    gint64 seq = 0;
-
-    /* Bookmarks must have a name, import may produce invalid items */
-    g_return_val_if_fail (katze_item_get_name (item), seq);
-
-    if (!db)
-        return seq;
-
-    if (katze_item_get_meta_integer (item, "id") > 0)
-        id = g_strdup_printf ("%" G_GINT64_FORMAT, katze_item_get_meta_integer(item, "id"));
-    else
-        id = g_strdup_printf ("NULL");
-
-    if (KATZE_ITEM_IS_BOOKMARK (item))
-        uri = katze_item_get_uri (item);
-
-    if (katze_item_get_text (item))
-        desc = katze_item_get_text (item);
-
-    /* Use folder, otherwise fallback to parent folder */
-    old_parent = katze_item_get_parent (item);
-    if (parentid > 0)
-        new_parentid = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
-    else if (old_parent && katze_item_get_meta_integer (old_parent, "id") > 0)
-        new_parentid = g_strdup_printf ("%" G_GINT64_FORMAT, katze_item_get_meta_integer (old_parent, "id"));
-    else
-        new_parentid = g_strdup_printf ("NULL");
-
-    sqlcmd = sqlite3_mprintf (
-            "INSERT INTO bookmarks (id, parentid, title, uri, desc, toolbar, app) "
-            "VALUES (%q, %q, '%q', '%q', '%q', %d, %d)",
-            id,
-            new_parentid,
-            katze_item_get_name (item),
-            katze_str_non_null (uri),
-            katze_str_non_null (desc),
-            katze_item_get_meta_boolean (item, "toolbar"),
-            katze_item_get_meta_boolean (item, "app"));
-
-    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) == SQLITE_OK)
+    do
     {
-        /* Get insert id */
-        if (g_str_equal (id, "NULL"))
-        {
-            KatzeArray* seq_array;
-
-            sqlite3_free (sqlcmd);
-            sqlcmd = sqlite3_mprintf (
-                    "SELECT seq FROM sqlite_sequence WHERE name = 'bookmarks'");
-
-            seq_array = katze_array_from_sqlite (db, sqlcmd);
-            if (katze_array_get_nth_item (seq_array, 0))
+        GtkTreeIter child;
+        KatzeItem *item;
+        gint64 itemid = -1;
+
+        gtk_tree_model_get (model, iter, 0, &item, -1);
+
+        if (!KATZE_ITEM_IS_SEPARATOR(item))
+        {
+            itemid = katze_item_get_meta_integer (item, "id");
+            g_object_unref (item);
+        }
+
+        if (id == itemid)
+            return TRUE;
+
+        if (gtk_tree_model_iter_children (model, &child, iter))
+        {
+            if (midori_bookmarks_reach_item_recurse (model, &child, id))
             {
-                KatzeItem* seq_item = katze_array_get_nth_item (seq_array, 0);
-
-                seq = katze_item_get_meta_integer (seq_item, "seq");
-                katze_item_set_meta_integer (item, "id", seq);
+                *iter = child;
+                return TRUE;
             }
-            g_object_unref (seq_array);
         }
     }
-    else
-    {
-        g_printerr (_("Failed to add bookmark item: %s\n"), errmsg);
-        sqlite3_free (errmsg);
-    }
-
-    sqlite3_free (sqlcmd);
-    g_free (new_parentid);
-    g_free (id);
-
-    return seq;
+    while (gtk_tree_model_iter_next(model, iter));
+
+    return FALSE;
+}
+
+static gboolean
+midori_bookmarks_reach_item (GtkTreeModel* model,
+			     GtkTreeIter* iter,
+			     gint64 id)
+{
+    if (!gtk_tree_model_get_iter_first(model, iter))
+        return FALSE;
+
+    return midori_bookmarks_reach_item_recurse (model, iter, id);
+}
+
+static void
+midori_bookmarks_add_item_to_model(GtkTreeStore*    model,
+				   GtkTreeIter*     parent,
+				   KatzeItem*       item)
+{
+    if (KATZE_ITEM_IS_BOOKMARK (item))
+    {
+        gchar* tooltip = g_markup_escape_text (katze_item_get_uri (item), -1);
+
+        gtk_tree_store_insert_with_values (model, NULL, parent,
+            0,
+            0, item, 1, tooltip, -1);
+        g_free (tooltip);
+    }
+    else
+    {
+        GtkTreeIter root_iter;
+
+        gtk_tree_store_insert_with_values (model, &root_iter, parent,
+            0, 0, item, -1);
+
+        /* That's an invisible dummy, so we always have an expander */
+        gtk_tree_store_insert_with_values (model, NULL, &root_iter,
+            0,
+            0, NULL, -1);
+    }
+}
+
+static void
+midori_bookmarks_update_item_in_model(MidoriBookmarks* bookmarks,
+				      GtkTreeStore*    model,
+				      GtkTreeIter*     iter,
+				      KatzeItem*       item)
+{
+    g_signal_handlers_block_by_func (model,
+        midori_bookmarks_row_changed_cb,
+        bookmarks);
+
+    if (KATZE_ITEM_IS_BOOKMARK (item))
+    {
+        gchar* tooltip = g_markup_escape_text (katze_item_get_uri (item), -1);
+
+        gtk_tree_store_set(model, iter,
+            0, item, 1, tooltip, -1);
+
+        g_free (tooltip);
+    }
+    else
+    {
+        gtk_tree_store_set(model, iter,
+            0, item, -1);
+    }
+
+    g_signal_handlers_unblock_by_func (model,
+        midori_bookmarks_row_changed_cb,
+        bookmarks);
+}
+
+static void
+midori_bookmarks_add_item (KatzeItem*       item,
+                           MidoriBookmarks* bookmarks);
+
+static gboolean
+midori_bookmarks_idle (MidoriBookmarks* bookmarks)
+{
+    GList* list_iter;
+
+    for (list_iter = bookmarks->pending_inserts; list_iter; list_iter = g_list_next (list_iter))
+    {
+        KatzeItem *item = KATZE_ITEM (list_iter->data);
+
+        midori_bookmarks_add_item (item, bookmarks);
+
+        g_object_unref (item);
+    }
+
+    g_list_free (bookmarks->pending_inserts);
+    bookmarks->pending_inserts = NULL;
+
+    return FALSE;
 }
 
 static void
@@ -325,11 +467,98 @@
                               KatzeItem*       item,
                               MidoriBookmarks* bookmarks)
 {
-    GtkTreeModel* model;
-    model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
-    gtk_tree_store_clear (GTK_TREE_STORE (model));
-    midori_bookmarks_read_from_db_to_model (bookmarks,
-        GTK_TREE_STORE (model), NULL, 0, bookmarks->filter);
+    if (!bookmarks->pending_inserts)
+        g_idle_add ((GSourceFunc)midori_bookmarks_idle, bookmarks);
+
+    g_object_ref (item);
+    bookmarks->pending_inserts = g_list_append (bookmarks->pending_inserts, item);
+}
+
+static void
+midori_bookmarks_add_item (KatzeItem*       item,
+                           MidoriBookmarks* bookmarks)
+{
+    gint64 id = katze_item_get_meta_integer (item, "id");
+    gint64 parentid = katze_item_get_meta_integer (item, "parentid");
+    GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
+    GtkTreeIter iter;
+
+    if (!parentid)
+    {
+        midori_bookmarks_add_item_to_model (GTK_TREE_STORE (model), NULL, item);
+    }
+    else if (midori_bookmarks_reach_item (model, &iter, parentid))
+    {
+        GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
+
+        if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (bookmarks->treeview), path))
+        {
+            midori_bookmarks_add_item_to_model (GTK_TREE_STORE (model), &iter, item);
+        }
+
+        gtk_tree_path_free (path);
+    }
+}
+
+static void
+midori_bookmarks_update_item_cb (KatzeArray*      array,
+				 KatzeItem*       item,
+				 MidoriBookmarks* bookmarks)
+{
+    gint64 id = katze_item_get_meta_integer (item, "id");
+    gint64 parentid = katze_item_get_meta_integer (item, "parentid");
+    GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
+    GtkTreeIter iter;
+
+    if (midori_bookmarks_reach_item (model, &iter, id))
+    {
+        gint64 old_parentid = 0;
+        GtkTreeIter parent;
+
+        if (gtk_tree_model_iter_parent (model, &parent, &iter))
+        {
+            KatzeItem* old_parent;
+
+            gtk_tree_model_get (model, &parent, 0, &old_parent, -1);
+
+            old_parentid = katze_item_get_meta_integer (old_parent, "id");
+
+            g_object_unref (old_parent);
+
+            if (parentid == old_parentid)
+            {
+                midori_bookmarks_update_item_in_model (bookmarks, GTK_TREE_STORE (model), &iter, item);
+            }
+            else
+            {
+                gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
+
+                if (!gtk_tree_model_iter_has_child (model, &parent))
+                {
+                    GtkTreePath* path = gtk_tree_model_get_path(model, &parent);
+
+                    if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (bookmarks->treeview), path))
+                        gtk_tree_view_collapse_row (GTK_TREE_VIEW (bookmarks->treeview), path);
+
+                    gtk_tree_path_free (path);
+                }
+
+                midori_bookmarks_add_item (item, bookmarks);
+            }
+        }
+        else if (parentid == 0)
+        {
+            midori_bookmarks_update_item_in_model (bookmarks, GTK_TREE_STORE (model), &iter, item);
+        }
+        else
+        {
+            gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
+
+            midori_bookmarks_add_item (item, bookmarks);
+        }
+    }
+    else
+        midori_bookmarks_add_item (item, bookmarks);
 }
 
 static void
@@ -337,12 +566,36 @@
                                  KatzeItem*       item,
                                  MidoriBookmarks* bookmarks)
 {
+    gint64 id = katze_item_get_meta_integer (item, "id");
     GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
-    gtk_tree_store_clear (GTK_TREE_STORE (model));
-    midori_bookmarks_read_from_db_to_model (bookmarks,
-        GTK_TREE_STORE (model), NULL, 0, bookmarks->filter);
+    GtkTreeIter iter;
+
+    if (midori_bookmarks_reach_item (model, &iter, id))
+    {
+        GtkTreeIter parent;
+
+        if (gtk_tree_model_iter_parent (model, &parent, &iter))
+        {
+            gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
+
+            if (!gtk_tree_model_iter_has_child (model, &parent))
+            {
+                GtkTreePath* path = gtk_tree_model_get_path(model, &parent);
+
+                if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (bookmarks->treeview), path))
+                    gtk_tree_view_collapse_row (GTK_TREE_VIEW (bookmarks->treeview), path);
+
+                gtk_tree_path_free (path);
+            }
+        }
+        else
+        {
+            gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
+        }
+    }
 }
 
+
 static void
 midori_bookmarks_update_cb (KatzeArray*      array,
                             MidoriBookmarks* bookmarks)
@@ -354,6 +607,42 @@
 }
 
 
+static gboolean
+midori_bookmarks_tree_store_row_drop_possible (GtkTreeDragDest*  drag_dest,
+					                           GtkTreePath*      dest_path,
+					                           GtkSelectionData* selection_data)
+{
+    gboolean row_drop_possible =
+     gtk_tree_store_gtk_tree_drag_dest_iface->row_drop_possible (drag_dest,
+         dest_path,
+         selection_data);
+
+    if (!row_drop_possible)
+        return FALSE;
+
+    if ((!gtk_tree_path_get_depth(dest_path) > 1)
+        && gtk_tree_path_up(dest_path))
+    {
+        GtkTreeModel* model = GTK_TREE_MODEL(drag_dest);
+        GtkTreeIter iter;
+
+        if (gtk_tree_model_get_iter (model, &iter, dest_path))
+        {
+            KatzeItem* item;
+
+            gtk_tree_model_get (model, &iter, 0, &item, -1);
+
+            if (!KATZE_ITEM_IS_FOLDER(item))
+                row_drop_possible = FALSE;
+
+            if (item)
+                g_object_unref (item);
+        }
+    }
+
+    return row_drop_possible;
+}
+
 static void
 midori_bookmarks_row_changed_cb (GtkTreeModel*    model,
                                  GtkTreePath*     path,
@@ -362,31 +651,37 @@
 {
     KatzeItem* item;
     GtkTreeIter parent;
-    KatzeItem* new_parent = NULL;
-    gint64 parentid;
-
-    gtk_tree_model_get (model, iter, 0, &item, -1);
+    gint64 parentid = 0;
 
     if (gtk_tree_model_iter_parent (model, &parent, iter))
     {
+        KatzeItem* new_parent;
+
         gtk_tree_model_get (model, &parent, 0, &new_parent, -1);
 
-        /* Bookmarks must not be moved into non-folder items */
-        if (!KATZE_ITEM_IS_FOLDER (new_parent))
-            parentid = 0;
-        else
-            parentid = katze_item_get_meta_integer (new_parent, "id");
+        /* Bookmarks cannot be moved into non-folder items */
+        g_assert (KATZE_ITEM_IS_FOLDER (new_parent));
+
+        parentid = katze_item_get_meta_integer (new_parent, "id");
+
+        g_object_unref (new_parent);
     }
-    else
-        parentid = 0;
-
-    katze_array_remove_item (bookmarks->array, item);
+
+    gtk_tree_model_get (model, iter, 0, &item, -1);
+
     katze_item_set_meta_integer (item, "parentid", parentid);
-    katze_array_add_item (bookmarks->array, item);
+
+    g_signal_handlers_block_by_func (bookmarks->bookmarks_db,
+        midori_bookmarks_update_item_cb,
+        bookmarks);
+
+    midori_bookmarks_db_update_item (bookmarks->bookmarks_db, item);
+
+    g_signal_handlers_unblock_by_func (bookmarks->bookmarks_db,
+        midori_bookmarks_update_item_cb,
+        bookmarks);
 
     g_object_unref (item);
-    if (new_parent)
-        g_object_unref (new_parent);
 }
 
 static void
@@ -412,24 +707,15 @@
     {
         KatzeItem* item;
         MidoriBrowser* browser;
-        gint64 parentid;
 
         gtk_tree_model_get (model, &iter, 0, &item, -1);
 
         g_assert (!KATZE_ITEM_IS_SEPARATOR (item));
 
         browser = midori_browser_get_for_widget (bookmarks->treeview);
-        parentid = katze_item_get_meta_integer (item, "parentid");
         midori_browser_edit_bookmark_dialog_new (
             browser, item, FALSE, KATZE_ITEM_IS_FOLDER (item), NULL);
 
-        if (katze_item_get_meta_integer (item, "parentid") != parentid)
-        {
-            gtk_tree_store_clear (GTK_TREE_STORE (model));
-            midori_bookmarks_read_from_db_to_model (bookmarks, GTK_TREE_STORE (model),
-                    NULL, 0, NULL);
-        }
-
         g_object_unref (item);
     }
 }
@@ -445,7 +731,7 @@
     gtk_widget_set_sensitive (GTK_WIDGET (bookmarks->edit), selected);
 }
 
-static gchar* 
+static gchar*
 midori_bookmarks_statusbar_bookmarks_str (gint count)
 {
     if (!count)
@@ -455,7 +741,7 @@
     return g_strdup_printf (ngettext ("%d bookmark", "%d bookmarks", count), count);
 }
 
-static gchar* 
+static gchar*
 midori_bookmarks_statusbar_subfolders_str (gint count)
 {
     if (!count)
@@ -481,9 +767,9 @@
 
         if (KATZE_ITEM_IS_FOLDER (item))
         {
-            gint child_folders_count = midori_array_count_recursive (bookmarks->array,
+            gint child_folders_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
                 "uri = ''", NULL, item, FALSE);
-            gint child_bookmarks_count = midori_array_count_recursive (bookmarks->array,
+            gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
                 "uri <> ''", NULL, item, FALSE);
             gchar* child_folders_str = midori_bookmarks_statusbar_subfolders_str (child_folders_count);
             gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
@@ -516,13 +802,13 @@
     }
     else
     {
-        gint child_folders_count = midori_array_count_recursive (bookmarks->array,
+        gint child_folders_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
             "uri = ''", NULL, NULL, FALSE);
-        gint child_bookmarks_count = midori_array_count_recursive (bookmarks->array,
+        gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
             "uri <> ''", NULL, NULL, FALSE);
         gchar* child_folders_str = midori_bookmarks_statusbar_subfolders_str (child_folders_count);
         gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
-        
+
         if (!child_bookmarks_count && (child_folders_count >= 1))
             /* i18n: [[n] folder(s)] and no bookmark */
             text = g_strdup_printf (_("%s and no bookmark"),
@@ -533,7 +819,7 @@
             /* i18n: [[n] bookmark(s)] and [[n] folder(s)] */
             text = g_strdup_printf (_("%s and %s"),
                 child_bookmarks_str, child_folders_str);
-        
+
         g_free (child_folders_str);
         g_free (child_bookmarks_str);
     }
@@ -541,9 +827,9 @@
     if (text)
     {
         MidoriBrowser* browser = midori_browser_get_for_widget (bookmarks->treeview);
-        
+
         g_object_set (browser, "statusbar-text", text, NULL);
-        
+
         g_free(text);
     }
 }
@@ -603,13 +889,8 @@
 
         gtk_tree_model_get (model, &iter, 0, &item, -1);
 
-        /* Manually remove the iter and block clearing the treeview */
-        gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
-        g_signal_handlers_block_by_func (bookmarks->array,
-            midori_bookmarks_remove_item_cb, bookmarks);
-        katze_array_remove_item (bookmarks->array, item);
-        g_signal_handlers_unblock_by_func (bookmarks->array,
-            midori_bookmarks_remove_item_cb, bookmarks);
+        midori_bookmarks_db_remove_item (bookmarks->bookmarks_db, item);
+
         g_object_unref (item);
     }
 }
@@ -693,9 +974,9 @@
     GtkTreeModel* model;
 
     model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
-    if (bookmarks->array)
+    if (bookmarks->bookmarks_db)
     {
-        g_object_unref (bookmarks->array);
+        g_object_unref (bookmarks->bookmarks_db);
         gtk_tree_store_clear (GTK_TREE_STORE (model));
     }
     katze_assign (bookmarks->app, app);
@@ -703,17 +984,19 @@
         return;
 
     g_object_ref (app);
-    bookmarks->array = katze_object_get_object (app, "bookmarks");
+    bookmarks->bookmarks_db = katze_object_get_object (app, "bookmarks");
     midori_bookmarks_read_from_db_to_model (bookmarks, GTK_TREE_STORE (model), NULL, 0, NULL);
-    g_signal_connect_after (bookmarks->array, "add-item",
-                      G_CALLBACK (midori_bookmarks_add_item_cb), bookmarks);
-    g_signal_connect (bookmarks->array, "remove-item",
-                      G_CALLBACK (midori_bookmarks_remove_item_cb), bookmarks);
-    g_signal_connect (bookmarks->array, "update",
-                      G_CALLBACK (midori_bookmarks_update_cb), bookmarks);
+    g_signal_connect_after (bookmarks->bookmarks_db, "add-item",
+        G_CALLBACK (midori_bookmarks_add_item_cb), bookmarks);
+    g_signal_connect_after (bookmarks->bookmarks_db, "update-item",
+        G_CALLBACK (midori_bookmarks_update_item_cb), bookmarks);
+    g_signal_connect (bookmarks->bookmarks_db, "remove-item",
+        G_CALLBACK (midori_bookmarks_remove_item_cb), bookmarks);
+    g_signal_connect (bookmarks->bookmarks_db, "update",
+        G_CALLBACK (midori_bookmarks_update_cb), bookmarks);
     g_signal_connect_after (model, "row-changed",
-                            G_CALLBACK (midori_bookmarks_row_changed_cb),
-                            bookmarks);
+        G_CALLBACK (midori_bookmarks_row_changed_cb),
+        bookmarks);
 }
 
 static void
@@ -943,12 +1226,12 @@
     menu = gtk_menu_new ();
     if (KATZE_ITEM_IS_FOLDER (item))
     {
-        gint child_bookmarks_count = midori_array_count_recursive (bookmarks->array,
+        gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
             "uri <> ''", NULL, item, FALSE);
 
         midori_bookmarks_popup_item (menu,
-            STOCK_TAB_NEW, _("Open all in _Tabs"), item, 
-            (!child_bookmarks_count ? NULL : midori_bookmarks_open_in_tab_activate_cb), 
+            STOCK_TAB_NEW, _("Open all in _Tabs"), item,
+            (!child_bookmarks_count ? NULL : midori_bookmarks_open_in_tab_activate_cb),
             bookmarks);
     }
     else
@@ -1080,7 +1363,7 @@
 static KatzeItem*
 midori_bookmarks_get_item_at_pos (GtkTreeView *treeview,
                                   gint x, gint y)
-{    
+{
     GtkTreeModel* model = gtk_tree_view_get_model (treeview);
     GtkTreePath* path;
     GtkTreeIter iter;
@@ -1088,13 +1371,13 @@
 
     gtk_tree_view_get_path_at_pos (treeview, x, y,
                                    &path, NULL, NULL, NULL);
-    
+
     if (!path)
         return NULL;
-    
+
     if (gtk_tree_model_get_iter (model, &iter, path))
         gtk_tree_model_get (model, &iter, 0, &item, -1);
-    
+
     gtk_tree_path_free (path);
 
     return item;
@@ -1166,7 +1449,7 @@
 
     if (bookmarks->hovering_item)
         g_object_unref (bookmarks->hovering_item);
-    
+
     bookmarks->hovering_item = NULL;
 
     g_object_set (browser, "statusbar-text", "", NULL);
@@ -1229,7 +1512,7 @@
     gtk_box_pack_start (GTK_BOX (bookmarks), box, FALSE, FALSE, 5);
 
     /* Create the treeview */
-    model = gtk_tree_store_new (2, KATZE_TYPE_ITEM, G_TYPE_STRING);
+    model = midori_bookmarks_tree_store_new (2, KATZE_TYPE_ITEM, G_TYPE_STRING);
     treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
     gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
     gtk_tree_view_set_tooltip_column (GTK_TREE_VIEW (treeview), 1);
@@ -1268,7 +1551,7 @@
                       "signal::leave-notify-event",
                       midori_bookmarks_leave_notify_event_cb, bookmarks,
                       NULL);
-    gtk_widget_add_events (GTK_WIDGET (treeview), 
+    gtk_widget_add_events (GTK_WIDGET (treeview),
                            GDK_POINTER_MOTION_MASK
                            | GDK_POINTER_MOTION_HINT_MASK);
 
@@ -1279,6 +1562,7 @@
     gtk_widget_show (treeview);
     gtk_box_pack_start (GTK_BOX (bookmarks), treeview, TRUE, TRUE, 0);
     bookmarks->treeview = treeview;
+    bookmarks->pending_inserts = NULL;
     bookmarks->hovering_item = NULL;
 }
 

=== modified file 'panels/midori-bookmarks.h'
--- panels/midori-bookmarks.h	2012-11-25 11:26:03 +0000
+++ panels/midori-bookmarks.h	2013-06-11 20:53:24 +0000
@@ -37,20 +37,6 @@
 GType
 midori_bookmarks_get_type               (void);
 
-gint64
-midori_bookmarks_insert_item_db (sqlite3*   db,
-                                 KatzeItem* item,
-                                 gint64     parentid);
-
-void
-midori_bookmarks_import_array_db (sqlite3*    db,
-                                  KatzeArray* array,
-                                  gint64      parentid);
-
-gboolean
-midori_bookmarks_update_item_db (sqlite3*   db,
-                                 KatzeItem* item);
-
 G_END_DECLS
 
 #endif /* __MIDORI_BOOKMARKS_PANEL_H__ */