Merge branch 'wip/carlosg/fts-error-propagation' into 'master'

Propagate errors from FTS table creation

See merge request GNOME/tracker!383

7 files changed, 236 insertions, 137 deletions

diff --git a/src/libtracker-data/tracker-data-manager.c b/src/libtracker-data/tracker-data-manager.c
index 5860b10b0..67f97e687 100644
--- a/src/libtracker-data/tracker-data-manager.c
+++ b/src/libtracker-data/tracker-data-manager.c
@@ -133,9 +133,10 @@ enum {
 };
 
 static gboolean tracker_data_manager_fts_changed (TrackerDataManager *manager);
-static void tracker_data_manager_update_fts (TrackerDataManager *manager,
-                                             TrackerDBInterface *iface,
-					     const gchar        *database);
+static gboolean tracker_data_manager_update_fts (TrackerDataManager  *manager,
+                                                 TrackerDBInterface  *iface,
+                                                 const gchar         *database,
+                                                 GError             **error);
 
 static void tracker_data_manager_initable_iface_init (GInitableIface *iface);
 
@@ -3534,56 +3535,71 @@ ontology_get_fts_properties (TrackerDataManager  *manager,
 	}
 }
 
-static void
-rebuild_fts_tokens (TrackerDataManager *manager,
-                    TrackerDBInterface *iface)
+static gboolean
+rebuild_fts_tokens (TrackerDataManager  *manager,
+                    TrackerDBInterface  *iface,
+                    GError             **error)
 {
 	GHashTableIter iter;
 	gchar *graph;
 
 	g_debug ("Rebuilding FTS tokens, this may take a moment...");
-	tracker_db_interface_sqlite_fts_rebuild_tokens (iface, "main");
+	if (!tracker_db_interface_sqlite_fts_rebuild_tokens (iface, "main", error))
+		return FALSE;
 
 	g_hash_table_iter_init (&iter, manager->graphs);
-	while (g_hash_table_iter_next (&iter, (gpointer*) &graph, NULL))
-		tracker_db_interface_sqlite_fts_rebuild_tokens (iface, graph);
+	while (g_hash_table_iter_next (&iter, (gpointer*) &graph, NULL)) {
+		if (!tracker_db_interface_sqlite_fts_rebuild_tokens (iface, graph, error))
+			return FALSE;
+	}
 
 	g_debug ("FTS tokens rebuilt");
 	/* Update the stamp file */
 	tracker_db_manager_tokenizer_update (manager->db_manager);
+
+	return TRUE;
 }
 
 static gboolean
-tracker_data_manager_init_fts (TrackerDataManager *manager,
-                               TrackerDBInterface *iface,
-                               const gchar        *database,
-                               gboolean            create)
+tracker_data_manager_init_fts (TrackerDataManager  *manager,
+                               TrackerDBInterface  *iface,
+                               const gchar         *database,
+                               gboolean             create,
+                               GError             **error)
 {
 	GHashTable *fts_props, *multivalued;
+	gboolean retval;
 
 	ontology_get_fts_properties (manager, &fts_props, &multivalued);
-	tracker_db_interface_sqlite_fts_init (iface,
-					      database,
-					      fts_props,
-	                                      multivalued, create);
+	retval = tracker_db_interface_sqlite_fts_init (iface,
+	                                               database,
+	                                               fts_props,
+	                                               multivalued, create,
+	                                               error);
 	g_hash_table_unref (fts_props);
 	g_hash_table_unref (multivalued);
-	return TRUE;
+
+	return retval;
 }
 
-static void
-tracker_data_manager_update_fts (TrackerDataManager *manager,
-                                 TrackerDBInterface *iface,
-                                 const gchar        *database)
+static gboolean
+tracker_data_manager_update_fts (TrackerDataManager  *manager,
+                                 TrackerDBInterface  *iface,
+                                 const gchar         *database,
+                                 GError             **error)
 {
 	GHashTable *fts_properties, *multivalued;
+	gboolean retval;
 
 	ontology_get_fts_properties (manager, &fts_properties, &multivalued);
-	tracker_db_interface_sqlite_fts_alter_table (iface, database,
-						     fts_properties,
-						     multivalued);
+	retval = tracker_db_interface_sqlite_fts_alter_table (iface, database,
+	                                                      fts_properties,
+	                                                      multivalued,
+	                                                      error);
 	g_hash_table_unref (fts_properties);
 	g_hash_table_unref (multivalued);
+
+	return retval;
 }
 
 GFile *
@@ -3665,11 +3681,14 @@ tracker_data_manager_initialize_iface (TrackerDataManager  *data_manager,
 				return FALSE;
 			}
 
-			tracker_data_manager_init_fts (data_manager, iface, value, FALSE);
+			if (!tracker_data_manager_init_fts (data_manager, iface,
+			                                    value, FALSE, error))
+				return FALSE;
 		}
 	}
 
-	tracker_data_manager_init_fts (data_manager, iface, "main", FALSE);
+	if (!tracker_data_manager_init_fts (data_manager, iface, "main", FALSE, error))
+		return FALSE;
 
 	return TRUE;
 }
@@ -3803,7 +3822,7 @@ tracker_data_manager_initable_init (GInitable     *initable,
 	TrackerDBCursor *cursor;
 	TrackerDBStatement *stmt;
 	GHashTable *ontos_table;
-	GHashTable *graphs;
+	GHashTable *graphs = NULL;
 	GList *sorted = NULL, *l;
 	gboolean read_only;
 	GError *internal_error = NULL;
@@ -3927,7 +3946,10 @@ tracker_data_manager_initable_init (GInitable     *initable,
 			return FALSE;
 		}
 
-		tracker_data_manager_init_fts (manager, iface, "main", TRUE);
+		if (!tracker_data_manager_init_fts (manager, iface, "main", TRUE, &internal_error)) {
+			g_propagate_error (error, internal_error);
+			return FALSE;
+		}
 
 		tracker_data_manager_initialize_iface (manager, iface, &internal_error);
 		if (internal_error) {
@@ -4259,12 +4281,13 @@ tracker_data_manager_initable_init (GInitable     *initable,
 				update_fts = tracker_data_manager_fts_changed (manager);
 
 				if (update_fts)
-					tracker_db_interface_sqlite_fts_delete_table (iface, "main");
+					tracker_db_interface_sqlite_fts_delete_table (iface, "main", &ontology_error);
 
-				tracker_data_ontology_setup_db (manager, iface, "main", TRUE,
-				                                &ontology_error);
+				if (!ontology_error)
+					tracker_data_ontology_setup_db (manager, iface, "main", TRUE, &ontology_error);
 
-				graphs = tracker_data_manager_ensure_graphs (manager, iface, &ontology_error);
+				if (!ontology_error)
+					graphs = tracker_data_manager_ensure_graphs (manager, iface, &ontology_error);
 
 				if (graphs) {
 					GHashTableIter iter;
@@ -4274,7 +4297,10 @@ tracker_data_manager_initable_init (GInitable     *initable,
 
 					while (g_hash_table_iter_next (&iter, &value, NULL)) {
 						if (update_fts)
-							tracker_db_interface_sqlite_fts_delete_table (iface, value);
+							tracker_db_interface_sqlite_fts_delete_table (iface, value, &ontology_error);
+
+						if (ontology_error)
+							break;
 
 						tracker_data_ontology_setup_db (manager, iface, value, TRUE,
 						                                &ontology_error);
@@ -4282,18 +4308,21 @@ tracker_data_manager_initable_init (GInitable     *initable,
 							break;
 
 						if (update_fts) {
-							tracker_data_manager_update_fts (manager, iface, value);
+							tracker_data_manager_update_fts (manager, iface, value, &ontology_error);
 						} else {
-							tracker_data_manager_init_fts (manager, iface, value, FALSE);
+							tracker_data_manager_init_fts (manager, iface, value, FALSE, &ontology_error);
 						}
+
+						if (ontology_error)
+							break;
 					}
 				}
 
 				if (!ontology_error) {
 					if (update_fts) {
-						tracker_data_manager_update_fts (manager, iface, "main");
+						tracker_data_manager_update_fts (manager, iface, "main", &ontology_error);
 					} else {
-						tracker_data_manager_init_fts (manager, iface, "main", FALSE);
+						tracker_data_manager_init_fts (manager, iface, "main", FALSE, &ontology_error);
 					}
 				}
 
@@ -4389,9 +4418,11 @@ skip_ontology_check:
 
 		tracker_db_manager_set_current_locale (manager->db_manager);
 
-		rebuild_fts_tokens (manager, iface);
+		if (!rebuild_fts_tokens (manager, iface, error))
+			return FALSE;
 	} else if (!read_only && tracker_db_manager_get_tokenizer_changed (manager->db_manager)) {
-		rebuild_fts_tokens (manager, iface);
+		if (!rebuild_fts_tokens (manager, iface, error))
+			return FALSE;
 	}
 
 	if (!read_only) {
@@ -4643,7 +4674,8 @@ tracker_data_manager_create_graph (TrackerDataManager  *manager,
 	                                     FALSE, error))
 		goto detach;
 
-	tracker_data_manager_init_fts (manager, iface, name, TRUE);
+	if (!tracker_data_manager_init_fts (manager, iface, name, TRUE, error))
+		goto detach;
 
 	id = tracker_data_ensure_graph (manager->data_update, name, error);
 	if (id == 0)
diff --git a/src/libtracker-data/tracker-db-interface-sqlite.c b/src/libtracker-data/tracker-db-interface-sqlite.c
index 0ecfc3535..0be15c283 100644
--- a/src/libtracker-data/tracker-db-interface-sqlite.c
+++ b/src/libtracker-data/tracker-db-interface-sqlite.c
@@ -2243,21 +2243,29 @@ _fts_create_properties (GHashTable *properties)
 	return (gchar **) g_ptr_array_free (cols, FALSE);
 }
 
-void
+gboolean
 tracker_db_interface_sqlite_fts_init (TrackerDBInterface  *db_interface,
                                       const gchar         *database,
                                       GHashTable          *properties,
                                       GHashTable          *multivalued,
-                                      gboolean             create)
+                                      gboolean             create,
+                                      GError             **error)
 {
+	GError *inner_error = NULL;
 	GStrv fts_columns;
 
-	tracker_fts_init_db (db_interface->db, db_interface, db_interface->flags, properties);
+	if (!tracker_fts_init_db (db_interface->db, db_interface,
+	                          db_interface->flags, properties, error))
+		return FALSE;
 
 	if (create &&
 	    !tracker_fts_create_table (db_interface->db, database, "fts5",
-				       properties, multivalued)) {
-		g_warning ("FTS tables creation failed");
+	                               properties, multivalued,
+	                               &inner_error)) {
+		g_propagate_prefixed_error (error,
+		                            inner_error,
+		                            "FTS tables creation failed: ");
+		return FALSE;
 	}
 
 	fts_columns = _fts_create_properties (properties);
@@ -2278,26 +2286,27 @@ tracker_db_interface_sqlite_fts_init (TrackerDBInterface  *db_interface,
 		                                              FALSE);
 		g_strfreev (fts_columns);
 	}
+
+	return TRUE;
 }
 
-void
-tracker_db_interface_sqlite_fts_delete_table (TrackerDBInterface *db_interface,
-                                              const gchar        *database)
+gboolean
+tracker_db_interface_sqlite_fts_delete_table (TrackerDBInterface  *db_interface,
+                                              const gchar         *database,
+                                              GError             **error)
 {
-	if (!tracker_fts_delete_table (db_interface->db, database, "fts5")) {
-		g_critical ("Failed to delete FTS table");
-	}
+	return tracker_fts_delete_table (db_interface->db, database, "fts5", error);
 }
 
-void
+gboolean
 tracker_db_interface_sqlite_fts_alter_table (TrackerDBInterface  *db_interface,
                                              const gchar         *database,
                                              GHashTable          *properties,
-                                             GHashTable          *multivalued)
+                                             GHashTable          *multivalued,
+                                             GError             **error)
 {
-	if (!tracker_fts_alter_table (db_interface->db, database, "fts5", properties, multivalued)) {
-		g_critical ("Failed to update FTS columns");
-	}
+	return tracker_fts_alter_table (db_interface->db, database, "fts5",
+	                                properties, multivalued, error);
 }
 
 static gchar *
@@ -2487,11 +2496,12 @@ tracker_db_interface_sqlite_fts_delete_id (TrackerDBInterface *db_interface,
 	return TRUE;
 }
 
-void
-tracker_db_interface_sqlite_fts_rebuild_tokens (TrackerDBInterface *interface,
-                                                const gchar        *database)
+gboolean
+tracker_db_interface_sqlite_fts_rebuild_tokens (TrackerDBInterface  *interface,
+                                                const gchar         *database,
+                                                GError             **error)
 {
-	tracker_fts_rebuild_tokens (interface->db, database, "fts5");
+	return tracker_fts_rebuild_tokens (interface->db, database, "fts5", error);
 }
 
 void
diff --git a/src/libtracker-data/tracker-db-interface-sqlite.h b/src/libtracker-data/tracker-db-interface-sqlite.h
index 20aa54618..1499a3aca 100644
--- a/src/libtracker-data/tracker-db-interface-sqlite.h
+++ b/src/libtracker-data/tracker-db-interface-sqlite.h
@@ -49,11 +49,12 @@ TrackerDBInterface *tracker_db_interface_sqlite_new                    (const gc
                                                                         GError                  **error);
 gint64              tracker_db_interface_sqlite_get_last_insert_id     (TrackerDBInterface       *interface);
 void                tracker_db_interface_sqlite_enable_shared_cache    (void);
-void                tracker_db_interface_sqlite_fts_init               (TrackerDBInterface       *interface,
+gboolean            tracker_db_interface_sqlite_fts_init               (TrackerDBInterface       *interface,
                                                                         const gchar              *database,
                                                                         GHashTable               *properties,
                                                                         GHashTable               *multivalued,
-                                                                        gboolean                  create);
+                                                                        gboolean                  create,
+                                                                        GError                  **error);
 void                tracker_db_interface_sqlite_reset_collator         (TrackerDBInterface       *interface);
 gboolean            tracker_db_interface_sqlite_wal_checkpoint         (TrackerDBInterface       *interface,
                                                                         gboolean                  blocking,
@@ -61,13 +62,15 @@ gboolean            tracker_db_interface_sqlite_wal_checkpoint         (TrackerD
 gboolean            tracker_db_interface_init_vtabs                    (TrackerDBInterface       *interface,
                                                                         gpointer                  vtab_data);
 
-void                tracker_db_interface_sqlite_fts_delete_table       (TrackerDBInterface       *interface,
-                                                                        const gchar              *database);
+gboolean            tracker_db_interface_sqlite_fts_delete_table       (TrackerDBInterface       *interface,
+                                                                        const gchar              *database,
+                                                                        GError                  **error);
 
-void                tracker_db_interface_sqlite_fts_alter_table        (TrackerDBInterface       *interface,
+gboolean            tracker_db_interface_sqlite_fts_alter_table        (TrackerDBInterface       *interface,
                                                                         const gchar              *database,
                                                                         GHashTable               *properties,
-                                                                        GHashTable               *multivalued);
+                                                                        GHashTable               *multivalued,
+                                                                        GError                  **error);
 gboolean            tracker_db_interface_sqlite_fts_update_text        (TrackerDBInterface       *db_interface,
                                                                         const gchar              *database,
 	                                                                int                       id,
@@ -82,9 +85,9 @@ gboolean            tracker_db_interface_sqlite_fts_delete_text        (TrackerD
 gboolean            tracker_db_interface_sqlite_fts_delete_id          (TrackerDBInterface       *interface,
                                                                         const gchar              *database,
                                                                         int                       rowid);
-void                tracker_db_interface_sqlite_fts_rebuild_tokens     (TrackerDBInterface       *interface,
-                                                                        const gchar              *database);
-
+gboolean            tracker_db_interface_sqlite_fts_rebuild_tokens     (TrackerDBInterface       *interface,
+                                                                        const gchar              *database,
+                                                                        GError                  **error);
 
 gboolean            tracker_db_interface_attach_database               (TrackerDBInterface       *db_interface,
                                                                         GFile                    *file,
diff --git a/src/libtracker-fts/tracker-fts-tokenizer.c b/src/libtracker-fts/tracker-fts-tokenizer.c
index d2688ac3b..707e81a81 100644
--- a/src/libtracker-fts/tracker-fts-tokenizer.c
+++ b/src/libtracker-fts/tracker-fts-tokenizer.c
@@ -380,7 +380,9 @@ tracker_rank_function (const Fts5ExtensionApi  *api,
 }
 
 static fts5_api *
-get_fts5_api (sqlite3 *db) {
+get_fts5_api (sqlite3  *db,
+              GError  **error)
+{
 	int rc = SQLITE_OK;
 	sqlite3_stmt *stmt;
 	fts5_api *api = NULL;
@@ -391,7 +393,7 @@ get_fts5_api (sqlite3 *db) {
 		rc = sqlite3_prepare_v2(db, "SELECT fts5(?1)",
 		                        -1, &stmt, 0);
 		if (rc != SQLITE_OK)
-			return NULL;
+			goto error;
 
 		sqlite3_bind_pointer (stmt, 1, (void*) &api, "fts5_api_ptr", NULL);
 		sqlite3_step (stmt);
@@ -402,7 +404,7 @@ get_fts5_api (sqlite3 *db) {
 		                        -1, &stmt, 0);
 
 		if (rc != SQLITE_OK)
-			return NULL;
+			goto error;
 
 		if (sqlite3_step (stmt) == SQLITE_ROW)
 			memcpy (&api, sqlite3_column_blob (stmt, 0), sizeof (api));
@@ -411,6 +413,14 @@ get_fts5_api (sqlite3 *db) {
 	sqlite3_finalize (stmt);
 
 	return api;
+
+error:
+	g_set_error (error,
+	             TRACKER_DB_INTERFACE_ERROR,
+	             TRACKER_DB_OPEN_ERROR,
+	             "Could not override fts5 tokenizer: %s",
+	             sqlite3_errstr (rc));
+	return NULL;
 }
 
 static TrackerTokenizerFunctionData *
@@ -437,14 +447,15 @@ gboolean
 tracker_tokenizer_initialize (sqlite3                *db,
                               TrackerDBInterface     *interface,
                               TrackerDBManagerFlags   flags,
-                              const gchar           **property_names)
+                              const gchar           **property_names,
+                              GError                **error)
 {
 	TrackerTokenizerData *data;
 	TrackerTokenizerFunctionData *func_data;
 	fts5_tokenizer *tokenizer;
 	fts5_api *api;
 
-	api = get_fts5_api (db);
+	api = get_fts5_api (db, error);
 
 	if (!api)
 		return FALSE;
diff --git a/src/libtracker-fts/tracker-fts-tokenizer.h b/src/libtracker-fts/tracker-fts-tokenizer.h
index 0065167a0..0e9da34c1 100644
--- a/src/libtracker-fts/tracker-fts-tokenizer.h
+++ b/src/libtracker-fts/tracker-fts-tokenizer.h
@@ -29,6 +29,7 @@
 gboolean tracker_tokenizer_initialize (sqlite3                *db,
                                        TrackerDBInterface     *interface,
                                        TrackerDBManagerFlags   flags,
-                                       const gchar           **property_names);
+                                       const gchar           **property_names,
+                                       GError                **error);
 
 #endif /* __TRACKER_FTS_TOKENIZER_H__ */
diff --git a/src/libtracker-fts/tracker-fts.c b/src/libtracker-fts/tracker-fts.c
index 1cb5041fe..55211fb81 100644
--- a/src/libtracker-fts/tracker-fts.c
+++ b/src/libtracker-fts/tracker-fts.c
@@ -65,10 +65,11 @@ get_fts_properties (GHashTable  *tables)
 }
 
 gboolean
-tracker_fts_init_db (sqlite3               *db,
-                     TrackerDBInterface    *interface,
-                     TrackerDBManagerFlags  flags,
-                     GHashTable            *tables)
+tracker_fts_init_db (sqlite3                *db,
+                     TrackerDBInterface     *interface,
+                     TrackerDBManagerFlags   flags,
+                     GHashTable             *tables,
+                     GError                **error)
 {
 	gchar **property_names;
 	gboolean retval;
@@ -76,24 +77,28 @@ tracker_fts_init_db (sqlite3               *db,
 	gchar *err;
 
 	if (sqlite3_load_extension (db, NULL, "sqlite3_fts5_init", &err) != SQLITE_OK) {
-		g_warning ("Could not load fts5 module: %s", err);
+		g_set_error (error,
+		             TRACKER_DB_INTERFACE_ERROR,
+		             TRACKER_DB_OPEN_ERROR,
+		             "Could not load fts5 module: %s", err);
 		return FALSE;
 	}
 #endif
 
 	property_names = get_fts_properties (tables);
-	retval = tracker_tokenizer_initialize (db, interface, flags, (const gchar **) property_names);
+	retval = tracker_tokenizer_initialize (db, interface, flags, (const gchar **) property_names, error);
 	g_strfreev (property_names);
 
 	return retval;
 }
 
 gboolean
-tracker_fts_create_table (sqlite3     *db,
-                          const gchar *database,
-                          gchar       *table_name,
-                          GHashTable  *tables,
-                          GHashTable  *grouped_columns)
+tracker_fts_create_table (sqlite3      *db,
+                          const gchar  *database,
+                          gchar        *table_name,
+                          GHashTable   *tables,
+                          GHashTable   *grouped_columns,
+                          GError      **error)
 {
 	GString *str, *from, *fts;
 	gchar *index_table;
@@ -153,17 +158,15 @@ tracker_fts_create_table (sqlite3     *db,
 	rc = sqlite3_exec(db, str->str, NULL, NULL, NULL);
 	g_string_free (str, TRUE);
 
-	if (rc != SQLITE_OK) {
-		g_assert_not_reached();
-		return FALSE;
-	}
+	if (rc != SQLITE_OK)
+		goto error;
 
 	g_string_append (fts, "tokenize=TrackerTokenizer)");
 	rc = sqlite3_exec(db, fts->str, NULL, NULL, NULL);
 	g_string_free (fts, TRUE);
 
 	if (rc != SQLITE_OK)
-		return FALSE;
+		goto error;
 
 	str = g_string_new (NULL);
 	g_string_append_printf (str,
@@ -172,13 +175,23 @@ tracker_fts_create_table (sqlite3     *db,
 	rc = sqlite3_exec (db, str->str, NULL, NULL, NULL);
 	g_string_free (str, TRUE);
 
-	return (rc == SQLITE_OK);
+error:
+	if (rc != SQLITE_OK) {
+		g_set_error (error,
+		             TRACKER_DB_INTERFACE_ERROR,
+		             TRACKER_DB_OPEN_ERROR,
+		             "%s", sqlite3_errstr (rc));
+		return FALSE;
+	}
+
+	return TRUE;
 }
 
 gboolean
-tracker_fts_delete_table (sqlite3     *db,
-			  const gchar *database,
-                          gchar       *table_name)
+tracker_fts_delete_table (sqlite3      *db,
+                          const gchar  *database,
+                          gchar        *table_name,
+                          GError      **error)
 {
 	gchar *query;
 	int rc;
@@ -194,15 +207,24 @@ tracker_fts_delete_table (sqlite3     *db,
 		g_free (query);
 	}
 
-	return rc == SQLITE_OK;
+	if (rc != SQLITE_OK) {
+		g_set_error (error,
+		             TRACKER_DB_INTERFACE_ERROR,
+		             TRACKER_DB_OPEN_ERROR,
+		             "%s", sqlite3_errstr (rc));
+		return FALSE;
+	}
+
+	return TRUE;
 }
 
 gboolean
-tracker_fts_alter_table (sqlite3     *db,
-			 const gchar *database,
-			 gchar       *table_name,
-			 GHashTable  *tables,
-			 GHashTable  *grouped_columns)
+tracker_fts_alter_table (sqlite3      *db,
+                         const gchar  *database,
+                         gchar        *table_name,
+                         GHashTable   *tables,
+                         GHashTable   *grouped_columns,
+                         GError      **error)
 {
 	gchar *query, *tmp_name;
 	int rc;
@@ -212,7 +234,7 @@ tracker_fts_alter_table (sqlite3     *db,
 
 	tmp_name = g_strdup_printf ("%s_TMP", table_name);
 
-	if (!tracker_fts_create_table (db, database, tmp_name, tables, grouped_columns)) {
+	if (!tracker_fts_create_table (db, database, tmp_name, tables, grouped_columns, error)) {
 		g_free (tmp_name);
 		return FALSE;
 	}
@@ -222,34 +244,41 @@ tracker_fts_alter_table (sqlite3     *db,
 	rc = sqlite3_exec (db, query, NULL, NULL, NULL);
 	g_free (query);
 
-	if (rc != SQLITE_OK) {
-		g_free (tmp_name);
-		return FALSE;
-	}
+	if (rc != SQLITE_OK)
+		goto error;
 
 	query = g_strdup_printf ("INSERT INTO \"%s\".%s(%s) VALUES('rebuild')",
 				 database, tmp_name, tmp_name);
 	rc = sqlite3_exec (db, query, NULL, NULL, NULL);
 	g_free (query);
 
-	if (rc != SQLITE_OK) {
-		g_free (tmp_name);
-		return FALSE;
-	}
+	if (rc != SQLITE_OK)
+		goto error;
 
 	query = g_strdup_printf ("ALTER TABLE \"%s\".%s RENAME TO %s",
 				 database, tmp_name, table_name);
 	rc = sqlite3_exec (db, query, NULL, NULL, NULL);
 	g_free (query);
+
+error:
 	g_free (tmp_name);
 
-	return rc == SQLITE_OK;
+	if (rc != SQLITE_OK) {
+		g_set_error (error,
+		             TRACKER_DB_INTERFACE_ERROR,
+		             TRACKER_DB_OPEN_ERROR,
+		             "%s", sqlite3_errstr (rc));
+		return FALSE;
+	}
+
+	return TRUE;
 }
 
-void
-tracker_fts_rebuild_tokens (sqlite3     *db,
-			    const gchar *database,
-                            const gchar *table_name)
+gboolean
+tracker_fts_rebuild_tokens (sqlite3      *db,
+			    const gchar  *database,
+                            const gchar  *table_name,
+                            GError      **error)
 {
 	gchar *query;
 	gint rc;
@@ -260,5 +289,13 @@ tracker_fts_rebuild_tokens (sqlite3     *db,
 	rc = sqlite3_exec(db, query, NULL, NULL, NULL);
 	g_free (query);
 
-	g_warn_if_fail (rc == SQLITE_OK);
+	if (rc != SQLITE_OK) {
+		g_set_error (error,
+		             TRACKER_DB_INTERFACE_ERROR,
+		             TRACKER_DB_OPEN_ERROR,
+		             "%s", sqlite3_errstr (rc));
+		return FALSE;
+	}
+
+	return TRUE;
 }
diff --git a/src/libtracker-fts/tracker-fts.h b/src/libtracker-fts/tracker-fts.h
index 059f81823..795837f38 100644
--- a/src/libtracker-fts/tracker-fts.h
+++ b/src/libtracker-fts/tracker-fts.h
@@ -29,26 +29,31 @@
 
 G_BEGIN_DECLS
 
-gboolean    tracker_fts_init_db          (sqlite3               *db,
-                                          TrackerDBInterface    *interface,
-                                          TrackerDBManagerFlags  flags,
-                                          GHashTable            *tables);
-gboolean    tracker_fts_create_table     (sqlite3     *db,
-                                          const gchar *database,
-                                          gchar       *table_name,
-                                          GHashTable  *tables,
-                                          GHashTable  *grouped_columns);
-gboolean    tracker_fts_delete_table     (sqlite3     *db,
-                                          const gchar *database,
-                                          gchar       *table_name);
-gboolean    tracker_fts_alter_table      (sqlite3     *db,
-                                          const gchar *database,
-                                          gchar       *table_name,
-                                          GHashTable  *tables,
-                                          GHashTable  *grouped_columns);
-void        tracker_fts_rebuild_tokens   (sqlite3     *db,
-                                          const gchar *database,
-                                          const gchar *table_name);
+gboolean    tracker_fts_init_db          (sqlite3                *db,
+                                          TrackerDBInterface     *interface,
+                                          TrackerDBManagerFlags   flags,
+                                          GHashTable             *tables,
+                                          GError                **error);
+gboolean    tracker_fts_create_table     (sqlite3      *db,
+                                          const gchar  *database,
+                                          gchar        *table_name,
+                                          GHashTable   *tables,
+                                          GHashTable   *grouped_columns,
+                                          GError      **error);
+gboolean    tracker_fts_delete_table     (sqlite3      *db,
+                                          const gchar  *database,
+                                          gchar        *table_name,
+                                          GError      **error);
+gboolean    tracker_fts_alter_table      (sqlite3      *db,
+                                          const gchar  *database,
+                                          gchar        *table_name,
+                                          GHashTable   *tables,
+                                          GHashTable   *grouped_columns,
+                                          GError      **error);
+gboolean    tracker_fts_rebuild_tokens   (sqlite3      *db,
+                                          const gchar  *database,
+                                          const gchar  *table_name,
+                                          GError      **error);
 
 G_END_DECLS