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

[André Auzi]

Seventh step for merge of fix-1179200

Here the database transactions are added in idle time processing to improve the processing speed.

Import bookmarks time is significantly reduced.

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

6404. By Cris Dywan on 2013-09-18

Use stock as string in liststore

6405. By Cris Dywan on 2013-09-18

Refactor excuting schema from file into a function

6406. By André Auzi on 2013-09-18

Introduces KatzeArray::update-item to handle metadata changes

6407. By Cris Dywan on 2013-09-19

Initialize priv->element to avoid crash when freeing

6408. By Launchpad Translations on behalf of midori on 2013-09-20

Launchpad automatic translations update.

6409. By Cris Dywan on 2013-09-22

Use destructive-action style class in ClearPrivateData

6410. By André Stösel on 2013-09-22

fix endless loop in Midori.Database.init

6411. By André Stösel on 2013-09-22

Check if execinfo.h header exists on BSD

6412. By André Stösel on 2013-09-26

use a separate signal to store the tab title

6413. By André Stösel on 2013-09-26

don't change uri/title if the tab isn't loaded

6414. By André Stösel on 2013-09-26

fix for proxy item ownership in delayed load extension

6415. By Olivier Duchateau on 2013-09-26

Install mo files in locale dir

6416. By Olivier Duchateau on 2013-09-26

Add CMakeLists.txt for config directory

6417. By André Auzi on 2013-09-27

fix bookmarks test regression after fix-1179200-4

6418. By Cris Dywan on 2013-09-27

Rasterize SVG to PNG with rsvg-convert

6419. By Cris Dywan on 2013-09-27

Add USE_APIDOCS to build API docs with CMake

6420. By Cris Dywan on 2013-09-29

Add missing PO_FILES argument to GETTEXT_PROCESS_PO_FILES

6421. By Launchpad Translations on behalf of midori on 2013-09-30

Launchpad automatic translations update.

6422. By Launchpad Translations on behalf of midori on 2013-10-01

Launchpad automatic translations update.

6423. By Paweł Forysiuk on 2013-10-01

Install config files to /etc when install prefix is /usr

6424. By Paweł Forysiuk on 2013-10-01

Allow running test under debug tools with cmake

6425. By Cris Dywan on 2013-10-01

Untangle implicit GTK+3 for Granite and WebKit2

6426. By Launchpad Translations on behalf of midori on 2013-10-02

Launchpad automatic translations update.

6427. By André Stösel on 2013-10-04

add tab sorting

6428. By André Stösel on 2013-10-06

handle tab movement

6429. By Matthew Boevink <email address hidden> on 2013-10-08

Fixes bug where certificate Security overlay failed to close

6430. By Matthew Boevink <email address hidden> on 2013-10-08

midori_panel_action_activate_cb forgot to update the action group

6431. By Launchpad Translations on behalf of midori on 2013-10-11

Launchpad automatic translations update.

6432. By Paweł Forysiuk on 2013-10-11

Drop waf build system and provide cmake-based "configure" script

6433. By André Auzi on 2013-10-11

Make tabby compile with Webkit2

6434. By André Stösel on 2013-10-11

handle urls as argument when starting midori

6435. By Paweł Forysiuk on 2013-10-11

Only install config files to /etc if prefix equals /usr

6436. By Launchpad Translations on behalf of midori on 2013-10-12

Launchpad automatic translations update.

6437. By gue5t <email address hidden> on 2013-10-15

Use tabby sorting increment when importing session.xbel tabs

6438. By gue5t <email address hidden> on 2013-10-16

Ensure tab spinners update as often as the menubar spinner to avoid desync

6439. By André Auzi on 2013-10-16

Implement MidoriBookmarksDatabase class by inheritence from MidoriDatabase

6440. By André Stösel on 2013-10-17

option to modify the number of tabs which will be restored in each idle callback

6441. By Launchpad Translations on behalf of midori on 2013-10-18

Launchpad automatic translations update.

6442. By Cris Dywan on 2013-10-18

Re-arrange data file installing to be more explicit

  Skip .ico, .res and .swf.
  And don't ignore files unwanted on Win32 otherwise they
  will be installed in the fallback.

6443. By Launchpad Translations on behalf of midori on 2013-10-19

Launchpad automatic translations update.

6444. By Launchpad Translations on behalf of midori on 2013-10-20

Launchpad automatic translations update.

6445. By Launchpad Translations on behalf of midori on 2013-10-21

Launchpad automatic translations update.

6446. By Launchpad Translations on behalf of midori on 2013-10-22

Launchpad automatic translations update.

6447. By Launchpad Translations on behalf of midori on 2013-10-24

Launchpad automatic translations update.

6448. By Launchpad Translations on behalf of midori on 2013-10-25

Launchpad automatic translations update.

6449. By Launchpad Translations on behalf of midori on 2013-10-27

Launchpad automatic translations update.

6450. By Cris Dywan on 2013-10-27

Enable old target policy on cmake < 2.8.8

6451. By André Stösel on 2013-10-27

allow "view source" on about pages

6452. By André Auzi on 2013-10-27

Cache bookmark items to avoid their recreation on database reads

6453. By Launchpad Translations on behalf of midori on 2013-10-28

Launchpad automatic translations update.

6454. By Paweł Forysiuk on 2013-10-28

Build fix: found undeclared in midori_bookmarks_db_remove_item_recursive

6455. By Paweł Forysiuk on 2013-10-28

Correct view source assertions in tab unit test

6456. By Paweł Forysiuk on 2013-10-30

Try to handle previous runs of cmake in configure wrapper

6457. By Launchpad Translations on behalf of midori on 2013-10-31

Launchpad automatic translations update.

6458. By Paweł Forysiuk on 2013-11-04

Update win32-release script for cmake, move unused docs/scripts to old folder

6459. By Paweł Forysiuk on 2013-11-05

Resolve compiler warnings in current trunk

Add EXTRA_WARNINGS flag to increase verbosity
Respect VALAC for the Vala compiler if defined
Sort out Vala 0.16 build issues
Make warnings fatal for bzr builds

6460. By André Stösel on 2013-11-05

remove unused variable

6461. By André Stösel on 2013-11-05

add function to view dom source

6462. By Cris Dywan on 2013-11-05

Use font-set signal and font family for GTK+ 3.2 font chooser

6463. By Cris Dywan on 2013-11-05

Cast WebKitDOMHtmlElement for getting source content

6464. By André Stösel on 2013-11-06

restore the last closed sessions if no session is opened

6465. By Cris Dywan on 2013-11-06

Check path being NULL in export before trying to inspect it

6466. By André Stösel on 2013-11-07

bugfix: it should be possible to use exension.set_.. api within hidden extensions

6467. By André Auzi on 2013-11-08

Reset item ids when re-importing bookmarks

6468. By Launchpad Translations on behalf of midori on 2013-11-12

Launchpad automatic translations update.

6469. By Paweł Forysiuk on 2013-11-12

Fix building on Ubuntu 12.04

6470. By Cris Dywan on 2013-11-12

Don't use context-menu signal in WebKitGTK+ < 1.10.0

6471. By Launchpad Translations on behalf of midori on 2013-11-13

Launchpad automatic translations update.

6472. By gue5t <email address hidden> on 2013-11-14

Fix autoscrolling if page contains a frame with our custom error page

6473. By Cris Dywan on 2013-11-14

Fix check for found valac and mention VALAC variable

6474. By Paweł Forysiuk on 2013-11-15

Provide sensible default font suggestions on Win32

6475. By André Stösel on 2013-11-15

removed unused preference dialog and related code

6476. By André Stösel on 2013-11-15

Check all browsers for opened sessions and whether they're popups

6477. By André Stösel on 2013-11-15

Remove stored popup sessions from the database

6478. By Cris Dywan on 2013-11-16

Hide WEbGL preference if it is unavailable

6479. By gue5t <email address hidden> on 2013-11-16

Use correct signal when clearing the trash

6480. By Cris Dywan on 2013-11-16

Swap NULL-check with main frame check

6481. By Launchpad Translations on behalf of midori on 2013-11-17

Launchpad automatic translations update.

6482. By gue5t <email address hidden> on 2013-11-17

Tweak searching for resources when running from build folder

6483. By Paweł Forysiuk on 2013-11-18

Add copyright note to appdata file

6484. By Launchpad Translations on behalf of midori on 2013-11-19

Launchpad automatic translations update.

6485. By André Stösel on 2013-11-19

handle tab duplication

6486. By André Stösel on 2013-11-19

Open speed dial or homepage according to preference

6487. By Paweł Forysiuk on 2013-11-19

makedist: Try to use system defaults

6488. By André Stösel on 2013-11-20

instead of creating devpet status icon on extension load, create it only to show new messages

6489. By Cris Dywan on 2013-11-20

Bump version to 0.5.6

6490. By Launchpad Translations on behalf of midori on 2013-11-20

Launchpad automatic translations update.

6491. By Isaac Smith on 2013-11-21

Allow printing without confirmation dialog on kiosk setups

6492. By Matthew Boevink <email address hidden> on 2013-11-22

Add close tabs to right feature

6493. By Launchpad Translations on behalf of midori on 2013-11-24

Launchpad automatic translations update.

6494. By gue5t <email address hidden> on 2013-11-24

Change preferences to refer to proxy address as a "URI" (not "hostname")

6495. By gue5t <email address hidden> on 2013-11-24

Correctly disable favicon database in app and private mode

6496. By gue5t <email address hidden> on 2013-11-24

Fix build with WebKit2 since 6491

6497. By gue5t <email address hidden> on 2013-11-24

Give NextForward its own label for toolbar editor

6498. By gue5t <email address hidden> on 2013-11-24

Introduce and use Midori.URI.get_hostname_for_display

6499. By Launchpad Translations on behalf of midori on 2013-11-25

Launchpad automatic translations update.

6500. By Cris Dywan on 2013-11-26

Set minimum value of 0 on spin button for maximum cache size

6501. By Launchpad Translations on behalf of midori on 2013-11-26

Launchpad automatic translations update.

6502. By Cody Garver on 2013-11-27

Move Preferences menu entry above About

6503. By gue5t <email address hidden> on 2013-11-29

Enable sidepanel in private mode

6504. By Launchpad Translations on behalf of midori on 2013-12-01

Launchpad automatic translations update.

6505. By Paweł Forysiuk on 2013-12-01

Adjust CMakeList .ico check to not skip nojs icons

6506. By Launchpad Translations on behalf of midori on 2013-12-02

Launchpad automatic translations update.

6507. By Cris Dywan on 2013-12-03

NULL-check treeview in midori_search_action_get_editor

6508. By Paweł Forysiuk on 2013-12-05

Work around symbol relocation issue old version of gcc present on Ubuntu LTS

6509. By Cris Dywan on 2013-12-09

Introduce notebook class converging separate implementations

6510. By Cris Dywan on 2013-12-09

Drop deprecated StaticNotebook used in KatzePreferences

6511. By Cris Dywan on 2013-12-09

Drop uncommented contractor support

6512. By Cris Dywan on 2013-12-09

Drop unused GraniteClutter-based animation support

6513. By André Stösel on 2013-12-10

New extension Flummi for running commands once or repeatedly on startup

6514. By Cris Dywan on 2013-12-10

Introduce high-level prepare/ DatabaseStatement API

6515. By Launchpad Translations on behalf of midori on 2013-12-11

Launchpad automatic translations update.

6516. By Launchpad Translations on behalf of midori on 2013-12-12

Launchpad automatic translations update.

6517. By André Stösel on 2013-12-12

execute commands given at start time

6518. By André Stösel on 2013-12-12

handle url arguments for blank sessions

6519. By Paweł Forysiuk on 2013-12-12

Don't try to create formhistory database if config_dir is NULL

6520. By Cris Dywan on 2013-12-12

Add flummi to POTFILES.in

6521. By Cris Dywan on 2013-12-12

Skip folders starting with _ from license and potfiles checks

6522. By Cris Dywan on 2013-12-19

Use int64 arguments in HistoryDatabase.query

6523. By Launchpad Translations on behalf of midori on 2013-12-20

Launchpad automatic translations update.

6524. By Launchpad Translations on behalf of midori on 2013-12-21

Launchpad automatic translations update.

6525. By André Auzi on 2013-12-26

improve bookmarks import performance using db transactions

6526. By André Auzi on 2013-12-26

merge lp:~aauzi/midori/fix-1179200-7

Unmerged revisions

6526. By André Auzi on 2013-12-26

merge lp:~aauzi/midori/fix-1179200-7

6525. By André Auzi on 2013-12-26

improve bookmarks import performance using db transactions

=== modified file 'katze/katze-array.c'
--- katze/katze-array.c	2012-08-08 23:02:56 +0000
+++ katze/katze-array.c	2013-09-17 21:46:23 +0000
@@ -25,38 +25,14 @@
  * #KatzeArray is a type aware container for items.
  */
 
-struct _KatzeArray
+G_DEFINE_TYPE (KatzeArray, katze_array, KATZE_TYPE_ITEM);
+
+struct _KatzeArrayPrivate
 {
-    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,
     REMOVE_ITEM,
@@ -90,7 +66,7 @@
     if (g_type_is_a (type, KATZE_TYPE_ITEM))
         katze_item_set_parent (item, array);
 
-    array->items = g_list_append (array->items, item);
+    array->priv->items = g_list_append (array->priv->items, item);
     _katze_array_update (array);
 }
 
@@ -98,7 +74,7 @@
 _katze_array_remove_item (KatzeArray* array,
                           gpointer   item)
 {
-    array->items = g_list_remove (array->items, item);
+    array->priv->items = g_list_remove (array->priv->items, item);
 
     if (KATZE_IS_ITEM (item))
         katze_item_set_parent (item, NULL);
@@ -111,8 +87,8 @@
                         gpointer    item,
                         gint        position)
 {
-    array->items = g_list_remove (array->items, item);
-    array->items = g_list_insert (array->items, item, position);
+    array->priv->items = g_list_remove (array->priv->items, item);
+    array->priv->items = g_list_insert (array->priv->items, item, position);
     _katze_array_update (array);
 }
 
@@ -121,10 +97,10 @@
 {
     GObject* item;
 
-    while ((item = g_list_nth_data (array->items, 0)))
+    while ((item = g_list_nth_data (array->priv->items, 0)))
         g_signal_emit (array, signals[REMOVE_ITEM], 0, item);
-    g_list_free (array->items);
-    array->items = NULL;
+    g_list_free (array->priv->items);
+    array->priv->items = NULL;
     _katze_array_update (array);
 }
 
@@ -217,13 +193,18 @@
     class->move_item = _katze_array_move_item;
     class->clear = _katze_array_clear;
     class->update = _katze_array_update;
+
+    g_type_class_add_private (class, sizeof (KatzeArrayPrivate));
 }
 
 static void
 katze_array_init (KatzeArray* array)
 {
-    array->type = G_TYPE_OBJECT;
-    array->items = NULL;
+    array->priv = G_TYPE_INSTANCE_GET_PRIVATE (array,
+        KATZE_TYPE_ARRAY, KatzeArrayPrivate);
+
+    array->priv->type = G_TYPE_OBJECT;
+    array->priv->items = NULL;
 }
 
 static void
@@ -232,9 +213,9 @@
     KatzeArray* array = KATZE_ARRAY (object);
     GList* items;
 
-    for (items = array->items; items; items = g_list_next (items))
+    for (items = array->priv->items; items; items = g_list_next (items))
         g_object_unref (items->data);
-    g_list_free (array->items);
+    g_list_free (array->priv->items);
 
     G_OBJECT_CLASS (katze_array_parent_class)->finalize (object);
 }
@@ -258,7 +239,7 @@
     g_return_val_if_fail (g_type_is_a (type, G_TYPE_OBJECT), NULL);
 
     array = g_object_new (KATZE_TYPE_ARRAY, NULL);
-    array->type = type;
+    array->priv->type = type;
 
     return array;
 }
@@ -279,7 +260,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), FALSE);
 
-    return g_type_is_a (array->type, is_a_type);
+    return g_type_is_a (array->priv->type, is_a_type);
 }
 
 /**
@@ -333,7 +314,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
 
-    return g_list_nth_data (array->items, n);
+    return g_list_nth_data (array->priv->items, n);
 }
 
 /**
@@ -349,7 +330,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), TRUE);
 
-    return !g_list_nth_data (array->items, 0);
+    return !g_list_nth_data (array->priv->items, 0);
 }
 
 /**
@@ -367,7 +348,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), -1);
 
-    return g_list_index (array->items, item);
+    return g_list_index (array->priv->items, item);
 }
 
 /**
@@ -401,7 +382,7 @@
     if (token_length < 1)
         token_length = strlen (token);
 
-    for (items = array->items; items; items = g_list_next (items))
+    for (items = array->priv->items; items; items = g_list_next (items))
     {
         const gchar* found_token = ((KatzeItem*)items->data)->token;
         if (found_token != NULL)
@@ -439,7 +420,7 @@
     g_return_val_if_fail (katze_array_is_a (array, KATZE_TYPE_ITEM), NULL);
     g_return_val_if_fail (uri != NULL, NULL);
 
-    for (items = array->items; items; items = g_list_next (items))
+    for (items = array->priv->items; items; items = g_list_next (items))
     {
         const gchar* found_uri = ((KatzeItem*)items->data)->uri;
         if (found_uri != NULL && !strcmp (found_uri, uri))
@@ -461,7 +442,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), 0);
 
-    return g_list_length (array->items);
+    return g_list_length (array->priv->items);
 }
 
 /**
@@ -499,7 +480,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
 
-    return g_list_copy (array->items);
+    return g_list_copy (array->priv->items);
 }
 
 GList*
@@ -507,7 +488,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
 
-    return array->items;
+    return array->priv->items;
 }
 
 /**

=== modified file 'katze/katze-array.h'
--- katze/katze-array.h	2011-01-19 20:58:26 +0000
+++ katze/katze-array.h	2013-09-17 21:46:23 +0000
@@ -31,6 +31,36 @@
 
 typedef struct _KatzeArray                       KatzeArray;
 typedef struct _KatzeArrayClass                  KatzeArrayClass;
+typedef struct _KatzeArrayPrivate                KatzeArrayPrivate;
+
+struct _KatzeArray
+{
+    KatzeItem parent_instance;
+
+    KatzeArrayPrivate* priv;
+};
+
+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);
+};
 
 GType
 katze_array_get_type               (void) G_GNUC_CONST;

=== modified file 'katze/katze-item.c'
--- katze/katze-item.c	2013-07-27 12:35:55 +0000
+++ katze/katze-item.c	2013-09-17 21:46:23 +0000
@@ -314,6 +314,9 @@
 {
     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);
@@ -418,6 +421,9 @@
 {
     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);

=== modified file 'midori/midori-array.c'
--- midori/midori-array.c	2013-08-05 12:50:34 +0000
+++ midori/midori-array.c	2013-09-17 21:46:23 +0000
@@ -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)

=== modified file 'midori/midori-bookmarks-db.c'
--- midori/midori-bookmarks-db.c	2013-09-08 10:53:32 +0000
+++ midori/midori-bookmarks-db.c	2013-09-17 21:46:23 +0000
@@ -25,14 +25,622 @@
     #include <unistd.h>
 #endif
 
-static gboolean
-midori_bookmarks_update_item_db (sqlite3*   db,
-				 KatzeItem* item);
-
-gint64
-midori_bookmarks_insert_item_db (sqlite3*   db,
-                                 KatzeItem* item,
-                                 gint64     parentid)
+/**
+ * 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;
+
+    /* Signals */
+    void
+    (*update_item)            (MidoriBookmarksDb* bookmarks,
+                               gpointer    item);
+};
+
+G_DEFINE_TYPE (MidoriBookmarksDb, midori_bookmarks_db, KATZE_TYPE_ARRAY);
+
+enum {
+    UPDATE_ITEM,
+
+    LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+static void
+_midori_bookmarks_db_add_item (KatzeArray* array,
+                               gpointer    item);
+
+static void
+_midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks,
+                                  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;
+
+    signals[UPDATE_ITEM] = g_signal_new (
+        "update-item",
+        G_TYPE_FROM_CLASS (class),
+        (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+        G_STRUCT_OFFSET (MidoriBookmarksDbClass, update_item),
+        0,
+        NULL,
+        g_cclosure_marshal_VOID__POINTER,
+        G_TYPE_NONE, 1,
+        G_TYPE_POINTER);
+
+    katze_array_class = KATZE_ARRAY_CLASS (class);
+
+    katze_array_class->add_item = _midori_bookmarks_db_add_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;
+
+    class->update_item = _midori_bookmarks_db_update_item;
+}
+
+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);
+    katze_item_set_name (KATZE_ITEM (bookmarks), _("Bookmarks"));
+    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;
+    KatzeArray* db_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));
+
+    db_parent = midori_bookmarks_db_get_item_parent (bookmarks, item);
+
+    g_return_if_fail (db_parent);
+
+    if (parent == db_parent)
+    {
+        if (IS_MIDORI_BOOKMARKS_DB (parent))
+            KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->update (parent);
+        else
+            katze_array_update (parent);
+        return;
+    }
+
+    if (IS_MIDORI_BOOKMARKS_DB (parent))
+        KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->add_item (parent, item);
+    else if (KATZE_IS_ARRAY (parent))
+        katze_array_add_item (parent, item);
+}
+
+/**
+ * _midori_bookmarks_db_update_item:
+ * @array: the main bookmarks array
+ * @item: a #KatzeItem
+ *
+ * Internal function that implements the %midori_bookmarks_db_update_item() post-processing.
+ * It relays an update to the appropriate #KatzeArray.
+ **/
+static void
+_midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks,
+                                  gpointer    item)
+{
+    KatzeArray* parent;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    g_return_if_fail (bookmarks->in_idle_func);
+
+    parent = katze_item_get_parent (KATZE_ITEM (item));
+
+    g_return_if_fail (parent);
+
+    katze_array_update (parent);
+}
+
+/**
+ * _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);
+
+    if (IS_MIDORI_BOOKMARKS_DB (parent))
+        KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->remove_item (parent, item);
+    else if (KATZE_IS_ARRAY (parent))
+        katze_array_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)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+
+    g_critical ("_midori_bookmarks_db_clear: not implemented\n");
+}
+
+/**
+ * midori_bookmarks_db_signal_update_item:
+ * @array: a #KatzeArray
+ * @item: an item
+ *
+ * Notify an update of the item of the array.
+ *
+ **/
+static void
+midori_bookmarks_db_signal_update_item (MidoriBookmarksDb* array,
+                                        gpointer    item)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+
+    g_signal_emit (array, signals[UPDATE_ITEM], 0, item);
+}
+
+/**
+ * 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)
+{
+    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);
+        midori_bookmarks_db_signal_update_item (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;
@@ -70,15 +678,15 @@
         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"));
+        "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)
     {
@@ -89,7 +697,7 @@
 
             sqlite3_free (sqlcmd);
             sqlcmd = sqlite3_mprintf (
-                    "SELECT seq FROM sqlite_sequence WHERE name = 'bookmarks'");
+                "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))
@@ -115,8 +723,17 @@
     return seq;
 }
 
-gboolean
-midori_bookmarks_update_item_db (sqlite3*   db,
+/**
+ * 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;
@@ -126,7 +743,7 @@
     gchar* id;
 
     id = g_strdup_printf ("%" G_GINT64_FORMAT,
-            katze_item_get_meta_integer (item, "id"));
+                          katze_item_get_meta_integer (item, "id"));
 
     if (katze_item_get_meta_integer (item, "parentid") > 0)
         parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
@@ -135,16 +752,16 @@
         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 = %q ;",
-            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"),
-            id);
+        "UPDATE bookmarks SET "
+        "parentid=%q, title='%q', uri='%q', desc='%q', toolbar=%d, app=%d "
+        "WHERE id = %q ;",
+        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"),
+        id);
 
     updated = TRUE;
     if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
@@ -162,68 +779,128 @@
 }
 
 /**
+ * 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;
+    gchar* id;
+
+    id = g_strdup_printf ("%" G_GINT64_FORMAT,
+                          katze_item_get_meta_integer (item, "id"));
+
+    sqlcmd = sqlite3_mprintf ("DELETE FROM bookmarks WHERE id = %q", 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);
+    g_free (id);
+    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));
+
+    /* Force NULL id for database addition */
+    if (NULL != katze_item_get_meta_string (item, "id"))
+    {
+	katze_item_set_meta_string (item, "id", NULL);
+    }
+
+    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.5
- **/
-void
-midori_array_update_item (KatzeArray* bookmarks,
-			  KatzeItem* item)
-{
-    g_return_if_fail (KATZE_IS_ARRAY (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"));
-
-    sqlite3* db = g_object_get_data (G_OBJECT (bookmarks), "db");
-
-    g_return_if_fail (db);
-
-    midori_bookmarks_update_item_db (db, item);
-}
-
-void
-midori_bookmarks_dbtracer (void*       dummy,
-                           const char* query)
-{
-    g_printerr ("%s\n", query);
-}
-
-static 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"));
-}
-
-static void
-midori_bookmarks_remove_item_cb (KatzeArray* array,
-                                 KatzeItem*  item,
-                                 sqlite3*    db)
-{
-    gchar* sqlcmd;
-    char* errmsg = NULL;
-    gchar* id;
-
-    id = g_strdup_printf ("%" G_GINT64_FORMAT,
-            katze_item_get_meta_integer (item, "id"));
-
-    sqlcmd = sqlite3_mprintf ("DELETE FROM bookmarks WHERE id = %q", id);
-
-    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
-    {
-        g_printerr (_("Failed to remove bookmark item: %s\n"), errmsg);
-        sqlite3_free (errmsg);
-    }
-
-    sqlite3_free (sqlcmd);
-    g_free (id);
+ * 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) \
@@ -237,8 +914,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)
 {
@@ -293,8 +970,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;
@@ -304,6 +997,7 @@
     gchar* sql_errmsg = NULL;
     gchar* import_errmsg = NULL;
     KatzeArray* array;
+    MidoriBookmarksDb* bookmarks;
 
     g_return_val_if_fail (errmsg != NULL, NULL);
 
@@ -321,7 +1015,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 "
@@ -442,7 +1136,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)");
@@ -452,13 +1146,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);
@@ -470,40 +1162,176 @@
         return NULL;
 }
 
+/**
+ * midori_bookmarks_db_on_quit:
+ * @bookmarks: the main bookmark array
+ *
+ * Delete the main bookmark array.
+ *
+ * Since: 0.5.2
+ **/
 void
-midori_bookmarks_on_quit (KatzeArray* array)
+midori_bookmarks_db_on_quit (MidoriBookmarksDb* bookmarks)
 {
-    g_return_if_fail (KATZE_IS_ARRAY (array));
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
 
-    sqlite3* db = g_object_get_data (G_OBJECT (array), "db");
-    g_return_if_fail (db != NULL);
-    sqlite3_close (db);
+    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_import_array (KatzeArray* bookmarks,
+midori_bookmarks_db_import_array (MidoriBookmarksDb* bookmarks,
                                KatzeArray* array,
                                gint64      parentid)
 {
     GList* list;
     KatzeItem* item;
 
-    if (!bookmarks)
-        return;
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ARRAY (array));
 
     KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
     {
         katze_item_set_meta_integer (item, "parentid", parentid);
-        katze_array_add_item (bookmarks, item);
-        if (KATZE_IS_ARRAY (item))
-          midori_bookmarks_import_array (bookmarks, KATZE_ARRAY (item),
-                                         katze_item_get_meta_integer(item, "id"));
+        midori_bookmarks_db_add_item (bookmarks, item);
     }
+
     g_list_free (list);
 }
 
 /**
- * midori_array_query_recursive:
+ * 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 (bookmarks->in_idle_func)
+	return;
+
+    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 future 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))
+        {
+            g_object_unref (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'"
@@ -514,38 +1342,35 @@
  *
  * Return value: a #KatzeArray on success, %NULL otherwise
  *
- * Since: 0.4.4
+ * Since: 0.5.2
  **/
 KatzeArray*
-midori_array_query_recursive (KatzeArray*  bookmarks,
-                              const gchar* fields,
-                              const gchar* condition,
-                              const gchar* value,
-                              gboolean     recursive)
+midori_bookmarks_db_query_recursive (MidoriBookmarksDb*  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 (IS_MIDORI_BOOKMARKS_DB (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);
+        array = midori_bookmarks_db_array_from_sqlite (bookmarks, sqlcmd_value);
         sqlite3_free (sqlcmd_value);
     }
     else
-        array = katze_array_from_sqlite (db, sqlcmd);
+        array = midori_bookmarks_db_array_from_sqlite (bookmarks, sqlcmd);
     g_free (sqlcmd);
 
     if (!recursive)
@@ -556,9 +1381,9 @@
         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_get_meta_integer (item, "id"));
+            KatzeArray* subarray = midori_bookmarks_db_query_recursive (bookmarks,
+                                                                        fields, "parentid=%q", parentid, TRUE);
             KatzeItem* subitem;
             GList* sublist;
 
@@ -576,21 +1401,21 @@
 }
 
 static gint64
-count_from_sqlite (sqlite3*     db,
-		   const gchar* sqlcmd)
+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);
+        count = sqlite3_column_int64(stmt, 0);
 
     sqlite3_clear_bindings (stmt);
     sqlite3_reset (stmt);
@@ -599,14 +1424,13 @@
 }
 
 static gint64
-midori_array_count_recursive_by_id (KatzeArray*  bookmarks,
-				    const gchar* condition,
-				    const gchar* value,
-				    gint64       id,
-				    gboolean     recursive)
+midori_bookmarks_db_count_recursive_by_id (MidoriBookmarksDb*  bookmarks,
+                                           const gchar*        condition,
+                                           const gchar*        value,
+                                           gint64              id,
+                                           gboolean            recursive)
 {
     gint64 count = -1;
-    sqlite3* db;
     gchar* sqlcmd;
     char* sqlcmd_value;
     sqlite3_stmt* stmt;
@@ -615,30 +1439,29 @@
     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_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);
+        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);
+        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);
+        count = midori_bookmarks_db_count_from_sqlite (bookmarks->db, sqlcmd_value);
         sqlite3_free (sqlcmd_value);
     }
     else
-        count = count_from_sqlite (db, sqlcmd);
+        count = midori_bookmarks_db_count_from_sqlite (bookmarks->db, sqlcmd);
 
     g_free (sqlcmd);
 
@@ -648,28 +1471,28 @@
     ids = NULL;
 
     if (id > 0)
-	sqlcmd_value = sqlite3_mprintf (
-	    "SELECT id FROM bookmarks "
-	    "WHERE parentid = %" G_GINT64_FORMAT " AND uri = ''", id);
+        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 = ''");
+        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)
+    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);
+        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);
@@ -677,29 +1500,29 @@
     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);
+        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_array_count_recursive:
- * @array: the main bookmark array
+ * 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
@@ -709,19 +1532,19 @@
  * Since: 0.5.2
  **/
 gint64
-midori_array_count_recursive (KatzeArray*  bookmarks,
-			      const gchar* condition,
-                              const gchar* value,
-			      KatzeItem*   folder,
-                              gboolean     recursive)
+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_array_count_recursive_by_id (bookmarks, condition,
-					       value, id,
-					       recursive);
+    return midori_bookmarks_db_count_recursive_by_id (bookmarks, condition,
+                                                      value, id,
+                                                      recursive);
 }

=== modified file 'midori/midori-bookmarks-db.h'
--- midori/midori-bookmarks-db.h	2013-09-08 10:53:32 +0000
+++ midori/midori-bookmarks-db.h	2013-09-17 21:46:23 +0000
@@ -16,33 +16,60 @@
 #include <sqlite3.h>
 #include <katze/katze.h>
 
-KatzeArray*
-midori_bookmarks_new (char** errmsg);
-
-void
-midori_bookmarks_on_quit (KatzeArray* array);
-
-void
-midori_array_update_item (KatzeArray* bookmarks, KatzeItem* item);
-
-void
-midori_bookmarks_import_array (KatzeArray* bookmarks,
-                               KatzeArray* array,
-                               gint64      parentid);
-
-KatzeArray*
-midori_array_query_recursive (KatzeArray*  bookmarks,
-			      const gchar* fields,
-			      const gchar* condition,
-			      const gchar* value,
-			      gboolean     recursive);
+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_db_query_recursive (MidoriBookmarksDb*  bookmarks,
+                                     const gchar* fields,
+                                     const gchar* condition,
+                                     const gchar* value,
+                                     gboolean     recursive);
 
 gint64
-midori_array_count_recursive (KatzeArray*  bookmarks,
-			      const gchar*        condition,
-			      const gchar*        value,
-			      KatzeItem*          folder,
-			      gboolean            recursive);
+midori_bookmarks_db_count_recursive (MidoriBookmarksDb*  bookmarks,
+				     const gchar*        condition,
+                                     const gchar*        value,
+				     KatzeItem*          folder,
+				     gboolean            recursive);
 
 gint64
 midori_bookmarks_insert_item_db (sqlite3*   db,

=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2013-09-16 22:00:41 +0000
+++ midori/midori-browser.c	2013-09-17 21:46:23 +0000
@@ -87,7 +87,7 @@
 
     MidoriWebSettings* settings;
     KatzeArray* proxy_array;
-    KatzeArray* bookmarks;
+    MidoriBookmarksDb* bookmarks;
     KatzeArray* trash;
     KatzeArray* search_engines;
     KatzeArray* history;
@@ -195,8 +195,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);
@@ -863,7 +863,7 @@
 }
 
 static GtkWidget*
-midori_bookmark_folder_button_new (KatzeArray* array,
+midori_bookmark_folder_button_new (MidoriBookmarksDb* array,
                                    gint64      selected_parentid)
 {
     GtkTreeStore* model;
@@ -1231,18 +1231,9 @@
         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_array_update_item (browser->bookmarks, bookmark);
-	    midori_browser_update_history (bookmark, "bookmark", "modify");
-
-	    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_toolbar)))
-		if (!gtk_widget_get_visible (browser->bookmarkbar))
-		    _action_set_active (browser, "Bookmarkbar", TRUE);
-	    if (gtk_widget_get_visible (browser->bookmarkbar))
-		midori_bookmarkbar_populate (browser);
-	}
+            midori_bookmarks_db_update_item (browser->bookmarks, bookmark);
 
         return_status = TRUE;
     }
@@ -2545,7 +2536,7 @@
                                      "bookmarks",
                                      "Bookmarks",
                                      "The bookmarks folder, containing all bookmarks",
-                                     KATZE_TYPE_ARRAY,
+                                     TYPE_MIDORI_BOOKMARKS_DB,
                                      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
     /**
@@ -3273,8 +3264,8 @@
     else
         condition = "parentid = %q";
 
-    bookmarks = midori_array_query_recursive  (browser->bookmarks,
-						 "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, FALSE);
+    bookmarks = midori_bookmarks_db_query_recursive (browser->bookmarks,
+        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, FALSE);
     if (!bookmarks)
         return FALSE;
 
@@ -4308,7 +4299,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
@@ -4320,7 +4311,7 @@
     MidoriContextAction* menu = midori_context_action_new ("BookmarkContextMenu", NULL, NULL, NULL);
     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);
 
         GtkAction* action = gtk_action_new ("BookmarkOpenAllTabs", _("Open all in _Tabs"), NULL, STOCK_TAB_NEW);
@@ -4590,8 +4581,7 @@
             if (error)
                 g_error_free (error);
         }
-        midori_bookmarks_import_array (browser->bookmarks, bookmarks, selected);
-
+        midori_bookmarks_db_import_array (browser->bookmarks, bookmarks, selected);
         g_object_unref (bookmarks);
         g_free (path);
     }
@@ -4645,7 +4635,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))
     {
@@ -7060,6 +7050,16 @@
 }
 
 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)
@@ -7091,8 +7091,8 @@
     gtk_toolbar_insert (GTK_TOOLBAR (browser->bookmarkbar),
                         gtk_separator_tool_item_new (), -1);
 
-    array = midori_array_query_recursive  (browser->bookmarks,
-					     "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL, FALSE);
+    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);
@@ -7132,7 +7132,7 @@
 
 static void
 midori_browser_set_bookmarks (MidoriBrowser* browser,
-                              KatzeArray*    bookmarks)
+                              MidoriBookmarksDb*    bookmarks)
 {
     MidoriWebSettings* settings;
 
@@ -7141,6 +7141,8 @@
         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);
     }
 
@@ -7174,6 +7176,8 @@
     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-09-08 11:09:40 +0000
+++ midori/midori-frontend.c	2013-09-17 21:46:23 +0000
@@ -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);
@@ -596,11 +596,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);
 

=== modified file 'panels/midori-bookmarks.c'
--- panels/midori-bookmarks.c	2013-09-08 11:09:40 +0000
+++ panels/midori-bookmarks.c	2013-09-17 21:46:23 +0000
@@ -45,7 +45,7 @@
     GtkWidget* delete;
     GtkWidget* treeview;
     MidoriApp* app;
-    KatzeArray* array;
+    MidoriBookmarksDb* bookmarks_db;
 
     gint filter_timeout;
     gchar* filter;
@@ -125,6 +125,7 @@
     return STOCK_BOOKMARKS;
 }
 
+#if 0 /* Make sure the following function is never used */
 /* TODO: Function never used */
 void
 midori_bookmarks_export_array_db (sqlite3*    db,
@@ -138,7 +139,7 @@
     gchar* parent_id;
 
     parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
-    if (!(root_array = midori_array_query_recursive (array, "*", "parentid = %q", parent_id, FALSE)))
+    if (!(root_array = midori_bookmarks_db_query_recursive (array, "*", "parentid = %q", parent_id, FALSE)))
     {
         g_free (parent_id);
         return;
@@ -160,6 +161,7 @@
     g_free (parent_id);
     g_list_free (list);
 }
+#endif /* 0 */
 
 static KatzeArray*
 midori_bookmarks_read_from_db (MidoriBookmarks* bookmarks,
@@ -169,21 +171,21 @@
     KatzeArray* array;
 
     if (keyword && *keyword)
-        array = midori_array_query_recursive  (bookmarks->array,
-				    "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, FALSE);
+        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_recursive  (bookmarks->array,
-					"id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, FALSE);
+            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_recursive (bookmarks->array,
-						  "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, FALSE);
+            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);
 }
@@ -274,9 +276,9 @@
     else
         parentid = 0;
 
-    katze_array_remove_item (bookmarks->array, item);
     katze_item_set_meta_integer (item, "parentid", parentid);
-    katze_array_add_item (bookmarks->array, item);
+
+    midori_bookmarks_db_update_item (bookmarks->bookmarks_db, item);
 
     g_object_unref (item);
     if (new_parent)
@@ -416,9 +418,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);
@@ -451,9 +453,9 @@
     }
     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);
@@ -499,10 +501,10 @@
 
         /* 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,
+        g_signal_handlers_block_by_func (bookmarks->bookmarks_db,
             midori_bookmarks_remove_item_cb, bookmarks);
-        katze_array_remove_item (bookmarks->array, item);
-        g_signal_handlers_unblock_by_func (bookmarks->array,
+        midori_bookmarks_db_remove_item (bookmarks->bookmarks_db, item);
+        g_signal_handlers_unblock_by_func (bookmarks->bookmarks_db,
             midori_bookmarks_remove_item_cb, bookmarks);
         g_object_unref (item);
     }
@@ -585,9 +587,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);
@@ -595,13 +597,13 @@
         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_signal_connect_after (bookmarks->bookmarks_db, "add-item",
+                            G_CALLBACK (midori_bookmarks_add_item_cb), bookmarks);
+    g_signal_connect (bookmarks->bookmarks_db, "remove-item",
                       G_CALLBACK (midori_bookmarks_remove_item_cb), bookmarks);
-    g_signal_connect (bookmarks->array, "update",
+    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),
@@ -835,7 +837,7 @@
     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,

=== modified file 'tests/bookmarks.c'
--- tests/bookmarks.c	2012-11-25 15:37:41 +0000
+++ tests/bookmarks.c	2013-09-17 21:46:23 +0000
@@ -10,11 +10,11 @@
  */
 
 #include "midori.h"
-#include "panels/midori-bookmarks.h"
+#include "midori-bookmarks-db.h"
 
 typedef struct
 {
-    KatzeArray* db_bookmarks;
+    MidoriBookmarksDb* db_bookmarks;
     KatzeArray* test_bookmarks;
 } BookmarksFixture;
 
@@ -37,7 +37,7 @@
     KatzeArray* folder;
     gchar *errmsg = NULL;
 
-    if (!(fixture->db_bookmarks = midori_bookmarks_new (&errmsg)))
+    if (!(fixture->db_bookmarks = midori_bookmarks_db_new (&errmsg)))
         g_error ("Bookmarks couldn't be loaded: %s\n", errmsg);
     g_assert (errmsg == NULL);
     g_assert (g_object_get_data (G_OBJECT (fixture->db_bookmarks), "db"));
@@ -84,8 +84,8 @@
 fixture_teardown (BookmarksFixture* fixture,
                   const TestParameters *params)
 {
-    midori_bookmarks_on_quit (fixture->db_bookmarks);
-    g_object_unref (fixture->db_bookmarks);
+    midori_bookmarks_db_on_quit (fixture->db_bookmarks);
+    /* g_object_unref (fixture->db_bookmarks); */
     g_object_unref (fixture->test_bookmarks);
 }
 
@@ -112,7 +112,7 @@
 /* NB: assumes "title" is unique in a set */
 static void
 compare_test_and_db (KatzeArray* test_bookmarks,
-                     KatzeArray* db_bookmarks,
+                     MidoriBookmarksDb* db_bookmarks,
                      gboolean verbose)
 {
     KatzeArray* db_items;
@@ -127,7 +127,7 @@
             g_print ("----------\n");
         }
 
-        db_items = midori_array_query_recursive (db_bookmarks,
+        db_items = midori_bookmarks_db_query_recursive (db_bookmarks,
                            "*", "title='%q'", katze_item_get_name (test_item), FALSE);
 
         /* FIXME g_assert_cmpint (katze_array_get_length (db_items), ==, 1); */
@@ -142,28 +142,33 @@
 }
 
 static void
+print_bookmarks (KatzeArray* test_bookmarks)
+{
+    KatzeItem* item;
+    GList* list;
+    KATZE_ARRAY_FOREACH_ITEM_L (item, test_bookmarks, list)
+    {
+	print_bookmark (item);
+	g_print ("----------\n");
+
+        if (KATZE_ITEM_IS_FOLDER(item))
+            print_bookmarks (KATZE_ARRAY (item));
+    }
+    g_list_free (list);
+}
+
+static void
 insert_bookmarks (KatzeArray* test_bookmarks,
-                  KatzeArray* db_bookmarks,
+                  MidoriBookmarksDb* db_bookmarks,
                   gboolean verbose)
 {
-    KatzeItem* item;
-    GList* list;
-    sqlite3 *db = g_object_get_data (G_OBJECT (db_bookmarks), "db");
 
-    KATZE_ARRAY_FOREACH_ITEM_L (item, test_bookmarks, list)
+    if (verbose)
     {
-        if (verbose)
-        {
-            print_bookmark (item);
-            g_print ("----------\n");
-        }
-
-        midori_bookmarks_insert_item_db (db, item, 0);
-
-        if (KATZE_ITEM_IS_FOLDER(item))
-            insert_bookmarks (KATZE_ARRAY (item), db_bookmarks, verbose);
+	print_bookmarks (test_bookmarks);
     }
-    g_list_free (list);
+
+    midori_bookmarks_db_import_array (db_bookmarks, test_bookmarks, 0);
 }
 
 static void