[tracker-miners/wip/carlosg/batches-and-resources: 2/2] WIP: Use TrackerBatch in tracker-miner-fs
- From: Carlos Garnacho <carlosg src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [tracker-miners/wip/carlosg/batches-and-resources: 2/2] WIP: Use TrackerBatch in tracker-miner-fs
- Date: Thu, 26 Nov 2020 23:18:50 +0000 (UTC)
commit 56c643b85412c4a8e427d40872741bb57f7d63a7
Author: Carlos Garnacho <carlosg gnome org>
Date: Fri Nov 27 00:17:32 2020 +0100
WIP: Use TrackerBatch in tracker-miner-fs
Use batches, and pass directly the resources on those, so we bypass
the SPARQL step here.
src/libtracker-miner/tracker-miner-fs.c | 103 +++++++--------------
src/libtracker-miner/tracker-miner-fs.h | 27 +++---
src/libtracker-miner/tracker-sparql-buffer.c | 133 +++++++++++++++++++++++++--
src/libtracker-miner/tracker-sparql-buffer.h | 4 +
src/miners/fs/tracker-miner-files.c | 119 +++++++++++-------------
5 files changed, 235 insertions(+), 151 deletions(-)
---
diff --git a/src/libtracker-miner/tracker-miner-fs.c b/src/libtracker-miner/tracker-miner-fs.c
index c5ca0e428..adb0a262f 100644
--- a/src/libtracker-miner/tracker-miner-fs.c
+++ b/src/libtracker-miner/tracker-miner-fs.c
@@ -400,8 +400,8 @@ tracker_miner_fs_class_init (TrackerMinerFSClass *klass)
G_STRUCT_OFFSET (TrackerMinerFSClass, process_file),
NULL, NULL,
NULL,
- G_TYPE_STRING,
- 2, G_TYPE_FILE, G_TYPE_FILE_INFO);
+ G_TYPE_NONE,
+ 3, G_TYPE_FILE, G_TYPE_FILE_INFO, TRACKER_TYPE_BATCH);
/**
* TrackerMinerFS::process-file-attributes:
@@ -436,8 +436,8 @@ tracker_miner_fs_class_init (TrackerMinerFSClass *klass)
G_STRUCT_OFFSET (TrackerMinerFSClass, process_file_attributes),
NULL, NULL,
NULL,
- G_TYPE_STRING,
- 2, G_TYPE_FILE, G_TYPE_FILE_INFO);
+ G_TYPE_NONE,
+ 3, G_TYPE_FILE, G_TYPE_FILE_INFO, TRACKER_TYPE_BATCH);
/**
* TrackerMinerFS::finished:
@@ -531,8 +531,8 @@ tracker_miner_fs_class_init (TrackerMinerFSClass *klass)
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (TrackerMinerFSClass, remove_file),
NULL, NULL, NULL,
- G_TYPE_STRING,
- 1, G_TYPE_FILE);
+ G_TYPE_NONE,
+ 2, G_TYPE_FILE, TRACKER_TYPE_BATCH);
signals[REMOVE_CHILDREN] =
g_signal_new ("remove-children",
@@ -540,8 +540,8 @@ tracker_miner_fs_class_init (TrackerMinerFSClass *klass)
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (TrackerMinerFSClass, remove_children),
NULL, NULL, NULL,
- G_TYPE_STRING,
- 1, G_TYPE_FILE);
+ G_TYPE_NONE,
+ 2, G_TYPE_FILE, TRACKER_TYPE_BATCH);
signals[MOVE_FILE] =
g_signal_new ("move-file",
@@ -549,8 +549,8 @@ tracker_miner_fs_class_init (TrackerMinerFSClass *klass)
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (TrackerMinerFSClass, move_file),
NULL, NULL, NULL,
- G_TYPE_STRING,
- 3, G_TYPE_FILE, G_TYPE_FILE, G_TYPE_BOOLEAN);
+ G_TYPE_NONE,
+ 4, G_TYPE_FILE, G_TYPE_FILE, TRACKER_TYPE_BATCH, G_TYPE_BOOLEAN);
quark_last_queue_event = g_quark_from_static_string ("tracker-last-queue-event");
}
@@ -1270,6 +1270,8 @@ sparql_buffer_task_finished_cb (GObject *object,
item_queue_handlers_set_up (fs);
}
+ tracker_lru_remove (fs->priv->urn_lru, task_file);
+
tracker_task_unref (task);
}
@@ -1334,6 +1336,7 @@ static gboolean
item_add_or_update (TrackerMinerFS *fs,
GFile *file,
GFileInfo *info,
+ TrackerBatch *batch,
gint priority,
gboolean attributes_update)
{
@@ -1356,13 +1359,11 @@ item_add_or_update (TrackerMinerFS *fs,
if (!attributes_update) {
TRACKER_NOTE (MINER_FS_EVENTS, g_message ("Processing file '%s'...", uri));
g_signal_emit (fs, signals[PROCESS_FILE], 0,
- file, info,
- &sparql);
+ file, info, batch);
} else {
TRACKER_NOTE (MINER_FS_EVENTS, g_message ("Processing attributes in file '%s'...", uri));
g_signal_emit (fs, signals[PROCESS_FILE_ATTRIBUTES], 0,
- file, info,
- &sparql);
+ file, info, batch);
}
fs->priv->total_files_processed++;
@@ -1378,9 +1379,9 @@ static gboolean
item_remove (TrackerMinerFS *fs,
GFile *file,
gboolean only_children,
- GString *task_sparql)
+ TrackerBatch *batch)
{
- gchar *uri, *sparql;
+ gchar *uri;
guint signal_num;
uri = g_file_get_uri (file);
@@ -1395,14 +1396,7 @@ item_remove (TrackerMinerFS *fs,
/* Call the implementation to generate a SPARQL update for the removal. */
signal_num = only_children ? REMOVE_CHILDREN : REMOVE_FILE;
- g_signal_emit (fs, signals[signal_num], 0, file, &sparql);
-
- if (sparql && sparql[0] != '\0') {
- g_string_append (task_sparql, sparql);
- g_string_append (task_sparql, ";\n");
- }
-
- g_free (sparql);
+ g_signal_emit (fs, signals[signal_num], 0, file, batch);
g_free (uri);
return TRUE;
@@ -1412,8 +1406,7 @@ static gboolean
item_move (TrackerMinerFS *fs,
GFile *dest_file,
GFile *source_file,
- GString *dest_task_sparql,
- GString *source_task_sparql,
+ TrackerBatch *batch,
gboolean is_dir)
{
gchar *uri, *source_uri, *sparql;
@@ -1434,24 +1427,17 @@ item_move (TrackerMinerFS *fs,
is_dir);
/* Delete destination item from store if any */
- item_remove (fs, dest_file, FALSE, dest_task_sparql);
+ item_remove (fs, dest_file, FALSE, batch);
/* If the original location is recursive, but the destination location
* is not, remove all children.
*/
if (!recursive &&
(source_flags & TRACKER_DIRECTORY_FLAG_RECURSE) != 0)
- item_remove (fs, source_file, TRUE, source_task_sparql);
-
- g_signal_emit (fs, signals[MOVE_FILE], 0, dest_file, source_file, recursive, &sparql);
+ item_remove (fs, source_file, TRUE, batch);
- if (sparql && sparql[0] != '\0') {
- /* This is treated as a task on dest_file */
- g_string_append (dest_task_sparql, sparql);
- g_string_append (dest_task_sparql, ";\n");
- }
+ g_signal_emit (fs, signals[MOVE_FILE], 0, dest_file, source_file, batch, recursive);
- g_free (sparql);
g_free (uri);
g_free (source_uri);
@@ -1582,11 +1568,11 @@ item_queue_get_progress (TrackerMinerFS *fs,
static void
push_task (TrackerMinerFS *fs,
GFile *file,
- gchar *sparql)
+ TrackerBatch *batch)
{
TrackerTask *task;
- task = tracker_sparql_task_new_take_sparql_str (file, sparql);
+ task = tracker_sparql_task_new_for_batch (file, batch);
tracker_sparql_buffer_push (fs->priv->sparql_buffer,
task,
G_PRIORITY_DEFAULT,
@@ -1608,9 +1594,8 @@ miner_handle_next_item (TrackerMinerFS *fs)
gboolean is_dir = FALSE;
TrackerMinerFSEventType type;
gint priority = 0;
- GString *task_sparql = NULL;
- GString *source_task_sparql = NULL;
GFileInfo *info = NULL;
+ TrackerBatch *batch;
if (fs->priv->timer_stopped) {
g_timer_start (fs->priv->timer);
@@ -1744,47 +1729,28 @@ miner_handle_next_item (TrackerMinerFS *fs)
return FALSE;
}
+ batch = tracker_sparql_buffer_get_current_batch (fs->priv->sparql_buffer);
+
/* Handle queues */
switch (type) {
case TRACKER_MINER_FS_EVENT_MOVED:
- task_sparql = g_string_new ("");
- source_task_sparql = g_string_new ("");
- keep_processing = item_move (fs, file, source_file, task_sparql, source_task_sparql, is_dir);
+ keep_processing = item_move (fs, file, source_file, batch, is_dir);
break;
case TRACKER_MINER_FS_EVENT_DELETED:
- task_sparql = g_string_new ("");
- keep_processing = item_remove (fs, file, FALSE, task_sparql);
+ keep_processing = item_remove (fs, file, FALSE, batch);
break;
case TRACKER_MINER_FS_EVENT_CREATED:
case TRACKER_MINER_FS_EVENT_UPDATED:
- parent = g_file_get_parent (file);
-
- keep_processing = item_add_or_update (fs, file, info, priority, attributes_update);
-
- if (parent) {
- g_object_unref (parent);
- }
-
+ keep_processing = item_add_or_update (fs, file, info, batch, priority, attributes_update);
break;
default:
g_assert_not_reached ();
}
- if (source_task_sparql) {
- if (source_task_sparql->len == 0) {
- g_string_free (source_task_sparql, TRUE);
- } else {
- push_task (fs, source_file, g_string_free (source_task_sparql, FALSE));
- }
- }
-
- if (task_sparql) {
- if (task_sparql->len == 0) {
- g_string_free (task_sparql, TRUE);
- } else {
- push_task (fs, file, g_string_free (task_sparql, FALSE));
- }
- }
+ if (source_file)
+ push_task (fs, source_file, batch);
+ if (file)
+ push_task (fs, file, batch);
if (!tracker_task_pool_limit_reached (TRACKER_TASK_POOL (fs->priv->sparql_buffer))) {
item_queue_handlers_set_up (fs);
@@ -2392,6 +2358,7 @@ tracker_miner_fs_get_folder_urn (TrackerMinerFS *fs,
return NULL;
if (!tracker_sparql_cursor_next (cursor, NULL, NULL)) {
+ tracker_lru_add (fs->priv->urn_lru, g_object_ref (file), NULL);
g_object_unref (cursor);
return NULL;
}
diff --git a/src/libtracker-miner/tracker-miner-fs.h b/src/libtracker-miner/tracker-miner-fs.h
index 9d26a3ae9..481e0dc19 100644
--- a/src/libtracker-miner/tracker-miner-fs.h
+++ b/src/libtracker-miner/tracker-miner-fs.h
@@ -91,34 +91,37 @@ struct _TrackerMinerFS {
typedef struct {
TrackerMinerClass parent;
- gchar * (* process_file) (TrackerMinerFS *fs,
+ void (* process_file) (TrackerMinerFS *fs,
GFile *file,
- GFileInfo *info);
+ GFileInfo *info,
+ TrackerBatch *batch);
void (* finished) (TrackerMinerFS *fs,
gdouble elapsed,
gint directories_found,
gint directories_ignored,
gint files_found,
gint files_ignored);
- gchar * (* process_file_attributes) (TrackerMinerFS *fs,
+ void (* process_file_attributes) (TrackerMinerFS *fs,
GFile *file,
- GFileInfo *info);
+ GFileInfo *info,
+ TrackerBatch *batch);
void (* finished_root) (TrackerMinerFS *fs,
GFile *root,
gint directories_found,
gint directories_ignored,
gint files_found,
gint files_ignored);
- gchar * (* remove_file) (TrackerMinerFS *fs,
- GFile *file);
- gchar * (* remove_children) (TrackerMinerFS *fs,
- GFile *file);
- gchar * (* move_file) (TrackerMinerFS *fs,
- GFile *dest,
+ void (* remove_file) (TrackerMinerFS *fs,
+ GFile *file,
+ TrackerBatch *batch);
+ void (* remove_children) (TrackerMinerFS *fs,
+ GFile *file,
+ TrackerBatch *batch);
+ void (* move_file) (TrackerMinerFS *fs,
+ GFile *dest,
GFile *source,
+ TrackerBatch *batch,
gboolean recursive);
- /* <Private> */
- gpointer padding[20];
} TrackerMinerFSClass;
/**
diff --git a/src/libtracker-miner/tracker-sparql-buffer.c b/src/libtracker-miner/tracker-sparql-buffer.c
index 7afa12dde..c61e908ae 100644
--- a/src/libtracker-miner/tracker-sparql-buffer.c
+++ b/src/libtracker-miner/tracker-sparql-buffer.c
@@ -33,6 +33,7 @@ typedef struct _TrackerSparqlBufferPrivate TrackerSparqlBufferPrivate;
typedef struct _SparqlTaskData SparqlTaskData;
typedef struct _UpdateArrayData UpdateArrayData;
typedef struct _UpdateData UpdateData;
+typedef struct _UpdateBatchData UpdateBatchData;
enum {
PROP_0,
@@ -45,6 +46,7 @@ struct _TrackerSparqlBufferPrivate
guint flush_timeout_id;
GPtrArray *tasks;
gint n_updates;
+ TrackerBatch *batch;
};
struct _SparqlTaskData
@@ -58,6 +60,12 @@ struct _UpdateData {
TrackerTask *task;
};
+struct _UpdateBatchData {
+ TrackerSparqlBuffer *buffer;
+ GPtrArray *tasks;
+ TrackerBatch *batch;
+};
+
struct _UpdateArrayData {
TrackerSparqlBuffer *buffer;
GPtrArray *tasks;
@@ -194,6 +202,75 @@ remove_task_foreach (TrackerTask *task,
tracker_task_pool_remove (pool, task);
}
+static void
+update_batch_data_free (UpdateBatchData *batch_data)
+{
+ g_object_unref (batch_data->batch);
+
+ g_ptr_array_foreach (batch_data->tasks,
+ (GFunc) remove_task_foreach,
+ batch_data->buffer);
+ g_ptr_array_free (batch_data->tasks, TRUE);
+
+ g_slice_free (UpdateBatchData, batch_data);
+}
+
+static void
+batch_execute_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ TrackerSparqlBufferPrivate *priv;
+ TrackerSparqlBuffer *buffer;
+ GError *error = NULL;
+ UpdateBatchData *update_data;
+ gint i;
+
+ update_data = user_data;
+ buffer = TRACKER_SPARQL_BUFFER (update_data->buffer);
+ priv = tracker_sparql_buffer_get_instance_private (buffer);
+ priv->n_updates--;
+
+ if (!tracker_batch_execute_finish (TRACKER_BATCH (object),
+ result,
+ &error)) {
+ g_critical ("Error executing batch: %s\n", error->message);
+ g_error_free (error);
+ return;
+ }
+
+ /* Report status on each task of the batch update */
+ for (i = 0; i < update_data->tasks->len; i++) {
+ TrackerTask *task;
+ SparqlTaskData *task_data;
+
+ task = g_ptr_array_index (update_data->tasks, i);
+ task_data = tracker_task_get_data (task);
+
+ /* Call finished handler with the error, if any */
+ if (error) {
+ g_task_return_error (task_data->async_task,
+ g_error_copy (error));
+ } else {
+ g_task_return_pointer (task_data->async_task,
+ tracker_task_ref (task),
+ (GDestroyNotify) tracker_task_unref);
+ }
+
+ g_clear_object (&task_data->async_task);
+
+ /* No need to deallocate the task here, it will be done when
+ * unref-ing the UpdateArrayData below */
+ }
+
+ g_clear_error (&error);
+ update_batch_data_free (update_data);
+
+ if (tracker_task_pool_limit_reached (TRACKER_TASK_POOL (buffer))) {
+ tracker_sparql_buffer_flush (buffer, "SPARQL buffer limit reached (after flush)");
+ }
+}
+
static void
update_array_data_free (UpdateArrayData *update_data)
{
@@ -282,9 +359,7 @@ tracker_sparql_buffer_flush (TrackerSparqlBuffer *buffer,
const gchar *reason)
{
TrackerSparqlBufferPrivate *priv;
- GArray *sparql_array;
- UpdateArrayData *update_data;
- gint i;
+ UpdateBatchData *update_data;
priv = tracker_sparql_buffer_get_instance_private (buffer);
@@ -304,6 +379,25 @@ tracker_sparql_buffer_flush (TrackerSparqlBuffer *buffer,
priv->flush_timeout_id = 0;
}
+ update_data = g_slice_new0 (UpdateBatchData);
+ update_data->buffer = buffer;
+ update_data->tasks = g_ptr_array_ref (priv->tasks);
+ update_data->batch = g_object_ref (priv->batch);
+
+ /* Empty pool, update_data will keep
+ * references to the tasks to keep
+ * these alive.
+ */
+ g_clear_pointer (&priv->tasks, g_ptr_array_unref);
+ g_clear_object (&priv->batch);
+ priv->n_updates++;
+
+ tracker_batch_execute_async (update_data->batch,
+ NULL,
+ batch_execute_cb,
+ update_data);
+
+#if 0
/* Loop buffer and construct array of strings */
sparql_array = g_array_new (FALSE, TRUE, sizeof (gchar *));
@@ -336,6 +430,7 @@ tracker_sparql_buffer_flush (TrackerSparqlBuffer *buffer,
NULL,
tracker_sparql_buffer_update_array_cb,
update_data);
+#endif
return TRUE;
}
@@ -445,11 +540,7 @@ tracker_sparql_buffer_push (TrackerSparqlBuffer *buffer,
(GDestroyNotify) tracker_task_unref);
}
- if (priority <= G_PRIORITY_HIGH) {
- sparql_buffer_push_high_priority (buffer, task, data);
- } else {
- sparql_buffer_push_to_pool (buffer, task);
- }
+ sparql_buffer_push_to_pool (buffer, task);
}
static SparqlTaskData *
@@ -559,3 +650,29 @@ tracker_sparql_buffer_get_state (TrackerSparqlBuffer *buffer,
return TRACKER_BUFFER_STATE_FLUSHING;
}
+
+TrackerBatch *
+tracker_sparql_buffer_get_current_batch (TrackerSparqlBuffer *buffer)
+{
+ TrackerSparqlBufferPrivate *priv;
+
+ g_return_val_if_fail (TRACKER_IS_SPARQL_BUFFER (buffer), NULL);
+
+ priv = tracker_sparql_buffer_get_instance_private (TRACKER_SPARQL_BUFFER (buffer));
+
+ if (!priv->batch)
+ priv->batch = tracker_sparql_connection_create_batch (priv->connection);
+
+ return priv->batch;
+}
+
+TrackerTask *
+tracker_sparql_task_new_for_batch (GFile *file,
+ TrackerBatch *batch)
+{
+ SparqlTaskData *data;
+
+ data = sparql_task_data_new (NULL, 0);
+ return tracker_task_new (file, data,
+ (GDestroyNotify) sparql_task_data_free);
+}
diff --git a/src/libtracker-miner/tracker-sparql-buffer.h b/src/libtracker-miner/tracker-sparql-buffer.h
index e7d4a2b4a..87f1b227c 100644
--- a/src/libtracker-miner/tracker-sparql-buffer.h
+++ b/src/libtracker-miner/tracker-sparql-buffer.h
@@ -80,6 +80,10 @@ TrackerTask * tracker_sparql_buffer_push_finish (TrackerSparqlBuffer *bu
TrackerSparqlBufferState tracker_sparql_buffer_get_state (TrackerSparqlBuffer *buffer,
GFile *file);
+TrackerBatch * tracker_sparql_buffer_get_current_batch (TrackerSparqlBuffer *buffer);
+TrackerTask * tracker_sparql_task_new_for_batch (GFile *file,
+ TrackerBatch *batch);
+
TrackerTask * tracker_sparql_task_new_take_sparql_str (GFile *file,
gchar *sparql_str);
TrackerTask * tracker_sparql_task_new_with_sparql_str (GFile *file,
diff --git a/src/miners/fs/tracker-miner-files.c b/src/miners/fs/tracker-miner-files.c
index f1604274c..1445d9162 100644
--- a/src/miners/fs/tracker-miner-files.c
+++ b/src/miners/fs/tracker-miner-files.c
@@ -183,19 +183,24 @@ static void set_up_application_indexing (TrackerMinerFiles *m
static void index_applications_changed_cb (GObject *gobject,
GParamSpec *arg1,
gpointer user_data);
-static gchar * miner_files_process_file (TrackerMinerFS *fs,
+static void miner_files_process_file (TrackerMinerFS *fs,
GFile *file,
- GFileInfo *info);
-static gchar * miner_files_process_file_attributes (TrackerMinerFS *fs,
+ GFileInfo *info,
+ TrackerBatch *batch);
+static void miner_files_process_file_attributes (TrackerMinerFS *fs,
GFile *file,
- GFileInfo *info);
-static gchar * miner_files_remove_children (TrackerMinerFS *fs,
- GFile *file);
-static gchar * miner_files_remove_file (TrackerMinerFS *fs,
- GFile *file);
-static gchar * miner_files_move_file (TrackerMinerFS *fs,
+ GFileInfo *info,
+ TrackerBatch *batch);
+static void miner_files_remove_children (TrackerMinerFS *fs,
+ GFile *file,
+ TrackerBatch *batch);
+static void miner_files_remove_file (TrackerMinerFS *fs,
+ GFile *file,
+ TrackerBatch *batch);
+static void miner_files_move_file (TrackerMinerFS *fs,
GFile *file,
GFile *source_file,
+ TrackerBatch *batch,
gboolean recursive);
static void miner_files_finished (TrackerMinerFS *fs,
gdouble elapsed,
@@ -2068,19 +2073,20 @@ miner_files_create_folder_information_element (TrackerMinerFiles *miner,
return resource;
}
-static gchar *
+static void
miner_files_process_file (TrackerMinerFS *fs,
GFile *file,
- GFileInfo *file_info)
+ GFileInfo *file_info,
+ TrackerBatch *batch)
{
TrackerMinerFilesPrivate *priv;
- TrackerResource *resource, *folder_resource = NULL;
+ TrackerResource *resource = NULL, *folder_resource = NULL, *graph_file = NULL;
const gchar *mime_type, *graph;
gchar *parent_urn;
gchar *delete_properties_sparql = NULL;
guint64 time_;
GFile *parent;
- gchar *uri, *sparql_str, *sparql_update_str, *time_str, *ie_update_str = NULL, *graph_file_str = NULL;
+ gchar *uri, *time_str;
gboolean is_directory;
priv = TRACKER_MINER_FILES (fs)->private;
@@ -2156,20 +2162,9 @@ miner_files_process_file (TrackerMinerFS *fs,
miner_files_add_to_datasource (TRACKER_MINER_FILES (fs), file, resource, folder_resource);
- sparql_update_str = tracker_resource_print_sparql_update (resource, NULL, DEFAULT_GRAPH);
-
- if (folder_resource) {
- ie_update_str = tracker_resource_print_sparql_update (folder_resource,
- NULL,
- DEFAULT_GRAPH);
- g_object_unref (folder_resource);
- }
-
graph = tracker_extract_module_manager_get_graph (mime_type);
if (graph) {
- TrackerResource *graph_file;
-
/* This mimetype will be extracted by some module, pre-fill the
* nfo:FileDataObject in that graph.
*/
@@ -2180,38 +2175,33 @@ miner_files_process_file (TrackerMinerFS *fs,
time_str = tracker_date_to_string (time_);
tracker_resource_set_string (graph_file, "nfo:fileLastModified", time_str);
g_free (time_str);
-
- graph_file_str = tracker_resource_print_sparql_update (graph_file,
- NULL, graph);
- g_object_unref (graph_file);
}
- sparql_str = g_strdup_printf ("%s %s %s %s",
- delete_properties_sparql ? delete_properties_sparql : "",
- sparql_update_str,
- ie_update_str ? ie_update_str : "",
- graph_file_str ? graph_file_str : "");
- g_free (ie_update_str);
- g_free (delete_properties_sparql);
- g_free (graph_file_str);
+ if (delete_properties_sparql)
+ tracker_batch_add_sparql (batch, delete_properties_sparql);
- g_object_run_dispose (G_OBJECT (resource));
- g_object_unref (resource);
- g_free (uri);
- g_free (sparql_update_str);
+ tracker_batch_add_resource (batch, DEFAULT_GRAPH, resource);
- return sparql_str;
+ if (graph_file)
+ tracker_batch_add_resource (batch, graph, graph_file);
+ if (folder_resource)
+ tracker_batch_add_resource (batch, DEFAULT_GRAPH, folder_resource);
+ g_object_unref (resource);
+ g_clear_object (&folder_resource);
+ g_clear_object (&graph_file);
+ g_free (uri);
}
-static gchar *
+static void
miner_files_process_file_attributes (TrackerMinerFS *fs,
GFile *file,
- GFileInfo *info)
+ GFileInfo *info,
+ TrackerBatch *batch)
{
TrackerResource *resource;
guint64 time_;
- gchar *uri, *time_str, *sparql_str;
+ gchar *uri, *time_str;
uri = g_file_get_uri (file);
resource = tracker_resource_new (uri);
@@ -2238,11 +2228,8 @@ miner_files_process_file_attributes (TrackerMinerFS *fs,
g_free (uri);
- sparql_str = tracker_resource_print_sparql_update (resource, NULL, DEFAULT_GRAPH);
-
+ tracker_batch_add_resource (batch, DEFAULT_GRAPH, resource);
g_object_unref (resource);
-
- return sparql_str;
}
static void
@@ -2258,15 +2245,16 @@ miner_files_finished (TrackerMinerFS *fs,
tracker_miner_files_check_unextracted (TRACKER_MINER_FILES (fs));
}
-static gchar *
-create_delete_sparql (GFile *file,
- gboolean delete_self,
- gboolean delete_children)
+static void
+add_delete_sparql (GFile *file,
+ TrackerBatch *batch,
+ gboolean delete_self,
+ gboolean delete_children)
{
GString *sparql;
gchar *uri;
- g_return_val_if_fail (delete_self || delete_children, NULL);
+ g_return_if_fail (delete_self || delete_children);
uri = g_file_get_uri (file);
sparql = g_string_new ("DELETE { "
@@ -2301,27 +2289,31 @@ create_delete_sparql (GFile *file,
g_string_append (sparql, ")}");
g_free (uri);
- return g_string_free (sparql, FALSE);
+ tracker_batch_add_sparql (batch, sparql->str);
+ g_string_free (sparql, TRUE);
}
-static gchar *
+static void
miner_files_remove_children (TrackerMinerFS *fs,
- GFile *file)
+ GFile *file,
+ TrackerBatch *batch)
{
- return create_delete_sparql (file, FALSE, TRUE);
+ add_delete_sparql (file, batch, FALSE, TRUE);
}
-static gchar *
+static void
miner_files_remove_file (TrackerMinerFS *fs,
- GFile *file)
+ GFile *file,
+ TrackerBatch *batch)
{
- return create_delete_sparql (file, TRUE, TRUE);
+ add_delete_sparql (file, batch, TRUE, TRUE);
}
-static gchar *
+static void
miner_files_move_file (TrackerMinerFS *fs,
GFile *file,
GFile *source_file,
+ TrackerBatch *batch,
gboolean recursive)
{
GString *sparql = g_string_new (NULL);
@@ -2470,12 +2462,13 @@ miner_files_move_file (TrackerMinerFS *fs,
uri, source_uri, source_uri);
}
+ tracker_batch_add_sparql (batch, sparql->str);
+
g_free (uri);
g_free (source_uri);
g_free (display_name);
g_clear_object (&new_parent);
-
- return g_string_free (sparql, FALSE);
+ g_string_free (sparql, TRUE);
}
TrackerMiner *
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
