GNOME.org
 

[tracker/sam/query-errors: 6/7] libtracker-sparql: Don't expose internal db interface errors


commit 9350af560c7316c7acd9eadf2457690b9d3b4200
Author: Sam Thursfield <sam afuera me uk>
Date:   Thu Jul 30 17:53:51 2020 +0200

    libtracker-sparql: Don't expose internal db interface errors
    
    We should not return TrackerDBInterfaceError, from the internal
    libtracker-data library, from public functions in libtracker-sparql.
    
    This problem is noticable as we register D-Bus error codes only for the
    public TrackerSparqlError type.
    
    Before, apps would show error messages like this:
    
        GDBus.Error:org.gtk.GDBus.UnmappedGError.Quark._tracker_2ddb_2dinterface_2derror_2dquark.Code0: 
example error message
    
    After this patch, the error is:
    
         GDBus.Error:org.freedesktop.Tracker.Error.QueryFailed: example error message

 .../libtracker-sparql/libtracker-sparql-docs.xml   |  1 +
 .../libtracker-sparql-sections.txt                 | 14 +++-
 .../libtracker-sparql/libtracker-sparql.types      |  1 -
 .../direct/tracker-direct-statement.c              | 18 ++++-
 src/libtracker-sparql/direct/tracker-direct.c      | 81 +++++++++----------
 src/libtracker-sparql/direct/tracker-direct.h      |  3 +
 src/libtracker-sparql/meson.build                  |  2 +
 src/libtracker-sparql/tracker-connection.c         | 13 ---
 src/libtracker-sparql/tracker-connection.h         | 53 +-----------
 src/libtracker-sparql/tracker-cursor.c             | 28 +++++--
 src/libtracker-sparql/tracker-error.c              | 86 ++++++++++++++++++++
 src/libtracker-sparql/tracker-error.h              | 94 ++++++++++++++++++++++
 src/libtracker-sparql/tracker-private.h            |  1 +
 src/libtracker-sparql/tracker-sparql.h             |  1 +
 14 files changed, 275 insertions(+), 121 deletions(-)
---
diff --git a/docs/reference/libtracker-sparql/libtracker-sparql-docs.xml 
b/docs/reference/libtracker-sparql/libtracker-sparql-docs.xml
index 473376198..4b5793f77 100644
--- a/docs/reference/libtracker-sparql/libtracker-sparql-docs.xml
+++ b/docs/reference/libtracker-sparql/libtracker-sparql-docs.xml
@@ -38,6 +38,7 @@
     <xi:include href="xml/tracker-endpoint.xml"/>
     <xi:include href="xml/tracker-misc.xml"/>
     <xi:include href="xml/tracker-version.xml"/>
+    <xi:include href="xml/tracker-sparql-error.xml"/>
   </part>
 
   <part id="base-ontology">
diff --git a/docs/reference/libtracker-sparql/libtracker-sparql-sections.txt 
b/docs/reference/libtracker-sparql/libtracker-sparql-sections.txt
index e7480374d..e78d96b0a 100644
--- a/docs/reference/libtracker-sparql/libtracker-sparql-sections.txt
+++ b/docs/reference/libtracker-sparql/libtracker-sparql-sections.txt
@@ -98,7 +98,6 @@ TRACKER_TYPE_NAMESPACE_MANAGER
 <SECTION>
 <FILE>tracker-sparql-connection</FILE>
 <TITLE>TrackerSparqlConnection</TITLE>
-TrackerSparqlError
 TrackerSparqlConnection
 TrackerSparqlConnectionFlags
 tracker_sparql_connection_new
@@ -136,14 +135,21 @@ TRACKER_TYPE_SPARQL_VALUE_TYPE
 tracker_sparql_connection_get_type
 TRACKER_TYPE_SPARQL_CONNECTION_FLAGS
 tracker_sparql_connection_flags_get_type
-TRACKER_TYPE_SPARQL_ERROR
-tracker_sparql_error_get_type
 <SUBSECTION Private>
 TrackerSparqlConnectionPrivate
-tracker_sparql_error_quark
 tracker_sparql_connection_construct
 </SECTION>
 
+<SECTION>
+<FILE>tracker-sparql-error</FILE>
+<TITLE>TrackerSparqlError</TITLE>
+TrackerSparqlError
+<SUBSECTION Standard>
+TRACKER_TYPE_SPARQL_ERROR
+<SUBSECTION Private>
+tracker_sparql_error_quark
+</SECTION>
+
 <SECTION>
 <FILE>tracker-sparql-statement</FILE>
 <TITLE>TrackerSparqlStatement</TITLE>
diff --git a/docs/reference/libtracker-sparql/libtracker-sparql.types 
b/docs/reference/libtracker-sparql/libtracker-sparql.types
index 51cfb2ea4..21681e1ee 100644
--- a/docs/reference/libtracker-sparql/libtracker-sparql.types
+++ b/docs/reference/libtracker-sparql/libtracker-sparql.types
@@ -10,5 +10,4 @@ tracker_resource_get_type
 tracker_sparql_connection_get_type
 tracker_sparql_connection_flags_get_type
 tracker_sparql_cursor_get_type
-tracker_sparql_error_get_type
 tracker_sparql_statement_get_type
diff --git a/src/libtracker-sparql/direct/tracker-direct-statement.c 
b/src/libtracker-sparql/direct/tracker-direct-statement.c
index 609dbb485..8e1bcdd8a 100644
--- a/src/libtracker-sparql/direct/tracker-direct-statement.c
+++ b/src/libtracker-sparql/direct/tracker-direct-statement.c
@@ -20,6 +20,7 @@
 #include "config.h"
 #include "tracker-direct-statement.h"
 #include "tracker-data.h"
+#include "tracker-private.h"
 
 typedef struct _TrackerDirectStatementPrivate TrackerDirectStatementPrivate;
 
@@ -143,10 +144,16 @@ tracker_direct_statement_execute (TrackerSparqlStatement  *stmt,
                                   GError                 **error)
 {
        TrackerDirectStatementPrivate *priv;
+       TrackerSparqlCursor *cursor;
+       GError *inner_error = NULL;
 
        priv = tracker_direct_statement_get_instance_private (TRACKER_DIRECT_STATEMENT (stmt));
 
-       return tracker_sparql_execute_cursor (priv->sparql, priv->values, error);
+       cursor = tracker_sparql_execute_cursor (priv->sparql, priv->values, &inner_error);
+       if (inner_error)
+               g_propagate_error (error, _translate_internal_error (inner_error));
+
+       return cursor;
 }
 
 static void
@@ -232,7 +239,14 @@ tracker_direct_statement_execute_finish (TrackerSparqlStatement  *stmt,
                                          GAsyncResult            *res,
                                          GError                 **error)
 {
-       return g_task_propagate_pointer (G_TASK (res), error);
+       TrackerSparqlCursor *cursor;
+       GError *inner_error = NULL;
+
+       cursor = g_task_propagate_pointer (G_TASK (res), &inner_error);
+       if (inner_error)
+               g_propagate_error (error, _translate_internal_error (inner_error));
+
+       return cursor;
 }
 
 static void
diff --git a/src/libtracker-sparql/direct/tracker-direct.c b/src/libtracker-sparql/direct/tracker-direct.c
index 355c5debf..07423c47b 100644
--- a/src/libtracker-sparql/direct/tracker-direct.c
+++ b/src/libtracker-sparql/direct/tracker-direct.c
@@ -26,6 +26,7 @@
 #include <libtracker-data/tracker-data.h>
 #include <libtracker-data/tracker-sparql.h>
 #include <libtracker-sparql/tracker-notifier-private.h>
+#include <libtracker-sparql/tracker-private.h>
 
 typedef struct _TrackerDirectConnectionPrivate TrackerDirectConnectionPrivate;
 
@@ -235,41 +236,6 @@ translate_flags (TrackerSparqlConnectionFlags flags)
        return db_flags;
 }
 
-static GError *
-translate_error (GError *error)
-{
-       GError *new_error = NULL;
-
-       if (error->domain == TRACKER_DATA_ONTOLOGY_ERROR) {
-               /* This is an internal error domain, so translate to a libtracker-sparql error code. */
-               switch (error->code) {
-                       case TRACKER_DATA_ONTOLOGY_NOT_FOUND:
-                               new_error = g_error_new_literal (TRACKER_SPARQL_ERROR,
-                                                                TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND,
-                                                                error->message);
-                               break;
-                       case TRACKER_DATA_UNSUPPORTED_LOCATION:
-                       case TRACKER_DATA_UNSUPPORTED_ONTOLOGY_CHANGE:
-                               new_error = g_error_new_literal (TRACKER_SPARQL_ERROR,
-                                                                TRACKER_SPARQL_ERROR_UNSUPPORTED,
-                                                                error->message);
-                               break;
-                       default:
-                               new_error = g_error_new_literal (TRACKER_SPARQL_ERROR,
-                                                                TRACKER_SPARQL_ERROR_INTERNAL,
-                                                                error->message);
-               }
-       }
-
-       if (new_error) {
-               g_error_free (error);
-               return new_error;
-       } else {
-               return error;
-       }
-}
-
-
 static gboolean
 tracker_direct_connection_initable_init (GInitable     *initable,
                                          GCancellable  *cancellable,
@@ -301,7 +267,7 @@ tracker_direct_connection_initable_init (GInitable     *initable,
                                                       priv->ontology,
                                                       100, 100);
        if (!g_initable_init (G_INITABLE (priv->data_manager), cancellable, &inner_error)) {
-               g_propagate_error (error, translate_error (inner_error));
+               g_propagate_error (error, _translate_internal_error (inner_error));
                g_clear_object (&priv->data_manager);
                return FALSE;
        }
@@ -649,19 +615,23 @@ tracker_direct_connection_query (TrackerSparqlConnection  *self,
        TrackerDirectConnection *conn;
        TrackerSparql *query;
        TrackerSparqlCursor *cursor;
+       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, error);
+       cursor = tracker_sparql_execute_cursor (query, NULL, &inner_error);
        g_object_unref (query);
 
        if (cursor)
                tracker_sparql_cursor_set_connection (cursor, self);
        g_mutex_unlock (&priv->mutex);
 
+       if (inner_error)
+               g_propagate_error (error, _translate_internal_error (inner_error));
+
        return cursor;
 }
 
@@ -686,7 +656,7 @@ tracker_direct_connection_query_async (TrackerSparqlConnection *self,
                              (GDestroyNotify) task_data_free);
 
        if (!g_thread_pool_push (priv->select_pool, task, &error)) {
-               g_task_return_error (task, error);
+               g_task_return_error (task, _translate_internal_error (error));
                g_object_unref (task);
        }
 }
@@ -717,14 +687,18 @@ tracker_direct_connection_update (TrackerSparqlConnection  *self,
        TrackerDirectConnectionPrivate *priv;
        TrackerDirectConnection *conn;
        TrackerData *data;
+       GError *inner_error = NULL;
 
        conn = TRACKER_DIRECT_CONNECTION (self);
        priv = tracker_direct_connection_get_instance_private (conn);
 
        g_mutex_lock (&priv->mutex);
        data = tracker_data_manager_get_data (priv->data_manager);
-       tracker_data_update_sparql (data, sparql, error);
+       tracker_data_update_sparql (data, sparql, &inner_error);
        g_mutex_unlock (&priv->mutex);
+
+       if (inner_error)
+               g_propagate_error (error, inner_error);
 }
 
 static void
@@ -754,7 +728,11 @@ tracker_direct_connection_update_finish (TrackerSparqlConnection  *self,
                                          GAsyncResult             *res,
                                          GError                  **error)
 {
-       g_task_propagate_boolean (G_TASK (res), error);
+       GError *inner_error = NULL;
+
+       g_task_propagate_boolean (G_TASK (res), &inner_error);
+       if (inner_error)
+               g_propagate_error (error, _translate_internal_error (inner_error));
 }
 
 static void
@@ -796,7 +774,14 @@ tracker_direct_connection_update_array_finish (TrackerSparqlConnection  *self,
                                                GAsyncResult             *res,
                                                GError                  **error)
 {
-       return g_task_propagate_boolean (G_TASK (res), error);
+       GError *inner_error = NULL;
+       gboolean result;
+
+       result = g_task_propagate_boolean (G_TASK (res), &inner_error);
+       if (inner_error)
+               g_propagate_error (error, _translate_internal_error (inner_error));
+
+       return result;
 }
 
 static GVariant *
@@ -809,15 +794,18 @@ tracker_direct_connection_update_blank (TrackerSparqlConnection  *self,
        TrackerDirectConnection *conn;
        TrackerData *data;
        GVariant *blank_nodes;
+       GError *inner_error = NULL;
 
        conn = TRACKER_DIRECT_CONNECTION (self);
        priv = tracker_direct_connection_get_instance_private (conn);
 
        g_mutex_lock (&priv->mutex);
        data = tracker_data_manager_get_data (priv->data_manager);
-       blank_nodes = tracker_data_update_sparql_blank (data, sparql, error);
+       blank_nodes = tracker_data_update_sparql_blank (data, sparql, &inner_error);
        g_mutex_unlock (&priv->mutex);
 
+       if (inner_error)
+               g_propagate_error (error, _translate_internal_error (inner_error));
        return blank_nodes;
 }
 
@@ -848,7 +836,14 @@ tracker_direct_connection_update_blank_finish (TrackerSparqlConnection  *self,
                                                GAsyncResult             *res,
                                                GError                  **error)
 {
-       return g_task_propagate_pointer (G_TASK (res), error);
+       GError *inner_error = NULL;
+       GVariant *result;
+
+       result = g_task_propagate_pointer (G_TASK (res), &inner_error);
+       if (inner_error)
+               g_propagate_error (error, _translate_internal_error (inner_error));
+
+       return result;
 }
 
 static TrackerNamespaceManager *
diff --git a/src/libtracker-sparql/direct/tracker-direct.h b/src/libtracker-sparql/direct/tracker-direct.h
index c47087dd5..264f1a2d1 100644
--- a/src/libtracker-sparql/direct/tracker-direct.h
+++ b/src/libtracker-sparql/direct/tracker-direct.h
@@ -53,4 +53,7 @@ TrackerDirectConnection *tracker_direct_connection_new (TrackerSparqlConnectionF
 
 TrackerDataManager *tracker_direct_connection_get_data_manager (TrackerDirectConnection *conn);
 
+/* Internal helper function */
+GError *translate_db_interface_error (GError *error);
+
 #endif /* __TRACKER_LOCAL_CONNECTION_H__ */
diff --git a/src/libtracker-sparql/meson.build b/src/libtracker-sparql/meson.build
index 0f904e189..8f01c29e3 100644
--- a/src/libtracker-sparql/meson.build
+++ b/src/libtracker-sparql/meson.build
@@ -14,6 +14,7 @@ libtracker_sparql_c_sources = files(
     'tracker-cursor.c',
     'tracker-endpoint.c',
     'tracker-endpoint-dbus.c',
+    'tracker-error.c',
     'tracker-namespace-manager.c',
     'tracker-notifier.c',
     'tracker-resource.c',
@@ -28,6 +29,7 @@ libtracker_sparql_c_public_headers = files(
     'tracker-cursor.h',
     'tracker-endpoint.h',
     'tracker-endpoint-dbus.h',
+    'tracker-error.h',
     'tracker-namespace-manager.h',
     'tracker-notifier.h',
     'tracker-ontologies.h',
diff --git a/src/libtracker-sparql/tracker-connection.c b/src/libtracker-sparql/tracker-connection.c
index 64189e9dc..df7f387fd 100644
--- a/src/libtracker-sparql/tracker-connection.c
+++ b/src/libtracker-sparql/tracker-connection.c
@@ -72,19 +72,6 @@
 G_DEFINE_ABSTRACT_TYPE (TrackerSparqlConnection, tracker_sparql_connection,
                         G_TYPE_OBJECT)
 
-G_STATIC_ASSERT (G_N_ELEMENTS (tracker_sparql_error_entries) == TRACKER_SPARQL_N_ERRORS);
-
-GQuark
-tracker_sparql_error_quark (void)
-{
-       static volatile gsize quark_volatile = 0;
-       g_dbus_error_register_error_domain ("tracker-sparql-error-quark",
-                                           &quark_volatile,
-                                           tracker_sparql_error_entries,
-                                           G_N_ELEMENTS (tracker_sparql_error_entries));
-       return (GQuark) quark_volatile;
-}
-
 static void
 tracker_sparql_connection_init (TrackerSparqlConnection *connection)
 {
diff --git a/src/libtracker-sparql/tracker-connection.h b/src/libtracker-sparql/tracker-connection.h
index 57699a953..ee92fde22 100644
--- a/src/libtracker-sparql/tracker-connection.h
+++ b/src/libtracker-sparql/tracker-connection.h
@@ -23,6 +23,7 @@
 #error "only <libtracker-sparql/tracker-sparql.h> must be included directly."
 #endif
 
+#include <libtracker-sparql/tracker-error.h>
 #include <libtracker-sparql/tracker-notifier.h>
 #include <libtracker-sparql/tracker-version.h>
 #include <gio/gio.h>
@@ -66,58 +67,6 @@ G_DECLARE_DERIVABLE_TYPE (TrackerSparqlConnection,
 #include "tracker-statement.h"
 #include "tracker-namespace-manager.h"
 
-/**
- * TrackerSparqlError:
- * @TRACKER_SPARQL_ERROR_PARSE: Error parsing the SPARQL string.
- * @TRACKER_SPARQL_ERROR_UNKNOWN_CLASS: Unknown class.
- * @TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY: Unknown property.
- * @TRACKER_SPARQL_ERROR_TYPE: Wrong type.
- * @TRACKER_SPARQL_ERROR_CONSTRAINT: Subject is not in the domain of a property or
- *                             trying to set multiple values for a single valued
- *                             property.
- * @TRACKER_SPARQL_ERROR_NO_SPACE: There was no disk space available to perform the request.
- * @TRACKER_SPARQL_ERROR_INTERNAL: Internal error.
- * @TRACKER_SPARQL_ERROR_UNSUPPORTED: Unsupported feature or method.
- * @TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH: Unknown graph.
- * @TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND: The specified ontology wasn't found.
- * @TRACKER_SPARQL_N_ERRORS: The total number of error codes.
- *
- * Error domain for Tracker Sparql. Errors in this domain will be from the
- * #TrackerSparqlError enumeration. See #GError for more information on error
- * domains.
- */
-typedef enum {
-       TRACKER_SPARQL_ERROR_PARSE,
-       TRACKER_SPARQL_ERROR_UNKNOWN_CLASS,
-       TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY,
-       TRACKER_SPARQL_ERROR_TYPE,
-       TRACKER_SPARQL_ERROR_CONSTRAINT,
-       TRACKER_SPARQL_ERROR_NO_SPACE,
-       TRACKER_SPARQL_ERROR_INTERNAL,
-       TRACKER_SPARQL_ERROR_UNSUPPORTED,
-       TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH,
-       TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND,
-       TRACKER_SPARQL_N_ERRORS,
-} TrackerSparqlError;
-
-static const GDBusErrorEntry tracker_sparql_error_entries[] =
-{
-       {TRACKER_SPARQL_ERROR_PARSE, "org.freedesktop.Tracker.Error.Parse"},
-       {TRACKER_SPARQL_ERROR_UNKNOWN_CLASS, "org.freedesktop.Tracker.Error.UnknownClass"},
-       {TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY, "org.freedesktop.Tracker.Error.UnknownProperty"},
-       {TRACKER_SPARQL_ERROR_TYPE, "org.freedesktop.Tracker.Error.Type"},
-       {TRACKER_SPARQL_ERROR_CONSTRAINT, "org.freedesktop.Tracker.Error.Constraint"},
-       {TRACKER_SPARQL_ERROR_NO_SPACE, "org.freedesktop.Tracker.Error.NoSpace"},
-       {TRACKER_SPARQL_ERROR_INTERNAL, "org.freedesktop.Tracker.Error.Internal"},
-       {TRACKER_SPARQL_ERROR_UNSUPPORTED, "org.freedesktop.Tracker.Error.Unsupported"},
-       {TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH, "org.freedesktop.Tracker.Error.UnknownGraph"},
-       {TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND, "org.freedesktop.Tracker.Error.OntologyNotFound"},
-};
-
-#define TRACKER_SPARQL_ERROR tracker_sparql_error_quark ()
-
-TRACKER_AVAILABLE_IN_ALL
-GQuark tracker_sparql_error_quark (void);
 
 TRACKER_AVAILABLE_IN_ALL
 TrackerSparqlConnection * tracker_sparql_connection_new (TrackerSparqlConnectionFlags   flags,
diff --git a/src/libtracker-sparql/tracker-cursor.c b/src/libtracker-sparql/tracker-cursor.c
index b1a2f2107..218eef8fb 100644
--- a/src/libtracker-sparql/tracker-cursor.c
+++ b/src/libtracker-sparql/tracker-cursor.c
@@ -415,13 +415,21 @@ tracker_sparql_cursor_next (TrackerSparqlCursor  *cursor,
                             GCancellable         *cancellable,
                             GError              **error)
 {
+       GError *inner_error = NULL;
+       gboolean success;
+
        g_return_val_if_fail (TRACKER_IS_SPARQL_CURSOR (cursor), FALSE);
        g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
        g_return_val_if_fail (!error || !*error, FALSE);
 
-       return TRACKER_SPARQL_CURSOR_GET_CLASS (cursor)->next (cursor,
-                                                              cancellable,
-                                                              error);
+       success = TRACKER_SPARQL_CURSOR_GET_CLASS (cursor)->next (cursor,
+                                                                 cancellable,
+                                                                 &inner_error);
+
+       if (inner_error)
+               g_propagate_error (error, _translate_internal_error (inner_error));
+
+       return success;
 }
 
 /**
@@ -464,13 +472,21 @@ tracker_sparql_cursor_next_finish (TrackerSparqlCursor  *cursor,
                                    GAsyncResult         *res,
                                    GError              **error)
 {
+       GError *inner_error = NULL;
+       gboolean success;
+
        g_return_val_if_fail (TRACKER_IS_SPARQL_CURSOR (cursor), FALSE);
        g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE);
        g_return_val_if_fail (!error || !*error, FALSE);
 
-       return TRACKER_SPARQL_CURSOR_GET_CLASS (cursor)->next_finish (cursor,
-                                                                     res,
-                                                                     error);
+       success = TRACKER_SPARQL_CURSOR_GET_CLASS (cursor)->next_finish (cursor,
+                                                                        res,
+                                                                        error);
+
+       if (inner_error)
+               g_propagate_error (error, _translate_internal_error (inner_error));
+
+       return success;
 }
 
 /**
diff --git a/src/libtracker-sparql/tracker-error.c b/src/libtracker-sparql/tracker-error.c
new file mode 100644
index 000000000..7683f598b
--- /dev/null
+++ b/src/libtracker-sparql/tracker-error.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2010, Nokia <ivan frade nokia com>
+ * Copyright (C) 2020, Sam Thursfield <sam afuera me uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "tracker-error.h"
+#include <libtracker-data/tracker-data.h>
+
+G_STATIC_ASSERT (G_N_ELEMENTS (tracker_sparql_error_entries) == TRACKER_SPARQL_N_ERRORS);
+
+GQuark
+tracker_sparql_error_quark (void)
+{
+       static volatile gsize quark_volatile = 0;
+       g_dbus_error_register_error_domain ("tracker-sparql-error-quark",
+                                           &quark_volatile,
+                                           tracker_sparql_error_entries,
+                                           G_N_ELEMENTS (tracker_sparql_error_entries));
+       return (GQuark) quark_volatile;
+}
+
+/* Converts internal error codes from libtracker-data into public
+ * TrackerSparqlError codes. */
+GError *
+_translate_internal_error (GError *error)
+{
+       GError *new_error = NULL;
+
+       if (error->domain == TRACKER_DATA_ONTOLOGY_ERROR) {
+               switch (error->code) {
+                       case TRACKER_DATA_ONTOLOGY_NOT_FOUND:
+                               new_error = g_error_new_literal (TRACKER_SPARQL_ERROR,
+                                                                TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND,
+                                                                error->message);
+                               break;
+                       case TRACKER_DATA_UNSUPPORTED_LOCATION:
+                       case TRACKER_DATA_UNSUPPORTED_ONTOLOGY_CHANGE:
+                               new_error = g_error_new_literal (TRACKER_SPARQL_ERROR,
+                                                                TRACKER_SPARQL_ERROR_UNSUPPORTED,
+                                                                error->message);
+                               break;
+                       default:
+                               new_error = g_error_new_literal (TRACKER_SPARQL_ERROR,
+                                                                TRACKER_SPARQL_ERROR_INTERNAL,
+                                                                error->message);
+               }
+       }
+
+       if (error->domain == TRACKER_DB_INTERFACE_ERROR) {
+               TrackerSparqlError new_code = TRACKER_SPARQL_ERROR_INTERNAL;
+
+               switch (error->code) {
+                       case TRACKER_DB_QUERY_ERROR: new_code = TRACKER_SPARQL_ERROR_QUERY_FAILED; break;
+                       case TRACKER_DB_OPEN_ERROR: new_code = TRACKER_SPARQL_ERROR_OPEN_ERROR; break;
+                       case TRACKER_DB_NO_SPACE: new_code = TRACKER_SPARQL_ERROR_NO_SPACE; break;
+                       /* This should never happen as we don't call sqlite3_interrupt()
+                        * anywhere, so it doesn't get its own public error code. */
+                       case TRACKER_DB_INTERRUPTED: new_code = TRACKER_SPARQL_ERROR_INTERNAL; break;
+                       default: g_warn_if_reached ();
+               }
+
+               new_error = g_error_new_literal (TRACKER_SPARQL_ERROR, new_code, error->message);
+       }
+
+       if (new_error) {
+               g_error_free (error);
+               return new_error;
+       } else {
+               return error;
+       }
+}
diff --git a/src/libtracker-sparql/tracker-error.h b/src/libtracker-sparql/tracker-error.h
new file mode 100644
index 000000000..6c2d59284
--- /dev/null
+++ b/src/libtracker-sparql/tracker-error.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2010, Nokia <ivan frade nokia com>
+ * Copyright (C) 2020, Sam Thursfield <sam afuera me uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#ifndef __TRACKER_ERROR_H__
+#define __TRACKER_ERROR_H__
+
+#include <gio/gio.h>
+#include <libtracker-sparql/tracker-version.h>
+
+/**
+ * SECTION: tracker-sparql-error
+ * @short_description: Error codes
+ * @title: TrackerSparqlError
+ * @stability: Stable
+ * @include: tracker-sparql.h
+ */
+
+/**
+ * TrackerSparqlError:
+ * @TRACKER_SPARQL_ERROR_CONSTRAINT: Subject is not in the domain of a property or
+ *                             trying to set multiple values for a single valued
+ *                             property.
+ * @TRACKER_SPARQL_ERROR_INTERNAL: Internal error.
+ * @TRACKER_SPARQL_ERROR_NO_SPACE: There was no disk space available to perform the request.
+ * @TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND: The specified ontology wasn't found.
+ * @TRACKER_SPARQL_ERROR_OPEN_ERROR: Problem encounted while opening the database.
+ * @TRACKER_SPARQL_ERROR_PARSE: Error parsing the SPARQL string.
+ * @TRACKER_SPARQL_ERROR_QUERY_FAILED: Problem while executing the query.
+ * @TRACKER_SPARQL_ERROR_TYPE: Type constraint failed when trying to insert data.
+ * @TRACKER_SPARQL_ERROR_UNKNOWN_CLASS: Unknown class.
+ * @TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH: Unknown graph.
+ * @TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY: Unknown property.
+ * @TRACKER_SPARQL_ERROR_UNSUPPORTED: Unsupported feature or method.
+ * @TRACKER_SPARQL_N_ERRORS: The total number of error codes.
+ *
+ * Error domain for Tracker Sparql. Errors in this domain will be from the
+ * #TrackerSparqlError enumeration. See #GError for more information on error
+ * domains.
+ */
+typedef enum {
+       TRACKER_SPARQL_ERROR_CONSTRAINT,
+       TRACKER_SPARQL_ERROR_INTERNAL,
+       TRACKER_SPARQL_ERROR_NO_SPACE,
+       TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND,
+       TRACKER_SPARQL_ERROR_OPEN_ERROR,
+       TRACKER_SPARQL_ERROR_PARSE,
+       TRACKER_SPARQL_ERROR_QUERY_FAILED,
+       TRACKER_SPARQL_ERROR_TYPE,
+       TRACKER_SPARQL_ERROR_UNKNOWN_CLASS,
+       TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH,
+       TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY,
+       TRACKER_SPARQL_ERROR_UNSUPPORTED,
+       TRACKER_SPARQL_N_ERRORS,
+} TrackerSparqlError;
+
+static const GDBusErrorEntry tracker_sparql_error_entries[] =
+{
+       {TRACKER_SPARQL_ERROR_CONSTRAINT, "org.freedesktop.Tracker.Error.Constraint"},
+       {TRACKER_SPARQL_ERROR_INTERNAL, "org.freedesktop.Tracker.Error.Internal"},
+       {TRACKER_SPARQL_ERROR_NO_SPACE, "org.freedesktop.Tracker.Error.NoSpace"},
+       {TRACKER_SPARQL_ERROR_ONTOLOGY_NOT_FOUND, "org.freedesktop.Tracker.Error.OntologyNotFound"},
+       {TRACKER_SPARQL_ERROR_OPEN_ERROR, "org.freedesktop.Tracker.Error.OpenError"},
+       {TRACKER_SPARQL_ERROR_PARSE, "org.freedesktop.Tracker.Error.Parse"},
+       {TRACKER_SPARQL_ERROR_QUERY_FAILED, "org.freedesktop.Tracker.Error.QueryFailed"},
+       {TRACKER_SPARQL_ERROR_TYPE, "org.freedesktop.Tracker.Error.Type"},
+       {TRACKER_SPARQL_ERROR_UNKNOWN_CLASS, "org.freedesktop.Tracker.Error.UnknownClass"},
+       {TRACKER_SPARQL_ERROR_UNKNOWN_GRAPH, "org.freedesktop.Tracker.Error.UnknownGraph"},
+       {TRACKER_SPARQL_ERROR_UNKNOWN_PROPERTY, "org.freedesktop.Tracker.Error.UnknownProperty"},
+       {TRACKER_SPARQL_ERROR_UNSUPPORTED, "org.freedesktop.Tracker.Error.Unsupported"},
+};
+
+#define TRACKER_SPARQL_ERROR tracker_sparql_error_quark ()
+
+TRACKER_AVAILABLE_IN_ALL
+GQuark tracker_sparql_error_quark (void);
+
+#endif
diff --git a/src/libtracker-sparql/tracker-private.h b/src/libtracker-sparql/tracker-private.h
index e80ca0ae6..d91f6e7f4 100644
--- a/src/libtracker-sparql/tracker-private.h
+++ b/src/libtracker-sparql/tracker-private.h
@@ -213,5 +213,6 @@ struct _TrackerNotifierClass {
 
 void tracker_sparql_cursor_set_connection (TrackerSparqlCursor     *cursor,
                                            TrackerSparqlConnection *connection);
+GError * _translate_internal_error (GError *error);
 
 #endif /* __TRACKER_PRIVATE_H__ */
diff --git a/src/libtracker-sparql/tracker-sparql.h b/src/libtracker-sparql/tracker-sparql.h
index 624b4ce8e..60432ff6a 100644
--- a/src/libtracker-sparql/tracker-sparql.h
+++ b/src/libtracker-sparql/tracker-sparql.h
@@ -23,6 +23,7 @@
 #define __LIBTRACKER_SPARQL_INSIDE__
 
 #include <libtracker-sparql/tracker-version.h>
+#include <libtracker-sparql/tracker-error.h>
 #include <libtracker-sparql/tracker-connection.h>
 #include <libtracker-sparql/tracker-cursor.h>
 #include <libtracker-sparql/tracker-endpoint.h>
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]