[tracker/wip/carlosg/serialize-api] libtracker-sparql: Add TrackerSerializeFlags argument to serialization API



commit 9f9be93f274f4d1cec9a4109a60e534697d61e86
Author: Carlos Garnacho <carlosg gnome org>
Date:   Fri Feb 4 13:10:22 2022 +0100

    libtracker-sparql: Add TrackerSerializeFlags argument to serialization API
    
    This is currently unused, but might be used for future expansion points (e.g.
    hint the desire for pretty RDF)

 src/libtracker-sparql/bus/tracker-bus-statement.vala    | 4 ++--
 src/libtracker-sparql/bus/tracker-bus.vala              | 8 ++++----
 src/libtracker-sparql/direct/tracker-direct-statement.c | 1 +
 src/libtracker-sparql/direct/tracker-direct.c           | 1 +
 src/libtracker-sparql/remote/tracker-remote-statement.c | 2 ++
 src/libtracker-sparql/remote/tracker-remote.vala        | 2 +-
 src/libtracker-sparql/tracker-connection.c              | 7 +++++++
 src/libtracker-sparql/tracker-connection.h              | 5 +++++
 src/libtracker-sparql/tracker-endpoint-dbus.c           | 6 +++++-
 src/libtracker-sparql/tracker-private.h                 | 2 ++
 src/libtracker-sparql/tracker-sparql.vapi               | 9 +++++++--
 src/libtracker-sparql/tracker-statement.c               | 7 +++++++
 src/libtracker-sparql/tracker-statement.h               | 1 +
 src/tracker/tracker-export.c                            | 1 +
 tests/libtracker-sparql/tracker-serialize-test.c        | 2 ++
 15 files changed, 48 insertions(+), 10 deletions(-)
---
diff --git a/src/libtracker-sparql/bus/tracker-bus-statement.vala 
b/src/libtracker-sparql/bus/tracker-bus-statement.vala
index bafe75aaa..6c4dfa892 100644
--- a/src/libtracker-sparql/bus/tracker-bus-statement.vala
+++ b/src/libtracker-sparql/bus/tracker-bus-statement.vala
@@ -94,7 +94,7 @@ public class Tracker.Bus.Statement : Tracker.Sparql.Statement {
                return yield Tracker.Bus.Connection.perform_query_call (bus, dbus_name, object_path, query, 
get_arguments (), cancellable);
        }
 
-       public async override GLib.InputStream serialize_async (RdfFormat format, GLib.Cancellable? 
cancellable) throws Sparql.Error, GLib.Error, GLib.IOError, GLib.DBusError {
-               return yield Tracker.Bus.Connection.perform_serialize (bus, dbus_name, object_path, format, 
query, get_arguments (), cancellable);
+       public async override GLib.InputStream serialize_async (SerializeFlags flags, RdfFormat format, 
GLib.Cancellable? cancellable) throws Sparql.Error, GLib.Error, GLib.IOError, GLib.DBusError {
+               return yield Tracker.Bus.Connection.perform_serialize (bus, dbus_name, object_path, flags, 
format, query, get_arguments (), cancellable);
        }
 }
diff --git a/src/libtracker-sparql/bus/tracker-bus.vala b/src/libtracker-sparql/bus/tracker-bus.vala
index c2b9354fb..ffa6f265d 100644
--- a/src/libtracker-sparql/bus/tracker-bus.vala
+++ b/src/libtracker-sparql/bus/tracker-bus.vala
@@ -392,14 +392,14 @@ public class Tracker.Bus.Connection : Tracker.Sparql.Connection {
                return batch;
        }
 
-       public static async GLib.InputStream perform_serialize (DBusConnection bus, string dbus_name, string 
object_path, RdfFormat format, string sparql, VariantBuilder? arguments, Cancellable? cancellable) throws 
GLib.IOError, GLib.Error {
+       public static async GLib.InputStream perform_serialize (DBusConnection bus, string dbus_name, string 
object_path, SerializeFlags flags, RdfFormat format, string sparql, VariantBuilder? arguments, Cancellable? 
cancellable) throws GLib.IOError, GLib.Error {
                UnixInputStream input;
                UnixOutputStream output;
                pipe (out input, out output);
 
                var message = new DBusMessage.method_call (dbus_name, object_path, ENDPOINT_IFACE, 
"Serialize");
                var fd_list = new UnixFDList ();
-               message.set_body (new Variant ("(shia{sv})", sparql, fd_list.append (output.fd), format, 
arguments));
+               message.set_body (new Variant ("(shiia{sv})", sparql, fd_list.append (output.fd), flags, 
format, arguments));
                message.set_unix_fd_list (fd_list);
 
                var reply = yield bus.send_message_with_reply (message, DBusSendMessageFlags.NONE, int.MAX, 
null, cancellable);
@@ -408,7 +408,7 @@ public class Tracker.Bus.Connection : Tracker.Sparql.Connection {
                return input;
        }
 
-       public async override GLib.InputStream serialize_async (RdfFormat format, string sparql, 
GLib.Cancellable? cancellable = null) throws Sparql.Error, GLib.Error, GLib.IOError, GLib.DBusError {
-               return yield perform_serialize (bus, dbus_name, object_path, format, sparql, null, 
cancellable);
+       public async override GLib.InputStream serialize_async (SerializeFlags flags, RdfFormat format, 
string sparql, GLib.Cancellable? cancellable = null) throws Sparql.Error, GLib.Error, GLib.IOError, 
GLib.DBusError {
+               return yield perform_serialize (bus, dbus_name, object_path, flags, format, sparql, null, 
cancellable);
        }
 }
diff --git a/src/libtracker-sparql/direct/tracker-direct-statement.c 
b/src/libtracker-sparql/direct/tracker-direct-statement.c
index d232d064b..86f58213b 100644
--- a/src/libtracker-sparql/direct/tracker-direct-statement.c
+++ b/src/libtracker-sparql/direct/tracker-direct-statement.c
@@ -342,6 +342,7 @@ tracker_direct_statement_execute_finish (TrackerSparqlStatement  *stmt,
 
 static void
 tracker_direct_statement_serialize_async (TrackerSparqlStatement *stmt,
+                                          TrackerSerializeFlags   flags,
                                           TrackerRdfFormat        format,
                                           GCancellable           *cancellable,
                                           GAsyncReadyCallback     callback,
diff --git a/src/libtracker-sparql/direct/tracker-direct.c b/src/libtracker-sparql/direct/tracker-direct.c
index f88fe6b52..8317f40d3 100644
--- a/src/libtracker-sparql/direct/tracker-direct.c
+++ b/src/libtracker-sparql/direct/tracker-direct.c
@@ -1331,6 +1331,7 @@ serialize_rdf_data_free (gpointer user_data)
 
 static void
 tracker_direct_connection_serialize_async (TrackerSparqlConnection  *self,
+                                           TrackerSerializeFlags     flags,
                                            TrackerRdfFormat          format,
                                            const gchar              *query,
                                            GCancellable             *cancellable,
diff --git a/src/libtracker-sparql/remote/tracker-remote-statement.c 
b/src/libtracker-sparql/remote/tracker-remote-statement.c
index 487f88967..beb94d2da 100644
--- a/src/libtracker-sparql/remote/tracker-remote-statement.c
+++ b/src/libtracker-sparql/remote/tracker-remote-statement.c
@@ -390,6 +390,7 @@ serialize_cb (GObject      *source,
 
 static void
 tracker_remote_statement_serialize_async (TrackerSparqlStatement *stmt,
+                                          TrackerSerializeFlags   flags,
                                           TrackerRdfFormat        format,
                                           GCancellable           *cancellable,
                                           GAsyncReadyCallback     callback,
@@ -414,6 +415,7 @@ tracker_remote_statement_serialize_async (TrackerSparqlStatement *stmt,
        }
 
        tracker_sparql_connection_serialize_async (tracker_sparql_statement_get_connection (stmt),
+                                                  flags,
                                                   format,
                                                   rewritten_query ? rewritten_query :
                                                   tracker_sparql_statement_get_sparql (stmt),
diff --git a/src/libtracker-sparql/remote/tracker-remote.vala 
b/src/libtracker-sparql/remote/tracker-remote.vala
index 98c85467f..71a1d3965 100644
--- a/src/libtracker-sparql/remote/tracker-remote.vala
+++ b/src/libtracker-sparql/remote/tracker-remote.vala
@@ -142,7 +142,7 @@ public class Tracker.Remote.Connection : Tracker.Sparql.Connection {
                return true;
        }
 
-       public async override GLib.InputStream serialize_async (RdfFormat format, string sparql, 
GLib.Cancellable? cancellable = null) throws Sparql.Error, GLib.Error, GLib.IOError, GLib.DBusError {
+       public async override GLib.InputStream serialize_async (SerializeFlags flags, RdfFormat format, 
string sparql, GLib.Cancellable? cancellable = null) throws Sparql.Error, GLib.Error, GLib.IOError, 
GLib.DBusError {
                var message = create_describe_request (sparql, format);
 #if SOUP2
                return yield _session.send_async (message, cancellable);
diff --git a/src/libtracker-sparql/tracker-connection.c b/src/libtracker-sparql/tracker-connection.c
index e2fb32578..33042b0f9 100644
--- a/src/libtracker-sparql/tracker-connection.c
+++ b/src/libtracker-sparql/tracker-connection.c
@@ -874,6 +874,7 @@ tracker_sparql_connection_load_statement_from_gresource (TrackerSparqlConnection
 /**
  * tracker_sparql_connection_serialize_async:
  * @connection: a #TrackerSparqlConnection
+ * @flags: serialization flags
  * @format: output RDF format
  * @query: SPARQL query
  * @cancellable: a #GCancellable
@@ -887,10 +888,14 @@ tracker_sparql_connection_load_statement_from_gresource (TrackerSparqlConnection
  * The SPARQL endpoint may not support the specified format, in that case
  * an error will be raised.
  *
+ * The @flags argument is reserved for future expansions, currently
+ * %TRACKER_SERIALIZE_FLAGS_NONE must be passed.
+ *
  * Since: 3.3
  **/
 void
 tracker_sparql_connection_serialize_async (TrackerSparqlConnection *connection,
+                                           TrackerSerializeFlags    flags,
                                            TrackerRdfFormat         format,
                                            const gchar             *query,
                                            GCancellable            *cancellable,
@@ -898,12 +903,14 @@ tracker_sparql_connection_serialize_async (TrackerSparqlConnection *connection,
                                            gpointer                 user_data)
 {
        g_return_if_fail (TRACKER_IS_SPARQL_CONNECTION (connection));
+       g_return_if_fail (flags == TRACKER_SERIALIZE_FLAGS_NONE);
        g_return_if_fail (format < TRACKER_N_RDF_FORMATS);
        g_return_if_fail (query != NULL);
        g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
        g_return_if_fail (callback != NULL);
 
        TRACKER_SPARQL_CONNECTION_GET_CLASS (connection)->serialize_async (connection,
+                                                                          flags,
                                                                           format,
                                                                           query,
                                                                           cancellable,
diff --git a/src/libtracker-sparql/tracker-connection.h b/src/libtracker-sparql/tracker-connection.h
index 5f6e145ea..edb185c84 100644
--- a/src/libtracker-sparql/tracker-connection.h
+++ b/src/libtracker-sparql/tracker-connection.h
@@ -60,6 +60,10 @@ typedef enum {
        TRACKER_N_RDF_FORMATS
 } TrackerRdfFormat;
 
+typedef enum {
+       TRACKER_SERIALIZE_FLAGS_NONE = 0,
+} TrackerSerializeFlags;
+
 /**
  * TrackerSparqlConnection:
  *
@@ -212,6 +216,7 @@ void tracker_sparql_connection_close (TrackerSparqlConnection *connection);
 
 TRACKER_AVAILABLE_IN_3_3
 void tracker_sparql_connection_serialize_async (TrackerSparqlConnection  *connection,
+                                                TrackerSerializeFlags     flags,
                                                 TrackerRdfFormat          format,
                                                 const gchar              *query,
                                                 GCancellable             *cancellable,
diff --git a/src/libtracker-sparql/tracker-endpoint-dbus.c b/src/libtracker-sparql/tracker-endpoint-dbus.c
index 47ea7ca86..fa840e0e3 100644
--- a/src/libtracker-sparql/tracker-endpoint-dbus.c
+++ b/src/libtracker-sparql/tracker-endpoint-dbus.c
@@ -63,6 +63,7 @@ static const gchar introspection_xml[] =
        "    <method name='Serialize'>"
        "      <arg type='s' name='query' direction='in' />"
        "      <arg type='h' name='output_stream' direction='in' />"
+       "      <arg type='i' name='flags' direction='in' />"
        "      <arg type='i' name='format' direction='in' />"
        "      <arg type='a{sv}' name='arguments' direction='in' />"
        "    </method>"
@@ -807,6 +808,7 @@ endpoint_dbus_iface_method_call (GDBusConnection       *connection,
                g_variant_iter_free (arguments);
                g_free (query);
        } else if (g_strcmp0 (method_name, "Serialize") == 0) {
+               TrackerSerializeFlags flags;
                TrackerRdfFormat format;
 
                if (tracker_endpoint_dbus_forbid_operation (endpoint_dbus,
@@ -819,7 +821,7 @@ endpoint_dbus_iface_method_call (GDBusConnection       *connection,
                        return;
                }
 
-               g_variant_get (parameters, "(shia{sv})", &query, &handle, &format, &arguments);
+               g_variant_get (parameters, "(shiia{sv})", &query, &handle, &flags, &format, &arguments);
 
                if (fd_list)
                        fd = g_unix_fd_list_get (fd_list, handle, &error);
@@ -845,6 +847,7 @@ endpoint_dbus_iface_method_call (GDBusConnection       *connection,
                                                         &error);
                                if (stmt) {
                                        tracker_sparql_statement_serialize_async (stmt,
+                                                                                 flags,
                                                                                  format,
                                                                                  request->cancellable,
                                                                                  stmt_serialize_cb,
@@ -858,6 +861,7 @@ endpoint_dbus_iface_method_call (GDBusConnection       *connection,
                                }
                        } else {
                                tracker_sparql_connection_serialize_async (conn,
+                                                                          flags,
                                                                           format,
                                                                           query,
                                                                           request->cancellable,
diff --git a/src/libtracker-sparql/tracker-private.h b/src/libtracker-sparql/tracker-private.h
index 2a7fd6d9e..bad99bd47 100644
--- a/src/libtracker-sparql/tracker-private.h
+++ b/src/libtracker-sparql/tracker-private.h
@@ -112,6 +112,7 @@ struct _TrackerSparqlConnectionClass
                                          gchar                   **path);
 
        void (* serialize_async) (TrackerSparqlConnection  *connection,
+                                 TrackerSerializeFlags     flags,
                                  TrackerRdfFormat          format,
                                  const gchar              *query,
                                  GCancellable             *cancellable,
@@ -234,6 +235,7 @@ struct _TrackerSparqlStatementClass
        void (* clear_bindings) (TrackerSparqlStatement *stmt);
 
         void (* serialize_async) (TrackerSparqlStatement *stmt,
+                                  TrackerSerializeFlags   flags,
                                   TrackerRdfFormat        format,
                                   GCancellable           *cancellable,
                                   GAsyncReadyCallback     callback,
diff --git a/src/libtracker-sparql/tracker-sparql.vapi b/src/libtracker-sparql/tracker-sparql.vapi
index ef759e23f..74a0f66df 100644
--- a/src/libtracker-sparql/tracker-sparql.vapi
+++ b/src/libtracker-sparql/tracker-sparql.vapi
@@ -59,6 +59,11 @@ namespace Tracker {
                TRIG,
        }
 
+       [CCode (cheader_filename = "libtracker-sparql/tracker-connection.h")]
+       public enum SerializeFlags {
+               NONE = 0,
+       }
+
        namespace Sparql {
                [CCode (cheader_filename = "libtracker-sparql/tracker-sparql.h")]
                public static string escape_string (string literal);
@@ -108,7 +113,7 @@ namespace Tracker {
                 public virtual void close ();
                 public async virtual bool close_async () throws GLib.IOError;
 
-                public async virtual GLib.InputStream serialize_async (RdfFormat format, string sparql, 
GLib.Cancellable? cancellable = null) throws Sparql.Error, GLib.Error, GLib.IOError, GLib.DBusError;
+                public async virtual GLib.InputStream serialize_async (SerializeFlags flags, RdfFormat 
format, string sparql, GLib.Cancellable? cancellable = null) throws Sparql.Error, GLib.Error, GLib.IOError, 
GLib.DBusError;
        }
 
        [CCode (cheader_filename = "libtracker-sparql/tracker-sparql.h")]
@@ -125,7 +130,7 @@ namespace Tracker {
 
                public abstract Cursor execute (GLib.Cancellable? cancellable) throws Sparql.Error, 
GLib.Error, GLib.IOError, GLib.DBusError;
                public async abstract Cursor execute_async (GLib.Cancellable? cancellable) throws 
Sparql.Error, GLib.Error, GLib.IOError, GLib.DBusError;
-               public async abstract GLib.InputStream serialize_async (RdfFormat format, GLib.Cancellable? 
cancellable) throws Sparql.Error, GLib.Error, GLib.IOError, GLib.DBusError;
+               public async abstract GLib.InputStream serialize_async (SerializeFlags flags, RdfFormat 
format, GLib.Cancellable? cancellable) throws Sparql.Error, GLib.Error, GLib.IOError, GLib.DBusError;
        }
 
        [CCode (cheader_filename = "libtracker-sparql/tracker-sparql.h")]
diff --git a/src/libtracker-sparql/tracker-statement.c b/src/libtracker-sparql/tracker-statement.c
index d064456c1..72c8604f6 100644
--- a/src/libtracker-sparql/tracker-statement.c
+++ b/src/libtracker-sparql/tracker-statement.c
@@ -402,6 +402,7 @@ tracker_sparql_statement_clear_bindings (TrackerSparqlStatement *stmt)
 /**
  * tracker_sparql_statement_serialize_async:
  * @stmt: a #TrackerSparqlStatement
+ * @flags: serialization flags
  * @format: RDF format of the serialized data
  * @cancellable: (nullable): a #GCancellable used to cancel the operation
  * @callback: user-defined #GAsyncReadyCallback to be called when
@@ -418,20 +419,26 @@ tracker_sparql_statement_clear_bindings (TrackerSparqlStatement *stmt)
  * The SPARQL endpoint may not support the specified format, in that case
  * an error will be raised.
  *
+ * The @flags argument is reserved for future expansions, currently
+ * %TRACKER_SERIALIZE_FLAGS_NONE must be passed.
+ *
  * Since: 3.3
  **/
 void
 tracker_sparql_statement_serialize_async (TrackerSparqlStatement *stmt,
+                                          TrackerSerializeFlags   flags,
                                           TrackerRdfFormat        format,
                                           GCancellable           *cancellable,
                                           GAsyncReadyCallback     callback,
                                           gpointer                user_data)
 {
        g_return_if_fail (TRACKER_IS_SPARQL_STATEMENT (stmt));
+       g_return_if_fail (flags == TRACKER_SERIALIZE_FLAGS_NONE);
        g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
        g_return_if_fail (callback != NULL);
 
        TRACKER_SPARQL_STATEMENT_GET_CLASS (stmt)->serialize_async (stmt,
+                                                                   flags,
                                                                    format,
                                                                    cancellable,
                                                                    callback,
diff --git a/src/libtracker-sparql/tracker-statement.h b/src/libtracker-sparql/tracker-statement.h
index 1581343f3..6d24db5ba 100644
--- a/src/libtracker-sparql/tracker-statement.h
+++ b/src/libtracker-sparql/tracker-statement.h
@@ -93,6 +93,7 @@ TrackerSparqlCursor * tracker_sparql_statement_execute_finish (TrackerSparqlStat
 
 TRACKER_AVAILABLE_IN_3_3
 void tracker_sparql_statement_serialize_async (TrackerSparqlStatement *stmt,
+                                               TrackerSerializeFlags   flags,
                                                TrackerRdfFormat        format,
                                                GCancellable           *cancellable,
                                                GAsyncReadyCallback     callback,
diff --git a/src/tracker/tracker-export.c b/src/tracker/tracker-export.c
index 84b70754c..9d9d42a83 100644
--- a/src/tracker/tracker-export.c
+++ b/src/tracker/tracker-export.c
@@ -346,6 +346,7 @@ export_run_default (void)
        loop = g_main_loop_new (NULL, FALSE);
 
        tracker_sparql_connection_serialize_async (connection,
+                                                  TRACKER_SERIALIZE_FLAGS_NONE,
                                                   show_graphs ?
                                                   TRACKER_RDF_FORMAT_TRIG :
                                                   TRACKER_RDF_FORMAT_TURTLE,
diff --git a/tests/libtracker-sparql/tracker-serialize-test.c 
b/tests/libtracker-sparql/tracker-serialize-test.c
index 26cef2023..f33a83b96 100644
--- a/tests/libtracker-sparql/tracker-serialize-test.c
+++ b/tests/libtracker-sparql/tracker-serialize-test.c
@@ -169,6 +169,7 @@ serialize (TestFixture   *test_fixture,
                tracker_sparql_statement_bind_string (stmt, "arg1", test_info->arg1);
 
                tracker_sparql_statement_serialize_async (stmt,
+                                                         TRACKER_SERIALIZE_FLAGS_NONE,
                                                          test_info->format,
                                                          NULL,
                                                          serialize_stmt_cb,
@@ -176,6 +177,7 @@ serialize (TestFixture   *test_fixture,
                g_object_unref (stmt);
        } else {
                tracker_sparql_connection_serialize_async (test_fixture->conn,
+                                                          TRACKER_SERIALIZE_FLAGS_NONE,
                                                           test_info->format,
                                                           query,
                                                           NULL,


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]