Merge branch 'query_experiments'

3 files changed, 77 insertions, 60 deletions

diff --git a/configure.ac b/configure.ac
index df5f23d1..0e141739 100644
--- a/configure.ac
+++ b/configure.ac
@@ -12,7 +12,7 @@ AC_PROG_CXX
 AC_DISABLE_STATIC
 AC_PROG_LIBTOOL
 
-AM_PROG_VALAC([0.17.4])
+AM_PROG_VALAC([0.18.0])
 AS_IF([test -z "$VALAC"], [AC_MSG_ERROR(["No Vala compiler found."])])
 
 AM_SILENT_RULES([yes])
@@ -29,7 +29,7 @@ AC_SUBST(CPPFLAGS)
 AC_SUBST(LDFLAGS)
 
 GLIB_REQUIRED=2.26.0
-SQLITE_REQUIRED=3.7
+SQLITE_REQUIRED=3.7.14
 VALADOC_REQUIRED=0.2
 
 ZEITGEIST_REQUIRED="glib-2.0 >= $GLIB_REQUIRED
diff --git a/libzeitgeist/log.vala b/libzeitgeist/log.vala
index 67dc0238..fa23efb5 100644
--- a/libzeitgeist/log.vala
+++ b/libzeitgeist/log.vala
@@ -137,11 +137,14 @@ public class Log : QueuedProxyWrapper
     * @param events An {@link GenericArray} of {@link Event}
     * @param cancellable To cancel the operation or NULL
     */
-    public async Array<uint32> insert_events (owned GenericArray<Event> events,
+    public async Array<uint32> insert_events (GenericArray<Event> events,
         Cancellable? cancellable=null) throws Error
     {
+        var events_cp = new GenericArray<Event>();
+        for (int i = 0; i < events.length; i++)
+            events_cp.add(events.get(i));
         yield wait_for_proxy ();
-        uint32[] ids = yield proxy.insert_events (Events.to_variant (events), cancellable);
+        uint32[] ids = yield proxy.insert_events (Events.to_variant (events_cp), cancellable);
         var result = new Array<uint32> ();
         // Ideally we'd just place "(owned) ids" into the GArray, but .data isn't
         // in the Vala bindings...
@@ -178,7 +181,7 @@ public class Log : QueuedProxyWrapper
     *
     * @param events An {@link GenericArray} of {@link Event}
     */
-    public async void insert_events_no_reply (owned GenericArray<Event> events)
+    public async void insert_events_no_reply (GenericArray<Event> events)
         throws Error
     {
         yield insert_events (events);
@@ -210,15 +213,18 @@ public class Log : QueuedProxyWrapper
     */
     public async ResultSet find_events (
         TimeRange time_range,
-        owned GenericArray<Event> event_templates,
+        GenericArray<Event> event_templates,
         StorageState storage_state,
         uint32 num_events,
         ResultType result_type,
         Cancellable? cancellable=null) throws Error
     {
+        var event_templates_cp = new GenericArray<Event>();
+        for (int i = 0; i < event_templates.length; i++)
+            event_templates_cp.add(event_templates.get(i));
         yield wait_for_proxy ();
         var result = yield proxy.find_events (time_range.to_variant (),
-            Events.to_variant (event_templates), storage_state,
+            Events.to_variant (event_templates_cp), storage_state,
             num_events, result_type, cancellable);
         return new SimpleResultSet (Events.from_variant (result));
     }
@@ -247,15 +253,18 @@ public class Log : QueuedProxyWrapper
     */
     public async uint32[] find_event_ids (
         TimeRange time_range,
-        owned GenericArray<Event> event_templates,
+        GenericArray<Event> event_templates,
         StorageState storage_state,
         uint32 num_events,
         ResultType result_type,
         Cancellable? cancellable=null) throws Error
     {
+        var event_templates_cp = new GenericArray<Event>();
+        for (int i = 0; i < event_templates.length; i++)
+            event_templates_cp.add(event_templates.get(i));
         yield wait_for_proxy ();
         return yield proxy.find_event_ids (time_range.to_variant (),
-            Events.to_variant (event_templates), storage_state,
+            Events.to_variant (event_templates_cp), storage_state,
             num_events, result_type, cancellable);
     }
 
@@ -276,13 +285,13 @@ public class Log : QueuedProxyWrapper
     * @param cancellable To cancel the operation or NULL
     */
     public async ResultSet get_events (
-        owned Array<uint32> event_ids,
+        Array<uint32> event_ids,
         Cancellable? cancellable=null) throws Error
     {
         uint32[] simple_event_ids = new uint32[event_ids.length];
-        yield wait_for_proxy ();
         for (int i = 0; i < event_ids.length; i++)
             simple_event_ids[i] = event_ids.index (i);
+        yield wait_for_proxy ();
         var result = yield proxy.get_events (simple_event_ids, cancellable);
         return new SimpleResultSet(Events.from_variant (result));
     }
@@ -304,17 +313,25 @@ public class Log : QueuedProxyWrapper
     */
     public async string[] find_related_uris (
         TimeRange time_range,
-        owned GenericArray<Event> event_templates,
-        owned GenericArray<Event> result_event_templates,
+        GenericArray<Event> event_templates,
+        GenericArray<Event> result_event_templates,
         StorageState storage_state,
         uint32 num_events,
         ResultType result_type,
         Cancellable? cancellable=null) throws Error
     {
+        var events_cp = new GenericArray<Event>();
+        for (int i = 0; i < event_templates.length; i++)
+            events_cp.add(event_templates.get(i));
+
+        var results_cp = new GenericArray<Event>();
+        for (int i = 0; i < result_event_templates.length; i++)
+            results_cp.add(result_event_templates.get(i));
+
         yield wait_for_proxy ();
         return yield proxy.find_related_uris (time_range.to_variant (),
-            Events.to_variant (event_templates),
-            Events.to_variant (result_event_templates),
+            Events.to_variant (events_cp),
+            Events.to_variant (results_cp),
             storage_state, num_events, result_type, cancellable);
     }
 
@@ -326,13 +343,13 @@ public class Log : QueuedProxyWrapper
     *
     * @param event_ids Array<uint32>
     */
-    public async TimeRange delete_events (owned Array<uint32> event_ids,
+    public async TimeRange delete_events (Array<uint32> event_ids,
             Cancellable? cancellable=null) throws Error
     {
-        yield wait_for_proxy ();
         uint32[] _ids = new uint32 [event_ids.length];
         for (int i=0; i<event_ids.length; i++)
             _ids[i] = event_ids.index(i);
+        yield wait_for_proxy ();
         Variant time_range = yield proxy.delete_events (_ids, cancellable);
         return new TimeRange.from_variant(time_range);
     }
@@ -350,7 +367,7 @@ public class Log : QueuedProxyWrapper
     *
     * @param monitor A {@link Monitor} to report back inserts and deletes
     */
-    public void install_monitor (owned Monitor monitor) throws Error
+    public void install_monitor (Monitor monitor) throws Error
     {
         // FIXME
         //monitor.destroy.connect (() => {});
diff --git a/src/db-reader.vala b/src/db-reader.vala
index f9434e1a..c78e155d 100644
--- a/src/db-reader.vala
+++ b/src/db-reader.vala
@@ -171,7 +171,7 @@ public class DbReader : Object
     public uint32[] find_event_ids_for_clause (WhereClause where,
         uint max_events, uint result_type) throws EngineError
     {
-        string sql = "SELECT DISTINCT id FROM event_view ";
+        string sql = "SELECT id FROM event_view ";
         string where_sql = "";
         if (!where.is_empty ())
         {
@@ -187,103 +187,103 @@ public class DbReader : Object
                 sql += where_sql + " ORDER BY ";
                 break;
             case ResultType.MOST_RECENT_EVENT_ORIGIN:
-                sql += group_and_sort ("origin", where_sql);
+                sql = group_and_sort ("origin", where_sql);
                 break;
             case ResultType.LEAST_RECENT_EVENT_ORIGIN:
-                sql += group_and_sort ("origin", where_sql);
+                sql = group_and_sort ("origin", where_sql);
                 break;
             case ResultType.MOST_POPULAR_EVENT_ORIGIN:
-                sql += group_and_sort ("origin", where_sql, false);
+                sql = group_and_sort ("origin", where_sql, false);
                 break;
             case ResultType.LEAST_POPULAR_EVENT_ORIGIN:
-                sql += group_and_sort ("origin", where_sql, true);
+                sql = group_and_sort ("origin", where_sql, true);
                 break;
             case ResultType.MOST_RECENT_SUBJECTS:
-                sql += group_and_sort ("subj_id", where_sql);
+                sql = group_and_sort ("subj_id", where_sql);
                 break;
             case ResultType.LEAST_RECENT_SUBJECTS:
-                sql += group_and_sort ("subj_id", where_sql);
+                sql = group_and_sort ("subj_id", where_sql);
                 break;
             case ResultType.MOST_POPULAR_SUBJECTS:
-                sql += group_and_sort ("subj_id", where_sql, false);
+                sql = group_and_sort ("subj_id", where_sql, false);
                 break;
             case ResultType.LEAST_POPULAR_SUBJECTS:
-                sql += group_and_sort ("subj_id", where_sql, true);
+                sql = group_and_sort ("subj_id", where_sql, true);
                 break;
             case ResultType.MOST_RECENT_CURRENT_URI:
-                sql += group_and_sort ("subj_id_current", where_sql);
+                sql = group_and_sort ("subj_id_current", where_sql);
                 break;
             case ResultType.LEAST_RECENT_CURRENT_URI:
-                sql += group_and_sort ("subj_id_current", where_sql);
+                sql = group_and_sort ("subj_id_current", where_sql);
                 break;
             case ResultType.MOST_POPULAR_CURRENT_URI:
-                sql += group_and_sort ("subj_id_current", where_sql, false);
+                sql = group_and_sort ("subj_id_current", where_sql, false);
                 break;
             case ResultType.LEAST_POPULAR_CURRENT_URI:
-                sql += group_and_sort ("subj_id_current", where_sql, true);
+                sql = group_and_sort ("subj_id_current", where_sql, true);
                 break;
             case ResultType.MOST_RECENT_ACTOR:
-                sql += group_and_sort ("actor", where_sql);
+                sql = group_and_sort ("actor", where_sql);
                 break;
             case ResultType.LEAST_RECENT_ACTOR:
-                sql += group_and_sort ("actor", where_sql);
+                sql = group_and_sort ("actor", where_sql);
                 break;
             case ResultType.MOST_POPULAR_ACTOR:
-                sql += group_and_sort ("actor", where_sql, false);
+                sql = group_and_sort ("actor", where_sql, false);
                 break;
             case ResultType.LEAST_POPULAR_ACTOR:
-                sql += group_and_sort ("actor", where_sql, true);
+                sql = group_and_sort ("actor", where_sql, true);
                 break;
             case ResultType.OLDEST_ACTOR:
-                sql += group_and_sort ("actor", where_sql, null, "min");
+                sql = group_and_sort ("actor", where_sql, null, "min");
                 break;
             case ResultType.MOST_RECENT_ORIGIN:
-                sql += group_and_sort ("subj_origin", where_sql);
+                sql = group_and_sort ("subj_origin", where_sql);
                 break;
             case ResultType.LEAST_RECENT_ORIGIN:
-                sql += group_and_sort ("subj_origin", where_sql);
+                sql = group_and_sort ("subj_origin", where_sql);
                 break;
             case ResultType.MOST_POPULAR_ORIGIN:
-                sql += group_and_sort ("subj_origin", where_sql, false);
+                sql = group_and_sort ("subj_origin", where_sql, false);
                 break;
             case ResultType.LEAST_POPULAR_ORIGIN:
-                sql += group_and_sort ("subj_origin", where_sql, true);
+                sql = group_and_sort ("subj_origin", where_sql, true);
                 break;
             case ResultType.MOST_RECENT_CURRENT_ORIGIN:
-                sql += group_and_sort ("subj_origin_current", where_sql);
+                sql = group_and_sort ("subj_origin_current", where_sql);
                 break;
             case ResultType.LEAST_RECENT_CURRENT_ORIGIN:
-                sql += group_and_sort ("subj_origin_current", where_sql);
+                sql = group_and_sort ("subj_origin_current", where_sql);
                 break;
             case ResultType.MOST_POPULAR_CURRENT_ORIGIN:
-                sql += group_and_sort ("subj_origin_current", where_sql, false);
+                sql = group_and_sort ("subj_origin_current", where_sql, false);
                 break;
             case ResultType.LEAST_POPULAR_CURRENT_ORIGIN:
-                sql += group_and_sort ("subj_origin_current", where_sql, true);
+                sql = group_and_sort ("subj_origin_current", where_sql, true);
                 break;
             case ResultType.MOST_RECENT_SUBJECT_INTERPRETATION:
-                sql += group_and_sort ("subj_interpretation", where_sql);
+                sql = group_and_sort ("subj_interpretation", where_sql);
                 break;
             case ResultType.LEAST_RECENT_SUBJECT_INTERPRETATION:
-                sql += group_and_sort ("subj_interpretation", where_sql);
+                sql = group_and_sort ("subj_interpretation", where_sql);
                 break;
             case ResultType.MOST_POPULAR_SUBJECT_INTERPRETATION:
-                sql += group_and_sort ("subj_interpretation", where_sql, false);
+                sql = group_and_sort ("subj_interpretation", where_sql, false);
                 break;
             case ResultType.LEAST_POPULAR_SUBJECT_INTERPRETATION:
-                sql += group_and_sort ("subj_interpretation", where_sql, true);
+                sql = group_and_sort ("subj_interpretation", where_sql, true);
                 break;
             case ResultType.MOST_RECENT_MIMETYPE:
-                sql += group_and_sort ("subj_mimetype", where_sql);
+                sql = group_and_sort ("subj_mimetype", where_sql);
                 break;
             case ResultType.LEAST_RECENT_MIMETYPE:
-                sql += group_and_sort ("subj_mimetype", where_sql);
+                sql = group_and_sort ("subj_mimetype", where_sql);
                 break;
             case ResultType.MOST_POPULAR_MIMETYPE:
-                sql += group_and_sort ("subj_mimetype", where_sql, false);
+                sql = group_and_sort ("subj_mimetype", where_sql, false);
                 break;
             case ResultType.LEAST_POPULAR_MIMETYPE:
-                sql += group_and_sort ("subj_mimetype", where_sql, true);
+                sql = group_and_sort ("subj_mimetype", where_sql, true);
                 break;
             default:
                 string error_message = "Invalid ResultType.";
@@ -297,8 +297,6 @@ public class DbReader : Object
 
         if (where.get_is_simple ())
             sql = sql.replace ("FROM event_view", "FROM event");
-        if (max_events > 0)
-            sql += " LIMIT %u".printf (max_events);
 
         int rc;
         Sqlite.Statement stmt;
@@ -318,8 +316,13 @@ public class DbReader : Object
 
         while ((rc = stmt.step()) == Sqlite.ROW)
         {
-            event_ids += (uint32) uint64.parse(
+            var event_id = (uint32) uint64.parse(
                 stmt.column_text (EventViewRows.ID));
+            // Events are supposed to be contiguous in the database
+            if (event_ids.length == 0 || event_ids[event_ids.length-1] != event_id) {
+                event_ids += event_id;
+                if (event_ids.length == max_events) break;
+            }
         }
         if (rc != Sqlite.DONE && rc != Sqlite.ROW)
         {
@@ -600,12 +603,9 @@ public class DbReader : Object
         }
 
         return """
-            NATURAL JOIN (
-                SELECT %s,
-                %s(timestamp) AS timestamp
+            SELECT id, %s, %s(timestamp) AS timestamp
                 %s
-                FROM event_view %s
-                GROUP BY %s)
+                FROM event_view %s AND %s IS NOT NULL
             GROUP BY %s
             ORDER BY %s 
             """.printf (