TrackerSparqlConnection

TrackerSparqlConnection

Synopsis

enum                TrackerSparqlError;
                    TrackerSparqlConnection;
TrackerSparqlConnection* tracker_sparql_connection_get  (GError **error);
TrackerSparqlConnection* tracker_sparql_connection_get_direct
                                                        (GError **error);
TrackerSparqlCursor* tracker_sparql_connection_query    (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                tracker_sparql_connection_query_async
                                                        (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
TrackerSparqlCursor* tracker_sparql_connection_query_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);
void                tracker_sparql_connection_update    (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         gint priority,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                tracker_sparql_connection_update_async
                                                        (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         gint priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
void                tracker_sparql_connection_update_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);
GVariant*           tracker_sparql_connection_update_blank
                                                        (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         gint priority,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                tracker_sparql_connection_update_blank_async
                                                        (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         gint priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
GVariant*           tracker_sparql_connection_update_blank_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);
void                tracker_sparql_connection_load      (TrackerSparqlConnection *self,
                                                         GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                tracker_sparql_connection_load_async
                                                        (TrackerSparqlConnection *self,
                                                         GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
void                tracker_sparql_connection_load_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);
TrackerSparqlCursor* tracker_sparql_connection_statistics
                                                        (TrackerSparqlConnection *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                tracker_sparql_connection_statistics_async
                                                        (TrackerSparqlConnection *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
TrackerSparqlCursor* tracker_sparql_connection_statistics_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);

Object Hierarchy

  GObject
   +----TrackerSparqlConnection

Description

Details

enum TrackerSparqlError

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
} TrackerSparqlError;


TrackerSparqlConnection

typedef struct _TrackerSparqlConnection TrackerSparqlConnection;

The TrackerSparqlConnection object represents a connection with the Tracker Store.


tracker_sparql_connection_get ()

TrackerSparqlConnection* tracker_sparql_connection_get  (GError **error);

Returns a new TrackerSparqlConnection, which will use the best method available to connect to the Tracker Store (direct-access for Read-Only queries, and D-Bus otherwise).

There are 2 environment variables which can be used to control which backends are used to set up the connection. If no environment variables are provided, then both backends are loaded and chosen based on their merits.

The TRACKER_SPARQL_BACKEND environment variable also allows the caller to switch between "auto" (the default), "direct" (for direct access) and "bus" for D-Bus backends. If you force a backend which does not support what you're doing (for example, using the "direct" backend for a SPARQL update) then you will see critical warnings in your code.

error :

GError for error reporting.

Returns :

a new TrackerSparqlConnection. Call g_object_unref() on the object when no longer used.

tracker_sparql_connection_get_direct ()

TrackerSparqlConnection* tracker_sparql_connection_get_direct
                                                        (GError **error);

Returns a new TrackerSparqlConnection, which uses direct-access method to connect to the Tracker Store. Note that this connection will only be able to perform Read-Only queries in the store.

If the TRACKER_SPARQL_BACKEND environment variable is set, it may override the choice to use a direct access connection here, for more details, see tracker_sparql_connection_get().

error :

GError for error reporting.

Returns :

a new TrackerSparqlConnection. Call g_object_unref() on the object when no longer used.

tracker_sparql_connection_query ()

TrackerSparqlCursor* tracker_sparql_connection_query    (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         GCancellable *cancellable,
                                                         GError **error);

Executes a SPARQL query on the store. The API call is completely synchronous, so it may block.

self :

a TrackerSparqlConnection

sparql :

string containing the SPARQL query

cancellable :

a GCancellable used to cancel the operation

error :

GError for error reporting.

Returns :

a TrackerSparqlCursor if results were found, NULL otherwise. On error, NULL is returned and the error is set accordingly. Call g_object_unref() on the returned cursor when no longer needed.

tracker_sparql_connection_query_async ()

void                tracker_sparql_connection_query_async
                                                        (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

Executes asynchronously a SPARQL query on the store.

self :

a TrackerSparqlConnection

sparql :

string containing the SPARQL query

cancellable :

a GCancellable used to cancel the operation

_callback_ :

user-defined GAsyncReadyCallback to be called when asynchronous operation is finished.

_user_data_ :

user-defined data to be passed to _callback_

tracker_sparql_connection_query_finish ()

TrackerSparqlCursor* tracker_sparql_connection_query_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);

self :

_res_ :

error :

Returns :


tracker_sparql_connection_update ()

void                tracker_sparql_connection_update    (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         gint priority,
                                                         GCancellable *cancellable,
                                                         GError **error);

Executes a SPARQL update on the store. The API call is completely synchronous, so it may block.

self :

a TrackerSparqlConnection

sparql :

string containing the SPARQL update query

priority :

the priority for the operation

cancellable :

a GCancellable used to cancel the operation

error :

GError for error reporting.

tracker_sparql_connection_update_async ()

void                tracker_sparql_connection_update_async
                                                        (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         gint priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

Executes asynchronously a SPARQL update on the store.

self :

a TrackerSparqlConnection

sparql :

string containing the SPARQL update query

priority :

the priority for the asynchronous operation

cancellable :

a GCancellable used to cancel the operation

_callback_ :

user-defined GAsyncReadyCallback to be called when asynchronous operation is finished.

_user_data_ :

user-defined data to be passed to _callback_

tracker_sparql_connection_update_finish ()

void                tracker_sparql_connection_update_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);

Finishes the asynchronous SPARQL update operation.

self :

a TrackerSparqlConnection

_res_ :

a GAsyncResult with the result of the operation

error :

GError for error reporting.

tracker_sparql_connection_update_blank ()

GVariant*           tracker_sparql_connection_update_blank
                                                        (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         gint priority,
                                                         GCancellable *cancellable,
                                                         GError **error);

Executes a SPARQL update on the store, and returns the URNs of the generated nodes, if any. The API call is completely synchronous, so it may block.

self :

a TrackerSparqlConnection

sparql :

string containing the SPARQL update query

priority :

the priority for the operation

cancellable :

a GCancellable used to cancel the operation

error :

GError for error reporting.

Returns :

a GVariant with the generated URNs, which should be freed with g_variant_unref() when no longer used.

tracker_sparql_connection_update_blank_async ()

void                tracker_sparql_connection_update_blank_async
                                                        (TrackerSparqlConnection *self,
                                                         const char *sparql,
                                                         gint priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

Executes asynchronously a SPARQL update on the store.

self :

a TrackerSparqlConnection

sparql :

string containing the SPARQL update query

priority :

the priority for the asynchronous operation

cancellable :

a GCancellable used to cancel the operation

_callback_ :

user-defined GAsyncReadyCallback to be called when asynchronous operation is finished.

_user_data_ :

user-defined data to be passed to _callback_

tracker_sparql_connection_update_blank_finish ()

GVariant*           tracker_sparql_connection_update_blank_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);

Finishes the asynchronous SPARQL update operation, and returns the URNs of the generated nodes, if any.

self :

a TrackerSparqlConnection

_res_ :

a GAsyncResult with the result of the operation

error :

GError for error reporting.

Returns :

a GVariant with the generated URNs, which should be freed with g_variant_unref() when no longer used.

tracker_sparql_connection_load ()

void                tracker_sparql_connection_load      (TrackerSparqlConnection *self,
                                                         GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

Loads a Turtle file (TTL) into the store. The API call is completely synchronous, so it may block.

self :

a TrackerSparqlConnection

file :

a GFile

cancellable :

a GCancellable used to cancel the operation

error :

GError for error reporting.

tracker_sparql_connection_load_async ()

void                tracker_sparql_connection_load_async
                                                        (TrackerSparqlConnection *self,
                                                         GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

Loads, asynchronously, a Turtle file (TTL) into the store.

self :

a TrackerSparqlConnection

file :

a GFile

cancellable :

a GCancellable used to cancel the operation

_callback_ :

user-defined GAsyncReadyCallback to be called when asynchronous operation is finished.

_user_data_ :

user-defined data to be passed to _callback_

tracker_sparql_connection_load_finish ()

void                tracker_sparql_connection_load_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);

Finishes the asynchronous load of the Turtle file.

self :

a TrackerSparqlConnection

_res_ :

a GAsyncResult with the result of the operation

error :

GError for error reporting.

tracker_sparql_connection_statistics ()

TrackerSparqlCursor* tracker_sparql_connection_statistics
                                                        (TrackerSparqlConnection *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

Retrieves the statistics from the Store. The API call is completely synchronous, so it may block.

self :

a TrackerSparqlConnection

cancellable :

a GCancellable used to cancel the operation

error :

GError for error reporting.

Returns :

a TrackerSparqlCursor to iterate the reply if successful, NULL on error. Call g_object_unref() on the returned cursor when no longer needed.

tracker_sparql_connection_statistics_async ()

void                tracker_sparql_connection_statistics_async
                                                        (TrackerSparqlConnection *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

Retrieves, asynchronously, the statistics from the Store.

self :

a TrackerSparqlConnection

cancellable :

a GCancellable used to cancel the operation

_callback_ :

user-defined GAsyncReadyCallback to be called when asynchronous operation is finished.

_user_data_ :

user-defined data to be passed to _callback_

tracker_sparql_connection_statistics_finish ()

TrackerSparqlCursor* tracker_sparql_connection_statistics_finish
                                                        (TrackerSparqlConnection *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);

Finishes the asynchronous retrieval of statistics from the Store.

self :

a TrackerSparqlConnection

_res_ :

a GAsyncResult with the result of the operation

error :

GError for error reporting.

Returns :

a TrackerSparqlCursor to iterate the reply if successful, NULL on error. Call g_object_unref() on the returned cursor when no longer needed.