core: Propagate parsing errors directly on TrackerSparql creation

We used to error out on parsing errors on first execution. Make this
propagated early, so that it is possible to know at TrackerSparqlStatement
creation time whether parsing was successful or not.

This typically didn't matter since statements could only be used with
select queries, and erroring out on first tracker_sparql_cursor_next()
is alright. But now statements are used for both updates and selects,
possibly from the same entrypoint, so it's better to error out early.

7 files changed, 81 insertions, 46 deletions

diff --git a/src/libtracker-sparql/core/tracker-data-query.c b/src/libtracker-sparql/core/tracker-data-query.c
index 7aa563338..627ea42ad 100644
--- a/src/libtracker-sparql/core/tracker-data-query.c
+++ b/src/libtracker-sparql/core/tracker-data-query.c
@@ -112,7 +112,9 @@ tracker_data_query_sparql_cursor (TrackerDataManager  *manager,
 
 	g_return_val_if_fail (query != NULL, NULL);
 
-	sparql_query = tracker_sparql_new (manager, query);
+	sparql_query = tracker_sparql_new (manager, query, error);
+	if (!sparql_query)
+		return NULL;
 
 	cursor = tracker_sparql_execute_cursor (sparql_query, NULL, error);
 
diff --git a/src/libtracker-sparql/core/tracker-data-update.c b/src/libtracker-sparql/core/tracker-data-update.c
index e564fdaf0..8c31ec39c 100644
--- a/src/libtracker-sparql/core/tracker-data-update.c
+++ b/src/libtracker-sparql/core/tracker-data-update.c
@@ -3252,11 +3252,14 @@ update_sparql (TrackerData  *data,
 		return NULL;
 	}
 
-	sparql_query = tracker_sparql_new_update (data->manager, update);
-	tracker_sparql_execute_update (sparql_query, NULL, NULL,
-	                               blank ? &blank_nodes : NULL,
-	                               &actual_error);
-	g_object_unref (sparql_query);
+	sparql_query = tracker_sparql_new_update (data->manager, update, &actual_error);
+
+	if (sparql_query) {
+		tracker_sparql_execute_update (sparql_query, NULL, NULL,
+		                               blank ? &blank_nodes : NULL,
+		                               &actual_error);
+		g_object_unref (sparql_query);
+	}
 
 	if (actual_error) {
 		tracker_data_rollback_transaction (data);
diff --git a/src/libtracker-sparql/core/tracker-sparql.c b/src/libtracker-sparql/core/tracker-sparql.c
index 6b08cfc84..f74870b9d 100644
--- a/src/libtracker-sparql/core/tracker-sparql.c
+++ b/src/libtracker-sparql/core/tracker-sparql.c
@@ -231,7 +231,6 @@ struct _TrackerSparql
 	gchar *sparql;
 
 	TrackerNodeTree *tree;
-	GError *parser_error;
 
 	struct {
 		GPtrArray *graphs;
@@ -9611,10 +9610,12 @@ tracker_sparql_needs_update (TrackerSparql *sparql)
 }
 
 TrackerSparql*
-tracker_sparql_new (TrackerDataManager *manager,
-                    const gchar        *query)
+tracker_sparql_new (TrackerDataManager  *manager,
+                    const gchar         *query,
+                    GError             **error)
 {
 	TrackerSparql *sparql;
+	GError *inner_error = NULL;
 
 	g_return_val_if_fail (TRACKER_IS_DATA_MANAGER (manager), NULL);
 	g_return_val_if_fail (query != NULL, NULL);
@@ -9629,7 +9630,13 @@ tracker_sparql_new (TrackerDataManager *manager,
 		sparql->sparql = g_strdup (query);
 
 	sparql->tree = tracker_sparql_parse_query (sparql->sparql, -1, NULL,
-	                                           &sparql->parser_error);
+	                                           &inner_error);
+
+	if (inner_error) {
+		g_propagate_error (error, inner_error);
+		g_object_unref (sparql);
+		return NULL;
+	}
 
 	return sparql;
 }
@@ -9779,11 +9786,6 @@ tracker_sparql_execute_cursor (TrackerSparql  *sparql,
 	}
 #endif
 
-	if (sparql->parser_error) {
-		g_propagate_error (error, sparql->parser_error);
-		goto error;
-	}
-
 	if (tracker_sparql_needs_update (sparql)) {
 		TrackerSparqlState state = { 0 };
 		TrackerSelectContext *select_context;
@@ -9836,11 +9838,13 @@ error:
 }
 
 TrackerSparql *
-tracker_sparql_new_update (TrackerDataManager *manager,
-                           const gchar        *query)
+tracker_sparql_new_update (TrackerDataManager  *manager,
+                           const gchar         *query,
+                           GError             **error)
 {
 	TrackerNodeTree *tree;
 	TrackerSparql *sparql;
+	GError *inner_error = NULL;
 	gsize len;
 
 	g_return_val_if_fail (TRACKER_IS_DATA_MANAGER (manager), NULL);
@@ -9855,12 +9859,12 @@ tracker_sparql_new_update (TrackerDataManager *manager,
 		sparql->sparql = g_strdup (query);
 
 	tree = tracker_sparql_parse_update (sparql->sparql, -1, &len,
-	                                    &sparql->parser_error);
+	                                    &inner_error);
 
-	if (tree && !sparql->parser_error && query[len] != '\0') {
+	if (tree && !inner_error && query[len] != '\0') {
 		tracker_node_tree_free (tree);
 		tree = NULL;
-		g_set_error (&sparql->parser_error,
+		g_set_error (&inner_error,
 			     TRACKER_SPARQL_ERROR,
 			     TRACKER_SPARQL_ERROR_PARSE,
 			     "Parser error at byte %" G_GSIZE_FORMAT ": Expected NIL character",
@@ -9879,6 +9883,12 @@ tracker_sparql_new_update (TrackerDataManager *manager,
 		                        (GDestroyNotify) tracker_update_op_group_clear);
 	}
 
+	if (inner_error) {
+		g_propagate_error (error, inner_error);
+		g_object_unref (sparql);
+		return NULL;
+	}
+
 	return sparql;
 }
 
@@ -10416,11 +10426,6 @@ tracker_sparql_execute_update (TrackerSparql  *sparql,
 		return FALSE;
 	}
 
-	if (sparql->parser_error) {
-		g_propagate_error (error, sparql->parser_error);
-		return FALSE;
-	}
-
 	if (update_bnodes)
 		g_variant_builder_init (&variant_builder, G_VARIANT_TYPE ("aaa{ss}"));
 
diff --git a/src/libtracker-sparql/core/tracker-sparql.h b/src/libtracker-sparql/core/tracker-sparql.h
index 4020d02f3..6928f7bbc 100644
--- a/src/libtracker-sparql/core/tracker-sparql.h
+++ b/src/libtracker-sparql/core/tracker-sparql.h
@@ -28,8 +28,9 @@
 G_DECLARE_FINAL_TYPE (TrackerSparql, tracker_sparql,
                       TRACKER, SPARQL, GObject)
 
-TrackerSparql *       tracker_sparql_new (TrackerDataManager *manager,
-                                          const gchar        *sparql);
+TrackerSparql *       tracker_sparql_new (TrackerDataManager  *manager,
+                                          const gchar         *sparql,
+                                          GError             **error);
 
 gboolean              tracker_sparql_is_serializable (TrackerSparql *sparql);
 
@@ -37,8 +38,9 @@ TrackerSparqlCursor * tracker_sparql_execute_cursor (TrackerSparql  *sparql,
                                                      GHashTable     *parameters,
                                                      GError        **error);
 
-TrackerSparql * tracker_sparql_new_update (TrackerDataManager *manager,
-                                           const gchar        *query);
+TrackerSparql * tracker_sparql_new_update (TrackerDataManager  *manager,
+                                           const gchar         *query,
+                                           GError             **error);
 gboolean tracker_sparql_execute_update (TrackerSparql  *sparql,
                                         GHashTable     *parameters,
                                         GHashTable     *bnode_map,
diff --git a/src/libtracker-sparql/direct/tracker-direct-batch.c b/src/libtracker-sparql/direct/tracker-direct-batch.c
index f0c309d10..663d23dce 100644
--- a/src/libtracker-sparql/direct/tracker-direct-batch.c
+++ b/src/libtracker-sparql/direct/tracker-direct-batch.c
@@ -287,13 +287,16 @@ tracker_direct_batch_update (TrackerDirectBatch  *batch,
 			TrackerSparql *query;
 
 			query = tracker_sparql_new_update (data_manager,
-			                                   elem->d.sparql);
-			tracker_sparql_execute_update (query,
-			                               NULL,
-			                               bnodes,
-			                               NULL,
-			                               &inner_error);
-			g_object_unref (query);
+			                                   elem->d.sparql,
+			                                   &inner_error);
+			if (query) {
+				tracker_sparql_execute_update (query,
+				                               NULL,
+				                               bnodes,
+				                               NULL,
+				                               &inner_error);
+				g_object_unref (query);
+			}
 		} else if (elem->type == TRACKER_DIRECT_BATCH_STATEMENT) {
 			tracker_direct_statement_execute_update (elem->d.statement.stmt,
 			                                         elem->d.statement.parameters,
diff --git a/src/libtracker-sparql/direct/tracker-direct-statement.c b/src/libtracker-sparql/direct/tracker-direct-statement.c
index 1f4f695a8..3896d575b 100644
--- a/src/libtracker-sparql/direct/tracker-direct-statement.c
+++ b/src/libtracker-sparql/direct/tracker-direct-statement.c
@@ -472,6 +472,13 @@ tracker_direct_statement_new (TrackerSparqlConnection  *conn,
 {
 	TrackerDirectStatement *direct;
 	TrackerDirectStatementPrivate *priv;
+	TrackerSparql *parser;
+
+	parser = tracker_sparql_new (tracker_direct_connection_get_data_manager (TRACKER_DIRECT_CONNECTION (conn)),
+	                             sparql,
+	                             error);
+	if (!parser)
+		return NULL;
 
 	direct = g_object_new (TRACKER_TYPE_DIRECT_STATEMENT,
 	                       "sparql", sparql,
@@ -479,8 +486,7 @@ tracker_direct_statement_new (TrackerSparqlConnection  *conn,
 	                       NULL);
 
 	priv = tracker_direct_statement_get_instance_private (direct);
-	priv->sparql = tracker_sparql_new (tracker_direct_connection_get_data_manager (TRACKER_DIRECT_CONNECTION (conn)),
-	                                   sparql);
+	priv->sparql = parser;
 
 	return direct;
 }
@@ -492,6 +498,13 @@ tracker_direct_statement_new_update (TrackerSparqlConnection  *conn,
 {
 	TrackerDirectStatement *direct;
 	TrackerDirectStatementPrivate *priv;
+	TrackerSparql *parser;
+
+	parser = tracker_sparql_new_update (tracker_direct_connection_get_data_manager (TRACKER_DIRECT_CONNECTION (conn)),
+	                                    sparql,
+	                                    error);
+	if (!parser)
+		return NULL;
 
 	direct = g_object_new (TRACKER_TYPE_DIRECT_STATEMENT,
 	                       "sparql", sparql,
@@ -499,8 +512,7 @@ tracker_direct_statement_new_update (TrackerSparqlConnection  *conn,
 	                       NULL);
 
 	priv = tracker_direct_statement_get_instance_private (direct);
-	priv->sparql = tracker_sparql_new_update (tracker_direct_connection_get_data_manager (TRACKER_DIRECT_CONNECTION (conn)),
-	                                          sparql);
+	priv->sparql = parser;
 
 	return direct;
 }
diff --git a/src/libtracker-sparql/direct/tracker-direct.c b/src/libtracker-sparql/direct/tracker-direct.c
index 30e6526fe..0d3be777f 100644
--- a/src/libtracker-sparql/direct/tracker-direct.c
+++ b/src/libtracker-sparql/direct/tracker-direct.c
@@ -363,7 +363,11 @@ serialize_in_thread (GTask    *task,
 	priv = tracker_direct_connection_get_instance_private (conn);
 
 	g_mutex_lock (&priv->mutex);
-	query = tracker_sparql_new (priv->data_manager, data->query);
+
+	query = tracker_sparql_new (priv->data_manager, data->query, &error);
+	if (!query)
+		goto out;
+
 	if (!tracker_sparql_is_serializable (query)) {
 		g_set_error (&error,
 		             TRACKER_SPARQL_ERROR,
@@ -868,17 +872,21 @@ tracker_direct_connection_query (TrackerSparqlConnection  *self,
 	TrackerDirectConnectionPrivate *priv;
 	TrackerDirectConnection *conn;
 	TrackerSparql *query;
-	TrackerSparqlCursor *cursor;
+	TrackerSparqlCursor *cursor = NULL;
 	GError *inner_error = NULL;
 
 	conn = TRACKER_DIRECT_CONNECTION (self);
 	priv = tracker_direct_connection_get_instance_private (conn);
 
 	g_mutex_lock (&priv->mutex);
-	query = tracker_sparql_new (priv->data_manager, sparql);
-	cursor = tracker_sparql_execute_cursor (query, NULL, &inner_error);
-	tracker_direct_connection_update_timestamp (conn);
-	g_object_unref (query);
+
+	query = tracker_sparql_new (priv->data_manager, sparql, &inner_error);
+	if (query) {
+		cursor = tracker_sparql_execute_cursor (query, NULL, &inner_error);
+		tracker_direct_connection_update_timestamp (conn);
+		g_object_unref (query);
+	}
+
 	g_mutex_unlock (&priv->mutex);
 
 	if (inner_error)