static TrackerDecoratorInfo * tracker_decorator_info_new (TrackerDecorator *decorator, TrackerSparqlCursor *cursor) { TrackerSparqlBuilder *sparql; TrackerDecoratorInfo *info; GCancellable *cancellable; info = g_slice_new0 (TrackerDecoratorInfo); info->urn = g_strdup (tracker_sparql_cursor_get_string (cursor, 0, NULL)); info->id = tracker_sparql_cursor_get_integer (cursor, 1); info->url = g_strdup (tracker_sparql_cursor_get_string (cursor, 2, NULL)); info->mimetype = g_strdup (tracker_sparql_cursor_get_string (cursor, 3, NULL)); info->ref_count = 1; cancellable = g_cancellable_new (); info->task = g_task_new (decorator, cancellable, decorator_task_done, info); g_object_unref (cancellable); sparql = tracker_sparql_builder_new_update (); g_task_set_task_data (info->task, sparql, (GDestroyNotify) g_object_unref); return info; }
static void find_channel_and_update (GObject *source_object, GAsyncResult *res, gpointer user_data) { gchar **values; GtkTreeModel *model; GtkTreeIter iter; TrackerSparqlCursor *cursor; GError *error; error = NULL; cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object), res, &error); if (error != NULL) { g_warning ("Unable to update channel: %s", error->message); g_error_free (error); return; } model = user_data; while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { if (retrive_row_by_id (model, tracker_sparql_cursor_get_string (cursor, 0, NULL), &iter) == TRUE) { gtk_list_store_set (GTK_LIST_STORE (model), &iter, PREDICATE_NAME, tracker_sparql_cursor_get_string (cursor, 1, NULL), PREDICATE_DOWNLOAD, tracker_sparql_cursor_get_boolean (cursor, 2), PREDICATE_DOWNPATH, tracker_sparql_cursor_get_string (cursor, 3, NULL), PREDICATE_MAXSIZE, tracker_sparql_cursor_get_double (cursor, 4), PREDICATE_EXPIRY, tracker_sparql_cursor_get_double (cursor, 5), 6, FALSE, -1); } } }
static void fill_model_with_channels (GObject *source_object, GAsyncResult *res, gpointer user_data) { int i; GtkWidget *dialog; GtkListStore *list; TrackerSparqlCursor *cursor; GError *error; error = NULL; cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object), res, &error); if (error != NULL) { dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Unable to fetch data about current feeds:\n%s", error->message); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "Is Tracker running?"); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); g_error_free (error); return; } list = user_data; while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { gtk_list_store_insert_with_values (list, NULL, G_MAXINT, PREDICATE_SUBJECT, tracker_sparql_cursor_get_string (cursor, 0, NULL), PREDICATE_NAME, tracker_sparql_cursor_get_string (cursor, 1, NULL), PREDICATE_DOWNLOAD, tracker_sparql_cursor_get_boolean (cursor, 2), PREDICATE_DOWNPATH, tracker_sparql_cursor_get_string (cursor, 3, NULL), PREDICATE_MAXSIZE, tracker_sparql_cursor_get_double (cursor, 4), PREDICATE_EXPIRY, tracker_sparql_cursor_get_double (cursor, 5), 6, FALSE, -1); } }
static void pass_channels (ReaderEngine *engine, TrackerSparqlCursor *cursor) { const gchar *subject; const gchar *title; const gchar *url; gint64 unread; GtkTreeModel *model; GtkTreeIter *iter; GtkTreeIter iter2; GtkTreeStore *items_model; GdkPixbuf *icon; ReaderEnginePrivate *priv; if (cursor != NULL) { priv = reader_engine_get_instance_private (engine); model = GTK_TREE_MODEL (priv->data); while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { subject = tracker_sparql_cursor_get_string (cursor, 0, NULL); title = tracker_sparql_cursor_get_string (cursor, 1, NULL); unread = tracker_sparql_cursor_get_integer (cursor, 2); url = tracker_sparql_cursor_get_string (cursor, 4, NULL); if (find_in_model (model, GD_MAIN_COLUMN_ID, subject, &iter)) { gtk_list_store_set (GTK_LIST_STORE (model), iter, GD_MAIN_COLUMN_PRIMARY_TEXT, title, EXTRA_COLUMN_UNREADS, unread, -1); gtk_tree_iter_free (iter); } else { items_model = gtk_tree_store_new (ITEM_COLUMN_LAST, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_STRING); g_signal_connect (items_model, "row-changed", G_CALLBACK (model_item_changed), engine); icon = get_icon_for_channel (tracker_sparql_cursor_get_string (cursor, 3, NULL)); gtk_list_store_append (GTK_LIST_STORE (model), &iter2); gtk_list_store_set (GTK_LIST_STORE (model), &iter2, GD_MAIN_COLUMN_ID, subject, GD_MAIN_COLUMN_PRIMARY_TEXT, title, GD_MAIN_COLUMN_ICON, icon, EXTRA_COLUMN_UNREADS, unread, EXTRA_COLUMN_URL, url, EXTRA_COLUMN_FEEDS_MODEL, items_model, -1); } collect_items (engine, subject, NULL); } g_object_unref (cursor); } }
static gchar * get_class_from_prefix (TrackerSparqlConnection *connection, const gchar *prefix) { GError *error = NULL; TrackerSparqlCursor *cursor; const gchar *query; gchar *found = NULL; query = "SELECT ?prefix ?ns " "WHERE {" " ?ns a tracker:Namespace ;" " tracker:prefix ?prefix " "}"; /* We have namespace prefix, get full name */ cursor = tracker_sparql_connection_query (connection, query, NULL, &error); if (error) { g_printerr ("%s, %s\n", _("Could not get namespace prefixes"), error->message); g_error_free (error); return NULL; } if (!cursor) { g_printerr ("%s\n", _("No namespace prefixes were found")); return NULL; } while (tracker_sparql_cursor_next (cursor, NULL, NULL) && !found) { const gchar *class_prefix, *class_name; class_prefix = tracker_sparql_cursor_get_string (cursor, 0, NULL); class_name = tracker_sparql_cursor_get_string (cursor, 1, NULL); if (strcmp (class_prefix, prefix) == 0) { found = g_strdup (class_name); } } g_object_unref (cursor); return found; }
static void handle_channel_deletes (ReaderEngine *engine, gint sub) { gchar *query; const gchar *subject; GtkTreeIter *iter; TrackerSparqlCursor *cursor; ReaderEnginePrivate *priv; priv = reader_engine_get_instance_private (engine); query = g_strdup_printf ("SELECT tracker:uri(%d) {}", sub); cursor = tracker_sparql_connection_query (priv->tracker, query, NULL, NULL); tracker_sparql_cursor_next (cursor, NULL, NULL); subject = tracker_sparql_cursor_get_string (cursor, 0, NULL); if (find_in_model (GTK_TREE_MODEL (priv->data), GD_MAIN_COLUMN_ID, subject, &iter)) { remove_channel_data (GTK_TREE_MODEL (priv->data), iter); gtk_list_store_remove (priv->data, iter); gtk_tree_iter_free (iter); } g_free (query); g_object_unref (cursor); }
static void photos_fetch_collections_job_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data) { PhotosFetchCollectionsJob *self = PHOTOS_FETCH_COLLECTIONS_JOB (user_data); TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object); GError *error; gboolean valid; gchar *urn; error = NULL; valid = tracker_sparql_cursor_next_finish (cursor, res, &error); if (error != NULL) { g_warning ("Unable to fetch collections: %s", error->message); g_error_free (error); goto end; } if (!valid) goto end; urn = g_strdup (tracker_sparql_cursor_get_string (cursor, 0, NULL)); self->collections = g_list_prepend (self->collections, urn); tracker_sparql_cursor_next_async (cursor, NULL, photos_fetch_collections_job_cursor_next, self); return; end: self->collections = g_list_reverse (self->collections); photos_fetch_collections_job_emit_callback (self); tracker_sparql_cursor_close (cursor); g_object_unref (self); }
GIcon * photos_utils_get_icon_from_cursor (TrackerSparqlCursor *cursor) { GIcon *icon = NULL; gboolean is_remote = FALSE; const gchar *identifier; const gchar *mime_type; const gchar *rdf_type; identifier = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_IDENTIFIER, NULL); if (identifier != NULL) { if (g_str_has_prefix (identifier, "facebook:") || g_str_has_prefix (identifier, "flickr:")) is_remote = TRUE; } if (!is_remote) { const gchar *uri; uri = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URI, NULL); if (uri != NULL) icon = photos_utils_get_thumbnail_icon (uri); } if (icon != NULL) goto out; mime_type = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_MIME_TYPE, NULL); if (mime_type != NULL) icon = g_content_type_get_icon (mime_type); if (icon != NULL) goto out; rdf_type = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_RDF_TYPE, NULL); if (mime_type != NULL) icon = photos_utils_icon_from_rdf_type (rdf_type); if (icon != NULL) goto out; icon = g_themed_icon_new ("image-x-generic"); out: return icon; }
static void photos_camera_cache_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data) { GTask *task = G_TASK (user_data); PhotosCameraCache *self; PhotosCameraCachePrivate *priv; TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object); GError *error; const gchar *manufacturer; const gchar *model; gchar *camera; gpointer key; self = PHOTOS_CAMERA_CACHE (g_task_get_source_object (task)); priv = self->priv; error = NULL; tracker_sparql_cursor_next_finish (cursor, res, &error); if (error != NULL) { g_task_return_error (task, error); goto out; } manufacturer = tracker_sparql_cursor_get_string (cursor, 0, NULL); model = tracker_sparql_cursor_get_string (cursor, 1, NULL); if (manufacturer == NULL && model == NULL) camera = NULL; else if (manufacturer == NULL || g_str_has_prefix (model, manufacturer)) camera = g_strdup (model); else if (model == NULL) camera = g_strdup (manufacturer); else camera = g_strconcat (manufacturer, " ", model, NULL); key = g_task_get_task_data (task); g_hash_table_insert (priv->cache, key, camera); g_task_return_pointer (task, g_strdup (camera), g_free); out: tracker_sparql_cursor_close (cursor); g_object_unref (task); }
static void pass_items (ReaderEngine *engine, TrackerSparqlCursor *cursor) { gboolean blocked; const gchar *channel_id; const gchar *item_id; GtkTreeIter iter; GtkTreeModel *model; GDateTime *date; if (cursor != NULL) { while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { channel_id = tracker_sparql_cursor_get_string (cursor, 0, NULL); model = reader_engine_get_items_model (engine, channel_id); if (model == NULL) continue; item_id = tracker_sparql_cursor_get_string (cursor, 1, NULL); date = item_cursor_to_time (cursor); if (dispose_item_in_model (model, item_id, date, &iter) == FALSE) { g_signal_handlers_block_by_func (model, G_CALLBACK (model_item_changed), engine); blocked = TRUE; } else { blocked = FALSE; } gtk_tree_store_set (GTK_TREE_STORE (model), &iter, ITEM_COLUMN_ID, item_id, ITEM_COLUMN_TITLE, tracker_sparql_cursor_get_string (cursor, 2, NULL), ITEM_COLUMN_URL, tracker_sparql_cursor_get_string (cursor, 3, NULL), ITEM_COLUMN_TIME, date, ITEM_COLUMN_CONTENTS, tracker_sparql_cursor_get_string (cursor, 5, NULL), ITEM_COLUMN_READ, tracker_sparql_cursor_get_boolean (cursor, 4) ? READ_FONT_WEIGHT : UNREAD_FONT_WEIGHT, -1); if (blocked == TRUE) g_signal_handlers_unblock_by_func (model, G_CALLBACK (model_item_changed), engine); } g_object_unref (cursor); } }
static void set_title (TrackerSparqlCursor *cursor, gint column, GrlMedia *media, GrlKeyID key) { const gchar *str = tracker_sparql_cursor_get_string (cursor, column, NULL); grl_data_set_boolean (GRL_DATA (media), GRL_METADATA_KEY_TITLE_FROM_FILENAME, FALSE); grl_media_set_title (media, str); }
static GDateTime* item_cursor_to_time (TrackerSparqlCursor *cursor) { const gchar *date; GTimeVal val; date = tracker_sparql_cursor_get_string (cursor, 6, NULL); g_time_val_from_iso8601 (date, &val); return g_date_time_new_from_timeval_local (&val); }
static void cursor_cb (GObject *object, GAsyncResult *res, gpointer user_data) { TrackerSparqlCursor *cursor; GError *error = NULL; MyData *md = user_data; gboolean more_results; cursor = TRACKER_SPARQL_CURSOR (object); more_results = tracker_sparql_cursor_next_finish (cursor, res, &error); if (!error) { static gint i = 0; if (more_results) { if (i++ < 5) { if (i == 1) { g_print ("Printing first 5 results:\n"); } g_print (" %s\n", tracker_sparql_cursor_get_string (cursor, 0, NULL)); if (i == 5) { g_print (" ...\n"); g_print (" Printing nothing for remaining results\n"); } } tracker_sparql_cursor_next_async (cursor, md->cancellable, cursor_cb, md); } else { g_print ("\n"); g_print ("Async cursor next took: %.6f (for all %d results)\n", g_timer_elapsed (md->timer, NULL), i); g_object_unref (cursor); g_main_loop_quit (md->loop); } } else { g_critical ("Could not run cursor next: %s", error->message); if (cursor) { g_object_unref (cursor); } g_error_free (error); g_main_loop_quit (md->loop); } }
static void cursor_callback (GObject *object, GAsyncResult *result, gpointer user_data) { GtkSearchEngineTracker *tracker; GError *error = NULL; TrackerSparqlCursor *cursor; GList *hits; gboolean success; gdk_threads_enter (); tracker = GTK_SEARCH_ENGINE_TRACKER (user_data); cursor = TRACKER_SPARQL_CURSOR (object); success = tracker_sparql_cursor_next_finish (cursor, result, &error); if (error) { _gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message); g_error_free (error); if (cursor) g_object_unref (cursor); gdk_threads_leave (); return; } if (!success) { _gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker)); if (cursor) g_object_unref (cursor); gdk_threads_leave (); return; } /* We iterate result by result, not n at a time. */ hits = g_list_append (NULL, (gchar*) tracker_sparql_cursor_get_string (cursor, 0, NULL)); _gtk_search_engine_hits_added (GTK_SEARCH_ENGINE (tracker), hits); g_list_free (hits); /* Get next */ cursor_next (tracker, cursor); gdk_threads_leave (); }
static void set_favourite (TrackerSparqlCursor *cursor, gint column, GrlMedia *media, GrlKeyID key) { const gchar *str = tracker_sparql_cursor_get_string (cursor, column, NULL); gboolean is_favourite = FALSE; if (str != NULL && g_str_has_suffix (str, "predefined-tag-favorite")) is_favourite = TRUE; grl_data_set_boolean (GRL_DATA (media), key, is_favourite); }
QString QTrackerDirectSyncResult::stringValue(int i) const { if (!cursor || pos() == QSparql::BeforeFirstRow || pos() == QSparql::AfterLastRow) return QString(); // get the no. of columns only once; it won't change between rows if (n_columns < 0) n_columns = tracker_sparql_cursor_get_n_columns(cursor); if (i < 0 || i >= n_columns) return QString(); return QString::fromUtf8(tracker_sparql_cursor_get_string(cursor, i, 0)); }
static inline void insert_string_value (TrackerSparqlCursor *const cursor, GVariantDict *const dict, gchar const *const key, gint const column) { GVariant *const value = g_variant_new_printf ( "%s", tracker_sparql_cursor_get_string (cursor, column, NULL) ); g_variant_dict_insert_value (dict, key, value); }
static void photos_fetch_metas_job_executed (TrackerSparqlCursor *cursor, gpointer user_data) { PhotosFetchMetasJob *self = PHOTOS_FETCH_METAS_JOB (user_data); GIcon *icon = NULL; PhotosFetchMeta *meta; gboolean is_collection; const gchar *id; const gchar *rdf_type; const gchar *title; id = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URN, NULL); title = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_TITLE, NULL); rdf_type = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_RDF_TYPE, NULL); is_collection = (strstr (rdf_type, "nfo#DataContainer") != NULL); if (!is_collection) icon = photos_utils_get_icon_from_cursor (cursor); if (title == NULL || title[0] == '\0') title = _("Untitled Photo"); meta = photos_fetch_meta_new (icon, id, title); if (is_collection) photos_fetch_metas_job_create_collection_pixbuf (self, meta); else { self->metas = g_list_prepend (self->metas, meta); photos_fetch_metas_job_collector (self); } g_clear_object (&icon); g_object_unref (self); }
static void set_date (TrackerSparqlCursor *cursor, gint column, GrlMedia *media, GrlKeyID key) { const gchar *str = tracker_sparql_cursor_get_string (cursor, column, NULL); if (key == GRL_METADATA_KEY_CREATION_DATE || key == GRL_METADATA_KEY_MODIFICATION_DATE) { GDateTime *date = grl_date_time_from_iso8601 (str); if (date) { grl_data_set_boxed (GRL_DATA (media), key, date); g_date_time_unref (date); } } }
static void set_orientation (TrackerSparqlCursor *cursor, gint column, GrlMedia *media, GrlKeyID key) { const gchar *str = tracker_sparql_cursor_get_string (cursor, column, NULL); if (g_str_has_suffix (str, "nfo#orientation-top")) grl_data_set_int (GRL_DATA (media), key, 0); else if (g_str_has_suffix (str, "nfo#orientation-right")) grl_data_set_int (GRL_DATA (media), key, 90); else if (g_str_has_suffix (str, "nfo#orientation-bottom")) grl_data_set_int (GRL_DATA (media), key, 180); else if (g_str_has_suffix (str, "nfo#orientation-left")) grl_data_set_int (GRL_DATA (media), key, 270); }
static void item_warn (TrackerSparqlConnection *conn, gint id, const gchar *sparql, const GError *error) { TrackerSparqlCursor *cursor; const gchar *elem; gchar *query; query = g_strdup_printf ("SELECT COALESCE (nie:url (?u), ?u) {" " ?u a rdfs:Resource. " " FILTER (tracker:id (?u) = %d)" "}", id); cursor = tracker_sparql_connection_query (conn, query, NULL, NULL); g_free (query); g_debug ("--8<------------------------------"); g_debug ("The information relevant for a bug report is between " "the dotted lines"); if (cursor && tracker_sparql_cursor_next (cursor, NULL, NULL)) { elem = tracker_sparql_cursor_get_string (cursor, 0, NULL); g_warning ("Could not insert metadata for item \"%s\": %s", elem, error->message); } else { g_warning ("Could not insert metadata for item with ID %d: %s", id, error->message); } g_warning ("If the error above is recurrent for the same item/ID, " "consider running \"%s\" in the terminal with the " "TRACKER_VERBOSITY=3 environment variable, and filing a " "bug with the additional information", g_get_prgname ()); g_debug ("Sparql was:\n%s", sparql); g_debug ("NOTE: The information above may contain data you " "consider sensitive. Feel free to edit it out, but please " "keep it as unmodified as you possibly can."); g_debug ("------------------------------>8--"); g_clear_object (&cursor); }
static void photos_fetch_ids_job_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data) { PhotosFetchIdsJob *self; GCancellable *cancellable; g_autoptr (GTask) task = G_TASK (user_data); TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object); GError *error; gboolean success; self = PHOTOS_FETCH_IDS_JOB (g_task_get_source_object (task)); cancellable = g_task_get_cancellable (task); error = NULL; /* Note that tracker_sparql_cursor_next_finish can return FALSE even * without an error. */ success = tracker_sparql_cursor_next_finish (cursor, res, &error); if (error != NULL) { g_task_return_error (task, error); goto end; } if (success) { const gchar *id; id = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URN, NULL); g_ptr_array_add (self->ids, g_strdup (id)); tracker_sparql_cursor_next_async (cursor, cancellable, photos_fetch_ids_job_cursor_next, g_object_ref (task)); return; } g_ptr_array_add (self->ids, NULL); g_task_return_pointer (task, self->ids->pdata, NULL); end: return; }
static void handle_channel_inserts (ReaderEngine *engine, gint sub) { gchar *query; const gchar *subject; TrackerSparqlCursor *cursor; ReaderEnginePrivate *priv; priv = reader_engine_get_instance_private (engine); query = g_strdup_printf ("SELECT tracker:uri(%d) {}", sub); cursor = tracker_sparql_connection_query (priv->tracker, query, NULL, NULL); tracker_sparql_cursor_next (cursor, NULL, NULL); subject = tracker_sparql_cursor_get_string (cursor, 0, NULL); collect_channels (engine, subject); g_free (query); g_object_unref (cursor); }
static void photos_application_activate_query_executed (TrackerSparqlCursor *cursor, gpointer user_data) { PhotosApplication *self = PHOTOS_APPLICATION (user_data); PhotosApplicationPrivate *priv = self->priv; GObject *item; const gchar *identifier; if (cursor == NULL) goto out; photos_item_manager_add_item (PHOTOS_ITEM_MANAGER (priv->item_mngr), cursor); identifier = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URN, NULL); item = photos_base_manager_get_object_by_id (priv->item_mngr, identifier); photos_application_activate_item (self, item); out: g_object_unref (self); }
static int status_stat (void) { TrackerSparqlConnection *connection; TrackerSparqlCursor *cursor; GError *error = NULL; connection = tracker_sparql_connection_get (NULL, &error); if (!connection) { g_printerr ("%s: %s\n", _("Could not establish a connection to Tracker"), error ? error->message : _("No error given")); g_clear_error (&error); return EXIT_FAILURE; } cursor = tracker_sparql_connection_statistics (connection, NULL, &error); g_object_unref (connection); if (error) { g_printerr ("%s, %s\n", _("Could not get Tracker statistics"), error->message); g_error_free (error); return EXIT_FAILURE; } /* We use search terms on ALL ontologies not just common ones */ if (terms && g_strv_length (terms) > 0) { show_all = TRUE; } if (!cursor) { g_print ("%s\n", _("No statistics available")); } else { GString *output; output = g_string_new (""); if (!show_all) { get_common_rdf_types (); } while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { const gchar *rdf_type; const gchar *rdf_type_count; rdf_type = tracker_sparql_cursor_get_string (cursor, 0, NULL); rdf_type_count = tracker_sparql_cursor_get_string (cursor, 1, NULL); if (!show_all && !g_hash_table_contains (common_rdf_types, rdf_type)) { continue; } if (terms) { gint i, n_terms; gboolean show_rdf_type = FALSE; n_terms = g_strv_length (terms); for (i = 0; i < n_terms && !show_rdf_type; i++) { show_rdf_type = g_str_match_string (terms[i], rdf_type, TRUE); } if (!show_rdf_type) { continue; } } g_string_append_printf (output, " %s = %s\n", rdf_type, rdf_type_count); } if (output->len > 0) { /* To translators: This is to say there are no * statistics found. We use a "Statistics: * None" with multiple print statements */ g_string_prepend (output, "\n"); g_string_prepend (output, _("Statistics:")); } else { g_string_append_printf (output, " %s\n", _("None")); } g_print ("%s\n", output->str); g_string_free (output, TRUE); if (common_rdf_types) { g_hash_table_unref (common_rdf_types); } g_object_unref (cursor); } return EXIT_SUCCESS; }
int main (int argc, char **argv) { TrackerSparqlConnection *connection; TrackerSparqlCursor *cursor; GOptionContext *context; GError *error = NULL; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); /* Translators: this messagge will apper immediately after the */ /* usage string - Usage: COMMAND [OPTION]... <THIS_MESSAGE> */ context = g_option_context_new (_(" - Show statistics for all Nepomuk defined ontology classes")); g_option_context_add_main_entries (context, entries, NULL); g_option_context_parse (context, &argc, &argv, NULL); if (print_version) { g_print ("\n" ABOUT "\n" LICENSE "\n"); g_option_context_free (context); return EXIT_SUCCESS; } /* We use search terms on ALL ontologies not just common ones */ if (terms && g_strv_length (terms) > 0) { show_all = TRUE; } g_option_context_free (context); connection = tracker_sparql_connection_get (NULL, &error); if (!connection) { g_printerr ("%s: %s\n", _("Could not establish a connection to Tracker"), error ? error->message : _("No error given")); g_clear_error (&error); return EXIT_FAILURE; } cursor = tracker_sparql_connection_statistics (connection, NULL, &error); if (error) { g_printerr ("%s, %s\n", _("Could not get Tracker statistics"), error->message); g_error_free (error); return EXIT_FAILURE; } if (!cursor) { g_print ("%s\n", _("No statistics available")); } else { GString *output; output = g_string_new (""); if (!show_all) { get_common_rdf_types (); } while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { const gchar *rdf_type; const gchar *rdf_type_count; rdf_type = tracker_sparql_cursor_get_string (cursor, 0, NULL); rdf_type_count = tracker_sparql_cursor_get_string (cursor, 1, NULL); if (!show_all && !g_hash_table_contains (common_rdf_types, rdf_type)) { continue; } if (terms) { gint i, n_terms; gboolean show_rdf_type = FALSE; n_terms = g_strv_length (terms); for (i = 0; i < n_terms && !show_rdf_type; i++) { show_rdf_type = g_str_match_string (terms[i], rdf_type, TRUE); } if (!show_rdf_type) { continue; } } g_string_append_printf (output, " %s = %s\n", rdf_type, rdf_type_count); } if (output->len > 0) { /* To translators: This is to say there are no * statistics found. We use a "Statistics: * None" with multiple print statements */ g_string_prepend (output, "\n"); g_string_prepend (output, _("Statistics:")); } else { g_string_append_printf (output, " %s\n", _("None")); } g_print ("%s\n", output->str); g_string_free (output, TRUE); if (common_rdf_types) { g_hash_table_unref (common_rdf_types); } g_object_unref (cursor); } g_object_unref (connection); return EXIT_SUCCESS; }
static int collect_debug (void) { /* What to collect? * This is based on information usually requested from maintainers to users. * * 1. Package details, e.g. version. * 2. Disk size, space left, type (SSD/etc) * 3. Size of dataset (tracker-stats), size of databases * 4. Current configuration (libtracker-fts, tracker-miner-fs, tracker-extract) * All txt files in ~/.cache/ * 5. Statistics about data (tracker-stats) */ GDir *d; gchar *data_dir; gchar *str; data_dir = g_build_filename (g_get_user_cache_dir (), "tracker", NULL); /* 1. Package details, e.g. version. */ g_print ("[Package Details]\n"); g_print ("%s: " PACKAGE_VERSION "\n", _("Version")); g_print ("\n\n"); /* 2. Disk size, space left, type (SSD/etc) */ guint64 remaining_bytes; gdouble remaining; g_print ("[%s]\n", _("Disk Information")); remaining_bytes = tracker_file_system_get_remaining_space (data_dir); str = g_format_size (remaining_bytes); remaining = tracker_file_system_get_remaining_space_percentage (data_dir); g_print ("%s: %s (%3.2lf%%)\n", _("Remaining space on database partition"), str, remaining); g_free (str); g_print ("\n\n"); /* 3. Size of dataset (tracker-stats), size of databases */ g_print ("[%s]\n", _("Data Set")); for (d = g_dir_open (data_dir, 0, NULL); d != NULL;) { const gchar *f; gchar *path; goffset size; f = g_dir_read_name (d); if (!f) { break; } if (g_str_has_suffix (f, ".txt")) { continue; } path = g_build_filename (data_dir, f, NULL); size = tracker_file_get_size (path); str = g_format_size (size); g_print ("%s\n%s\n\n", path, str); g_free (str); g_free (path); } g_dir_close (d); g_print ("\n"); /* 4. Current configuration (libtracker-fts, tracker-miner-fs, tracker-extract) * All txt files in ~/.cache/ */ GSList *all, *l; g_print ("[%s]\n", _("Configuration")); all = tracker_gsettings_get_all (NULL); if (all) { for (l = all; l; l = l->next) { ComponentGSettings *c = l->data; gchar **keys, **p; if (!c) { continue; } keys = g_settings_list_keys (c->settings); for (p = keys; p && *p; p++) { GVariant *v; gchar *printed; v = g_settings_get_value (c->settings, *p); printed = g_variant_print (v, FALSE); g_print ("%s.%s: %s\n", c->name, *p, printed); g_free (printed); g_variant_unref (v); } } tracker_gsettings_free (all); } else { g_print ("** %s **\n", _("No configuration was found")); } g_print ("\n\n"); g_print ("[%s]\n", _("States")); for (d = g_dir_open (data_dir, 0, NULL); d != NULL;) { const gchar *f; gchar *path; gchar *content = NULL; f = g_dir_read_name (d); if (!f) { break; } if (!g_str_has_suffix (f, ".txt")) { continue; } path = g_build_filename (data_dir, f, NULL); if (g_file_get_contents (path, &content, NULL, NULL)) { /* Special case last-index.txt which is time() dump to file */ if (g_str_has_suffix (path, "last-crawl.txt")) { guint64 then, now; now = (guint64) time (NULL); then = g_ascii_strtoull (content, NULL, 10); str = tracker_seconds_to_string (now - then, FALSE); g_print ("%s\n%s (%s)\n\n", path, content, str); } else { g_print ("%s\n%s\n\n", path, content); } g_free (content); } g_free (path); } g_dir_close (d); g_print ("\n"); /* 5. Statistics about data (tracker-stats) */ TrackerSparqlConnection *connection; GError *error = NULL; g_print ("[%s]\n", _("Data Statistics")); connection = tracker_sparql_connection_get (NULL, &error); if (!connection) { g_print ("** %s, %s **\n", _("No connection available"), error ? error->message : _("No error given")); g_clear_error (&error); } else { TrackerSparqlCursor *cursor; cursor = tracker_sparql_connection_statistics (connection, NULL, &error); if (error) { g_print ("** %s, %s **\n", _("Could not get statistics"), error ? error->message : _("No error given")); g_error_free (error); } else { if (!cursor) { g_print ("** %s **\n", _("No statistics were available")); } else { gint count = 0; while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { g_print ("%s: %s\n", tracker_sparql_cursor_get_string (cursor, 0, NULL), tracker_sparql_cursor_get_string (cursor, 1, NULL)); count++; } if (count == 0) { g_print ("%s\n", _("Database is currently empty")); } g_object_unref (cursor); } } } g_object_unref (connection); g_print ("\n\n"); g_print ("\n"); g_free (data_dir); return EXIT_SUCCESS; }
static void photos_base_item_populate_from_cursor (PhotosBaseItem *self, TrackerSparqlCursor *cursor) { PhotosBaseItemPrivate *priv = self->priv; GTimeVal timeval; const gchar *date_created; const gchar *equipment; const gchar *flash; const gchar *mtime; const gchar *title; const gchar *uri; uri = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URI, NULL); priv->uri = g_strdup ((uri == NULL) ? "" : uri); priv->id = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URN, NULL)); priv->identifier = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_IDENTIFIER, NULL)); priv->author = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_AUTHOR, NULL)); priv->resource_urn = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_RESOURCE_URN, NULL)); priv->favorite = tracker_sparql_cursor_get_boolean (cursor, PHOTOS_QUERY_COLUMNS_RESOURCE_FAVORITE); mtime = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_MTIME, NULL); if (mtime != NULL) { g_time_val_from_iso8601 (mtime, &timeval); priv->mtime = (gint64) timeval.tv_sec; } else priv->mtime = g_get_real_time () / 1000000; priv->mime_type = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_MIME_TYPE, NULL)); priv->rdf_type = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_RDF_TYPE, NULL)); photos_base_item_update_info_from_type (self); date_created = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_DATE_CREATED, NULL); if (date_created != NULL) { g_time_val_from_iso8601 (date_created, &timeval); priv->date_created = (gint64) timeval.tv_sec; } else priv->date_created = -1; if (g_strcmp0 (priv->id, PHOTOS_COLLECTION_SCREENSHOT) == 0) title = _("Screenshots"); else title = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_TITLE, NULL); if (title == NULL) title = ""; priv->name = g_strdup (title); priv->filename = g_strdup (tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_FILENAME, NULL)); priv->width = tracker_sparql_cursor_get_integer (cursor, PHOTOS_QUERY_COLUMNS_WIDTH); priv->height = tracker_sparql_cursor_get_integer (cursor, PHOTOS_QUERY_COLUMNS_HEIGHT); equipment = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_EQUIPMENT, NULL); priv->equipment = g_quark_from_string (equipment); priv->exposure_time = tracker_sparql_cursor_get_double (cursor, PHOTOS_QUERY_COLUMNS_EXPOSURE_TIME); priv->fnumber = tracker_sparql_cursor_get_double (cursor, PHOTOS_QUERY_COLUMNS_FNUMBER); priv->focal_length = tracker_sparql_cursor_get_double (cursor, PHOTOS_QUERY_COLUMNS_FOCAL_LENGTH); priv->iso_speed = tracker_sparql_cursor_get_double (cursor, PHOTOS_QUERY_COLUMNS_ISO_SPEED); flash = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_FLASH, NULL); priv->flash = g_quark_from_string (flash); priv->name_fallback = PHOTOS_BASE_ITEM_GET_CLASS (self)->create_name_fallback (self); photos_base_item_refresh_icon (self); }
static void on_query_finished (GObject *source_object, GAsyncResult *res, gpointer user_data) { GError *error = NULL; TrackerSparqlCursor *cursor = NULL; GDir *dir = NULL; GHashTable *table = NULL; const gchar *name; gchar *dirname = NULL; GList *to_remove = NULL; cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object), res, &error); if (error) { goto on_error; } dirname = g_build_filename (g_get_user_cache_dir (), "media-art", NULL); if (!g_file_test (dirname, G_FILE_TEST_EXISTS)) { /* Ignore this and just quit the function */ goto on_error; } dir = g_dir_open (dirname, 0, &error); if (error) { goto on_error; } table = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, (GDestroyNotify) NULL); while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { gchar *target = NULL, *album_path = NULL; const gchar *album, *artist; album = tracker_sparql_cursor_get_string (cursor, 0, NULL); artist = tracker_sparql_cursor_get_value_type (cursor, 1) != TRACKER_SPARQL_VALUE_TYPE_UNBOUND ? tracker_sparql_cursor_get_string (cursor, 1, NULL) : NULL; /* The get_path API does stripping itself */ media_art_get_path (artist, album, "album", NULL, &target, NULL); g_hash_table_replace (table, target, target); /* Also add the file to which the symlinks are made */ media_art_get_path (NULL, album, "album", NULL, &album_path, NULL); g_hash_table_replace (table, album_path, album_path); } /* Perhaps we should have an internal list of media art files that we made, * instead of going over all the media art (which could also have been made * by other softwares) */ for (name = g_dir_read_name (dir); name != NULL; name = g_dir_read_name (dir)) { gpointer value; gchar *full; full = g_build_filename (dirname, name, NULL); value = g_hash_table_lookup (table, full); if (!value) { g_message ("Removing media-art file %s: no album exists that has " "any songs for this media-art cache", name); to_remove = g_list_prepend (to_remove, (gpointer) full); } else { g_free (full); } } g_list_foreach (to_remove, (GFunc) g_unlink, NULL); g_list_foreach (to_remove, (GFunc) g_free, NULL); g_list_free (to_remove); on_error: g_free (dirname); if (table) { g_hash_table_unref (table); } if (cursor) { g_object_unref (cursor); } if (dir) { g_dir_close (dir); } if (error) { g_critical ("Error running cleanup of media-art: %s", error->message ? error->message : "No error given"); g_error_free (error); } }
GHashTable * tracker_sparql_get_prefixes (void) { TrackerSparqlConnection *connection; TrackerSparqlCursor *cursor; GError *error = NULL; GHashTable *retval; const gchar *query; connection = tracker_sparql_connection_get (NULL, &error); if (!connection) { g_printerr ("%s: %s\n", _("Could not establish a connection to Tracker"), error ? error->message : _("No error given")); g_clear_error (&error); return NULL; } retval = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); /* FIXME: Would like to get this in the same SPARQL that we * use to get the info, but doesn't seem possible at the * moment with the limited string manipulation features we * support in SPARQL. */ query = "SELECT ?ns ?prefix " "WHERE {" " ?ns a tracker:Namespace ;" " tracker:prefix ?prefix " "}"; cursor = tracker_sparql_connection_query (connection, query, NULL, &error); g_object_unref (connection); if (error) { g_printerr ("%s, %s\n", _("Unable to retrieve namespace prefixes"), error->message); g_error_free (error); return retval; } if (!cursor) { g_printerr ("%s\n", _("No namespace prefixes were returned")); return retval; } while (tracker_sparql_cursor_next (cursor, NULL, NULL)) { const gchar *key, *value; key = tracker_sparql_cursor_get_string (cursor, 0, NULL); value = tracker_sparql_cursor_get_string (cursor, 1, NULL); if (!key || !value) { continue; } g_hash_table_insert (retval, g_strndup (key, strlen (key) - 1), g_strdup (value)); } if (cursor) { g_object_unref (cursor); } return retval; }