Add WIP TrackerResource classwip/resource

3 files changed, 232 insertions, 212 deletions

diff --git a/src/libtracker-sparql/Makefile.am b/src/libtracker-sparql/Makefile.am
index 48ed4ad23..94985e8a4 100644
--- a/src/libtracker-sparql/Makefile.am
+++ b/src/libtracker-sparql/Makefile.am
@@ -22,6 +22,8 @@ libtracker_sparql_la_SOURCES =   \
 	tracker-builder.vala                           \
 	tracker-connection.vala                        \
 	tracker-cursor.vala                            \
+	tracker-resource.c                             \
+	tracker-resource.h                             \
 	tracker-utils.vala                             \
 	tracker-uri.c                                  \
 	tracker-ontologies.h \
diff --git a/src/libtracker-sparql/tracker-resource.c b/src/libtracker-sparql/tracker-resource.c
new file mode 100644
index 000000000..ba7e14d3a
--- /dev/null
+++ b/src/libtracker-sparql/tracker-resource.c
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2016, Sam Thursfield <sam@afuera.me.uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "config.h"
+
+G_DEFINE_TYPE (TrackerResource, tracker_resource, G_TYPE_OBJECT);
+
+/**
+ * SECTION: tracker-resource
+ * @short_description: Represenets a single Tracker source
+ * @title: TrackerResource
+ * @stability: Stable
+ * @include: tracker-resource.h
+ *
+ * <para>
+ * #TrackerResource keeps track of a set of properties for a given resource.
+ * The resulting data can be serialized in several ways.
+ * </para>
+ */
+
+/**
+ * TrackerResource:
+ *
+ * The <structname>TrackerResource</structname> object represents information
+ * about a given resource.
+ */
+
+struct _TrackerResourcePrivate {
+	char *identifier;
+	GHashTable *properties;
+	GHashTable *properties_overwrite;
+}
+
+static void
+tracker_resource_class_init (TrackerResourceClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->finalize     = resource_finalize;
+
+	g_type_class_add_private (object_class, sizeof (TrackerResourcePrivate));
+}
+
+static void
+tracker_resource_init (TrackerResource *resource)
+{
+	resource->priv = G_TYPE_INSTANCE_GET_PRIVATE (resource,
+	                                              TRACKER_TYPE_RESOURCE,
+	                                              TrackerResourcePrivate);
+
+	/* Values of properties */
+	resource->priv->properties = g_hash_table_new_full (
+	    g_direct_hash,
+	    g_direct_equal,
+	    NULL,
+	    g_value_unset);
+
+	/* TRUE for any property where we should delete any existing values. */
+	resource->priv->properties_overwrite = g_hash_table_new_full (
+	    g_direct_hash,
+	    g_direct_equal,
+	    NULL,
+	    NULL);
+}
+
+static void
+resource_finalize (GObject *object)
+{
+	TrackerResourcePrivate *priv;
+
+	priv = ((TrackerResource *)object)->priv;
+
+	g_hash_table_unref (priv->properties_overwrite);
+	g_hash_table_unref (priv->properties);
+
+	(G_OBJECT_CLASS (tracker_resource_parent_class)->finalize) (object);
+}
+
+
+/**
+ * tracker_resource_new()
+ *
+ * Creates a TrackerResource instance.
+ *
+ * Returns: a newly created #TrackerResource. Free with g_object_unref() when done
+ *
+ * Since: 1.10
+ */
+TrackerResource *
+tracker_resource_new (const char *identifier)
+{
+	return g_object_new (TRACKER_TYPE_RESOURCE, NULL);
+}
+
+GValue *
+tracker_resource_get_property (TrackerResource *self,
+                               const char *property)
+{
+
+	return g)hash_table_lookup (self->priv->properties, property);
+}
+
+void
+tracker_resource_set_property (TrackerResource *self,
+                               const char *property,
+                               GValue *value)
+{
+	/* Note that this should generate a DELETE; INSERT in the SPARQL
+	 * query: we're assming the property has only one value.
+	 */
+	g_hash_table_replace (self->priv->properties,
+	                      property,
+	                      value);
+};
+
+gint
+tracker_resource_identifier_compare_func (TrackerResource *resource,
+                                          const char *identifier)
+{
+	return g_strcmp (resource->priv->identifier, identifier);
+}
diff --git a/src/tracker-extract/tracker-extract-gstreamer.c b/src/tracker-extract/tracker-extract-gstreamer.c
index a419b54c7..723461137 100644
--- a/src/tracker-extract/tracker-extract-gstreamer.c
+++ b/src/tracker-extract/tracker-extract-gstreamer.c
@@ -2,6 +2,7 @@
  * Copyright (C) 2006, Laurent Aguerreche <laurent.aguerreche@free.fr>
  * Copyright (C) 2007, Jamie McCracken <jamiemcc@gnome.org>
  * Copyright (C) 2008, Nokia <ivan.frade@nokia.com>
+ * Copyright (C) 2016, Sam Thursfield <sam@afuera.me.uk>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -155,91 +156,44 @@ static void common_extract_stream_metadata (MetadataExtractor    *extractor,
 
 static void
 add_artist (MetadataExtractor     *extractor,
-            TrackerSparqlBuilder  *preupdate,
-            const gchar           *graph,
             const gchar           *artist_name,
             gchar                **p_artist_uri)
 {
+	TrackerResource *artist;
+	GValue *value;
+
 	g_return_if_fail (artist_name != NULL);
 
 	*p_artist_uri = tracker_sparql_escape_uri_printf ("urn:artist:%s", artist_name);
 
 	/* Check if already added to the preupdate, to avoid sending 9 identical INSERTs */
-	if (g_slist_find_custom (extractor->artist_list, artist_name, (GCompareFunc) strcmp))
+	if (g_slist_find_custom (extractor->artist_list, artist_name, tracker_resource_identifier_compare_func))
 		return;
 
-	tracker_sparql_builder_insert_open (preupdate, NULL);
-	if (graph) {
-		tracker_sparql_builder_graph_open (preupdate, graph);
-	}
-
-	tracker_sparql_builder_subject_iri (preupdate, *p_artist_uri);
-	tracker_sparql_builder_predicate (preupdate, "a");
-	tracker_sparql_builder_object (preupdate, "nmm:Artist");
-	tracker_sparql_builder_predicate (preupdate, "nmm:artistName");
-	tracker_sparql_builder_object_unvalidated (preupdate, artist_name);
-
-	if (graph) {
-		tracker_sparql_builder_graph_close (preupdate);
-	}
-	tracker_sparql_builder_insert_close (preupdate);
-
-	extractor->artist_list = g_slist_prepend (extractor->artist_list, g_strdup (artist_name));
-}
-
-static void
-add_string_gst_tag (TrackerSparqlBuilder *metadata,
-                    const gchar          *key,
-                    GstTagList           *tag_list,
-                    const gchar          *tag)
-{
-	gchar *s;
-	gboolean ret;
-
-	s = NULL;
-	ret = gst_tag_list_get_string (tag_list, tag, &s);
-
-	if (s) {
-		if (ret && s[0] != '\0') {
-			tracker_sparql_builder_predicate (metadata, key);
-			tracker_sparql_builder_object_unvalidated (metadata, s);
-		}
+	artist = tracker_resource_new (*p_artist_uri);
 
-		g_free (s);
-	}
-}
-
-static void
-add_uint_gst_tag (TrackerSparqlBuilder  *metadata,
-                  const gchar           *key,
-                  GstTagList            *tag_list,
-                  const gchar           *tag)
-{
-	gboolean ret;
-	guint n;
+	g_value_set_string (value, "nmm:Artist");
+	tracker_resource_set_property("rdf:type", value);
 
-	ret = gst_tag_list_get_uint (tag_list, tag, &n);
+	g_value_set_string (value, artist_name);
+	tracker_resource_set_property("nmm:artistName", value);
 
-	if (ret) {
-		tracker_sparql_builder_predicate (metadata, key);
-		tracker_sparql_builder_object_int64 (metadata, n);
-	}
+	extractor->artist_list = g_slist_prepend (extractor->artist_list, artist);
 }
 
 static void
-add_double_gst_tag (TrackerSparqlBuilder  *metadata,
-                    const gchar           *key,
-                    GstTagList            *tag_list,
-                    const gchar           *tag)
+add_gst_tag (TrackerResource      *resource,
+             const gchar          *key,
+             GstTagList           *tag_list,
+             const gchar          *tag)
 {
 	gboolean ret;
-	gdouble n;
+	GValue *value;
 
-	ret = gst_tag_list_get_double (tag_list, tag, &n);
+	ret = gst_tag_list_copy_value (&value, tag_list, tag);
 
 	if (ret) {
-		tracker_sparql_builder_predicate (metadata, key);
-		tracker_sparql_builder_object_int64 (metadata, (gint64) n);
+		tracker_resource_set_property (key, value);
 	}
 }
 
@@ -359,7 +313,7 @@ add_date_time_gst_tag_with_mtime_fallback (TrackerSparqlBuilder  *metadata,
 }
 
 static void
-add_keywords_gst_tag (TrackerSparqlBuilder *metadata,
+add_keywords_gst_tag (TrackerResource      *resource,
                       GstTagList           *tag_list)
 {
 	gboolean ret;
@@ -374,8 +328,9 @@ add_keywords_gst_tag (TrackerSparqlBuilder *metadata,
 		keywords = g_strsplit_set (str, " ,", -1);
 
 		while (keywords[i]) {
-			tracker_sparql_builder_predicate (metadata, "nie:keyword");
-			tracker_sparql_builder_object_unvalidated (metadata, g_strstrip (keywords[i]));
+			GValue *value;
+			g_value_set_string (&value, g_strstrip (keywords[i]);
+			tracker_resource_append_property ("nie:keyword", value);
 			i++;
 		}
 
@@ -385,46 +340,20 @@ add_keywords_gst_tag (TrackerSparqlBuilder *metadata,
 }
 
 static void
-replace_double_gst_tag (TrackerSparqlBuilder  *preupdate,
-                        const gchar           *uri,
-                        const gchar           *key,
-                        GstTagList            *tag_list,
-                        const gchar           *tag,
-                        const gchar           *graph)
+replace_gst_tag (TrackerSparqlBuilder  *preupdate,
+                 const gchar           *key,
+                 GstTagList            *tag_list,
+                 const gchar           *tag)
 {
-	gdouble  value;
+	GValue *value;
 	gboolean has_it;
 
-	has_it = gst_tag_list_get_double (tag_list, tag, &value);
+	has_it = gst_tag_list_copy_value (tag_list, tag, &value);
 
 	if (! has_it)
 		return;
 
-	tracker_sparql_builder_delete_open (preupdate, NULL);
-	tracker_sparql_builder_subject_iri (preupdate, uri);
-	tracker_sparql_builder_predicate (preupdate, key);
-	tracker_sparql_builder_object_variable (preupdate, "unknown");
-	tracker_sparql_builder_delete_close (preupdate);
-
-	tracker_sparql_builder_where_open (preupdate);
-	tracker_sparql_builder_subject_iri (preupdate, uri);
-	tracker_sparql_builder_predicate (preupdate, key);
-	tracker_sparql_builder_object_variable (preupdate, "unknown");
-	tracker_sparql_builder_where_close (preupdate);
-
-	tracker_sparql_builder_insert_open (preupdate, NULL);
-	if (graph) {
-		tracker_sparql_builder_graph_open (preupdate, graph);
-	}
-
-	tracker_sparql_builder_subject_iri (preupdate, uri);
-	tracker_sparql_builder_predicate (preupdate, key);
-	tracker_sparql_builder_object_double (preupdate, value);
-
-	if (graph) {
-		tracker_sparql_builder_graph_close (preupdate);
-	}
-	tracker_sparql_builder_insert_close (preupdate);
+	tracker_resource_set_property (key, value);
 }
 
 static gchar *
@@ -534,13 +463,13 @@ get_embedded_media_art (MetadataExtractor *extractor)
 static void
 extractor_apply_geolocation_metadata (MetadataExtractor     *extractor,
                                       GstTagList            *tag_list,
-                                      TrackerSparqlBuilder  *preupdate,
-                                      TrackerSparqlBuilder  *metadata,
-                                      const gchar           *graph)
+                                      TrackerResource       *main_resource)
 {
+	GSList *new)resources = NULL;
 	gchar *country = NULL, *city = NULL, *sublocation = NULL;
 	gdouble lat, lon, alt;
 	gboolean has_coords;
+	GValue *value;
 
 	g_debug ("Retrieving geolocation metadata...");
 
@@ -554,66 +483,58 @@ extractor_apply_geolocation_metadata (MetadataExtractor     *extractor,
 	gst_tag_list_get_string (tag_list, GST_TAG_GEO_LOCATION_SUBLOCATION, &sublocation);
 
 	if (city || country || sublocation || has_coords) {
+		TrackerResource *address;
+		TrackerResource *location;
 		gchar *address_uri = NULL;
 
 		/* Create postal address */
 		if (city || country || sublocation) {
 			address_uri = tracker_sparql_get_uuid_urn ();
+			address = tracker_resource_new (address_uri);
 
-			tracker_sparql_builder_insert_open (preupdate, NULL);
-			if (graph) {
-				tracker_sparql_builder_graph_open (preupdate, graph);
-			}
-
-			tracker_sparql_builder_subject_iri (preupdate, address_uri);
-			tracker_sparql_builder_predicate (preupdate, "a");
-			tracker_sparql_builder_object (preupdate, "nco:PostalAddress");
+			g_value_set_string (value, "nco:PostalAddress");
+			tracker_resource_set_property ("rdf:type", value);
 
 			if (sublocation) {
-				tracker_sparql_builder_predicate (preupdate, "nco:region");
-				tracker_sparql_builder_object_unvalidated (preupdate, sublocation);
+				g_value_set_string (value, sublocation);
+				tracker_resource_set_property ("nco:region", value);
 			}
 
 			if (city) {
-				tracker_sparql_builder_predicate (preupdate, "nco:locality");
-				tracker_sparql_builder_object_unvalidated (preupdate, city);
+				g_value_set_string (value, city);
+				tracker_resource_set_property ("nco:locality", value);
 			}
 
 			if (country) {
-				tracker_sparql_builder_predicate (preupdate, "nco:country");
-				tracker_sparql_builder_object_unvalidated (preupdate, country);
+				g_value_set_string (value, country);
+				tracker_resource_set_property ("nco:country", value);
 			}
-
-			if (graph) {
-				tracker_sparql_builder_graph_close (preupdate);
-			}
-			tracker_sparql_builder_insert_close (preupdate);
 		}
 
-		/* Create geolocation */
-		tracker_sparql_builder_predicate (metadata, "slo:location");
+		location = tracker_resource_new (NULL);
+		g_value_set_object (value, location);
+		tracker_resource_set_property )main_resource, "slo:location", value);
 
-		tracker_sparql_builder_object_blank_open (metadata);
-		tracker_sparql_builder_predicate (metadata, "a");
-		tracker_sparql_builder_object (metadata, "slo:GeoLocation");
+		tracker_resource_set_property (location, "slo:GeoLocation");
 
 		if (address_uri) {
-			tracker_sparql_builder_predicate (metadata, "slo:postalAddress");
-			tracker_sparql_builder_object_iri (metadata, address_uri);
+			g_value_set_object (value, address);
+			tracker_resource_set_property (main_resource,
+			                               "slo:postalAddress",
+			                               value);
 		}
 
 		if (has_coords) {
-			tracker_sparql_builder_predicate (metadata, "slo:latitude");
-			tracker_sparql_builder_object_double (metadata, lat);
+			g_value_set_double (value, lat);
+			tracker_resource_set_property ("slo:latitude", value);
 
-			tracker_sparql_builder_predicate (metadata, "slo:longitude");
-			tracker_sparql_builder_object_double (metadata, lon);
+			g_value_set_double (value, lon);
+			tracker_resource_set_property ("slo:longitude", value);
 
-			tracker_sparql_builder_predicate (metadata, "slo:altitude");
-			tracker_sparql_builder_object_double (metadata, alt);
+			g_value_set_double (value, alt);
+			tracker_resource_set_property ("slo:altitude", value);
 		}
 
-		tracker_sparql_builder_object_blank_close (metadata);
 		g_free (address_uri);
 	}
 
@@ -641,9 +562,7 @@ static void
 extractor_apply_general_metadata (MetadataExtractor     *extractor,
                                   GstTagList            *tag_list,
                                   const gchar           *file_url,
-                                  TrackerSparqlBuilder  *preupdate,
-                                  TrackerSparqlBuilder  *metadata,
-                                  const gchar           *graph,
+                                  TrackerResource       *resource,
                                   gchar                **p_performer_uri,
                                   gchar                **p_composer_uri)
 {
@@ -662,38 +581,37 @@ extractor_apply_general_metadata (MetadataExtractor     *extractor,
 	performer = tracker_coalesce_strip (2, performer_temp, artist_temp);
 
 	if (performer != NULL) {
-		add_artist (extractor, preupdate, graph, performer, p_performer_uri);
+		add_artist (extractor, performer, p_performer_uri);
 	}
 
 	if (composer != NULL) {
-		add_artist (extractor, preupdate, graph, composer, p_composer_uri);
+		add_artist (extractor, composer, p_composer_uri);
 	}
 
 	gst_tag_list_get_string (tag_list, GST_TAG_GENRE, &genre);
 	gst_tag_list_get_string (tag_list, GST_TAG_TITLE, &title);
 
 	if (genre && g_strcmp0 (genre, "Unknown") != 0) {
-		tracker_sparql_builder_predicate (metadata, "nfo:genre");
-		tracker_sparql_builder_object_unvalidated (metadata, genre);
+		tracker_resource_append_property ("nfo:genre", genre);
 	}
 
-	tracker_guarantee_title_from_file (metadata,
+	tracker_guarantee_title_from_file (resource,
 	                                   "nie:title",
 	                                   title,
 	                                   file_url,
 	                                   &title_guaranteed);
 
-	add_date_time_gst_tag_with_mtime_fallback (metadata,
+	add_date_time_gst_tag_with_mtime_fallback (resource,
 	                                           file_url,
 	                                           "nie:contentCreated",
 	                                           tag_list,
 	                                           GST_TAG_DATE_TIME,
 	                                           GST_TAG_DATE);
 
-	add_string_gst_tag (metadata, "nie:copyright", tag_list, GST_TAG_COPYRIGHT);
-	add_string_gst_tag (metadata, "nie:license", tag_list, GST_TAG_LICENSE);
-	add_string_gst_tag (metadata, "dc:coverage", tag_list, GST_TAG_LOCATION);
-	add_string_gst_tag (metadata, "nie:comment", tag_list, GST_TAG_COMMENT);
+	add_gst_tag (resource, "nie:copyright", tag_list, GST_TAG_COPYRIGHT);
+	add_gst_tag (resource, "nie:license", tag_list, GST_TAG_LICENSE);
+	add_gst_tag (resource, "dc:coverage", tag_list, GST_TAG_LOCATION);
+	add_gst_tag (resource, "nie:comment", tag_list, GST_TAG_COMMENT);
 
 #ifdef HAVE_LIBMEDIAART
 	if (extractor->media_art_type == MEDIA_ART_VIDEO) {
@@ -715,18 +633,20 @@ extractor_apply_general_metadata (MetadataExtractor     *extractor,
 static void
 extractor_apply_album_metadata (MetadataExtractor     *extractor,
                                 GstTagList            *tag_list,
-                                TrackerSparqlBuilder  *preupdate,
-                                const gchar           *graph,
+                                TrackerResource       *resource,
                                 gchar                **p_album_artist_uri,
                                 gchar                **p_album_uri,
                                 gchar                **p_album_disc_uri)
 {
-	gchar *album_artist;
+	TrackerResource *album;
+	TrackerResource *album_artist;
+	gchar *album_artist_name;
 	gchar *album_title = NULL;
 	gchar *album_artist_temp = NULL;
 	gchar *track_artist_temp = NULL;
 	gboolean has_it;
 	guint count;
+	GValue *value;
 
 	gst_tag_list_get_string (tag_list, GST_TAG_ALBUM, &album_title);
 
@@ -736,66 +656,38 @@ extractor_apply_album_metadata (MetadataExtractor     *extractor,
 	gst_tag_list_get_string (tag_list, GST_TAG_ALBUM_ARTIST, &album_artist_temp);
 	gst_tag_list_get_string (tag_list, GST_TAG_ARTIST, &track_artist_temp);
 
-	album_artist = g_strdup (tracker_coalesce_strip (2, album_artist_temp, track_artist_temp));
+	album_artist_name = g_strdup (tracker_coalesce_strip (2, album_artist_temp, track_artist_temp));
 
-        if (album_artist != NULL) {
-                add_artist (extractor, preupdate, graph, album_artist, p_album_artist_uri);
+        if (album_artist_name != NULL) {
+                album_artist = add_artist (extractor, resource, album_artist_name, p_album_artist_uri);
                 *p_album_uri = tracker_sparql_escape_uri_printf ("urn:album:%s:%s", album_title, album_artist);
         } else {
                 *p_album_uri = tracker_sparql_escape_uri_printf ("urn:album:%s", album_title);
         }
 
-	tracker_sparql_builder_insert_open (preupdate, NULL);
-	if (graph) {
-		tracker_sparql_builder_graph_open (preupdate, graph);
-	}
+	album = tracker_resource_new (*p_album_uri);
+
+	g_value_set_string (value,  "nmm:MusicAlbum")
+	tracker)resource_set_property (album, "rdf:type", value);
 
-	tracker_sparql_builder_subject_iri (preupdate, *p_album_uri);
-	tracker_sparql_builder_predicate (preupdate, "a");
-	tracker_sparql_builder_object (preupdate, "nmm:MusicAlbum");
 	/* FIXME: nmm:albumTitle is now deprecated
 	 * tracker_sparql_builder_predicate (preupdate, "nie:title");
 	 */
-	tracker_sparql_builder_predicate (preupdate, "nmm:albumTitle");
-	tracker_sparql_builder_object_unvalidated (preupdate, album_title);
+	tracker_resource_set_property (album, "nmm:albumTitle", album_title);
 
 	if (*p_album_artist_uri) {
-		tracker_sparql_builder_predicate (preupdate, "nmm:albumArtist");
-		tracker_sparql_builder_object_iri (preupdate, *p_album_artist_uri);
+		tracker_resource_set_property (album,
+		                               "nmm:albumArtist",
+		                               album_artist);
 	}
 
-	if (graph) {
-		tracker_sparql_builder_graph_close (preupdate);
-	}
-	tracker_sparql_builder_insert_close (preupdate);
-
 	has_it = gst_tag_list_get_uint (tag_list, GST_TAG_TRACK_COUNT, &count);
 
 	if (has_it) {
-		tracker_sparql_builder_delete_open (preupdate, NULL);
-		tracker_sparql_builder_subject_iri (preupdate, *p_album_uri);
-		tracker_sparql_builder_predicate (preupdate, "nmm:albumTrackCount");
-		tracker_sparql_builder_object_variable (preupdate, "unknown");
-		tracker_sparql_builder_delete_close (preupdate);
-		tracker_sparql_builder_where_open (preupdate);
-		tracker_sparql_builder_subject_iri (preupdate, *p_album_uri);
-		tracker_sparql_builder_predicate (preupdate, "nmm:albumTrackCount");
-		tracker_sparql_builder_object_variable (preupdate, "unknown");
-		tracker_sparql_builder_where_close (preupdate);
-
-		tracker_sparql_builder_insert_open (preupdate, NULL);
-		if (graph) {
-			tracker_sparql_builder_graph_open (preupdate, graph);
-		}
-
-		tracker_sparql_builder_subject_iri (preupdate, *p_album_uri);
-		tracker_sparql_builder_predicate (preupdate, "nmm:albumTrackCount");
-		tracker_sparql_builder_object_int64 (preupdate, count);
-
-		if (graph) {
-			tracker_sparql_builder_graph_close (preupdate);
-		}
-		tracker_sparql_builder_insert_close (preupdate);
+		g_value_set_int (value, count);
+		tracker_resource_set_property (album,
+		                               "nmm:albumTrackCount");
+		                               value);
 	}
 
 	has_it = gst_tag_list_get_uint (tag_list, GST_TAG_ALBUM_VOLUME_NUMBER, &count);
@@ -1608,13 +1500,12 @@ discoverer_init_and_run (MetadataExtractor *extractor,
 #endif /* defined(GSTREAMER_BACKEND_DISCOVERER) || \
           defined(GSTREAMER_BACKEND_GUPNP_DLNA) */
 
-static void
+static TrackerResource *
 tracker_extract_gstreamer (const gchar          *uri,
                            TrackerExtractInfo   *info,
-                           ExtractMime           type,
-                           const gchar          *graph)
+                           ExtractMime           type)
 {
-	TrackerSparqlBuilder *metadata, *preupdate, *postupdate;
+	TrackerResource *main_resource;
 	MetadataExtractor *extractor;
 	GstBuffer *buffer;
 	gchar *cue_sheet;
@@ -1626,13 +1517,6 @@ tracker_extract_gstreamer (const gchar          *uri,
 
 	g_return_if_fail (uri);
 
-	graph = tracker_extract_info_get_graph (info);
-	metadata = tracker_extract_info_get_metadata_builder (info);
-	preupdate = tracker_extract_info_get_preupdate_builder (info);
-	postupdate = tracker_extract_info_get_postupdate_builder (info);
-
-	g_return_if_fail (metadata);
-
 	gst_init (NULL, NULL);
 
 	extractor = g_slice_new0 (MetadataExtractor);
@@ -1661,12 +1545,7 @@ tracker_extract_gstreamer (const gchar          *uri,
 			extractor->toc = tracker_cue_sheet_parse_uri (uri);
 		}
 
-		extract_metadata (extractor,
-		                  uri,
-		                  preupdate,
-		                  postupdate,
-		                  metadata,
-		                  graph);
+		main)resource = extract_metadata (extractor, uri);
 
 #ifdef HAVE_LIBMEDIAART
 		if (extractor->media_art_type != MEDIA_ART_NONE &&
@@ -1730,6 +1609,8 @@ tracker_extract_gstreamer (const gchar          *uri,
 	discoverer_shutdown (extractor);
 
 	g_slice_free (MetadataExtractor, extractor);
+
+	return main)resource;
 }
 
 G_MODULE_EXPORT gboolean