gda_xa_transaction_new ()

GdaXaTransaction *
gda_xa_transaction_new (guint32 format,
                        const gchar *global_transaction_id);

Creates a new GdaXaTransaction object, which will control the process of performing a distributed transaction across several connections.

gda_xa_transaction_register_connection ()

gboolean
gda_xa_transaction_register_connection
                               (GdaXaTransaction *xa_trans,
                                GdaConnection *cnc,
                                const gchar *branch,
                                GError **error);

Registers cnc to be used by xa_trans to create a distributed transaction.

Note: any GdaConnection object can only be registered with at most one GdaXaTransaction object; also some connections may not be registered at all with a GdaXaTransaction object because the database provider being used does not support it.

gda_xa_transaction_unregister_connection ()

void
gda_xa_transaction_unregister_connection
                               (GdaXaTransaction *xa_trans,
                                GdaConnection *cnc);

Unregisters cnc to be used by xa_trans to create a distributed transaction. This is the opposite of gda_xa_transaction_register_connection().

gda_xa_transaction_begin ()

gboolean
gda_xa_transaction_begin (GdaXaTransaction *xa_trans,
                          GError **error);

Begins a distributed transaction (managed by xa_trans ). Please note that this phase may fail for some connections if a (normal) transaction is already started (this depends on the database provider being used), so it's better to avoid starting any (normal) transaction on any of the connections registered with xa_trans .

gda_xa_transaction_commit ()

gboolean
gda_xa_transaction_commit (GdaXaTransaction *xa_trans,
                           GSList **cnc_to_recover,
                           GError **error);

Commits a distributed transaction (managed by xa_trans ). The commit is composed of two phases:

If the PREPARE phase fails for any of the connection registered with xa_trans , then the distributed commit fails and FALSE is returned. During the COMMIT phase, some commit may actually fail but the transaction can still be completed because the PREPARE phase succeeded (through the recover method).

gda_xa_transaction_rollback ()

gboolean
gda_xa_transaction_rollback (GdaXaTransaction *xa_trans,
                             GError **error);

Cancels a distributed transaction (managed by xa_trans ).

gda_xa_transaction_commit_recovered ()

gboolean
gda_xa_transaction_commit_recovered (GdaXaTransaction *xa_trans,
                                     GSList **cnc_to_recover,
                                     GError **error);

Tries to commit the data prepared but which failed to commit (see gda_xa_transaction_commit()). This method allows one to terminate a distributed transaction which succeeded but for which some connections needed to be recovered.

gda_xa_transaction_id_to_string ()

gchar *
gda_xa_transaction_id_to_string (const GdaXaTransactionId *xid);

Creates a string representation of xid , in the format <gtrid>,<bqual>,<formatID> the <gtrid> and <bqual> strings contain alphanumeric characters, and non alphanumeric characters are converted to "ab" where ab is the hexadecimal representation of the character.

gda_xa_transaction_string_to_id ()

GdaXaTransactionId *
gda_xa_transaction_string_to_id (const gchar *str);

Creates a new GdaXaTransactionId structure from its string representation, it's the opposite of gda_xa_transaction_id_to_string().

[skip]

struct GdaXaTransaction

struct GdaXaTransaction {
	GObject                  object;
	GdaXaTransactionPrivate *priv;
};

enum GdaXaTransactionError

struct GdaXaTransactionId

struct GdaXaTransactionId {
	guint32  format;
	gushort  gtrid_length;
	gushort  bqual_length;
	char     data [128];
};