Merge lp:~midori/midori/mackerel2 into lp:midori

[Cris Dywan]

Port Tabby to DatabaseStatement API

[Paweł Forysiuk (tuxator)]

review: Approve

=== modified file 'extensions/tabby.vala'
--- extensions/tabby.vala	2014-01-12 18:15:53 +0000
+++ extensions/tabby.vala	2014-03-16 20:28:56 +0000
@@ -350,29 +350,25 @@
     namespace Local {
         private class Session : Base.Session {
             public int64 id { get; private set; }
-            private unowned Sqlite.Database db;
+            private Midori.Database database;
 
             public override void add_item (Katze.Item item) {
                 GLib.DateTime time = new DateTime.now_local ();
-                string? sorting = item.get_meta_string ("sorting");
+                string? sorting = item.get_meta_string ("sorting") ?? "1";
                 string sqlcmd = "INSERT INTO `tabs` (`crdate`, `tstamp`, `session_id`, `uri`, `title`, `sorting`) VALUES (:tstamp, :tstamp, :session_id, :uri, :title, :sorting);";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tstamp"), time.to_unix ());
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                stmt.bind_text (stmt.bind_parameter_index (":uri"), item.uri);
-                stmt.bind_text (stmt.bind_parameter_index (":title"), item.name);
-                if (sorting == null)
-                    stmt.bind_double (stmt.bind_parameter_index (":sorting"), double.parse ("1"));
-                else
-                    stmt.bind_double (stmt.bind_parameter_index (":sorting"), double.parse (sorting));
 
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg);
-                else {
-                    int64 tab_id = this.db.last_insert_rowid ();
+                try {
+                    var statement = database.prepare (sqlcmd,
+                        ":tstamp", typeof (int64), time.to_unix (),
+                        ":session_id", typeof (int64), this.id,
+                        ":uri", typeof (string), item.uri,
+                        ":title", typeof (string), item.name,
+                        ":sorting", typeof (double), double.parse (sorting));
+                    statement.exec ();
+                    int64 tab_id = statement.row_id ();
                     item.set_meta_integer ("tabby-id", tab_id);
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
                 }
             }
 
@@ -380,28 +376,28 @@
                 unowned Katze.Item item = view.get_proxy_item ();
                 int64 tab_id = item.get_meta_integer ("tabby-id");
                 string sqlcmd = "UPDATE `tabs` SET uri = :uri WHERE session_id = :session_id AND id = :tab_id;";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
-                stmt.bind_text (stmt.bind_parameter_index (":uri"), uri);
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tab_id"), tab_id);
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
+                try {
+                    database.prepare (sqlcmd,
+                                      ":uri", typeof (string), uri,
+                                      ":session_id", typeof (int64), this.id,
+                                      ":tab_id", typeof (int64), tab_id).exec ();
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
+                }
             }
 
             protected override void data_changed (Midori.View view) {
                 unowned Katze.Item item = view.get_proxy_item ();
                 int64 tab_id = item.get_meta_integer ("tabby-id");
                 string sqlcmd = "UPDATE `tabs` SET title = :title WHERE session_id = :session_id AND id = :tab_id;";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
-                stmt.bind_text (stmt.bind_parameter_index (":title"), view.get_display_title ());
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tab_id"), tab_id);
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
+                try {
+                    database.prepare (sqlcmd,
+                                      ":title", typeof (string), view.get_display_title (),
+                                      ":session_id", typeof (int64), this.id,
+                                      ":tab_id", typeof (int64), tab_id).exec ();
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
+                }
             }
 
             protected override void tab_added (Midori.Browser browser, Midori.View view) {
@@ -419,13 +415,13 @@
                 int64 tab_id = item.get_meta_integer ("tabby-id");
                 /* FixMe: mark as deleted */
                 string sqlcmd = "DELETE FROM `tabs` WHERE session_id = :session_id AND id = :tab_id;";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tab_id"), tab_id);
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
+                try {
+                    database.prepare (sqlcmd,
+                                      ":session_id", typeof (int64), this.id,
+                                      ":tab_id", typeof (int64), tab_id).exec ();
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
+                }
             }
 
             protected override void tab_switched (Midori.View? old_view, Midori.View? new_view) {
@@ -433,14 +429,14 @@
                 unowned Katze.Item item = new_view.get_proxy_item ();
                 int64 tab_id = item.get_meta_integer ("tabby-id");
                 string sqlcmd = "UPDATE `tabs` SET tstamp = :tstamp WHERE session_id = :session_id AND id = :tab_id;";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tab_id"), tab_id);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tstamp"), time.to_unix ());
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
+                try {
+                    database.prepare (sqlcmd,
+                        ":session_id", typeof (int64), this.id,
+                        ":tab_id", typeof (int64), tab_id,
+                        ":tstamp", typeof (int64), time.to_unix ()).exec ();
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
+                }
             }
 
             protected override void tab_reordered (Gtk.Widget tab, uint pos) {
@@ -450,36 +446,29 @@
                 unowned Katze.Item item = view.get_proxy_item ();
                 int64 tab_id = item.get_meta_integer ("tabby-id");
                 string sqlcmd = "UPDATE `tabs` SET sorting = :sorting WHERE session_id = :session_id AND id = :tab_id;";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tab_id"), tab_id);
-                stmt.bind_double (stmt.bind_parameter_index (":sorting"), sorting);
-
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
+                try {
+                    database.prepare (sqlcmd,
+                        ":session_id", typeof (int64), this.id,
+                        ":tab_id", typeof (int64), tab_id,
+                        ":sorting", typeof (double), sorting).exec ();
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
+                }
 
                 item.set_meta_string ("sorting", sorting.to_string ());
             }
 
             public override void remove() {
-                string sqlcmd = "DELETE FROM `tabs` WHERE session_id = :session_id;";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
-
-                sqlcmd = "DELETE FROM `sessions` WHERE id = :session_id;";
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
+                string sqlcmd = """
+                    DELETE FROM `tabs` WHERE session_id = :session_id;
+                    DELETE FROM `sessions` WHERE id = :session_id;
+                    """;
+                try {
+                    database.prepare (sqlcmd,
+                        ":session_id", typeof (int64), this.id). exec ();
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
+                }
             }
 
             public override void close() {
@@ -501,104 +490,98 @@
 
                 GLib.DateTime time = new DateTime.now_local ();
                 string sqlcmd = "UPDATE `sessions` SET closed = 1, tstamp = :tstamp WHERE id = :session_id;";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
-
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tstamp"), time.to_unix ());
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg ());
+                try {
+                    database.prepare (sqlcmd,
+                        ":session_id", typeof (int64), this.id,
+                        ":tstamp", typeof (int64), time.to_unix ()).exec ();
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
+                }
             }
 
             public override Katze.Array get_tabs() {
                 Katze.Array tabs = new Katze.Array (typeof (Katze.Item));
 
                 string sqlcmd = "SELECT id, uri, title, sorting FROM tabs WHERE session_id = :session_id ORDER BY tstamp DESC";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to select from database: %s"), db.errmsg ());
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                int result = stmt.step ();
-                if (!(result == Sqlite.DONE || result == Sqlite.ROW)) {
-                    critical (_("Failed to select from database: %s"), db.errmsg ());
-                    return tabs;
+                try {
+                    var statement = database.prepare (sqlcmd,
+                        ":session_id", typeof (int64), this.id);
+                    while (statement.step ()) {
+                        Katze.Item item = new Katze.Item ();
+                        int64 id = statement.get_int64 ("id");
+                        string uri = statement.get_string ("uri");
+                        string title = statement.get_string ("title");
+                        double sorting = statement.get_double ("sorting");
+                        item.uri = uri;
+                        item.name = title;
+                        item.set_meta_integer ("tabby-id", id);
+                        item.set_meta_string ("sorting", sorting.to_string ());
+                        tabs.add_item (item);
+                    }
+                } catch (Error error) {
+                    critical (_("Failed to select from database: %s"), error.message);
                 }
-
-                while (result == Sqlite.ROW) {
-                    Katze.Item item = new Katze.Item ();
-                    int64 id = stmt.column_int64 (0);
-                    string uri = stmt.column_text (1);
-                    string title = stmt.column_text (2);
-                    item.uri = uri;
-                    item.name = title;
-                    item.set_meta_integer ("tabby-id", id);
-                    item.set_meta_string ("sorting", stmt.column_double (3).to_string ());
-                    tabs.add_item (item);
-                    result = stmt.step ();
-                 }
-
-                 return tabs;
+                return tabs;
             }
 
             public override double? get_max_sorting () {
                 string sqlcmd = "SELECT MAX(sorting) FROM tabs WHERE session_id = :session_id";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to select from database: %s"), db.errmsg ());
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                int result = stmt.step ();
-                if (!(result == Sqlite.DONE || result == Sqlite.ROW)) {
-                    critical (_("Failed to select from database: %s"), db.errmsg ());
-                } else if (result == Sqlite.ROW) {
+                try {
+                    var statement = database.prepare (sqlcmd,
+                        ":session_id", typeof (int64), this.id);
+                    statement.step ();
                     double? sorting;
-                    string? sorting_string = stmt.column_double (0).to_string ();
-                    if (sorting_string != null) { /* we have to use a seperate if condition to avoid a `possibly unassigned local variable` error */
+                    string? sorting_string = statement.get_int64 ("MAX(sorting)").to_string ();
+                    if (sorting_string != null) {
+                        /* we have to use a seperate if condition to avoid
+                           a `possibly unassigned local variable` error */
                         if (double.try_parse (sorting_string, out sorting)) {
                             return sorting;
                         }
                     }
-                 }
+                } catch (Error error) {
+                    critical (_("Failed to select from database: %s"), error.message);
+                }
 
                  return double.parse ("0");
             }
 
-            internal Session (Sqlite.Database db) {
-                this.db = db;
+            internal Session (Midori.Database database) {
+                this.database = database;
 
                 GLib.DateTime time = new DateTime.now_local ();
 
                 string sqlcmd = "INSERT INTO `sessions` (`tstamp`) VALUES (:tstamp);";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tstamp"), time.to_unix ());
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg);
-                else
-                    this.id = this.db.last_insert_rowid ();
+
+                try {
+                    var statement = database.prepare (sqlcmd,
+                        ":tstamp", typeof (int64), time.to_unix ());
+                    statement.exec ();
+                    this.id = statement.row_id ();
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
+                }
             }
 
-            internal Session.with_id (Sqlite.Database db, int64 id) {
-                this.db = db;
+            internal Session.with_id (Midori.Database database, int64 id) {
+                this.database = database;
                 this.id = id;
 
                 GLib.DateTime time = new DateTime.now_local ();
                 string sqlcmd = "UPDATE `sessions` SET closed = 0, tstamp = :tstamp WHERE id = :session_id;";
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to update database: %s"), db.errmsg);
 
-                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
-                stmt.bind_int64 (stmt.bind_parameter_index (":tstamp"), time.to_unix ());
-                if (stmt.step () != Sqlite.DONE)
-                    critical (_("Failed to update database: %s"), db.errmsg);
+                try {
+                    database.prepare (sqlcmd,
+                        ":session_id", typeof (int64), this.id,
+                        ":tstamp", typeof (int64), time.to_unix ()).exec ();
+                } catch (Error error) {
+                    critical (_("Failed to update database: %s"), error.message);
+                }
             }
         }
 
         private class Storage : Base.Storage {
             private Midori.Database database;
-            private unowned Sqlite.Database db;
 
             public override Katze.Array get_sessions () {
                 Katze.Array sessions = new Katze.Array (typeof (Session));
@@ -609,39 +592,38 @@
                     SELECT * FROM (SELECT id, closed FROM sessions WHERE closed = 1 ORDER BY tstamp DESC LIMIT 1)
                     ORDER BY closed;
                 """;
-                Sqlite.Statement stmt;
-                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
-                    critical (_("Failed to select from database: %s"), db.errmsg);
-                int result = stmt.step ();
-                if (!(result == Sqlite.DONE || result == Sqlite.ROW)) {
-                    critical (_("Failed to select from database: %s"), db.errmsg);
-                    return sessions;
-                }
-
-                while (result == Sqlite.ROW) {
-                    int64 id = stmt.column_int64 (0);
-                    int64 closed = stmt.column_int64 (1);
-                    if (closed == 0 || sessions.is_empty ()) {
-                        sessions.add_item (new Session.with_id (this.db, id));
+                try {
+                    var statement = database.prepare (sqlcmd);
+                    while (statement.step ()) {
+                        int64 id = statement.get_int64 ("id");
+                        int64 closed = statement.get_int64 ("closed");
+                        if (closed == 0 || sessions.is_empty ()) {
+                            sessions.add_item (new Session.with_id (this.database, id));
+                        }
                     }
-                    result = stmt.step ();
-                 }
+                } catch (Error error) {
+                    critical (_("Failed to select from database: %s"), error.message);
+                }
 
                 if (sessions.is_empty ()) {
-                    sessions.add_item (new Session (this.db));
+                    sessions.add_item (new Session (this.database));
                 }
 
                 return sessions;
             }
 
             public override void import_session (Katze.Array tabs) {
-                this.db.exec ("BEGIN;");
-                base.import_session(tabs);
-                this.db.exec("COMMIT;");
+                try {
+                    database.transaction (()=>{
+                        base.import_session(tabs); return true;
+                    });
+                } catch (Error error) {
+                    critical (_("Failed to select from database: %s"), error.message);
+                }
             }
 
             public override Base.Session get_new_session () {
-                return new Session (this.db) as Base.Session;
+                return new Session (this.database) as Base.Session;
             }
 
             internal Storage (Midori.App app) {
@@ -652,7 +634,6 @@
                 } catch (Midori.DatabaseError schema_error) {
                     error (schema_error.message);
                 }
-                db = database.db;
 
                 if (database.first_use) {
                     string config_file = Midori.Paths.get_config_filename_for_reading ("session.xbel");
 
=== modified file 'midori/midori-database.vala'
--- midori/midori-database.vala	2014-01-29 21:52:10 +0000
+++ midori/midori-database.vala	2014-03-16 20:28:56 +0000
@@ -23,6 +23,11 @@
     }
 
     /*
+     * Since: 0.5.8
+     */
+    public delegate bool DatabaseCallback () throws DatabaseError;
+
+    /*
      * Since: 0.5.7
      */
     public class DatabaseStatement : GLib.Object, GLib.Initable {
@@ -30,6 +35,7 @@
         protected Sqlite.Statement _stmt = null;
         public Database? database { get; set construct; }
         public string? query { get; set construct; }
+        private int64 last_row_id = -1;
 
         public DatabaseStatement (Database database, string query) throws DatabaseError {
             Object (database: database, query: query);
@@ -79,9 +85,21 @@
             int result = stmt.step ();
             if (result != Sqlite.DONE && result != Sqlite.ROW)
                 throw new DatabaseError.EXECUTE (database.db.errmsg ());
+            last_row_id = database.db.last_insert_rowid ();
             return result == Sqlite.ROW;
         }
 
+        /*
+         * Returns the id of the last inserted row.
+         * It is an error to ask for an id without having inserted a row.
+         * Since: 0.5.8
+         */
+        public int64 row_id () throws DatabaseError {
+            if (last_row_id == -1)
+                throw new DatabaseError.EXECUTE ("No row id");
+            return last_row_id;
+        }
+
         private int column_index (string name) throws DatabaseError {
             for (int i = 0; i < stmt.column_count (); i++) {
                 if (name == stmt.column_name (i))
@@ -219,9 +237,14 @@
             } catch (Error error) {
                 throw new DatabaseError.FILENAME ("Failed to open schema: %s".printf (schema_filename));
             }
-            schema = "BEGIN TRANSACTION; %s; COMMIT;".printf (schema);
-            if (db.exec (schema) != Sqlite.OK)
-                throw new DatabaseError.EXECUTE ("Failed to execute schema: %s".printf (schema));
+            transaction (()=> { return exec (schema); });
+            return true;
+        }
+
+        public bool transaction (DatabaseCallback callback) throws DatabaseError {
+            exec ("BEGIN TRANSACTION;");
+            callback ();
+            exec ("COMMIT;");
             return true;
         }