[libgda] Don't use GStaticMutex (which is deprecated) anymore



commit aad56d2c0d88397aefc3cd8f565843b37074efc3
Author: Vivien Malerba <malerba gnome-db org>
Date:   Mon May 6 21:15:45 2013 +0200

    Don't use GStaticMutex (which is deprecated) anymore

 .../DocBook/gda-report-docbook-document.c          |   16 ++--
 libgda-report/RML/gda-report-rml-document.c        |   22 ++--
 libgda-report/engine/gda-report-engine.c           |   14 ++--
 libgda-report/gda-report-document.c                |    6 +-
 libgda-xslt/sqlexslt.c                             |    6 +-
 libgda/dir-blob-op.c                               |    6 +-
 libgda/gda-batch.c                                 |    6 +-
 libgda/gda-blob-op.c                               |    6 +-
 libgda/gda-column.c                                |    6 +-
 libgda/gda-connection-event.c                      |    6 +-
 libgda/gda-connection.c                            |   22 ++--
 libgda/gda-data-access-wrapper.c                   |    6 +-
 libgda/gda-data-comparator.c                       |    6 +-
 libgda/gda-data-handler.c                          |    6 +-
 libgda/gda-data-meta-wrapper.c                     |    6 +-
 libgda/gda-data-model-array.c                      |    6 +-
 libgda/gda-data-model-bdb.c                        |    6 +-
 libgda/gda-data-model-dir.c                        |    6 +-
 libgda/gda-data-model-dsn-list.c                   |    6 +-
 libgda/gda-data-model-import.c                     |    6 +-
 libgda/gda-data-model-iter.c                       |    6 +-
 libgda/gda-data-pivot.c                            |   12 +-
 libgda/gda-data-proxy.c                            |   22 ++--
 libgda/gda-data-select.c                           |    6 +-
 libgda/gda-holder.c                                |   12 +-
 libgda/gda-init.c                                  |    8 +-
 libgda/gda-meta-store.c                            |   14 ++--
 libgda/gda-meta-struct.c                           |    6 +-
 libgda/gda-mutex.c                                 |   24 +++---
 libgda/gda-row.c                                   |    6 +-
 libgda/gda-server-operation.c                      |    6 +-
 libgda/gda-server-provider.c                       |   12 +-
 libgda/gda-set.c                                   |    6 +-
 libgda/gda-sql-builder.c                           |    6 +-
 libgda/gda-statement.c                             |    6 +-
 libgda/gda-transaction-status.c                    |    6 +-
 libgda/gda-tree-manager.c                          |    6 +-
 libgda/gda-tree-mgr-columns.c                      |    6 +-
 libgda/gda-tree-mgr-label.c                        |    6 +-
 libgda/gda-tree-mgr-ldap.c                         |    6 +-
 libgda/gda-tree-mgr-schemas.c                      |    6 +-
 libgda/gda-tree-mgr-select.c                       |    6 +-
 libgda/gda-tree-mgr-tables.c                       |    6 +-
 libgda/gda-tree-node.c                             |    6 +-
 libgda/gda-tree.c                                  |    6 +-
 libgda/gda-types.c                                 |    6 +-
 libgda/gda-xa-transaction.c                        |    6 +-
 libgda/handlers/gda-handler-bin.c                  |    6 +-
 libgda/handlers/gda-handler-boolean.c              |    6 +-
 libgda/handlers/gda-handler-numerical.c            |    6 +-
 libgda/handlers/gda-handler-string.c               |    6 +-
 libgda/handlers/gda-handler-time.c                 |    6 +-
 libgda/handlers/gda-handler-type.c                 |    6 +-
 libgda/providers-support/gda-pstmt.c               |    6 +-
 libgda/sql-parser/gda-sql-parser.c                 |   12 +-
 libgda/sql-parser/gda-statement-struct.c           |    6 +-
 libgda/sqlite/gda-sqlite-blob-op.c                 |    6 +-
 libgda/sqlite/gda-sqlite-handler-bin.c             |    6 +-
 libgda/sqlite/gda-sqlite-handler-boolean.c         |    6 +-
 libgda/sqlite/gda-sqlite-meta.c                    |    6 +-
 libgda/sqlite/gda-sqlite-provider.c                |   84 +++++++++---------
 libgda/sqlite/gda-sqlite-pstmt.c                   |    6 +-
 libgda/sqlite/gda-sqlite-recordset.c               |    6 +-
 libgda/sqlite/virtual/gda-ldap-connection.c        |    6 +-
 libgda/sqlite/virtual/gda-vconnection-data-model.c |   12 +-
 libgda/sqlite/virtual/gda-vconnection-hub.c        |    6 +-
 libgda/sqlite/virtual/gda-virtual-connection.c     |    6 +-
 libgda/sqlite/virtual/gda-virtual-provider.c       |    6 +-
 libgda/sqlite/virtual/gda-vprovider-data-model.c   |    6 +-
 libgda/sqlite/virtual/gda-vprovider-hub.c          |    6 +-
 libgda/thread-wrapper/gda-thread-blob-op.c         |    6 +-
 libgda/thread-wrapper/gda-thread-provider.c        |   18 ++--
 libgda/thread-wrapper/gda-thread-recordset.c       |    6 +-
 libgda/thread-wrapper/gda-thread-wrapper.c         |    6 +-
 providers/bdb/gda-bdb-provider.c                   |    6 +-
 providers/firebird/gda-firebird-blob-op.c          |    6 +-
 providers/firebird/gda-firebird-meta.c             |    8 +-
 providers/firebird/gda-firebird-parser.c           |    6 +-
 providers/firebird/gda-firebird-provider.c         |   12 +-
 providers/firebird/gda-firebird-pstmt.c            |    6 +-
 providers/firebird/gda-firebird-recordset.c        |    6 +-
 providers/jdbc/gda-jdbc-blob-op.c                  |    6 +-
 providers/jdbc/gda-jdbc-meta.c                     |    6 +-
 providers/jdbc/gda-jdbc-provider.c                 |   12 +-
 providers/jdbc/gda-jdbc-pstmt.c                    |    6 +-
 providers/jdbc/gda-jdbc-recordset.c                |    6 +-
 providers/jdbc/libmain.c                           |    8 +-
 providers/ldap/gda-ldap-provider.c                 |    6 +-
 providers/ldap/gdaprov-data-model-ldap.c           |    6 +-
 providers/mdb/gda-mdb-provider.c                   |   16 ++--
 providers/mysql/gda-mysql-blob-op.c                |    6 +-
 providers/mysql/gda-mysql-handler-boolean.c        |    6 +-
 providers/mysql/gda-mysql-provider.c               |   12 +-
 providers/mysql/gda-mysql-pstmt.c                  |    6 +-
 providers/mysql/gda-mysql-recordset.c              |    6 +-
 providers/oracle/gda-oracle-blob-op.c              |    6 +-
 providers/oracle/gda-oracle-meta.c                 |    6 +-
 providers/oracle/gda-oracle-parser.c               |    6 +-
 providers/oracle/gda-oracle-provider.c             |   12 +-
 providers/oracle/gda-oracle-pstmt.c                |    6 +-
 providers/oracle/gda-oracle-recordset.c            |    6 +-
 providers/postgres/gda-postgres-blob-op.c          |    6 +-
 providers/postgres/gda-postgres-handler-bin.c      |    6 +-
 providers/postgres/gda-postgres-provider.c         |   12 +-
 providers/postgres/gda-postgres-pstmt.c            |    6 +-
 providers/postgres/gda-postgres-recordset.c        |    6 +-
 providers/reuseable/mysql/gda-mysql-meta.c         |    6 +-
 providers/reuseable/mysql/gda-mysql-parser.c       |    6 +-
 providers/reuseable/postgres/gda-postgres-meta.c   |    6 +-
 providers/reuseable/postgres/gda-postgres-parser.c |    6 +-
 .../skel-implementation/capi/gda-capi-blob-op.c    |    6 +-
 providers/skel-implementation/capi/gda-capi-meta.c |    6 +-
 .../skel-implementation/capi/gda-capi-parser.c     |    6 +-
 .../skel-implementation/capi/gda-capi-provider.c   |   12 +-
 .../skel-implementation/capi/gda-capi-pstmt.c      |    6 +-
 .../skel-implementation/capi/gda-capi-recordset.c  |    6 +-
 .../models/gda-models-provider.c                   |    6 +-
 providers/web/gda-web-blob-op.c                    |    6 +-
 providers/web/gda-web-provider.c                   |    6 +-
 providers/web/gda-web-pstmt.c                      |    6 +-
 providers/web/gda-web-recordset.c                  |    6 +-
 providers/web/php/test.php                         |   97 ++++++++++++++++++++
 samples/BDB/custom-bdb-model.c                     |    6 +-
 tests/data-model-errors.c                          |    6 +-
 tests/multi-threading/dummy-object.c               |    6 +-
 tools/browser/auth-dialog.c                        |    6 +-
 tools/browser/browser-connection.c                 |    6 +-
 tools/browser/browser-connections-list.c           |    6 +-
 tools/browser/browser-core.c                       |    6 +-
 tools/browser/browser-variable.c                   |    6 +-
 tools/browser/browser-virtual-connection.c         |    6 +-
 tools/browser/browser-window.c                     |    6 +-
 tools/browser/common/fk-declare.c                  |    6 +-
 tools/browser/connection-binding-properties.c      |    6 +-
 .../data-manager/data-manager-perspective.c        |    6 +-
 tools/browser/data-manager/data-source-editor.c    |    6 +-
 tools/browser/data-manager/data-source-manager.c   |    6 +-
 tools/browser/data-manager/data-source.c           |    6 +-
 .../browser/dummy-perspective/dummy-perspective.c  |    6 +-
 .../ldap-browser/ldap-browser-perspective.c        |    6 +-
 tools/browser/ldap-browser/mgr-ldap-classes.c      |    6 +-
 tools/browser/ldap-browser/mgr-ldap-entries.c      |    6 +-
 tools/browser/login-dialog.c                       |    6 +-
 tools/browser/mgr-favorites.c                      |    6 +-
 tools/browser/query-exec/query-exec-perspective.c  |    6 +-
 tools/browser/schema-browser/mgr-columns.c         |    6 +-
 .../schema-browser/schema-browser-perspective.c    |    6 +-
 tools/gda-threader.c                               |    6 +-
 tools/gda-tree-mgr-xml.c                           |    6 +-
 tools/tools-favorites.c                            |    6 +-
 tools/web-server.c                                 |    6 +-
 151 files changed, 679 insertions(+), 582 deletions(-)
---
diff --git a/libgda-report/DocBook/gda-report-docbook-document.c 
b/libgda-report/DocBook/gda-report-docbook-document.c
index e333b1d..55e7b89 100644
--- a/libgda-report/DocBook/gda-report-docbook-document.c
+++ b/libgda-report/DocBook/gda-report-docbook-document.c
@@ -136,7 +136,7 @@ gda_report_docbook_document_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaReportDocbookDocumentClass),
                        (GBaseInitFunc) NULL,
@@ -149,10 +149,10 @@ gda_report_docbook_document_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_REPORT_DOCUMENT, "GdaReportDocbookDocument", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -260,7 +260,7 @@ gda_report_docbook_document_new (GdaReportEngine *engine)
 static gboolean
 gda_report_docbook_document_run_as_html (GdaReportDocument *doc, const gchar *filename, GError **error)
 {
-       static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex init_mutex;
        static gchar *xsltproc = NULL;
        GdaReportDocbookDocument *fdoc;
        gchar **argv;
@@ -271,7 +271,7 @@ gda_report_docbook_document_run_as_html (GdaReportDocument *doc, const gchar *fi
        fdoc = GDA_REPORT_DOCBOOK_DOCUMENT (doc);
        g_return_val_if_fail (fdoc->priv, FALSE);
 
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
        if (!xsltproc) {
                xsltproc = g_find_program_in_path ("xsltproc");
                if (!xsltproc) {
@@ -284,7 +284,7 @@ gda_report_docbook_document_run_as_html (GdaReportDocument *doc, const gchar *fi
                if (!xsltproc) {
                        g_set_error (error, 0, 0,
                                     _("Could not find the '%s' program"), "xsltproc");
-                       g_static_mutex_unlock (&init_mutex);
+                       g_mutex_unlock (&init_mutex);
                        return FALSE;
                }
        }
@@ -299,11 +299,11 @@ gda_report_docbook_document_run_as_html (GdaReportDocument *doc, const gchar *fi
                if (!fdoc->priv->html_stylesheet) {
                        g_set_error (error, 0, 0, "%s", 
                                     _("Could not find the DocBook XSL stylesheet for HTML"));
-                       g_static_mutex_unlock (&init_mutex);
+                       g_mutex_unlock (&init_mutex);
                        return FALSE;
                }
        }
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 
        argv = g_new (gchar *, 9);
        argv[0] = g_strdup (xsltproc);
diff --git a/libgda-report/RML/gda-report-rml-document.c b/libgda-report/RML/gda-report-rml-document.c
index d5b250a..7bb13bc 100644
--- a/libgda-report/RML/gda-report-rml-document.c
+++ b/libgda-report/RML/gda-report-rml-document.c
@@ -109,7 +109,7 @@ gda_report_rml_document_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaReportRmlDocumentClass),
                        (GBaseInitFunc) NULL,
@@ -122,10 +122,10 @@ gda_report_rml_document_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_REPORT_DOCUMENT, "GdaReportRmlDocument", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -189,13 +189,13 @@ gda_report_rml_document_new (GdaReportEngine *engine)
 static gboolean
 gda_report_rml_document_run_as_html (GdaReportDocument *doc, const gchar *filename, GError **error)
 {
-       static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex init_mutex;
        static gchar *converter = NULL;
 
        g_return_val_if_fail (GDA_IS_REPORT_RML_DOCUMENT (doc), FALSE);
        g_return_val_if_fail (filename && *filename, FALSE);
 
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
        if (!converter) {
                converter = g_find_program_in_path ("trml2html.py");
                if (!converter) {
@@ -208,11 +208,11 @@ gda_report_rml_document_run_as_html (GdaReportDocument *doc, const gchar *filena
                if (!converter) {
                        g_set_error (error, 0, 0,
                                     _("Could not find the '%s' program"), "trml2html.py");
-                       g_static_mutex_unlock (&init_mutex);
+                       g_mutex_unlock (&init_mutex);
                        return FALSE;
                }
        }
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 
        return _gda_report_document_run_converter_path (doc, filename, converter, "trml2html", error);
 }
@@ -220,13 +220,13 @@ gda_report_rml_document_run_as_html (GdaReportDocument *doc, const gchar *filena
 static gboolean
 gda_report_rml_document_run_as_pdf (GdaReportDocument *doc, const gchar *filename, GError **error)
 {
-       static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex init_mutex;
        static gchar *converter = NULL;
 
        g_return_val_if_fail (GDA_IS_REPORT_RML_DOCUMENT (doc), FALSE);
        g_return_val_if_fail (filename && *filename, FALSE);
 
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
        if (!converter) {
                converter = g_find_program_in_path ("trml2pdf.py");
                if (!converter) {
@@ -239,11 +239,11 @@ gda_report_rml_document_run_as_pdf (GdaReportDocument *doc, const gchar *filenam
                if (!converter) {
                        g_set_error (error, 0, 0,
                                     _("Could not find the '%s' program"), "trml2pdf.py");
-                       g_static_mutex_unlock (&init_mutex);
+                       g_mutex_unlock (&init_mutex);
                        return FALSE;
                }
        }
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 
        return _gda_report_document_run_converter_path (doc, filename, converter, "trml2pdf", error);
 }
diff --git a/libgda-report/engine/gda-report-engine.c b/libgda-report/engine/gda-report-engine.c
index 8fce0f0..fe0c130 100644
--- a/libgda-report/engine/gda-report-engine.c
+++ b/libgda-report/engine/gda-report-engine.c
@@ -155,7 +155,7 @@ gda_report_engine_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaReportEngineClass),
                        (GBaseInitFunc) NULL,
@@ -168,10 +168,10 @@ gda_report_engine_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaReportEngine", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -1107,12 +1107,12 @@ evaluate_expression (GdaReportEngine *engine, RunContext *context, const gchar *
        GdaDataModel *model;
        GValue *retval;
        gchar *sql;
-       static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex init_mutex;
        GdaConnection *vcnc = NULL;
        GdaSqlParser *parser;
 
        /* create a virtual connection to execute the expression, if it's the first time */
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
        if (!vcnc) {
                static GdaVirtualProvider *provider = NULL;
 
@@ -1120,11 +1120,11 @@ evaluate_expression (GdaReportEngine *engine, RunContext *context, const gchar *
                        provider = gda_vprovider_data_model_new ();
                vcnc = gda_virtual_connection_open (provider, error);
                if (! vcnc) {
-                       g_static_mutex_unlock (&init_mutex);
+                       g_mutex_unlock (&init_mutex);
                        return NULL;
                }
        }
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 
        /* parser */
        parser = g_object_get_data (G_OBJECT (context->cnc), "__gda_parser");
diff --git a/libgda-report/gda-report-document.c b/libgda-report/gda-report-document.c
index 47fdc29..1dbb44f 100644
--- a/libgda-report/gda-report-document.c
+++ b/libgda-report/gda-report-document.c
@@ -119,7 +119,7 @@ gda_report_document_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaReportDocumentClass),
                        (GBaseInitFunc) NULL,
@@ -132,10 +132,10 @@ gda_report_document_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaReportDocument", &info, 
G_TYPE_FLAG_ABSTRACT);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda-xslt/sqlexslt.c b/libgda-xslt/sqlexslt.c
index f978a94..98fab34 100644
--- a/libgda-xslt/sqlexslt.c
+++ b/libgda-xslt/sqlexslt.c
@@ -38,10 +38,10 @@
 void
 gda_xslt_register (void)
 {
-       static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex init_mutex;
        static int init = 0;
 
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
        if (!init) {
                int init_res;
                init = 1;
@@ -54,7 +54,7 @@ gda_xslt_register (void)
                                 init_res);
                }
        }
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 /**
diff --git a/libgda/dir-blob-op.c b/libgda/dir-blob-op.c
index 19b00db..8f5e55c 100644
--- a/libgda/dir-blob-op.c
+++ b/libgda/dir-blob-op.c
@@ -51,7 +51,7 @@ _gda_dir_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDirBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -64,10 +64,10 @@ _gda_dir_blob_op_get_type (void)
                        (GInstanceInitFunc) gda_dir_blob_op_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaDirBlobOp", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-batch.c b/libgda/gda-batch.c
index 4f2a2f1..f47b6ac 100644
--- a/libgda/gda-batch.c
+++ b/libgda/gda-batch.c
@@ -81,7 +81,7 @@ gda_batch_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaBatchClass),
                        (GBaseInitFunc) NULL,
@@ -95,10 +95,10 @@ gda_batch_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaBatch", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-blob-op.c b/libgda/gda-blob-op.c
index 9596f55..018b98d 100644
--- a/libgda/gda-blob-op.c
+++ b/libgda/gda-blob-op.c
@@ -41,7 +41,7 @@ gda_blob_op_get_type (void)
         static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaBlobOpClass),
                         (GBaseInitFunc) NULL,
@@ -55,10 +55,10 @@ gda_blob_op_get_type (void)
                        0
                 };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (PARENT_TYPE, "GdaBlobOp", &info, G_TYPE_FLAG_ABSTRACT);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-column.c b/libgda/gda-column.c
index 0192656..3b14893 100644
--- a/libgda/gda-column.c
+++ b/libgda/gda-column.c
@@ -181,7 +181,7 @@ gda_column_get_type (void)
        static GType type = 0;
        
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaColumnClass),
                        (GBaseInitFunc) NULL,
@@ -194,10 +194,10 @@ gda_column_get_type (void)
                        (GInstanceInitFunc) gda_column_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (PARENT_TYPE, "GdaColumn", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        
        return type;
diff --git a/libgda/gda-connection-event.c b/libgda/gda-connection-event.c
index 76a7bcf..c162393 100644
--- a/libgda/gda-connection-event.c
+++ b/libgda/gda-connection-event.c
@@ -55,7 +55,7 @@ gda_connection_event_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaConnectionEventClass),
                        (GBaseInitFunc) NULL,
@@ -68,10 +68,10 @@ gda_connection_event_get_type (void)
                        (GInstanceInitFunc) gda_connection_event_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaConnectionEvent", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/gda-connection.c b/libgda/gda-connection.c
index 5e0381b..15a68da 100644
--- a/libgda/gda-connection.c
+++ b/libgda/gda-connection.c
@@ -69,7 +69,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 
-static GStaticMutex parser_mutex = G_STATIC_MUTEX_INIT;
+static GMutex parser_mutex;
 static GdaSqlParser *internal_parser = NULL;
 
 #define PROV_CLASS(provider) (GDA_SERVER_PROVIDER_CLASS (G_OBJECT_GET_CLASS (provider)))
@@ -676,7 +676,7 @@ gda_connection_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaConnectionClass),
                        (GBaseInitFunc) NULL,
@@ -695,12 +695,12 @@ gda_connection_get_type (void)
                         NULL
                 };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaConnection", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_LOCKABLE, &lockable_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -1158,12 +1158,12 @@ cnc_task_free (CncTask *task)
 GdaServerProvider *
 _gda_connection_get_internal_thread_provider (void)
 {
-       static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+       static GMutex mutex;
 
-       g_static_mutex_lock (&mutex);
+       g_mutex_lock (&mutex);
        if (!_gda_thread_wrapper_provider)
                _gda_thread_wrapper_provider = GDA_SERVER_PROVIDER (g_object_new (GDA_TYPE_THREAD_PROVIDER, 
NULL));
-       g_static_mutex_unlock (&mutex);
+       g_mutex_unlock (&mutex);
        return _gda_thread_wrapper_provider;
 }
 
@@ -3584,10 +3584,10 @@ gda_connection_execute_select_command (GdaConnection *cnc, const gchar *sql, GEr
                              || g_str_has_prefix (sql, "SELECT"),
                              NULL);
 
-       g_static_mutex_lock (&parser_mutex);
+       g_mutex_lock (&parser_mutex);
        if (!internal_parser)
                internal_parser = gda_sql_parser_new ();
-       g_static_mutex_unlock (&parser_mutex);
+       g_mutex_unlock (&parser_mutex);
 
        stmt = gda_sql_parser_parse_string (internal_parser, sql, NULL, error);
        if (!stmt)
@@ -3621,10 +3621,10 @@ gda_connection_execute_non_select_command (GdaConnection *cnc, const gchar *sql,
                              || GDA_IS_CONNECTION (cnc)
                              || !gda_connection_is_opened (cnc), -1);
 
-       g_static_mutex_lock (&parser_mutex);
+       g_mutex_lock (&parser_mutex);
        if (!internal_parser)
                internal_parser = gda_sql_parser_new ();
-       g_static_mutex_unlock (&parser_mutex);
+       g_mutex_unlock (&parser_mutex);
 
        stmt = gda_sql_parser_parse_string (internal_parser, sql, NULL, error);
        if (!stmt)
diff --git a/libgda/gda-data-access-wrapper.c b/libgda/gda-data-access-wrapper.c
index 952835d..ee14a8b 100644
--- a/libgda/gda-data-access-wrapper.c
+++ b/libgda/gda-data-access-wrapper.c
@@ -106,7 +106,7 @@ gda_data_access_wrapper_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataAccessWrapperClass),
                        (GBaseInitFunc) NULL,
@@ -126,12 +126,12 @@ gda_data_access_wrapper_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataAccessWrapper", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-data-comparator.c b/libgda/gda-data-comparator.c
index 70781fc..dda96b5 100644
--- a/libgda/gda-data-comparator.c
+++ b/libgda/gda-data-comparator.c
@@ -90,7 +90,7 @@ gda_data_comparator_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataComparatorClass),
                        (GBaseInitFunc) NULL,
@@ -104,10 +104,10 @@ gda_data_comparator_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataComparator", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-data-handler.c b/libgda/gda-data-handler.c
index b57a8d2..784318c 100644
--- a/libgda/gda-data-handler.c
+++ b/libgda/gda-data-handler.c
@@ -307,11 +307,11 @@ gtype_equal (gconstpointer a, gconstpointer b)
 GdaDataHandler *
 gda_data_handler_get_default (GType for_type)
 {
-       static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+       static GMutex mutex;
        static GHashTable *hash = NULL;
        GdaDataHandler *dh;
 
-       g_static_mutex_lock (&mutex);
+       g_mutex_lock (&mutex);
        if (!hash) {
                hash = g_hash_table_new_full (gtype_hash, gtype_equal,
                                              NULL, (GDestroyNotify) g_object_unref);
@@ -339,7 +339,7 @@ gda_data_handler_get_default (GType for_type)
                 g_hash_table_insert (hash, (gpointer) G_TYPE_GTYPE, gda_handler_type_new ());
                 g_hash_table_insert (hash, (gpointer) G_TYPE_UINT, gda_handler_numerical_new ());
        }
-       g_static_mutex_unlock (&mutex);
+       g_mutex_unlock (&mutex);
 
        dh = g_hash_table_lookup (hash, (gpointer) for_type);
        return dh;
diff --git a/libgda/gda-data-meta-wrapper.c b/libgda/gda-data-meta-wrapper.c
index 06a2496..a950981 100644
--- a/libgda/gda-data-meta-wrapper.c
+++ b/libgda/gda-data-meta-wrapper.c
@@ -120,7 +120,7 @@ _gda_data_meta_wrapper_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataMetaWrapperClass),
                        (GBaseInitFunc) NULL,
@@ -140,12 +140,12 @@ _gda_data_meta_wrapper_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataMetaWrapper", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-data-model-array.c b/libgda/gda-data-model-array.c
index 38a1dc7..6eeb5eb 100644
--- a/libgda/gda-data-model-array.c
+++ b/libgda/gda-data-model-array.c
@@ -124,7 +124,7 @@ gda_data_model_array_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataModelArrayClass),
                        (GBaseInitFunc) NULL,
@@ -145,12 +145,12 @@ gda_data_model_array_get_type (void)
                 };
 
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataModelArray", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-data-model-bdb.c b/libgda/gda-data-model-bdb.c
index 74ba799..306cb40 100644
--- a/libgda/gda-data-model-bdb.c
+++ b/libgda/gda-data-model-bdb.c
@@ -229,7 +229,7 @@ gda_data_model_bdb_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataModelBdbClass),
                        (GBaseInitFunc) NULL,
@@ -248,7 +248,7 @@ gda_data_model_bdb_get_type (void)
                         NULL
                 };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataModelBdb", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
@@ -279,7 +279,7 @@ gda_data_model_bdb_get_type (void)
                        else
                                g_module_make_resident (module);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-data-model-dir.c b/libgda/gda-data-model-dir.c
index 1ce75f7..f9415d2 100644
--- a/libgda/gda-data-model-dir.c
+++ b/libgda/gda-data-model-dir.c
@@ -266,7 +266,7 @@ gda_data_model_dir_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataModelDirClass),
                        (GBaseInitFunc) NULL,
@@ -285,12 +285,12 @@ gda_data_model_dir_get_type (void)
                         NULL
                 };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataModelDir", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-data-model-dsn-list.c b/libgda/gda-data-model-dsn-list.c
index fd784f8..8c83410 100644
--- a/libgda/gda-data-model-dsn-list.c
+++ b/libgda/gda-data-model-dsn-list.c
@@ -231,7 +231,7 @@ _gda_data_model_dsn_list_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataModelDsnListClass),
                        (GBaseInitFunc) NULL,
@@ -250,12 +250,12 @@ _gda_data_model_dsn_list_get_type (void)
                         NULL
                 };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataModelDsnList", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/gda-data-model-import.c b/libgda/gda-data-model-import.c
index 09e524a..600d31d 100644
--- a/libgda/gda-data-model-import.c
+++ b/libgda/gda-data-model-import.c
@@ -189,7 +189,7 @@ gda_data_model_import_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataModelImportClass),
                        (GBaseInitFunc) NULL,
@@ -209,12 +209,12 @@ gda_data_model_import_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataModelImport", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-data-model-iter.c b/libgda/gda-data-model-iter.c
index 7cd4b48..f2fd5a4 100644
--- a/libgda/gda-data-model-iter.c
+++ b/libgda/gda-data-model-iter.c
@@ -108,7 +108,7 @@ gda_data_model_iter_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataModelIterClass),
                        (GBaseInitFunc) NULL,
@@ -123,10 +123,10 @@ gda_data_model_iter_get_type (void)
                };
 
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SET, "GdaDataModelIter", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-data-pivot.c b/libgda/gda-data-pivot.c
index 48e4b3d..9a97a2b 100644
--- a/libgda/gda-data-pivot.c
+++ b/libgda/gda-data-pivot.c
@@ -121,7 +121,7 @@ static GdaDataModelAccessFlags gda_data_pivot_get_access_flags(GdaDataModel *mod
 static const GValue        *gda_data_pivot_get_value_at    (GdaDataModel *model, gint col, gint row, GError 
**error);
 
 static GObjectClass *parent_class = NULL;
-static GStaticMutex provider_mutex = G_STATIC_MUTEX_INIT;
+static GMutex provider_mutex;
 static GdaVirtualProvider *virtual_provider = NULL;
 
 /**
@@ -135,7 +135,7 @@ gda_data_pivot_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataPivotClass),
                        (GBaseInitFunc) NULL,
@@ -155,12 +155,12 @@ gda_data_pivot_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataPivot", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
@@ -2134,10 +2134,10 @@ create_vcnc (GdaDataPivot *pivot, GError **error)
        if (pivot->priv->vcnc)
                return TRUE;
 
-       g_static_mutex_lock (&provider_mutex);
+       g_mutex_lock (&provider_mutex);
        if (!virtual_provider)
                virtual_provider = gda_vprovider_data_model_new ();
-       g_static_mutex_unlock (&provider_mutex);
+       g_mutex_unlock (&provider_mutex);
 
        vcnc = gda_virtual_connection_open (virtual_provider, &lerror);
        if (! vcnc) {
diff --git a/libgda/gda-data-proxy.c b/libgda/gda-data-proxy.c
index 1c7e2bb..4b6179c 100644
--- a/libgda/gda-data-proxy.c
+++ b/libgda/gda-data-proxy.c
@@ -104,9 +104,9 @@ static void fetch_current_cached_changes (GdaDataProxy *proxy);
 static GObjectClass  *parent_class = NULL;
 extern GdaAttributesManager *gda_holder_attributes_manager;
 
-static GStaticMutex parser_mutex = G_STATIC_MUTEX_INIT;
+static GMutex parser_mutex;
 static GdaSqlParser *internal_parser;
-static GStaticMutex provider_mutex = G_STATIC_MUTEX_INIT;
+static GMutex provider_mutex;
 static GdaVirtualProvider *virtual_provider = NULL;
 
 /* signals */
@@ -513,7 +513,7 @@ gda_data_proxy_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataProxyClass),
                        (GBaseInitFunc) NULL,
@@ -533,12 +533,12 @@ gda_data_proxy_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataProxy", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
@@ -722,9 +722,9 @@ gda_data_proxy_class_init (GdaDataProxyClass *klass)
                                                               "set to TRUE to keep track of changes even 
when the proxied data model is changed", FALSE,
                                                               (G_PARAM_READABLE | G_PARAM_WRITABLE)));
 
-       g_static_mutex_lock (&parser_mutex);
+       g_mutex_lock (&parser_mutex);
        internal_parser = gda_sql_parser_new ();
-       g_static_mutex_unlock (&parser_mutex);
+       g_mutex_unlock (&parser_mutex);
 }
 
 static void
@@ -3061,10 +3061,10 @@ apply_filter_statement (GdaDataProxy *proxy, GError **error)
        if (!stmt)
                goto clean_previous_filter;
 
-       g_static_mutex_lock (&provider_mutex);
+       g_mutex_lock (&provider_mutex);
        if (!virtual_provider)
                virtual_provider = gda_vprovider_data_model_new ();
-       g_static_mutex_unlock (&provider_mutex);
+       g_mutex_unlock (&provider_mutex);
 
        /* Force direct data access where proxy_row <=> absolute_row */
        proxy->priv->force_direct_mapping = TRUE;
@@ -3242,9 +3242,9 @@ gda_data_proxy_set_filter_expr (GdaDataProxy *proxy, const gchar *filter_expr, G
                sql = g_strdup_printf (FILTER_SELECT_WHERE "%s", filter_expr);
        g_free (tmp);
 
-       g_static_mutex_lock (&parser_mutex);
+       g_mutex_lock (&parser_mutex);
        stmt = gda_sql_parser_parse_string (internal_parser, sql, &ptr, NULL);
-       g_static_mutex_unlock (&parser_mutex);
+       g_mutex_unlock (&parser_mutex);
        g_free (sql);
        if (ptr || !stmt || (gda_statement_get_statement_type (stmt) != GDA_SQL_STATEMENT_SELECT)) {
                /* also catches problems with multiple statements in @filter_expr, such as SQL code injection 
*/
diff --git a/libgda/gda-data-select.c b/libgda/gda-data-select.c
index 9c656e3..29c6343 100644
--- a/libgda/gda-data-select.c
+++ b/libgda/gda-data-select.c
@@ -199,7 +199,7 @@ gda_data_select_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataSelectClass),
                        (GBaseInitFunc) NULL,
@@ -219,12 +219,12 @@ gda_data_select_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataSelect", &info, 
G_TYPE_FLAG_ABSTRACT);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-holder.c b/libgda/gda-holder.c
index 6d6cfd4..345061f 100644
--- a/libgda/gda-holder.c
+++ b/libgda/gda-holder.c
@@ -141,7 +141,7 @@ gda_holder_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaHolderClass),
                        (GBaseInitFunc) NULL,
@@ -161,12 +161,12 @@ gda_holder_get_type (void)
                         NULL
                 };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaHolder", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_LOCKABLE, &lockable_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -475,7 +475,7 @@ gda_holder_new_inline (GType type, const gchar *id, ...)
 {
        GdaHolder *holder;
 
-       static GStaticMutex serial_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex serial_mutex;
        static guint serial = 0;
 
        holder = gda_holder_new (type);
@@ -487,9 +487,9 @@ gda_holder_new_inline (GType type, const gchar *id, ...)
                if (id)
                        holder->priv->id = g_strdup (id);
                else {
-                       g_static_mutex_lock (&serial_mutex);
+                       g_mutex_lock (&serial_mutex);
                        holder->priv->id = g_strdup_printf ("%d", serial++);
-                       g_static_mutex_unlock (&serial_mutex);
+                       g_mutex_unlock (&serial_mutex);
                }
 
                va_start (ap, id);
diff --git a/libgda/gda-init.c b/libgda/gda-init.c
index b919a46..3ae26ec 100644
--- a/libgda/gda-init.c
+++ b/libgda/gda-init.c
@@ -123,15 +123,15 @@ gda_locale_changed (void)
 void
 gda_init (void)
 {
-       static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex init_mutex;
        static gboolean initialized = FALSE;
 
        GType type;
        gchar *file;
 
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
        if (initialized) {
-               g_static_mutex_unlock (&init_mutex);
+               g_mutex_unlock (&init_mutex);
                gda_log_error (_("Ignoring attempt to re-initialize GDA library."));
                return;
        }
@@ -261,7 +261,7 @@ gda_init (void)
        g_free (file);
 
        initialized = TRUE;
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 /**
diff --git a/libgda/gda-meta-store.c b/libgda/gda-meta-store.c
index 3960c33..d16c4fa 100644
--- a/libgda/gda-meta-store.c
+++ b/libgda/gda-meta-store.c
@@ -74,13 +74,13 @@ gda_meta_context_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
-               g_static_mutex_lock (&registering);
+               static GMutex registering;
+               g_mutex_lock (&registering);
                 if (type == 0)
                        type = g_boxed_type_register_static ("GdaMetaContext",
                                                             (GBoxedCopyFunc) gda_meta_context_copy,
                                                             (GBoxedFreeFunc) gda_meta_context_free);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -4117,7 +4117,7 @@ gda_meta_store_set_attribute_value (GdaMetaStore *store, const gchar *att_name,
                                    const gchar *att_value, GError **error)
 {
        GdaMetaStoreClass *klass;
-       static GStaticMutex set_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex set_mutex;
        static GdaSet *set = NULL;
        gboolean started_transaction = FALSE;
 
@@ -4133,15 +4133,15 @@ gda_meta_store_set_attribute_value (GdaMetaStore *store, const gchar *att_name,
        gda_mutex_lock (store->priv->mutex);
 
        klass = (GdaMetaStoreClass *) G_OBJECT_GET_CLASS (store);
-       g_static_mutex_lock (&set_mutex);
+       g_mutex_lock (&set_mutex);
        if (!set) {
                if (!gda_statement_get_parameters (klass->cpriv->prep_stmts [STMT_SET_ATT_VALUE], &set, 
error)) {
-                       g_static_mutex_unlock (&set_mutex);
+                       g_mutex_unlock (&set_mutex);
                        gda_mutex_unlock (store->priv->mutex);
                        return FALSE;
                }
        }
-       g_static_mutex_unlock (&set_mutex);
+       g_mutex_unlock (&set_mutex);
 
        if (!gda_set_set_holder_value (set, error, "name", att_name)) {
                gda_mutex_unlock (store->priv->mutex);
diff --git a/libgda/gda-meta-struct.c b/libgda/gda-meta-struct.c
index acbd5e7..a8a76a1 100644
--- a/libgda/gda-meta-struct.c
+++ b/libgda/gda-meta-struct.c
@@ -94,7 +94,7 @@ gda_meta_struct_get_type (void) {
        static GType type = 0;
        
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaMetaStructClass),
                        (GBaseInitFunc) NULL,
@@ -108,10 +108,10 @@ gda_meta_struct_get_type (void) {
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaMetaStruct", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-mutex.c b/libgda/gda-mutex.c
index 54dbabb..9d9cccc 100644
--- a/libgda/gda-mutex.c
+++ b/libgda/gda-mutex.c
@@ -148,7 +148,7 @@ enum MutexRecStatus {
 static enum MutexRecStatus impl_status = UNKNOWN;
 
 #ifdef GDA_DEBUG_MUTEX
-static GStaticMutex debug_mutex = G_STATIC_MUTEX_INIT;
+static GMutex debug_mutex;
 
 typedef enum {
        USAGE_LOCK,
@@ -178,9 +178,9 @@ struct _GdaMutex {
 void
 gda_mutex_debug (GdaMutex *mutex, gboolean debug)
 {
-       g_static_mutex_lock (&debug_mutex);
+       g_mutex_lock (&debug_mutex);
        mutex->debug = debug;
-       g_static_mutex_unlock (&debug_mutex);
+       g_mutex_unlock (&debug_mutex);
 }
 
 void
@@ -193,7 +193,7 @@ gda_mutex_dump_usage (GdaMutex *mutex, FILE *stream)
        else
                st = stdout;
 
-       g_static_mutex_lock (&debug_mutex);
+       g_mutex_lock (&debug_mutex);
        if (mutex->debug) {
                g_fprintf (st, "%s (mutex=>%p): locked&unlocked %d times\n", __FUNCTION__, mutex,
                           mutex->nb_locked_unlocked);
@@ -210,13 +210,13 @@ gda_mutex_dump_usage (GdaMutex *mutex, FILE *stream)
                        g_fprintf (st, "\t------ END GdaMutex %p usage\n", mutex);
                }
        }
-       g_static_mutex_unlock (&debug_mutex);
+       g_mutex_unlock (&debug_mutex);
 }
 
 static void
 gda_mutex_usage_locked (GdaMutex *mutex)
 {
-       g_static_mutex_lock (&debug_mutex);
+       g_mutex_lock (&debug_mutex);
 
        if (mutex->debug) {
                GdaMutexUsage usage;
@@ -238,14 +238,14 @@ gda_mutex_usage_locked (GdaMutex *mutex)
 
                g_array_prepend_val (mutex->usages, usage);
        }
-       g_static_mutex_unlock (&debug_mutex);
+       g_mutex_unlock (&debug_mutex);
        gda_mutex_dump_usage (mutex, NULL);
 }
 
 static void
 gda_mutex_usage_unlocked (GdaMutex *mutex)
 {
-       g_static_mutex_lock (&debug_mutex);
+       g_mutex_lock (&debug_mutex);
        if (mutex->debug) {
                void *array[FRAMES_SIZE];
                size_t size;
@@ -291,7 +291,7 @@ gda_mutex_usage_unlocked (GdaMutex *mutex)
                }
                free (strings);
        }
-       g_static_mutex_unlock (&debug_mutex);
+       g_mutex_unlock (&debug_mutex);
        gda_mutex_dump_usage (mutex, NULL);
 }
 
@@ -310,9 +310,9 @@ GdaMutex*
 gda_mutex_new ()
 {
        if (G_UNLIKELY (impl_status == UNKNOWN)) {
-               static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+               static GMutex init_mutex;
 
-               g_static_mutex_lock (&init_mutex);
+               g_mutex_lock (&init_mutex);
                if (impl_status == UNKNOWN) {
                        if (!g_thread_supported ()) 
                                impl_status = NON_SUPPORTED;
@@ -333,7 +333,7 @@ gda_mutex_new ()
 #endif
                        }
                }
-                g_static_mutex_unlock (&init_mutex);
+                g_mutex_unlock (&init_mutex);
        }
 
        if (impl_status == NON_SUPPORTED) {
diff --git a/libgda/gda-row.c b/libgda/gda-row.c
index d3ba252..3ab1477 100644
--- a/libgda/gda-row.c
+++ b/libgda/gda-row.c
@@ -189,7 +189,7 @@ gda_row_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaRowClass),
                        (GBaseInitFunc) NULL,
@@ -202,10 +202,10 @@ gda_row_get_type (void)
                        (GInstanceInitFunc) gda_row_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (PARENT_TYPE, "GdaRow", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/gda-server-operation.c b/libgda/gda-server-operation.c
index 651cf5a..0a67b6c 100644
--- a/libgda/gda-server-operation.c
+++ b/libgda/gda-server-operation.c
@@ -279,7 +279,7 @@ gda_server_operation_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
 
                static const GTypeInfo info = {
                        sizeof (GdaServerOperationClass),
@@ -294,10 +294,10 @@ gda_server_operation_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (!type)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaServerOperation", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-server-provider.c b/libgda/gda-server-provider.c
index 126e10d..efd8702 100644
--- a/libgda/gda-server-provider.c
+++ b/libgda/gda-server-provider.c
@@ -206,7 +206,7 @@ gda_server_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaServerProviderClass),
                        (GBaseInitFunc) NULL,
@@ -219,10 +219,10 @@ gda_server_provider_get_type (void)
                        (GInstanceInitFunc) gda_server_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaServerProvider", &info, 
G_TYPE_FLAG_ABSTRACT);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -471,10 +471,10 @@ gda_server_provider_create_operation (GdaServerProvider *provider, GdaConnection
                                      GdaServerOperationType type, 
                                      GdaSet *options, GError **error)
 {
-       static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex init_mutex;
        static OpReq **op_req_table = NULL;
 
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
        if (! op_req_table) {
                op_req_table = g_new0 (OpReq *, GDA_SERVER_OPERATION_LAST);
 
@@ -499,7 +499,7 @@ gda_server_provider_create_operation (GdaServerProvider *provider, GdaConnection
 
                op_req_table [GDA_SERVER_OPERATION_CREATE_USER] = op_req_CREATE_USER;
        }
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 
        g_return_val_if_fail (GDA_IS_SERVER_PROVIDER (provider), NULL);
        g_return_val_if_fail (!cnc || GDA_IS_CONNECTION (cnc), FALSE);
diff --git a/libgda/gda-set.c b/libgda/gda-set.c
index 1e706df..7166d0e 100644
--- a/libgda/gda-set.c
+++ b/libgda/gda-set.c
@@ -790,7 +790,7 @@ gda_set_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaSetClass),
                        (GBaseInitFunc) NULL,
@@ -804,10 +804,10 @@ gda_set_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaSet", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/gda-sql-builder.c b/libgda/gda-sql-builder.c
index 73683c9..a10ee78 100644
--- a/libgda/gda-sql-builder.c
+++ b/libgda/gda-sql-builder.c
@@ -82,7 +82,7 @@ gda_sql_builder_get_type (void) {
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaSqlBuilderClass),
                        (GBaseInitFunc) NULL,
@@ -96,10 +96,10 @@ gda_sql_builder_get_type (void) {
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaSqlBuilder", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-statement.c b/libgda/gda-statement.c
index e806f57..c80fe08 100644
--- a/libgda/gda-statement.c
+++ b/libgda/gda-statement.c
@@ -102,7 +102,7 @@ gda_statement_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaStatementClass),
                        (GBaseInitFunc) NULL,
@@ -116,10 +116,10 @@ gda_statement_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaStatement", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/gda-transaction-status.c b/libgda/gda-transaction-status.c
index 835e712..43efc4d 100644
--- a/libgda/gda-transaction-status.c
+++ b/libgda/gda-transaction-status.c
@@ -107,7 +107,7 @@ gda_transaction_status_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaTransactionStatusClass),
                        (GBaseInitFunc) NULL,
@@ -119,10 +119,10 @@ gda_transaction_status_get_type (void)
                        (GInstanceInitFunc) gda_transaction_status_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (PARENT_TYPE, "GdaTransactionStatus", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/gda-tree-manager.c b/libgda/gda-tree-manager.c
index 20af905..b3c294b 100644
--- a/libgda/gda-tree-manager.c
+++ b/libgda/gda-tree-manager.c
@@ -176,7 +176,7 @@ gda_tree_manager_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeManagerClass),
                         (GBaseInitFunc) NULL,
@@ -190,10 +190,10 @@ gda_tree_manager_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (G_TYPE_OBJECT, "GdaTreeManager", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-tree-mgr-columns.c b/libgda/gda-tree-mgr-columns.c
index 349bb6b..2a400d7 100644
--- a/libgda/gda-tree-mgr-columns.c
+++ b/libgda/gda-tree-mgr-columns.c
@@ -175,7 +175,7 @@ gda_tree_mgr_columns_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeMgrColumnsClass),
                         (GBaseInitFunc) NULL,
@@ -189,10 +189,10 @@ gda_tree_mgr_columns_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "GdaTreeMgrColumns", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-tree-mgr-label.c b/libgda/gda-tree-mgr-label.c
index 2325a72..e361c37 100644
--- a/libgda/gda-tree-mgr-label.c
+++ b/libgda/gda-tree-mgr-label.c
@@ -113,7 +113,7 @@ gda_tree_mgr_label_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeMgrLabelClass),
                         (GBaseInitFunc) NULL,
@@ -127,10 +127,10 @@ gda_tree_mgr_label_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "GdaTreeMgrLabel", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-tree-mgr-ldap.c b/libgda/gda-tree-mgr-ldap.c
index 63b7025..3902d6c 100644
--- a/libgda/gda-tree-mgr-ldap.c
+++ b/libgda/gda-tree-mgr-ldap.c
@@ -132,7 +132,7 @@ gda_tree_mgr_ldap_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeMgrLdapClass),
                         (GBaseInitFunc) NULL,
@@ -146,10 +146,10 @@ gda_tree_mgr_ldap_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "GdaTreeMgrLdap", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-tree-mgr-schemas.c b/libgda/gda-tree-mgr-schemas.c
index edb118f..513c988 100644
--- a/libgda/gda-tree-mgr-schemas.c
+++ b/libgda/gda-tree-mgr-schemas.c
@@ -143,7 +143,7 @@ gda_tree_mgr_schemas_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeMgrSchemasClass),
                         (GBaseInitFunc) NULL,
@@ -157,10 +157,10 @@ gda_tree_mgr_schemas_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "GdaTreeMgrSchemas", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-tree-mgr-select.c b/libgda/gda-tree-mgr-select.c
index c37609a..ce6dc7c 100644
--- a/libgda/gda-tree-mgr-select.c
+++ b/libgda/gda-tree-mgr-select.c
@@ -139,7 +139,7 @@ gda_tree_mgr_select_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeMgrSelectClass),
                         (GBaseInitFunc) NULL,
@@ -153,10 +153,10 @@ gda_tree_mgr_select_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "GdaTreeMgrSelect", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-tree-mgr-tables.c b/libgda/gda-tree-mgr-tables.c
index 5f16aca..b290403 100644
--- a/libgda/gda-tree-mgr-tables.c
+++ b/libgda/gda-tree-mgr-tables.c
@@ -167,7 +167,7 @@ gda_tree_mgr_tables_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeMgrTablesClass),
                         (GBaseInitFunc) NULL,
@@ -181,10 +181,10 @@ gda_tree_mgr_tables_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "GdaTreeMgrTables", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-tree-node.c b/libgda/gda-tree-node.c
index 5e46be2..6817e99 100644
--- a/libgda/gda-tree-node.c
+++ b/libgda/gda-tree-node.c
@@ -311,7 +311,7 @@ gda_tree_node_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeNodeClass),
                         (GBaseInitFunc) NULL,
@@ -325,10 +325,10 @@ gda_tree_node_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (G_TYPE_OBJECT, "GdaTreeNode", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-tree.c b/libgda/gda-tree.c
index 0a3aca4..527bfde 100644
--- a/libgda/gda-tree.c
+++ b/libgda/gda-tree.c
@@ -235,7 +235,7 @@ gda_tree_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeClass),
                         (GBaseInitFunc) NULL,
@@ -249,10 +249,10 @@ gda_tree_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (G_TYPE_OBJECT, "GdaTree", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/libgda/gda-types.c b/libgda/gda-types.c
index e0457f9..59ebc39 100644
--- a/libgda/gda-types.c
+++ b/libgda/gda-types.c
@@ -30,11 +30,11 @@ _gda_slist_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
-               g_static_mutex_lock (&registering);
+               static GMutex registering;
+               g_mutex_lock (&registering);
                 if (type == 0)
                        type = g_pointer_type_register_static ("GdaSList");
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/gda-xa-transaction.c b/libgda/gda-xa-transaction.c
index 2c9e3c5..31a1e55 100644
--- a/libgda/gda-xa-transaction.c
+++ b/libgda/gda-xa-transaction.c
@@ -220,7 +220,7 @@ gda_xa_transaction_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaXaTransactionClass),
                        (GBaseInitFunc) NULL,
@@ -232,10 +232,10 @@ gda_xa_transaction_get_type (void)
                        (GInstanceInitFunc) gda_xa_transaction_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaXaTransaction", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/handlers/gda-handler-bin.c b/libgda/handlers/gda-handler-bin.c
index eb8dd6b..88fb8ae 100644
--- a/libgda/handlers/gda-handler-bin.c
+++ b/libgda/handlers/gda-handler-bin.c
@@ -60,7 +60,7 @@ gda_handler_bin_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaHandlerBinClass),
                        (GBaseInitFunc) NULL,
@@ -80,12 +80,12 @@ gda_handler_bin_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaHandlerBin", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/handlers/gda-handler-boolean.c b/libgda/handlers/gda-handler-boolean.c
index 0ddff95..fb7a8aa 100644
--- a/libgda/handlers/gda-handler-boolean.c
+++ b/libgda/handlers/gda-handler-boolean.c
@@ -59,7 +59,7 @@ gda_handler_boolean_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaHandlerBooleanClass),
                        (GBaseInitFunc) NULL,
@@ -79,12 +79,12 @@ gda_handler_boolean_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaHandlerBoolean", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/handlers/gda-handler-numerical.c b/libgda/handlers/gda-handler-numerical.c
index 8b61ade..903a15a 100644
--- a/libgda/handlers/gda-handler-numerical.c
+++ b/libgda/handlers/gda-handler-numerical.c
@@ -61,7 +61,7 @@ gda_handler_numerical_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaHandlerNumericalClass),
                        (GBaseInitFunc) NULL,
@@ -81,12 +81,12 @@ gda_handler_numerical_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaHandlerNumerical", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/handlers/gda-handler-string.c b/libgda/handlers/gda-handler-string.c
index 2274afa..c9018ed 100644
--- a/libgda/handlers/gda-handler-string.c
+++ b/libgda/handlers/gda-handler-string.c
@@ -61,7 +61,7 @@ gda_handler_string_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaHandlerStringClass),
                        (GBaseInitFunc) NULL,
@@ -81,12 +81,12 @@ gda_handler_string_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaHandlerString", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/handlers/gda-handler-time.c b/libgda/handlers/gda-handler-time.c
index fb4c91b..bdd43df 100644
--- a/libgda/handlers/gda-handler-time.c
+++ b/libgda/handlers/gda-handler-time.c
@@ -87,7 +87,7 @@ gda_handler_time_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaHandlerTimeClass),
                        (GBaseInitFunc) NULL,
@@ -107,12 +107,12 @@ gda_handler_time_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaHandlerTime", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/handlers/gda-handler-type.c b/libgda/handlers/gda-handler-type.c
index 69932e9..32a9efb 100644
--- a/libgda/handlers/gda-handler-type.c
+++ b/libgda/handlers/gda-handler-type.c
@@ -56,7 +56,7 @@ gda_handler_type_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaHandlerTypeClass),
                        (GBaseInitFunc) NULL,
@@ -76,12 +76,12 @@ gda_handler_type_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaHandlerType", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/providers-support/gda-pstmt.c b/libgda/providers-support/gda-pstmt.c
index 13bdda5..0c43c3b 100644
--- a/libgda/providers-support/gda-pstmt.c
+++ b/libgda/providers-support/gda-pstmt.c
@@ -46,7 +46,7 @@ gda_pstmt_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaPStmtClass),
                        (GBaseInitFunc) NULL,
@@ -60,10 +60,10 @@ gda_pstmt_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaPStmt", &info, 
G_TYPE_FLAG_ABSTRACT);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/sql-parser/gda-sql-parser.c b/libgda/sql-parser/gda-sql-parser.c
index 778b0fe..37af1fa 100644
--- a/libgda/sql-parser/gda-sql-parser.c
+++ b/libgda/sql-parser/gda-sql-parser.c
@@ -117,7 +117,7 @@ gda_sql_parser_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaSqlParserClass),
                        (GBaseInitFunc) NULL,
@@ -137,12 +137,12 @@ gda_sql_parser_get_type (void)
                         NULL
                 };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaSqlParser", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_LOCKABLE, &lockable_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
@@ -907,12 +907,12 @@ str_casehash (gconstpointer v)
 static gint
 keywordCode (GdaSqlParser *parser, gchar *str, gint len)
 {
-       static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+       static GMutex mutex;
        static GHashTable *keywords = NULL;
        gint type;
        gchar oldc;
 
-       g_static_mutex_lock (&mutex);
+       g_mutex_lock (&mutex);
        if (!keywords) {
                /* if keyword begins with a number, it is the GdaSqlParserFlavour to which it only applies:
                * for example "4start" would refer to the START keyword for PostgreSQL only */
@@ -997,7 +997,7 @@ keywordCode (GdaSqlParser *parser, gchar *str, gint len)
                g_hash_table_insert (keywords, "work", GINT_TO_POINTER (L_TRANSACTION));
                g_hash_table_insert (keywords, "write", GINT_TO_POINTER (L_WRITE));
        }
-       g_static_mutex_unlock (&mutex);
+       g_mutex_unlock (&mutex);
 
        oldc = str[len];
        str[len] = 0;
diff --git a/libgda/sql-parser/gda-statement-struct.c b/libgda/sql-parser/gda-statement-struct.c
index 42257fb..0eb20c0 100644
--- a/libgda/sql-parser/gda-statement-struct.c
+++ b/libgda/sql-parser/gda-statement-struct.c
@@ -55,10 +55,10 @@ gda_sql_error_quark (void)
 GdaSqlStatementContentsInfo *
 gda_sql_statement_get_contents_infos  (GdaSqlStatementType type)
 {
-       static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+       static GMutex mutex;
        static GdaSqlStatementContentsInfo **contents = NULL;
 
-       g_static_mutex_lock (&mutex);
+       g_mutex_lock (&mutex);
        if (!contents) {
                contents = g_new0 (GdaSqlStatementContentsInfo *, GDA_SQL_STATEMENT_NONE);
 
@@ -75,7 +75,7 @@ gda_sql_statement_get_contents_infos  (GdaSqlStatementType type)
                contents [GDA_SQL_STATEMENT_ROLLBACK_SAVEPOINT] = 
_gda_sql_statement_rollback_savepoint_get_infos ();
                contents [GDA_SQL_STATEMENT_DELETE_SAVEPOINT] = _gda_sql_statement_delete_savepoint_get_infos 
();
        }
-       g_static_mutex_unlock (&mutex);
+       g_mutex_unlock (&mutex);
 
        return contents[type];
 }
diff --git a/libgda/sqlite/gda-sqlite-blob-op.c b/libgda/sqlite/gda-sqlite-blob-op.c
index 1e94c07..9c41a81 100644
--- a/libgda/sqlite/gda-sqlite-blob-op.c
+++ b/libgda/sqlite/gda-sqlite-blob-op.c
@@ -50,7 +50,7 @@ _gda_sqlite_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaSqliteBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -63,10 +63,10 @@ _gda_sqlite_blob_op_get_type (void)
                        (GInstanceInitFunc) gda_sqlite_blob_op_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, CLASS_PREFIX "BlobOp", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/sqlite/gda-sqlite-handler-bin.c b/libgda/sqlite/gda-sqlite-handler-bin.c
index 0ca3748..42e3e3a 100644
--- a/libgda/sqlite/gda-sqlite-handler-bin.c
+++ b/libgda/sqlite/gda-sqlite-handler-bin.c
@@ -57,7 +57,7 @@ _gda_sqlite_handler_bin_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaSqliteHandlerBinClass),
                        (GBaseInitFunc) NULL,
@@ -77,12 +77,12 @@ _gda_sqlite_handler_bin_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, CLASS_PREFIX "HandlerBin", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/sqlite/gda-sqlite-handler-boolean.c b/libgda/sqlite/gda-sqlite-handler-boolean.c
index ff1d564..6e86cd4 100644
--- a/libgda/sqlite/gda-sqlite-handler-boolean.c
+++ b/libgda/sqlite/gda-sqlite-handler-boolean.c
@@ -55,7 +55,7 @@ _gda_sqlite_handler_boolean_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaSqliteHandlerBooleanClass),
                        (GBaseInitFunc) NULL,
@@ -75,12 +75,12 @@ _gda_sqlite_handler_boolean_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, CLASS_PREFIX "HandlerBoolean", &info, 
0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/sqlite/gda-sqlite-meta.c b/libgda/sqlite/gda-sqlite-meta.c
index 379936d..02a3e20 100644
--- a/libgda/sqlite/gda-sqlite-meta.c
+++ b/libgda/sqlite/gda-sqlite-meta.c
@@ -83,7 +83,7 @@ static gchar *internal_sql[] = {
 /*
  * predefined statements' GdaStatement
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 static GdaSet        *internal_params = NULL;
 
@@ -153,7 +153,7 @@ to_caseless_string (gchar *string)
 void
 _gda_sqlite_provider_meta_init (GdaServerProvider *provider)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -187,7 +187,7 @@ _gda_sqlite_provider_meta_init (GdaServerProvider *provider)
                                                 "idxname", G_TYPE_STRING, "");
        }
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 static GdaStatement *
diff --git a/libgda/sqlite/gda-sqlite-provider.c b/libgda/sqlite/gda-sqlite-provider.c
index faa89ae..f31214c 100644
--- a/libgda/sqlite/gda-sqlite-provider.c
+++ b/libgda/sqlite/gda-sqlite-provider.c
@@ -389,7 +389,7 @@ static CollationFunction collation_functions[] = {
 /*
  * Prepared internal statements
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 
 typedef enum {
@@ -568,7 +568,7 @@ gda_sqlite_provider_class_init (GdaSqliteProviderClass *klass)
 static void
 gda_sqlite_provider_init (GdaSqliteProvider *sqlite_prv, G_GNUC_UNUSED GdaSqliteProviderClass *klass)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                /* configure multi threading environment */
@@ -589,7 +589,7 @@ gda_sqlite_provider_init (GdaSqliteProvider *sqlite_prv, G_GNUC_UNUSED GdaSqlite
        /* meta data init */
        _gda_sqlite_provider_meta_init ((GdaServerProvider*) sqlite_prv);
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 GType
@@ -598,7 +598,7 @@ gda_sqlite_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaSqliteProviderClass),
                        (GBaseInitFunc) NULL,
@@ -610,7 +610,7 @@ gda_sqlite_provider_get_type (void)
                        (GInstanceInitFunc) gda_sqlite_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
 #ifdef WITH_BDBSQLITE
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, CLASS_PREFIX "Provider", 
&info, 0);
@@ -634,7 +634,7 @@ gda_sqlite_provider_get_type (void)
   #endif
 #endif
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -722,7 +722,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
        gint errmsg;
        SqliteConnectionData *cdata;
        gchar *dup = NULL;
-       static GStaticMutex cnc_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex cnc_mutex;
 #ifdef SQLITE_HAS_CODEC
        const gchar *passphrase = NULL;
 #endif
@@ -735,7 +735,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                 return FALSE;
        }
 
-       g_static_mutex_lock (&cnc_mutex);
+       g_mutex_lock (&cnc_mutex);
 
        /* get all parameters received */
        dirname = gda_quark_list_find (params, "DB_DIR");
@@ -760,7 +760,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                        if (!str) {
                                gda_connection_add_event_string (cnc,
                                                                 _("The connection string must contain DB_DIR 
and DB_NAME values"));
-                               g_static_mutex_unlock (&cnc_mutex);
+                               g_mutex_unlock (&cnc_mutex);
                                return FALSE;
                        }
                        else {
@@ -790,7 +790,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                                                                           "DB_DIR (the path to the database 
file) and DB_NAME "
                                                                           "(the database file without the 
'%s' at the end)."), FILE_EXTENSION);
                                        g_free (dup);
-                                       g_static_mutex_unlock (&cnc_mutex);
+                                       g_mutex_unlock (&cnc_mutex);
                                        return FALSE;
                                }
                                else
@@ -812,7 +812,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                                                                 _("The DB_DIR part of the connection string 
must point "
                                                                   "to a valid directory"));
                                g_free (dup);
-                               g_static_mutex_unlock (&cnc_mutex);
+                               g_mutex_unlock (&cnc_mutex);
                                return FALSE;
                        }
 
@@ -853,7 +853,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                gda_connection_add_event_string (cnc, SQLITE3_CALL (sqlite3_errmsg) (cdata->connection));
                gda_sqlite_free_cnc_data (cdata);
 
-               g_static_mutex_unlock (&cnc_mutex);
+               g_mutex_unlock (&cnc_mutex);
                return FALSE;
        }
 
@@ -869,7 +869,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                if (errmsg != SQLITE_OK) {
                        gda_connection_add_event_string (cnc, _("Wrong encryption passphrase"));
                        gda_sqlite_free_cnc_data (cdata);
-                       g_static_mutex_unlock (&cnc_mutex);
+                       g_mutex_unlock (&cnc_mutex);
                        return FALSE;
                }
        }
@@ -890,7 +890,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                else {
                        gda_connection_add_event_string (cnc, _("Extension loading is not supported"));
                        gda_sqlite_free_cnc_data (cdata);
-                       g_static_mutex_unlock (&cnc_mutex);
+                       g_mutex_unlock (&cnc_mutex);
                        return FALSE;
                }
        }
@@ -936,7 +936,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                        SQLITE3_CALL (sqlite3_free) (errmsg);
                        gda_sqlite_free_cnc_data (cdata);
                        gda_connection_internal_set_provider_data (cnc, NULL, (GDestroyNotify) 
gda_sqlite_free_cnc_data);
-                       g_static_mutex_unlock (&cnc_mutex);
+                       g_mutex_unlock (&cnc_mutex);
                        return FALSE;
                }
        }
@@ -961,7 +961,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                        gda_sqlite_free_cnc_data (cdata);
                        gda_connection_internal_set_provider_data (cnc, NULL,
                                                        (GDestroyNotify) gda_sqlite_free_cnc_data);
-                       g_static_mutex_unlock (&cnc_mutex);
+                       g_mutex_unlock (&cnc_mutex);
                        return FALSE;
                }
        }
@@ -974,7 +974,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                                gda_sqlite_free_cnc_data (cdata);
                                gda_connection_internal_set_provider_data (cnc, NULL,
                                                        (GDestroyNotify) gda_sqlite_free_cnc_data);
-                               g_static_mutex_unlock (&cnc_mutex);
+                               g_mutex_unlock (&cnc_mutex);
                                return FALSE;
                        }
                }
@@ -1002,7 +1002,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                                                                 func->name);
                                gda_sqlite_free_cnc_data (cdata);
                                gda_connection_internal_set_provider_data (cnc, NULL, (GDestroyNotify) 
gda_sqlite_free_cnc_data);
-                               g_static_mutex_unlock (&cnc_mutex);
+                               g_mutex_unlock (&cnc_mutex);
                                return FALSE;
                        }
                }
@@ -1022,7 +1022,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                                                                 func->name);
                                gda_sqlite_free_cnc_data (cdata);
                                gda_connection_internal_set_provider_data (cnc, NULL, (GDestroyNotify) 
gda_sqlite_free_cnc_data);
-                               g_static_mutex_unlock (&cnc_mutex);
+                               g_mutex_unlock (&cnc_mutex);
                                return FALSE;
                        }
                }
@@ -1041,7 +1041,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
                                                                 func->name);
                                gda_sqlite_free_cnc_data (cdata);
                                gda_connection_internal_set_provider_data (cnc, NULL, (GDestroyNotify) 
gda_sqlite_free_cnc_data);
-                               g_static_mutex_unlock (&cnc_mutex);
+                               g_mutex_unlock (&cnc_mutex);
                                return FALSE;
                        }
                }
@@ -1052,7 +1052,7 @@ gda_sqlite_provider_open_connection (GdaServerProvider *provider, GdaConnection
        else
                g_object_set (G_OBJECT (cnc), "thread-owner", g_thread_self (), NULL);
 
-       g_static_mutex_unlock (&cnc_mutex);
+       g_mutex_unlock (&cnc_mutex);
        return TRUE;
 }
 
@@ -1105,16 +1105,16 @@ gda_sqlite_provider_close_connection (GdaServerProvider *provider, GdaConnection
 static const gchar *
 gda_sqlite_provider_get_server_version (GdaServerProvider *provider, GdaConnection *cnc)
 {
-       static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+       static GMutex mutex;
        static gchar *version_string = NULL;
 
        g_return_val_if_fail (GDA_IS_CONNECTION (cnc), FALSE);
        g_return_val_if_fail (gda_connection_get_provider (cnc) == provider, NULL);
 
-       g_static_mutex_lock (&mutex);
+       g_mutex_lock (&mutex);
        if (!version_string)
                version_string = g_strdup_printf ("SQLite version %s", SQLITE_VERSION);
-       g_static_mutex_unlock (&mutex);
+       g_mutex_unlock (&mutex);
 
        return (const gchar *) version_string;
 }
@@ -1474,9 +1474,9 @@ gda_sqlite_provider_begin_transaction (GdaServerProvider *provider, GdaConnectio
        }
 
        if (name) {
-               static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+               static GMutex mutex;
                static GdaSet *params_set = NULL;
-               g_static_mutex_lock (&mutex);
+               g_mutex_lock (&mutex);
                if (!params_set)
                        params_set = gda_set_new_inline (1, "name", G_TYPE_STRING, name);
                else if (! gda_set_set_holder_value (params_set, error, "name", name))
@@ -1484,7 +1484,7 @@ gda_sqlite_provider_begin_transaction (GdaServerProvider *provider, GdaConnectio
                if (status && gda_connection_statement_execute_non_select (cnc, 
internal_stmt[INTERNAL_BEGIN_NAMED],
                                                                           params_set, NULL, error) == -1)
                        status = FALSE;
-               g_static_mutex_unlock (&mutex);
+               g_mutex_unlock (&mutex);
        }
        else {
                if (gda_connection_statement_execute_non_select (cnc, internal_stmt[INTERNAL_BEGIN],
@@ -1509,9 +1509,9 @@ gda_sqlite_provider_commit_transaction (GdaServerProvider *provider, GdaConnecti
        g_return_val_if_fail (gda_connection_get_provider (cnc) == provider, FALSE);
 
        if (name) {
-               static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+               static GMutex mutex;
                static GdaSet *params_set = NULL;
-               g_static_mutex_lock (&mutex);
+               g_mutex_lock (&mutex);
                if (!params_set)
                        params_set = gda_set_new_inline (1, "name", G_TYPE_STRING, name);
                else if (!gda_set_set_holder_value (params_set, error, "name", name))
@@ -1519,7 +1519,7 @@ gda_sqlite_provider_commit_transaction (GdaServerProvider *provider, GdaConnecti
                if (status && gda_connection_statement_execute_non_select (cnc, 
internal_stmt[INTERNAL_COMMIT_NAMED],
                                                                           params_set, NULL, error) == -1)
                        status = FALSE;
-               g_static_mutex_unlock (&mutex);
+               g_mutex_unlock (&mutex);
        }
        else {
                if (gda_connection_statement_execute_non_select (cnc, internal_stmt[INTERNAL_COMMIT],
@@ -1545,9 +1545,9 @@ gda_sqlite_provider_rollback_transaction (GdaServerProvider *provider,
        g_return_val_if_fail (gda_connection_get_provider (cnc) == provider, FALSE);
 
        if (name) {
-               static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+               static GMutex mutex;
                static GdaSet *params_set = NULL;
-               g_static_mutex_lock (&mutex);
+               g_mutex_lock (&mutex);
                if (!params_set)
                        params_set = gda_set_new_inline (1, "name", G_TYPE_STRING, name);
                else if (! gda_set_set_holder_value (params_set, error, "name", name))
@@ -1555,7 +1555,7 @@ gda_sqlite_provider_rollback_transaction (GdaServerProvider *provider,
                if (status && gda_connection_statement_execute_non_select (cnc, 
internal_stmt[INTERNAL_ROLLBACK_NAMED],
                                                                           params_set, NULL, error) == -1)
                        status = FALSE;
-               g_static_mutex_unlock (&mutex);
+               g_mutex_unlock (&mutex);
        }
        else {
                if (gda_connection_statement_execute_non_select (cnc, internal_stmt[INTERNAL_ROLLBACK],
@@ -1577,9 +1577,9 @@ gda_sqlite_provider_add_savepoint (GdaServerProvider *provider, GdaConnection *c
        g_return_val_if_fail (gda_connection_get_provider (cnc) == provider, FALSE);
        g_return_val_if_fail (name && *name, FALSE);
 
-       static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+       static GMutex mutex;
        static GdaSet *params_set = NULL;
-       g_static_mutex_lock (&mutex);
+       g_mutex_lock (&mutex);
        if (!params_set)
                params_set = gda_set_new_inline (1, "name", G_TYPE_STRING, name);
        else if (! gda_set_set_holder_value (params_set, error, "name", name))
@@ -1587,7 +1587,7 @@ gda_sqlite_provider_add_savepoint (GdaServerProvider *provider, GdaConnection *c
        if (status && gda_connection_statement_execute_non_select (cnc, internal_stmt[INTERNAL_ADD_SAVEPOINT],
                                                                   params_set, NULL, error) == -1)
                status = FALSE;
-       g_static_mutex_unlock (&mutex);
+       g_mutex_unlock (&mutex);
 
        /*g_print ("%s(%p) => %s\n", __FUNCTION__, cnc, status ? "TRUE" : "FALSE");*/
        return status;
@@ -1603,9 +1603,9 @@ gda_sqlite_provider_rollback_savepoint (GdaServerProvider *provider, GdaConnecti
        g_return_val_if_fail (gda_connection_get_provider (cnc) == provider, FALSE);
        g_return_val_if_fail (name && *name, FALSE);
 
-       static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+       static GMutex mutex;
        static GdaSet *params_set = NULL;
-       g_static_mutex_lock (&mutex);
+       g_mutex_lock (&mutex);
        if (!params_set)
                params_set = gda_set_new_inline (1, "name", G_TYPE_STRING, name);
        else if (! gda_set_set_holder_value (params_set, error, "name", name))
@@ -1613,7 +1613,7 @@ gda_sqlite_provider_rollback_savepoint (GdaServerProvider *provider, GdaConnecti
        if (status && gda_connection_statement_execute_non_select (cnc, 
internal_stmt[INTERNAL_ROLLBACK_SAVEPOINT],
                                                                   params_set, NULL, error) == -1)
                status = FALSE;
-       g_static_mutex_unlock (&mutex);
+       g_mutex_unlock (&mutex);
 
        /*g_print ("%s(%p) => %s\n", __FUNCTION__, cnc, status ? "TRUE" : "FALSE");*/
        return status;
@@ -1629,9 +1629,9 @@ gda_sqlite_provider_delete_savepoint (GdaServerProvider *provider, GdaConnection
        g_return_val_if_fail (gda_connection_get_provider (cnc) == provider, FALSE);
        g_return_val_if_fail (name && *name, FALSE);
 
-       static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+       static GMutex mutex;
        static GdaSet *params_set = NULL;
-       g_static_mutex_lock (&mutex);
+       g_mutex_lock (&mutex);
        if (!params_set)
                params_set = gda_set_new_inline (1, "name", G_TYPE_STRING, name);
        else if (! gda_set_set_holder_value (params_set, error, "name", name))
@@ -1639,7 +1639,7 @@ gda_sqlite_provider_delete_savepoint (GdaServerProvider *provider, GdaConnection
        if (status && gda_connection_statement_execute_non_select (cnc, 
internal_stmt[INTERNAL_RELEASE_SAVEPOINT],
                                                                   params_set, NULL, error) == -1)
                status = FALSE;
-       g_static_mutex_unlock (&mutex);
+       g_mutex_unlock (&mutex);
 
        /*g_print ("%s(%p) => %s\n", __FUNCTION__, cnc, status ? "TRUE" : "FALSE");*/
        return status;
diff --git a/libgda/sqlite/gda-sqlite-pstmt.c b/libgda/sqlite/gda-sqlite-pstmt.c
index c0696e7..ad281bc 100644
--- a/libgda/sqlite/gda-sqlite-pstmt.c
+++ b/libgda/sqlite/gda-sqlite-pstmt.c
@@ -40,7 +40,7 @@ _gda_sqlite_pstmt_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaSqlitePStmtClass),
                        (GBaseInitFunc) NULL,
@@ -54,10 +54,10 @@ _gda_sqlite_pstmt_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_PSTMT, CLASS_PREFIX "PStmt", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/sqlite/gda-sqlite-recordset.c b/libgda/sqlite/gda-sqlite-recordset.c
index 1bc76bb..72b0889 100644
--- a/libgda/sqlite/gda-sqlite-recordset.c
+++ b/libgda/sqlite/gda-sqlite-recordset.c
@@ -134,7 +134,7 @@ _gda_sqlite_recordset_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaSqliteRecordsetClass),
                        (GBaseInitFunc) NULL,
@@ -147,10 +147,10 @@ _gda_sqlite_recordset_get_type (void)
                        (GInstanceInitFunc) gda_sqlite_recordset_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, CLASS_PREFIX "Recordset", &info, 
0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/sqlite/virtual/gda-ldap-connection.c b/libgda/sqlite/virtual/gda-ldap-connection.c
index a047959..0f5cea9 100644
--- a/libgda/sqlite/virtual/gda-ldap-connection.c
+++ b/libgda/sqlite/virtual/gda-ldap-connection.c
@@ -297,7 +297,7 @@ gda_ldap_connection_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                if (type == 0) {
                        static GTypeInfo info = {
                                sizeof (GdaLdapConnectionClass),
@@ -311,10 +311,10 @@ gda_ldap_connection_get_type (void)
                                0
                        };
                        
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_VCONNECTION_DATA_MODEL, "GdaLdapConnection", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
                }
        }
 
diff --git a/libgda/sqlite/virtual/gda-vconnection-data-model.c 
b/libgda/sqlite/virtual/gda-vconnection-data-model.c
index 8f8c6dd..822a273 100644
--- a/libgda/sqlite/virtual/gda-vconnection-data-model.c
+++ b/libgda/sqlite/virtual/gda-vconnection-data-model.c
@@ -192,7 +192,7 @@ gda_vconnection_data_model_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                if (type == 0) {
                        static GTypeInfo info = {
                                sizeof (GdaVconnectionDataModelClass),
@@ -205,11 +205,11 @@ gda_vconnection_data_model_get_type (void)
                                (GInstanceInitFunc) gda_vconnection_data_model_init,
                                0
                        };
-                       
-               g_static_mutex_lock (&registering);
-               if (type == 0)
-                       type = g_type_register_static (GDA_TYPE_VIRTUAL_CONNECTION, 
"GdaVconnectionDataModel", &info, 0);
-               g_static_mutex_unlock (&registering);
+
+                       g_mutex_lock (&registering);
+                       if (type == 0)
+                               type = g_type_register_static (GDA_TYPE_VIRTUAL_CONNECTION, 
"GdaVconnectionDataModel", &info, 0);
+                       g_mutex_unlock (&registering);
                }
        }
 
diff --git a/libgda/sqlite/virtual/gda-vconnection-hub.c b/libgda/sqlite/virtual/gda-vconnection-hub.c
index 4206008..87eb19e 100644
--- a/libgda/sqlite/virtual/gda-vconnection-hub.c
+++ b/libgda/sqlite/virtual/gda-vconnection-hub.c
@@ -103,7 +103,7 @@ gda_vconnection_hub_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                if (type == 0) {
                        static GTypeInfo info = {
                                sizeof (GdaVconnectionHubClass),
@@ -117,10 +117,10 @@ gda_vconnection_hub_get_type (void)
                                0
                        };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_VCONNECTION_DATA_MODEL, "GdaVconnectionHub", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
                }
        }
 
diff --git a/libgda/sqlite/virtual/gda-virtual-connection.c b/libgda/sqlite/virtual/gda-virtual-connection.c
index b60b60c..e04df44 100644
--- a/libgda/sqlite/virtual/gda-virtual-connection.c
+++ b/libgda/sqlite/virtual/gda-virtual-connection.c
@@ -97,7 +97,7 @@ gda_virtual_connection_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaVirtualConnectionClass),
                        (GBaseInitFunc) NULL,
@@ -110,10 +110,10 @@ gda_virtual_connection_get_type (void)
                        0
                };
                        
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (PARENT_TYPE, "GdaVirtualConnection", &info, 
G_TYPE_FLAG_ABSTRACT);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/sqlite/virtual/gda-virtual-provider.c b/libgda/sqlite/virtual/gda-virtual-provider.c
index 84299bc..d9955b0 100644
--- a/libgda/sqlite/virtual/gda-virtual-provider.c
+++ b/libgda/sqlite/virtual/gda-virtual-provider.c
@@ -80,7 +80,7 @@ gda_virtual_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                if (type == 0) {
                        static GTypeInfo info = {
                                sizeof (GdaVirtualProviderClass),
@@ -94,10 +94,10 @@ gda_virtual_provider_get_type (void)
                                0
                        };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (PARENT_TYPE, "GdaVirtualProvider", &info, 
G_TYPE_FLAG_ABSTRACT);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
                }
        }
 
diff --git a/libgda/sqlite/virtual/gda-vprovider-data-model.c 
b/libgda/sqlite/virtual/gda-vprovider-data-model.c
index be0f739..2ffbdd1 100644
--- a/libgda/sqlite/virtual/gda-vprovider-data-model.c
+++ b/libgda/sqlite/virtual/gda-vprovider-data-model.c
@@ -115,7 +115,7 @@ gda_vprovider_data_model_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                if (type == 0) {
                        static GTypeInfo info = {
                                sizeof (GdaVproviderDataModelClass),
@@ -129,10 +129,10 @@ gda_vprovider_data_model_get_type (void)
                                0
                        };
                        
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_VIRTUAL_PROVIDER, "GdaVproviderDataModel", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
                }
        }
 
diff --git a/libgda/sqlite/virtual/gda-vprovider-hub.c b/libgda/sqlite/virtual/gda-vprovider-hub.c
index 10e000e..90e95be 100644
--- a/libgda/sqlite/virtual/gda-vprovider-hub.c
+++ b/libgda/sqlite/virtual/gda-vprovider-hub.c
@@ -102,7 +102,7 @@ gda_vprovider_hub_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                if (type == 0) {
                        static GTypeInfo info = {
                                sizeof (GdaVproviderHubClass),
@@ -116,10 +116,10 @@ gda_vprovider_hub_get_type (void)
                                0
                        };
                        
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_VPROVIDER_DATA_MODEL, "GdaVproviderHub", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
                }
        }
 
diff --git a/libgda/thread-wrapper/gda-thread-blob-op.c b/libgda/thread-wrapper/gda-thread-blob-op.c
index ad7668d..5682a23 100644
--- a/libgda/thread-wrapper/gda-thread-blob-op.c
+++ b/libgda/thread-wrapper/gda-thread-blob-op.c
@@ -47,7 +47,7 @@ _gda_thread_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaThreadBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -60,10 +60,10 @@ _gda_thread_blob_op_get_type (void)
                        (GInstanceInitFunc) gda_thread_blob_op_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaThreadBlobOp", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/libgda/thread-wrapper/gda-thread-provider.c b/libgda/thread-wrapper/gda-thread-provider.c
index 7292692..2e0f6b6 100644
--- a/libgda/thread-wrapper/gda-thread-provider.c
+++ b/libgda/thread-wrapper/gda-thread-provider.c
@@ -267,7 +267,7 @@ _gda_thread_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaThreadProviderClass),
                        (GBaseInitFunc) NULL,
@@ -279,10 +279,10 @@ _gda_thread_provider_get_type (void)
                        (GInstanceInitFunc) gda_thread_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, "GdaThreadProvider", &info, 
0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -376,8 +376,8 @@ create_connection_data (GdaServerProvider *provider, GdaConnection *cnc, GdaQuar
        GdaThreadWrapper *wr = NULL;
        gboolean wr_created = FALSE;
 
-       static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
-       g_static_mutex_lock (&mutex);
+       static GMutex mutex;
+       g_mutex_lock (&mutex);
 
        /* test if connection has to be opened using a DSN or a connection string */
        gchar *dsn, *auth_string, *cnc_string;
@@ -425,14 +425,14 @@ create_connection_data (GdaServerProvider *provider, GdaConnection *cnc, GdaQuar
                        gda_connection_add_event_string (cnc, "%s", _("Multi threading is not supported or 
enabled"));
                        g_free (data->prov_name);
                        g_free (data);
-                       g_static_mutex_unlock (&mutex);
+                       g_mutex_unlock (&mutex);
                        return NULL;
                }
        }
        else {
                /* here wr_created == FALSE */
                g_object_ref (wr);
-               g_static_mutex_unlock (&mutex);
+               g_mutex_unlock (&mutex);
        }
        
        /* open sub connection */
@@ -456,7 +456,7 @@ create_connection_data (GdaServerProvider *provider, GdaConnection *cnc, GdaQuar
                g_free (data->prov_name);
                g_free (data);
                if (wr_created)
-                       g_static_mutex_unlock (&mutex);
+                       g_mutex_unlock (&mutex);
                return NULL;
        }
        
@@ -479,7 +479,7 @@ create_connection_data (GdaServerProvider *provider, GdaConnection *cnc, GdaQuar
                                             g_strdup (gda_server_provider_get_name (cdata->cnc_provider)),
                                             g_object_ref (wr));
                }
-               g_static_mutex_unlock (&mutex);
+               g_mutex_unlock (&mutex);
        }
 
        return cdata;
diff --git a/libgda/thread-wrapper/gda-thread-recordset.c b/libgda/thread-wrapper/gda-thread-recordset.c
index e873bc0..0bb5628 100644
--- a/libgda/thread-wrapper/gda-thread-recordset.c
+++ b/libgda/thread-wrapper/gda-thread-recordset.c
@@ -127,7 +127,7 @@ _gda_thread_recordset_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaThreadRecordsetClass),
                        (GBaseInitFunc) NULL,
@@ -140,10 +140,10 @@ _gda_thread_recordset_get_type (void)
                        (GInstanceInitFunc) gda_thread_recordset_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, "GdaThreadRecordset", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/libgda/thread-wrapper/gda-thread-wrapper.c b/libgda/thread-wrapper/gda-thread-wrapper.c
index a368bfa..f3298cd 100644
--- a/libgda/thread-wrapper/gda-thread-wrapper.c
+++ b/libgda/thread-wrapper/gda-thread-wrapper.c
@@ -767,7 +767,7 @@ gda_thread_wrapper_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaThreadWrapperClass),
                         (GBaseInitFunc) NULL,
@@ -781,10 +781,10 @@ gda_thread_wrapper_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (G_TYPE_OBJECT, "GdaThreadWrapper", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/providers/bdb/gda-bdb-provider.c b/providers/bdb/gda-bdb-provider.c
index d70b0f1..301fe59 100644
--- a/providers/bdb/gda-bdb-provider.c
+++ b/providers/bdb/gda-bdb-provider.c
@@ -92,7 +92,7 @@ gda_bdb_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaBdbProviderClass),
                        (GBaseInitFunc) NULL,
@@ -104,10 +104,10 @@ gda_bdb_provider_get_type (void)
                        (GInstanceInitFunc) gda_bdb_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_VPROVIDER_DATA_MODEL, "GdaBdbProvider", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/firebird/gda-firebird-blob-op.c b/providers/firebird/gda-firebird-blob-op.c
index 1efe514..8e6c874 100644
--- a/providers/firebird/gda-firebird-blob-op.c
+++ b/providers/firebird/gda-firebird-blob-op.c
@@ -48,7 +48,7 @@ gda_firebird_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaFirebirdBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -60,7 +60,7 @@ gda_firebird_blob_op_get_type (void)
                        0,
                        (GInstanceInitFunc) gda_firebird_blob_op_init
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
 #ifdef FIREBIRD_EMBED
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaFirebirdBlobOpEmbed", &info, 0);
@@ -68,7 +68,7 @@ gda_firebird_blob_op_get_type (void)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaFirebirdBlobOp", &info, 0);
 #endif
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/firebird/gda-firebird-meta.c b/providers/firebird/gda-firebird-meta.c
index 4afc12c..6e87de1 100644
--- a/providers/firebird/gda-firebird-meta.c
+++ b/providers/firebird/gda-firebird-meta.c
@@ -214,7 +214,7 @@ static gchar *internal_sql[] = {
  * global static values, and
  * predefined statements' GdaStatement, all initialized in _gda_postgres_provider_meta_init()
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 static GdaSqlParser *internal_parser = NULL;
 static GdaSet       *i_set = NULL;
@@ -228,7 +228,7 @@ static GdaSet       *i_set = NULL;
 void
 _gda_firebird_provider_meta_init (GdaServerProvider *provider)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -246,7 +246,7 @@ _gda_firebird_provider_meta_init (GdaServerProvider *provider)
                                            "constraint_name", G_TYPE_STRING, "",
                                            "field_name", G_TYPE_STRING, ""
                                            , "char_set_name", G_TYPE_STRING, "");
-               g_static_mutex_unlock (&init_mutex);
+               g_mutex_unlock (&init_mutex);
        
                /* initialize static values here */
                /*
@@ -256,7 +256,7 @@ _gda_firebird_provider_meta_init (GdaServerProvider *provider)
        
        }
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 gboolean
diff --git a/providers/firebird/gda-firebird-parser.c b/providers/firebird/gda-firebird-parser.c
index f529d85..0ccbf31 100644
--- a/providers/firebird/gda-firebird-parser.c
+++ b/providers/firebird/gda-firebird-parser.c
@@ -33,7 +33,7 @@ gda_firebird_parser_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaFirebirdParserClass),
                        (GBaseInitFunc) NULL,
@@ -46,7 +46,7 @@ gda_firebird_parser_get_type (void)
                        (GInstanceInitFunc) gda_firebird_parser_init
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
 #ifdef FIREBIRD_EMBED
                        type = g_type_register_static (GDA_TYPE_SQL_PARSER, "GdaFirebirdParserEmbed", &info, 
0);
@@ -54,7 +54,7 @@ gda_firebird_parser_get_type (void)
                        type = g_type_register_static (GDA_TYPE_SQL_PARSER, "GdaFirebirdParser", &info, 0);
 #endif
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/firebird/gda-firebird-provider.c b/providers/firebird/gda-firebird-provider.c
index adfd2ba..a3467a3 100644
--- a/providers/firebird/gda-firebird-provider.c
+++ b/providers/firebird/gda-firebird-provider.c
@@ -179,7 +179,7 @@ static gchar * firebird_render_expr (GdaSqlExpr *expr, GdaSqlRenderingContext *c
  * TO_ADD: any prepared statement to be used internally by the provider should be
  *         declared here, as constants and as SQL statements
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 
 typedef enum {
@@ -297,7 +297,7 @@ gda_firebird_provider_class_init (GdaFirebirdProviderClass *klass)
 static void
 gda_firebird_provider_init (GdaFirebirdProvider *firebird_prv, GdaFirebirdProviderClass *klass)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
        if (!internal_stmt) {
                InternalStatementItem i;
                GdaSqlParser *parser;
@@ -314,7 +314,7 @@ gda_firebird_provider_init (GdaFirebirdProvider *firebird_prv, GdaFirebirdProvid
        /* meta data init */
        _gda_firebird_provider_meta_init ((GdaServerProvider*) firebird_prv);
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 GType
@@ -323,7 +323,7 @@ gda_firebird_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaFirebirdProviderClass),
                        (GBaseInitFunc) NULL,
@@ -334,7 +334,7 @@ gda_firebird_provider_get_type (void)
                        0,
                        (GInstanceInitFunc) gda_firebird_provider_init
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
 #ifdef FIREBIRD_EMBED
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, "GdaFirebirdProviderEmbed", 
&info, 0);
@@ -342,7 +342,7 @@ gda_firebird_provider_get_type (void)
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, "GdaFirebirdProvider", 
&info, 0);
 #endif
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/firebird/gda-firebird-pstmt.c b/providers/firebird/gda-firebird-pstmt.c
index 23c1e3e..c6cb8fb 100644
--- a/providers/firebird/gda-firebird-pstmt.c
+++ b/providers/firebird/gda-firebird-pstmt.c
@@ -38,7 +38,7 @@ gda_firebird_pstmt_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaFirebirdPStmtClass),
                        (GBaseInitFunc) NULL,
@@ -52,7 +52,7 @@ gda_firebird_pstmt_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
 #ifdef FIREBIRD_EMBED
                        type = g_type_register_static (GDA_TYPE_PSTMT, "GdaFirebirdPStmtEmbed", &info, 0);
@@ -60,7 +60,7 @@ gda_firebird_pstmt_get_type (void)
                        type = g_type_register_static (GDA_TYPE_PSTMT, "GdaFirebirdPStmt", &info, 0);
 #endif
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/firebird/gda-firebird-recordset.c b/providers/firebird/gda-firebird-recordset.c
index 2a2f036..40473e6 100644
--- a/providers/firebird/gda-firebird-recordset.c
+++ b/providers/firebird/gda-firebird-recordset.c
@@ -136,7 +136,7 @@ gda_firebird_recordset_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaFirebirdRecordsetClass),
                        (GBaseInitFunc) NULL,
@@ -149,7 +149,7 @@ gda_firebird_recordset_get_type (void)
                        (GInstanceInitFunc) gda_firebird_recordset_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
 #ifdef FIREBIRD_EMBED
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, "GdaFirebirdRecordsetEmbed", 
&info, 0);
@@ -157,7 +157,7 @@ gda_firebird_recordset_get_type (void)
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, "GdaFirebirdRecordset", &info, 
0);
 #endif
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/jdbc/gda-jdbc-blob-op.c b/providers/jdbc/gda-jdbc-blob-op.c
index 0130f13..c7f9781 100644
--- a/providers/jdbc/gda-jdbc-blob-op.c
+++ b/providers/jdbc/gda-jdbc-blob-op.c
@@ -51,7 +51,7 @@ gda_jdbc_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaJdbcBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -64,10 +64,10 @@ gda_jdbc_blob_op_get_type (void)
                        (GInstanceInitFunc) gda_jdbc_blob_op_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaJdbcBlobOp", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/jdbc/gda-jdbc-meta.c b/providers/jdbc/gda-jdbc-meta.c
index 6fe1726..876ee32 100644
--- a/providers/jdbc/gda-jdbc-meta.c
+++ b/providers/jdbc/gda-jdbc-meta.c
@@ -46,15 +46,15 @@ static gboolean
 init_meta_obj (GdaConnection *cnc, JNIEnv *jenv, JdbcConnectionData *cdata, GError **error)
 {
        GError *lerror = NULL;
-       static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+       static GMutex init_mutex;
 
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (cdata->jmeta_obj)
                return TRUE;
        cdata->jmeta_obj = jni_wrapper_method_call (jenv, GdaJConnection__getJMeta,
                                                    cdata->jcnc_obj, NULL, NULL, &lerror);
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
        if (!cdata->jmeta_obj) {
                if (error && lerror)
                        *error = g_error_copy (lerror);
diff --git a/providers/jdbc/gda-jdbc-provider.c b/providers/jdbc/gda-jdbc-provider.c
index 8875f7d..f88b01b 100644
--- a/providers/jdbc/gda-jdbc-provider.c
+++ b/providers/jdbc/gda-jdbc-provider.c
@@ -146,7 +146,7 @@ static void gda_jdbc_free_cnc_data (JdbcConnectionData *cdata);
  * TO_ADD: any prepared statement to be used internally by the provider should be
  *         declared here, as constants and as SQL statements
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 
 typedef enum {
@@ -268,7 +268,7 @@ extern JavaVM *_jdbc_provider_java_vm;
 static void
 gda_jdbc_provider_init (GdaJdbcProvider *jdbc_prv, G_GNUC_UNUSED GdaJdbcProviderClass *klass)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -288,7 +288,7 @@ gda_jdbc_provider_init (GdaJdbcProvider *jdbc_prv, G_GNUC_UNUSED GdaJdbcProvider
 
        /* TO_ADD: any other provider's init should be added here */
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 GType
@@ -297,7 +297,7 @@ gda_jdbc_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaJdbcProviderClass),
                        (GBaseInitFunc) NULL,
@@ -309,10 +309,10 @@ gda_jdbc_provider_get_type (void)
                        (GInstanceInitFunc) gda_jdbc_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, "GdaJdbcProvider", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/jdbc/gda-jdbc-pstmt.c b/providers/jdbc/gda-jdbc-pstmt.c
index e8b6365..c578a61 100644
--- a/providers/jdbc/gda-jdbc-pstmt.c
+++ b/providers/jdbc/gda-jdbc-pstmt.c
@@ -39,7 +39,7 @@ gda_jdbc_pstmt_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaJdbcPStmtClass),
                        (GBaseInitFunc) NULL,
@@ -53,10 +53,10 @@ gda_jdbc_pstmt_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_PSTMT, "GdaJdbcPStmt", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/jdbc/gda-jdbc-recordset.c b/providers/jdbc/gda-jdbc-recordset.c
index ef35fab..c682a60 100644
--- a/providers/jdbc/gda-jdbc-recordset.c
+++ b/providers/jdbc/gda-jdbc-recordset.c
@@ -118,7 +118,7 @@ gda_jdbc_recordset_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaJdbcRecordsetClass),
                        (GBaseInitFunc) NULL,
@@ -131,10 +131,10 @@ gda_jdbc_recordset_get_type (void)
                        (GInstanceInitFunc) gda_jdbc_recordset_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, "GdaJdbcRecordset", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/jdbc/libmain.c b/providers/jdbc/libmain.c
index cef2c0b..ae1555f 100644
--- a/providers/jdbc/libmain.c
+++ b/providers/jdbc/libmain.c
@@ -43,7 +43,7 @@
 static GModule *jvm_handle = NULL;
 
 /* JVM's symbols */
-static GStaticMutex vm_create = G_STATIC_MUTEX_INIT;
+static GMutex vm_create;
 static jint (*__CreateJavaVM) (JavaVM **pvm, void **penv, void *args) = NULL;
 JavaVM *_jdbc_provider_java_vm = NULL;
 
@@ -388,9 +388,9 @@ load_jvm ()
        gboolean jvm_found = FALSE;
        const gchar *env;
 
-       g_static_mutex_lock (&vm_create);
+       g_mutex_lock (&vm_create);
        if (_jdbc_provider_java_vm) {
-               g_static_mutex_unlock (&vm_create);
+               g_mutex_unlock (&vm_create);
                return TRUE;
        }
 
@@ -487,7 +487,7 @@ load_jvm ()
                        g_warning (_("Could not find the JVM runtime (libjvm.so), JDBC provider is 
unavailable."));
        }
 
-       g_static_mutex_unlock (&vm_create);
+       g_mutex_unlock (&vm_create);
        return jvm_found;
 }
 
diff --git a/providers/ldap/gda-ldap-provider.c b/providers/ldap/gda-ldap-provider.c
index 2eba344..11ddcb4 100644
--- a/providers/ldap/gda-ldap-provider.c
+++ b/providers/ldap/gda-ldap-provider.c
@@ -112,7 +112,7 @@ gda_ldap_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaLdapProviderClass),
                        (GBaseInitFunc) NULL,
@@ -124,10 +124,10 @@ gda_ldap_provider_get_type (void)
                        (GInstanceInitFunc) gda_ldap_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_VPROVIDER_DATA_MODEL, "GdaLdapProvider", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/ldap/gdaprov-data-model-ldap.c b/providers/ldap/gdaprov-data-model-ldap.c
index a97708c..8f640ac 100644
--- a/providers/ldap/gdaprov-data-model-ldap.c
+++ b/providers/ldap/gdaprov-data-model-ldap.c
@@ -327,7 +327,7 @@ gdaprov_data_model_ldap_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaDataModelLdapClass),
                        (GBaseInitFunc) NULL,
@@ -346,12 +346,12 @@ gdaprov_data_model_ldap_get_type (void)
                         NULL
                 };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaDataModelLdap", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/mdb/gda-mdb-provider.c b/providers/mdb/gda-mdb-provider.c
index 60fae92..67c33e9 100644
--- a/providers/mdb/gda-mdb-provider.c
+++ b/providers/mdb/gda-mdb-provider.c
@@ -63,7 +63,7 @@ static const gchar *gda_mdb_provider_get_database (GdaServerProvider *provider,
 
 
 static GObjectClass *parent_class = NULL;
-static GStaticMutex mdb_init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex mdb_init_mutex;
 static gint loaded_providers = 0;
 char *g_input_ptr;
 
@@ -109,11 +109,11 @@ gda_mdb_provider_finalize (GObject *object)
        parent_class->finalize (object);
 
        /* call MDB exit function if there are no more providers */
-       g_static_mutex_lock (&mdb_init_mutex);
+       g_mutex_lock (&mdb_init_mutex);
        loaded_providers--;
        if (loaded_providers == 0)
                mdb_exit ();
-       g_static_mutex_unlock (&mdb_init_mutex);
+       g_mutex_unlock (&mdb_init_mutex);
 }
 
 GType
@@ -122,7 +122,7 @@ gda_mdb_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaMdbProviderClass),
                        (GBaseInitFunc) NULL,
@@ -134,10 +134,10 @@ gda_mdb_provider_get_type (void)
                        (GInstanceInitFunc) gda_mdb_provider_init,
                        NULL
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_VPROVIDER_DATA_MODEL, "GdaMdbProvider", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
@@ -148,11 +148,11 @@ gda_mdb_provider_new (void)
 {
        GdaMdbProvider *provider;
 
-       g_static_mutex_lock (&mdb_init_mutex);
+       g_mutex_lock (&mdb_init_mutex);
        if (loaded_providers == 0) 
                mdb_init ();
        loaded_providers++;
-       g_static_mutex_unlock (&mdb_init_mutex);
+       g_mutex_unlock (&mdb_init_mutex);
 
        provider = g_object_new (gda_mdb_provider_get_type (), NULL);
        return GDA_SERVER_PROVIDER (provider);
diff --git a/providers/mysql/gda-mysql-blob-op.c b/providers/mysql/gda-mysql-blob-op.c
index 015f5f1..4aa592b 100644
--- a/providers/mysql/gda-mysql-blob-op.c
+++ b/providers/mysql/gda-mysql-blob-op.c
@@ -49,7 +49,7 @@ gda_mysql_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaMysqlBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -62,10 +62,10 @@ gda_mysql_blob_op_get_type (void)
                        (GInstanceInitFunc) gda_mysql_blob_op_init,
                        NULL
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaMysqlBlobOp", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/mysql/gda-mysql-handler-boolean.c b/providers/mysql/gda-mysql-handler-boolean.c
index c7ab3a3..da8c13d 100644
--- a/providers/mysql/gda-mysql-handler-boolean.c
+++ b/providers/mysql/gda-mysql-handler-boolean.c
@@ -55,7 +55,7 @@ gda_mysql_handler_boolean_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaMysqlHandlerBooleanClass),
                        (GBaseInitFunc) NULL,
@@ -75,12 +75,12 @@ gda_mysql_handler_boolean_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaMysqlHandlerBoolean", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/mysql/gda-mysql-provider.c b/providers/mysql/gda-mysql-provider.c
index edd5969..37d8bbd 100644
--- a/providers/mysql/gda-mysql-provider.c
+++ b/providers/mysql/gda-mysql-provider.c
@@ -239,7 +239,7 @@ static void gda_mysql_free_cnc_data (MysqlConnectionData  *cdata);
  * TO_ADD: any prepared statement to be used internally by the provider should be
  *         declared here, as constants and as SQL statements
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 
 typedef enum {
@@ -377,7 +377,7 @@ static void
 gda_mysql_provider_init (GdaMysqlProvider       *mysql_prv,
                         G_GNUC_UNUSED GdaMysqlProviderClass  *klass)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -399,7 +399,7 @@ gda_mysql_provider_init (GdaMysqlProvider       *mysql_prv,
        mysql_prv->test_mode = FALSE;
        mysql_prv->test_identifiers_case_sensitive = TRUE;
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 GType
@@ -408,7 +408,7 @@ gda_mysql_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaMysqlProviderClass),
                        (GBaseInitFunc) NULL,
@@ -420,10 +420,10 @@ gda_mysql_provider_get_type (void)
                        (GInstanceInitFunc) gda_mysql_provider_init,
                        NULL
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, "GdaMysqlProvider", &info, 
0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/mysql/gda-mysql-pstmt.c b/providers/mysql/gda-mysql-pstmt.c
index 509b9c3..64df7ff 100644
--- a/providers/mysql/gda-mysql-pstmt.c
+++ b/providers/mysql/gda-mysql-pstmt.c
@@ -43,7 +43,7 @@ gda_mysql_pstmt_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaMysqlPStmtClass),
                        (GBaseInitFunc) NULL,
@@ -57,10 +57,10 @@ gda_mysql_pstmt_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_PSTMT, "GdaMysqlPStmt", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/mysql/gda-mysql-recordset.c b/providers/mysql/gda-mysql-recordset.c
index 67a5b11..d2d7f3a 100644
--- a/providers/mysql/gda-mysql-recordset.c
+++ b/providers/mysql/gda-mysql-recordset.c
@@ -289,7 +289,7 @@ gda_mysql_recordset_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaMysqlRecordsetClass),
                        (GBaseInitFunc) NULL,
@@ -302,10 +302,10 @@ gda_mysql_recordset_get_type (void)
                        (GInstanceInitFunc) gda_mysql_recordset_init,
                        NULL
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, "GdaMysqlRecordset", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/oracle/gda-oracle-blob-op.c b/providers/oracle/gda-oracle-blob-op.c
index 80fdd42..94de8cf 100644
--- a/providers/oracle/gda-oracle-blob-op.c
+++ b/providers/oracle/gda-oracle-blob-op.c
@@ -48,7 +48,7 @@ gda_oracle_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaOracleBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -61,10 +61,10 @@ gda_oracle_blob_op_get_type (void)
                        (GInstanceInitFunc) gda_oracle_blob_op_init,
                        NULL
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaOracleBlobOp", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/oracle/gda-oracle-meta.c b/providers/oracle/gda-oracle-meta.c
index c20a77a..ebdaa37 100644
--- a/providers/oracle/gda-oracle-meta.c
+++ b/providers/oracle/gda-oracle-meta.c
@@ -96,7 +96,7 @@ static gchar *internal_sql[] = {
  * global static values, and
  * predefined statements' GdaStatement, all initialized in _gda_oracle_provider_meta_init()
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 static GdaSet        *i_set = NULL;
 static GdaSqlParser  *internal_parser = NULL;
@@ -107,7 +107,7 @@ static GdaSqlParser  *internal_parser = NULL;
 void
 _gda_oracle_provider_meta_init (GdaServerProvider *provider)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -126,7 +126,7 @@ _gda_oracle_provider_meta_init (GdaServerProvider *provider)
                                            "name2", G_TYPE_STRING, "");
        }
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 gboolean
diff --git a/providers/oracle/gda-oracle-parser.c b/providers/oracle/gda-oracle-parser.c
index 640ff30..d428de9 100644
--- a/providers/oracle/gda-oracle-parser.c
+++ b/providers/oracle/gda-oracle-parser.c
@@ -33,7 +33,7 @@ gda_oracle_parser_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaOracleParserClass),
                        (GBaseInitFunc) NULL,
@@ -46,10 +46,10 @@ gda_oracle_parser_get_type (void)
                        (GInstanceInitFunc) gda_oracle_parser_init
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SQL_PARSER, "GdaOracleParser", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/oracle/gda-oracle-provider.c b/providers/oracle/gda-oracle-provider.c
index d79fe70..b4dd251 100644
--- a/providers/oracle/gda-oracle-provider.c
+++ b/providers/oracle/gda-oracle-provider.c
@@ -156,7 +156,7 @@ static void gda_oracle_free_cnc_data (OracleConnectionData *cdata);
  * TO_ADD: any prepared statement to be used internally by the provider should be
  *         declared here, as constants and as SQL statements
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 
 typedef enum {
@@ -300,7 +300,7 @@ gda_oracle_provider_class_init (GdaOracleProviderClass *klass)
 static void
 gda_oracle_provider_init (GdaOracleProvider *oracle_prv, G_GNUC_UNUSED GdaOracleProviderClass *klass)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -318,7 +318,7 @@ gda_oracle_provider_init (GdaOracleProvider *oracle_prv, G_GNUC_UNUSED GdaOracle
        /* meta data init */
        _gda_oracle_provider_meta_init ((GdaServerProvider*) oracle_prv);
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 GType
@@ -327,7 +327,7 @@ gda_oracle_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaOracleProviderClass),
                        (GBaseInitFunc) NULL,
@@ -339,10 +339,10 @@ gda_oracle_provider_get_type (void)
                        (GInstanceInitFunc) gda_oracle_provider_init,
                        NULL
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, "GdaOracleProvider", &info, 
0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/oracle/gda-oracle-pstmt.c b/providers/oracle/gda-oracle-pstmt.c
index 215b270..ca9d5d3 100644
--- a/providers/oracle/gda-oracle-pstmt.c
+++ b/providers/oracle/gda-oracle-pstmt.c
@@ -39,7 +39,7 @@ gda_oracle_pstmt_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaOraclePStmtClass),
                        (GBaseInitFunc) NULL,
@@ -53,10 +53,10 @@ gda_oracle_pstmt_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_PSTMT, "GdaOraclePStmt", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/oracle/gda-oracle-recordset.c b/providers/oracle/gda-oracle-recordset.c
index 45f769e..d517226 100644
--- a/providers/oracle/gda-oracle-recordset.c
+++ b/providers/oracle/gda-oracle-recordset.c
@@ -116,7 +116,7 @@ gda_oracle_recordset_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaOracleRecordsetClass),
                        (GBaseInitFunc) NULL,
@@ -129,10 +129,10 @@ gda_oracle_recordset_get_type (void)
                        (GInstanceInitFunc) gda_oracle_recordset_init,
                        NULL
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, "GdaOracleRecordset", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/postgres/gda-postgres-blob-op.c b/providers/postgres/gda-postgres-blob-op.c
index 35fe86f..951c66d 100644
--- a/providers/postgres/gda-postgres-blob-op.c
+++ b/providers/postgres/gda-postgres-blob-op.c
@@ -53,7 +53,7 @@ gda_postgres_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaPostgresBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -66,10 +66,10 @@ gda_postgres_blob_op_get_type (void)
                        (GInstanceInitFunc) gda_postgres_blob_op_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaPostgresBlobOp", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/postgres/gda-postgres-handler-bin.c b/providers/postgres/gda-postgres-handler-bin.c
index d3da924..f3255b1 100644
--- a/providers/postgres/gda-postgres-handler-bin.c
+++ b/providers/postgres/gda-postgres-handler-bin.c
@@ -58,7 +58,7 @@ gda_postgres_handler_bin_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaPostgresHandlerBinClass),
                        (GBaseInitFunc) NULL,
@@ -78,12 +78,12 @@ gda_postgres_handler_bin_get_type (void)
                        NULL
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaPostgresHandlerBin", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_HANDLER, &data_entry_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/postgres/gda-postgres-provider.c b/providers/postgres/gda-postgres-provider.c
index ee56670..aea1189 100644
--- a/providers/postgres/gda-postgres-provider.c
+++ b/providers/postgres/gda-postgres-provider.c
@@ -165,7 +165,7 @@ static void gda_postgres_free_cnc_data (PostgresConnectionData *cdata);
  * TO_ADD: any prepared statement to be used internally by the provider should be
  *         declared here, as constants and as SQL statements
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 
 typedef enum {
@@ -302,7 +302,7 @@ gda_postgres_provider_class_init (GdaPostgresProviderClass *klass)
 static void
 gda_postgres_provider_init (GdaPostgresProvider *postgres_prv, G_GNUC_UNUSED GdaPostgresProviderClass *klass)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -320,7 +320,7 @@ gda_postgres_provider_init (GdaPostgresProvider *postgres_prv, G_GNUC_UNUSED Gda
        /* meta data init */
        _gda_postgres_provider_meta_init ((GdaServerProvider*) postgres_prv);
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 GType
@@ -329,7 +329,7 @@ gda_postgres_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaPostgresProviderClass),
                        (GBaseInitFunc) NULL,
@@ -341,10 +341,10 @@ gda_postgres_provider_get_type (void)
                        (GInstanceInitFunc) gda_postgres_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, "GdaPostgresProvider", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/postgres/gda-postgres-pstmt.c b/providers/postgres/gda-postgres-pstmt.c
index 65d8e23..830ed96 100644
--- a/providers/postgres/gda-postgres-pstmt.c
+++ b/providers/postgres/gda-postgres-pstmt.c
@@ -40,7 +40,7 @@ gda_postgres_pstmt_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaPostgresPStmtClass),
                        (GBaseInitFunc) NULL,
@@ -54,10 +54,10 @@ gda_postgres_pstmt_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_PSTMT, "GdaPostgresPStmt", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/postgres/gda-postgres-recordset.c b/providers/postgres/gda-postgres-recordset.c
index f750040..8096f4a 100644
--- a/providers/postgres/gda-postgres-recordset.c
+++ b/providers/postgres/gda-postgres-recordset.c
@@ -238,7 +238,7 @@ gda_postgres_recordset_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaPostgresRecordsetClass),
                        (GBaseInitFunc) NULL,
@@ -251,10 +251,10 @@ gda_postgres_recordset_get_type (void)
                        (GInstanceInitFunc) gda_postgres_recordset_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, "GdaPostgresRecordset", &info, 
0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/reuseable/mysql/gda-mysql-meta.c b/providers/reuseable/mysql/gda-mysql-meta.c
index 8f77c2b..551f2fd 100644
--- a/providers/reuseable/mysql/gda-mysql-meta.c
+++ b/providers/reuseable/mysql/gda-mysql-meta.c
@@ -239,7 +239,7 @@ static gchar *internal_sql[] = {
  * global static values, and
  * predefined statements' GdaStatement, all initialized in _gda_postgres_provider_meta_init()
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 static GdaSet        *i_set = NULL;
 
@@ -249,7 +249,7 @@ static GdaSet        *i_set = NULL;
 void
 _gda_mysql_provider_meta_init (GdaServerProvider  *provider)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -275,7 +275,7 @@ _gda_mysql_provider_meta_init (GdaServerProvider  *provider)
                                            "name2", G_TYPE_STRING, "");
        }
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 
 #ifdef GDA_DEBUG
        _gda_mysql_test_keywords ();
diff --git a/providers/reuseable/mysql/gda-mysql-parser.c b/providers/reuseable/mysql/gda-mysql-parser.c
index 3110c34..5c5af63 100644
--- a/providers/reuseable/mysql/gda-mysql-parser.c
+++ b/providers/reuseable/mysql/gda-mysql-parser.c
@@ -34,7 +34,7 @@ gda_mysql_parser_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaMysqlParserClass),
                        (GBaseInitFunc) NULL,
@@ -48,12 +48,12 @@ gda_mysql_parser_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_from_name ("GdaMysqlParser");
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SQL_PARSER, "GdaMysqlParser", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/reuseable/postgres/gda-postgres-meta.c 
b/providers/reuseable/postgres/gda-postgres-meta.c
index 435f5b2..42e47e2 100644
--- a/providers/reuseable/postgres/gda-postgres-meta.c
+++ b/providers/reuseable/postgres/gda-postgres-meta.c
@@ -271,7 +271,7 @@ static gchar *internal_sql[] = {
  * global static values, and
  * predefined statements' GdaStatement, all initialized in _gda_postgres_provider_meta_init()
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 static GdaSet       *i_set = NULL;
 
@@ -281,7 +281,7 @@ static GdaSet       *i_set = NULL;
 void
 _gda_postgres_provider_meta_init (GdaServerProvider *provider)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -307,7 +307,7 @@ _gda_postgres_provider_meta_init (GdaServerProvider *provider)
                                            "oid", G_TYPE_UINT, 0);
        }
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 
 #ifdef GDA_DEBUG
        _gda_postgres_test_keywords ();
diff --git a/providers/reuseable/postgres/gda-postgres-parser.c 
b/providers/reuseable/postgres/gda-postgres-parser.c
index c6d8ab9..b1c0175 100644
--- a/providers/reuseable/postgres/gda-postgres-parser.c
+++ b/providers/reuseable/postgres/gda-postgres-parser.c
@@ -34,7 +34,7 @@ gda_postgres_parser_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaPostgresParserClass),
                        (GBaseInitFunc) NULL,
@@ -48,12 +48,12 @@ gda_postgres_parser_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_from_name ("GdaPostgresParser");
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SQL_PARSER, "GdaPostgresParser", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/skel-implementation/capi/gda-capi-blob-op.c 
b/providers/skel-implementation/capi/gda-capi-blob-op.c
index af278cf..c42dd0f 100644
--- a/providers/skel-implementation/capi/gda-capi-blob-op.c
+++ b/providers/skel-implementation/capi/gda-capi-blob-op.c
@@ -52,7 +52,7 @@ gda_capi_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaCapiBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -65,10 +65,10 @@ gda_capi_blob_op_get_type (void)
                        (GInstanceInitFunc) gda_capi_blob_op_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaCapiBlobOp", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/skel-implementation/capi/gda-capi-meta.c 
b/providers/skel-implementation/capi/gda-capi-meta.c
index a0fe637..97b36cd 100644
--- a/providers/skel-implementation/capi/gda-capi-meta.c
+++ b/providers/skel-implementation/capi/gda-capi-meta.c
@@ -56,7 +56,7 @@ static gchar *internal_sql[] = {
  * global static values, and
  * predefined statements' GdaStatement, all initialized in _gda_capi_provider_meta_init()
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 static GdaSet        *i_set = NULL;
 static GdaSqlParser  *internal_parser = NULL;
@@ -69,7 +69,7 @@ static GdaSqlParser  *internal_parser = NULL;
 void
 _gda_capi_provider_meta_init (GdaServerProvider *provider)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -88,7 +88,7 @@ _gda_capi_provider_meta_init (GdaServerProvider *provider)
                                            "name2", G_TYPE_STRING, "");
        }
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 
 #ifdef GDA_DEBUG
        /* make sure the reserved keywords hash works correctly */
diff --git a/providers/skel-implementation/capi/gda-capi-parser.c 
b/providers/skel-implementation/capi/gda-capi-parser.c
index c92f36e..1ab88a3 100644
--- a/providers/skel-implementation/capi/gda-capi-parser.c
+++ b/providers/skel-implementation/capi/gda-capi-parser.c
@@ -38,7 +38,7 @@ gda_capi_parser_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaCapiParserClass),
                        (GBaseInitFunc) NULL,
@@ -52,10 +52,10 @@ gda_capi_parser_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SQL_PARSER, "GdaCapiParser", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/skel-implementation/capi/gda-capi-provider.c 
b/providers/skel-implementation/capi/gda-capi-provider.c
index ae01cfd..81648df 100644
--- a/providers/skel-implementation/capi/gda-capi-provider.c
+++ b/providers/skel-implementation/capi/gda-capi-provider.c
@@ -144,7 +144,7 @@ static void gda_capi_free_cnc_data (CapiConnectionData *cdata);
  * TO_ADD: any prepared statement to be used internally by the provider should be
  *         declared here, as constants and as SQL statements
  */
-static GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
+static GMutex init_mutex;
 static GdaStatement **internal_stmt = NULL;
 
 typedef enum {
@@ -263,7 +263,7 @@ gda_capi_provider_class_init (GdaCapiProviderClass *klass)
 static void
 gda_capi_provider_init (GdaCapiProvider *capi_prv, G_GNUC_UNUSED GdaCapiProviderClass *klass)
 {
-       g_static_mutex_lock (&init_mutex);
+       g_mutex_lock (&init_mutex);
 
        if (!internal_stmt) {
                InternalStatementItem i;
@@ -283,7 +283,7 @@ gda_capi_provider_init (GdaCapiProvider *capi_prv, G_GNUC_UNUSED GdaCapiProvider
 
        /* TO_ADD: any other provider's init should be added here */
 
-       g_static_mutex_unlock (&init_mutex);
+       g_mutex_unlock (&init_mutex);
 }
 
 GType
@@ -292,7 +292,7 @@ gda_capi_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaCapiProviderClass),
                        (GBaseInitFunc) NULL,
@@ -304,10 +304,10 @@ gda_capi_provider_get_type (void)
                        (GInstanceInitFunc) gda_capi_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, "GdaCapiProvider", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/skel-implementation/capi/gda-capi-pstmt.c 
b/providers/skel-implementation/capi/gda-capi-pstmt.c
index 6092587..3ec7469 100644
--- a/providers/skel-implementation/capi/gda-capi-pstmt.c
+++ b/providers/skel-implementation/capi/gda-capi-pstmt.c
@@ -42,7 +42,7 @@ gda_capi_pstmt_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaCapiPStmtClass),
                        (GBaseInitFunc) NULL,
@@ -56,10 +56,10 @@ gda_capi_pstmt_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_PSTMT, "GdaCapiPStmt", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/skel-implementation/capi/gda-capi-recordset.c 
b/providers/skel-implementation/capi/gda-capi-recordset.c
index 389a9df..58276be 100644
--- a/providers/skel-implementation/capi/gda-capi-recordset.c
+++ b/providers/skel-implementation/capi/gda-capi-recordset.c
@@ -113,7 +113,7 @@ gda_capi_recordset_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaCapiRecordsetClass),
                        (GBaseInitFunc) NULL,
@@ -126,10 +126,10 @@ gda_capi_recordset_get_type (void)
                        (GInstanceInitFunc) gda_capi_recordset_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, "GdaCapiRecordset", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/skel-implementation/models/gda-models-provider.c 
b/providers/skel-implementation/models/gda-models-provider.c
index f3d9d11..7ae9a83 100644
--- a/providers/skel-implementation/models/gda-models-provider.c
+++ b/providers/skel-implementation/models/gda-models-provider.c
@@ -94,7 +94,7 @@ gda_models_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaModelsProviderClass),
                        (GBaseInitFunc) NULL,
@@ -106,10 +106,10 @@ gda_models_provider_get_type (void)
                        (GInstanceInitFunc) gda_models_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_VPROVIDER_DATA_MODEL, "GdaModelsProvider", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/web/gda-web-blob-op.c b/providers/web/gda-web-blob-op.c
index cf112fa..1169766 100644
--- a/providers/web/gda-web-blob-op.c
+++ b/providers/web/gda-web-blob-op.c
@@ -50,7 +50,7 @@ gda_web_blob_op_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaWebBlobOpClass),
                        (GBaseInitFunc) NULL,
@@ -63,10 +63,10 @@ gda_web_blob_op_get_type (void)
                        (GInstanceInitFunc) gda_web_blob_op_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_BLOB_OP, "GdaWebBlobOp", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/web/gda-web-provider.c b/providers/web/gda-web-provider.c
index 8fb7daa..fb58ddc 100644
--- a/providers/web/gda-web-provider.c
+++ b/providers/web/gda-web-provider.c
@@ -237,7 +237,7 @@ gda_web_provider_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (GdaWebProviderClass),
                        (GBaseInitFunc) NULL,
@@ -249,10 +249,10 @@ gda_web_provider_get_type (void)
                        (GInstanceInitFunc) gda_web_provider_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_SERVER_PROVIDER, "GdaWebProvider", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/web/gda-web-pstmt.c b/providers/web/gda-web-pstmt.c
index 621a0d5..dd75629 100644
--- a/providers/web/gda-web-pstmt.c
+++ b/providers/web/gda-web-pstmt.c
@@ -41,7 +41,7 @@ gda_web_pstmt_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaWebPStmtClass),
                        (GBaseInitFunc) NULL,
@@ -55,10 +55,10 @@ gda_web_pstmt_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_PSTMT, "GdaWebPStmt", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/providers/web/gda-web-recordset.c b/providers/web/gda-web-recordset.c
index abc5768..fada6de 100644
--- a/providers/web/gda-web-recordset.c
+++ b/providers/web/gda-web-recordset.c
@@ -110,7 +110,7 @@ gda_web_recordset_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaWebRecordsetClass),
                        (GBaseInitFunc) NULL,
@@ -123,10 +123,10 @@ gda_web_recordset_get_type (void)
                        (GInstanceInitFunc) gda_web_recordset_init,
                        0
                };
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GDA_TYPE_DATA_SELECT, "GdaWebRecordset", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/providers/web/php/test.php b/providers/web/php/test.php
new file mode 100644
index 0000000..f9b02fd
--- /dev/null
+++ b/providers/web/php/test.php
@@ -0,0 +1,97 @@
+<?php
+
+session_cache_limiter('nocache');
+header('Content-type: text/plain; charset=UTF-8');
+
+include_once "gda-utils.php";
+include_once "gda-exception.php";
+include_once "gda-config.php";
+
+if (! try_include ("MDB2.php", true)) {
+       echo "ERROR: The PEAR MDB2 extension is required\n";
+       exit (1);
+}
+
+if (! extension_loaded ("SimpleXML")) {
+       echo "ERROR: The SimpleXML extension is required\n";
+       exit (1);
+}
+
+function handle_pear_error ($res)
+{
+       if (PEAR::isError($res)) {
+               $cause = "\tStandard Message [".$res->getMessage()."]\n". 
+                       "\tUser Information [".$res->getUserInfo()."]\n".
+                       "\tDebug Information [".$res->getDebugInfo()."]";
+               echo "ERROR: $cause\n";
+       }
+}
+
+$mdb2 = MDB2::connect("mysql://vmalerba:Escobar unix(/tmp/mysql.sock)/sales");
+handle_pear_error ($mdb2);
+$mdb2->loadModule('Reverse', null, true);
+
+$prep = $mdb2->prepare((string) "SHOW VARIABLES WHERE Variable_name = 'lower_case_table_names'",
+                      null, MDB2_PREPARE_RESULT);
+//$prep = $mdb2->prepare((string) "Select * from information_schema.tables",
+//                    null, MDB2_PREPARE_RESULT);
+handle_pear_error ($prep);
+
+$res = $prep->execute (null);
+handle_pear_error ($res);
+
+$reply = new SimpleXMLElement("<reply></reply>");
+$node = $reply->addChild ("gda_array", null);
+$ncols = $res->numCols();
+
+/* compute field type */
+echo "M1\n";
+$tableinfo = $mdb2->reverse->tableInfo ($res, NULL);
+echo "M2\n";
+if (! PEAR::isError ($tableinfo)) {
+       //var_dump($tableinfo);
+       $gtypes = array();
+       $dbtypes = array();
+       for ($i = 0; $i < $ncols; $i++) {
+               $gtypes [$i] = mdb2_type_to_gtype ($tableinfo[$i]['mdb2type']);
+               $dbtypes [$i] = $tableinfo[$i]['type'];
+       }
+}
+
+$colnames = $res->getColumnNames ();
+if (PEAR::isError ($colnames))
+       unset ($colnames);
+for ($i = 0; $i < $ncols; $i++) {
+       $field = $node->addChild ("gda_array_field", null);
+       $field->addAttribute ("id", "FI".$i);
+       if (isset ($colnames)) {
+               foreach ($colnames as $name => $pos) {
+                       if ($pos == $i) {
+                               $field->addAttribute ("name", $name);
+                               break;
+                       }
+               }
+       }
+       if (isset ($gtypes))
+               $field->addAttribute ("gdatype", $gtypes[$i]);
+       else
+               $field->addAttribute ("gdatype", "string");
+       if (isset ($dbtypes) && $dbtypes[$i])
+               $field->addAttribute ("dbtype", $dbtypes[$i]);
+       $field->addAttribute ("nullok", "TRUE");
+}
+               
+$data = $node->addChild ("gda_array_data", null);
+while (($row = $res->fetchRow())) {
+       // MDB2's default fetchmode is MDB2_FETCHMODE_ORDERED
+       $xmlrow = $data->addChild ("gda_array_row", null);
+       for ($i = 0; $i < $ncols; $i++) {
+               $val = $xmlrow->addChild ("gda_value");
+               $val[0] = str_replace ("&", "&amp;", $row[$i]);
+       }
+}
+echo $reply->asXml();
+
+echo "OK.\n";
+
+?>
\ No newline at end of file
diff --git a/samples/BDB/custom-bdb-model.c b/samples/BDB/custom-bdb-model.c
index 86d3df9..481d17b 100644
--- a/samples/BDB/custom-bdb-model.c
+++ b/samples/BDB/custom-bdb-model.c
@@ -67,7 +67,7 @@ custom_data_model_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static GTypeInfo info = {
                        sizeof (CustomDataModelClass),
                        (GBaseInitFunc) NULL,
@@ -79,10 +79,10 @@ custom_data_model_get_type (void)
                        (GInstanceInitFunc) custom_data_model_init
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (PARENT_TYPE, "CustomDataModel", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/tests/data-model-errors.c b/tests/data-model-errors.c
index 6f4f008..fe57c6d 100644
--- a/tests/data-model-errors.c
+++ b/tests/data-model-errors.c
@@ -213,7 +213,7 @@ data_model_errors_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (DataModelErrorsClass),
                        (GBaseInitFunc) NULL,
@@ -232,12 +232,12 @@ data_model_errors_get_type (void)
                         NULL
                 };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (G_TYPE_OBJECT, "DataModelErrors", &info, 0);
                        g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tests/multi-threading/dummy-object.c b/tests/multi-threading/dummy-object.c
index 160c2bc..c32495e 100644
--- a/tests/multi-threading/dummy-object.c
+++ b/tests/multi-threading/dummy-object.c
@@ -46,7 +46,7 @@ dummy_object_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (DummyObjectClass),
                        (GBaseInitFunc) NULL,
@@ -60,10 +60,10 @@ dummy_object_get_type (void)
                        NULL
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "DummyObject", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/tools/browser/auth-dialog.c b/tools/browser/auth-dialog.c
index c1f5986..d15d866 100644
--- a/tools/browser/auth-dialog.c
+++ b/tools/browser/auth-dialog.c
@@ -89,7 +89,7 @@ auth_dialog_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (AuthDialogClass),
                        (GBaseInitFunc) NULL,
@@ -103,10 +103,10 @@ auth_dialog_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GTK_TYPE_DIALOG, "AuthDialog", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/tools/browser/browser-connection.c b/tools/browser/browser-connection.c
index dd81706..b23ac35 100644
--- a/tools/browser/browser-connection.c
+++ b/tools/browser/browser-connection.c
@@ -229,7 +229,7 @@ browser_connection_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (BrowserConnectionClass),
                        (GBaseInitFunc) NULL,
@@ -244,10 +244,10 @@ browser_connection_get_type (void)
                };
 
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "BrowserConnection", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/browser-connections-list.c b/tools/browser/browser-connections-list.c
index f5d3248..33b9292 100644
--- a/tools/browser/browser-connections-list.c
+++ b/tools/browser/browser-connections-list.c
@@ -61,7 +61,7 @@ browser_connections_list_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (BrowserConnectionsListClass),
                        (GBaseInitFunc) NULL,
@@ -75,10 +75,10 @@ browser_connections_list_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GTK_TYPE_WINDOW, "BrowserConnectionsList", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/browser-core.c b/tools/browser/browser-core.c
index 7afa662..c1f4c76 100644
--- a/tools/browser/browser-core.c
+++ b/tools/browser/browser-core.c
@@ -59,7 +59,7 @@ browser_core_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (BrowserCoreClass),
                        (GBaseInitFunc) NULL,
@@ -74,10 +74,10 @@ browser_core_get_type (void)
                };
 
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "BrowserCore", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/browser-variable.c b/tools/browser/browser-variable.c
index 4cd8c38..726258d 100644
--- a/tools/browser/browser-variable.c
+++ b/tools/browser/browser-variable.c
@@ -41,7 +41,7 @@ browser_variable_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (BrowserVariableClass),
                        (GBaseInitFunc) NULL,
@@ -56,10 +56,10 @@ browser_variable_get_type (void)
                };
 
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "BrowserVariable", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/browser-virtual-connection.c b/tools/browser/browser-virtual-connection.c
index 61a1703..e2fbe39 100644
--- a/tools/browser/browser-virtual-connection.c
+++ b/tools/browser/browser-virtual-connection.c
@@ -60,7 +60,7 @@ browser_virtual_connection_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (BrowserVirtualConnectionClass),
                        (GBaseInitFunc) NULL,
@@ -74,10 +74,10 @@ browser_virtual_connection_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (BROWSER_TYPE_CONNECTION, "BrowserVirtualConnection", 
&info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/browser-window.c b/tools/browser/browser-window.c
index 964f083..9219327 100644
--- a/tools/browser/browser-window.c
+++ b/tools/browser/browser-window.c
@@ -121,7 +121,7 @@ browser_window_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (BrowserWindowClass),
                        (GBaseInitFunc) NULL,
@@ -136,10 +136,10 @@ browser_window_get_type (void)
                };
 
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GTK_TYPE_WINDOW, "BrowserWindow", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/common/fk-declare.c b/tools/browser/common/fk-declare.c
index 94b194a..b19ae0f 100644
--- a/tools/browser/common/fk-declare.c
+++ b/tools/browser/common/fk-declare.c
@@ -74,7 +74,7 @@ fk_declare_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (FkDeclareClass),
                        (GBaseInitFunc) NULL,
@@ -88,10 +88,10 @@ fk_declare_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GTK_TYPE_DIALOG, "FkDeclare", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/tools/browser/connection-binding-properties.c b/tools/browser/connection-binding-properties.c
index 34b91b0..a3304f2 100644
--- a/tools/browser/connection-binding-properties.c
+++ b/tools/browser/connection-binding-properties.c
@@ -55,7 +55,7 @@ connection_binding_properties_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (ConnectionBindingPropertiesClass),
                        (GBaseInitFunc) NULL,
@@ -69,10 +69,10 @@ connection_binding_properties_get_type (void)
                        0
                };
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GTK_TYPE_DIALOG, "ConnectionBindingProperties", &info, 
0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/data-manager/data-manager-perspective.c 
b/tools/browser/data-manager/data-manager-perspective.c
index 15c1ed7..5896631 100644
--- a/tools/browser/data-manager/data-manager-perspective.c
+++ b/tools/browser/data-manager/data-manager-perspective.c
@@ -60,7 +60,7 @@ data_manager_perspective_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (DataManagerPerspectiveClass),
                        (GBaseInitFunc) NULL,
@@ -80,12 +80,12 @@ data_manager_perspective_get_type (void)
                         NULL
                 };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (GTK_TYPE_BOX, "DataManagerPerspective", &info, 0);
                        g_type_add_interface_static (type, BROWSER_PERSPECTIVE_TYPE, &perspective_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/data-manager/data-source-editor.c b/tools/browser/data-manager/data-source-editor.c
index 7e4415c..9ee2255 100644
--- a/tools/browser/data-manager/data-source-editor.c
+++ b/tools/browser/data-manager/data-source-editor.c
@@ -55,7 +55,7 @@ data_source_editor_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (DataSourceEditorClass),
                        (GBaseInitFunc) NULL,
@@ -70,10 +70,10 @@ data_source_editor_get_type (void)
                };
 
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GTK_TYPE_BOX, "DataSourceEditor", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/data-manager/data-source-manager.c 
b/tools/browser/data-manager/data-source-manager.c
index eecf0e4..32da12f 100644
--- a/tools/browser/data-manager/data-source-manager.c
+++ b/tools/browser/data-manager/data-source-manager.c
@@ -66,7 +66,7 @@ data_source_manager_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (DataSourceManagerClass),
                        (GBaseInitFunc) NULL,
@@ -81,10 +81,10 @@ data_source_manager_get_type (void)
                };
 
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "DataSourceManager", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/data-manager/data-source.c b/tools/browser/data-manager/data-source.c
index 3bd9fab..c5bc6b9 100644
--- a/tools/browser/data-manager/data-source.c
+++ b/tools/browser/data-manager/data-source.c
@@ -165,7 +165,7 @@ data_source_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (DataSourceClass),
                        (GBaseInitFunc) NULL,
@@ -180,10 +180,10 @@ data_source_get_type (void)
                };
 
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "DataSource", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/dummy-perspective/dummy-perspective.c 
b/tools/browser/dummy-perspective/dummy-perspective.c
index d0f1bf6..17e5489 100644
--- a/tools/browser/dummy-perspective/dummy-perspective.c
+++ b/tools/browser/dummy-perspective/dummy-perspective.c
@@ -44,7 +44,7 @@ dummy_perspective_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (DummyPerspectiveClass),
                        (GBaseInitFunc) NULL,
@@ -64,12 +64,12 @@ dummy_perspective_get_type (void)
                         NULL
                 };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (GTK_TYPE_BOX, "DummyPerspective", &info, 0);
                        g_type_add_interface_static (type, BROWSER_PERSPECTIVE_TYPE, &perspective_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/ldap-browser/ldap-browser-perspective.c 
b/tools/browser/ldap-browser/ldap-browser-perspective.c
index c9b0c67..334605a 100644
--- a/tools/browser/ldap-browser/ldap-browser-perspective.c
+++ b/tools/browser/ldap-browser/ldap-browser-perspective.c
@@ -62,7 +62,7 @@ ldap_browser_perspective_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (LdapBrowserPerspectiveClass),
                        (GBaseInitFunc) NULL,
@@ -82,12 +82,12 @@ ldap_browser_perspective_get_type (void)
                         NULL
                 };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (GTK_TYPE_BOX, "LdapBrowserPerspective", &info, 0);
                        g_type_add_interface_static (type, BROWSER_PERSPECTIVE_TYPE, &perspective_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/ldap-browser/mgr-ldap-classes.c b/tools/browser/ldap-browser/mgr-ldap-classes.c
index d4f886e..6a2ea8b 100644
--- a/tools/browser/ldap-browser/mgr-ldap-classes.c
+++ b/tools/browser/ldap-browser/mgr-ldap-classes.c
@@ -93,7 +93,7 @@ mgr_ldap_classes_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (MgrLdapClassesClass),
                         (GBaseInitFunc) NULL,
@@ -107,10 +107,10 @@ mgr_ldap_classes_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "_MgrLdapClasses", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/tools/browser/ldap-browser/mgr-ldap-entries.c b/tools/browser/ldap-browser/mgr-ldap-entries.c
index d1b98bb..a85bb7c 100644
--- a/tools/browser/ldap-browser/mgr-ldap-entries.c
+++ b/tools/browser/ldap-browser/mgr-ldap-entries.c
@@ -93,7 +93,7 @@ mgr_ldap_entries_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (MgrLdapEntriesClass),
                         (GBaseInitFunc) NULL,
@@ -107,10 +107,10 @@ mgr_ldap_entries_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "MgrLdapEntries", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/tools/browser/login-dialog.c b/tools/browser/login-dialog.c
index 70b55cf..a8db035 100644
--- a/tools/browser/login-dialog.c
+++ b/tools/browser/login-dialog.c
@@ -59,7 +59,7 @@ login_dialog_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (LoginDialogClass),
                        (GBaseInitFunc) NULL,
@@ -73,10 +73,10 @@ login_dialog_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (GTK_TYPE_DIALOG, "LoginDialog", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/tools/browser/mgr-favorites.c b/tools/browser/mgr-favorites.c
index 0f16267..2799773 100644
--- a/tools/browser/mgr-favorites.c
+++ b/tools/browser/mgr-favorites.c
@@ -140,7 +140,7 @@ mgr_favorites_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (MgrFavoritesClass),
                         (GBaseInitFunc) NULL,
@@ -154,10 +154,10 @@ mgr_favorites_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "MgrFavorites", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/tools/browser/query-exec/query-exec-perspective.c 
b/tools/browser/query-exec/query-exec-perspective.c
index 350616b..4e4305c 100644
--- a/tools/browser/query-exec/query-exec-perspective.c
+++ b/tools/browser/query-exec/query-exec-perspective.c
@@ -68,7 +68,7 @@ query_exec_perspective_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (QueryExecPerspectiveClass),
                        (GBaseInitFunc) NULL,
@@ -88,12 +88,12 @@ query_exec_perspective_get_type (void)
                         NULL
                 };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (GTK_TYPE_BOX, "QueryExecPerspective", &info, 0);
                        g_type_add_interface_static (type, BROWSER_PERSPECTIVE_TYPE, &perspective_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/browser/schema-browser/mgr-columns.c b/tools/browser/schema-browser/mgr-columns.c
index a3f8f0c..74e9ce6 100644
--- a/tools/browser/schema-browser/mgr-columns.c
+++ b/tools/browser/schema-browser/mgr-columns.c
@@ -123,7 +123,7 @@ mgr_columns_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (MgrColumnsClass),
                         (GBaseInitFunc) NULL,
@@ -137,10 +137,10 @@ mgr_columns_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "MgrColumns", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/tools/browser/schema-browser/schema-browser-perspective.c 
b/tools/browser/schema-browser/schema-browser-perspective.c
index 92f8beb..68c7a5f 100644
--- a/tools/browser/schema-browser/schema-browser-perspective.c
+++ b/tools/browser/schema-browser/schema-browser-perspective.c
@@ -64,7 +64,7 @@ schema_browser_perspective_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (SchemaBrowserPerspectiveClass),
                        (GBaseInitFunc) NULL,
@@ -84,12 +84,12 @@ schema_browser_perspective_get_type (void)
                         NULL
                 };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0) {
                        type = g_type_register_static (GTK_TYPE_BOX, "SchemaBrowserPerspective", &info, 0);
                        g_type_add_interface_static (type, BROWSER_PERSPECTIVE_TYPE, &perspective_info);
                }
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/gda-threader.c b/tools/gda-threader.c
index 207d030..2f3716e 100644
--- a/tools/gda-threader.c
+++ b/tools/gda-threader.c
@@ -70,7 +70,7 @@ gda_threader_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (GdaThreaderClass),
                        (GBaseInitFunc) NULL,
@@ -84,10 +84,10 @@ gda_threader_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "GdaThreader", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;
diff --git a/tools/gda-tree-mgr-xml.c b/tools/gda-tree-mgr-xml.c
index b5795cf..7572572 100644
--- a/tools/gda-tree-mgr-xml.c
+++ b/tools/gda-tree-mgr-xml.c
@@ -90,7 +90,7 @@ gda_tree_mgr_xml_get_type (void)
         static GType type = 0;
 
         if (G_UNLIKELY (type == 0)) {
-                static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+                static GMutex registering;
                 static const GTypeInfo info = {
                         sizeof (GdaTreeMgrXmlClass),
                         (GBaseInitFunc) NULL,
@@ -104,10 +104,10 @@ gda_tree_mgr_xml_get_type (void)
                        0
                 };
 
-                g_static_mutex_lock (&registering);
+                g_mutex_lock (&registering);
                 if (type == 0)
                         type = g_type_register_static (GDA_TYPE_TREE_MANAGER, "GdaTreeMgrXml", &info, 0);
-                g_static_mutex_unlock (&registering);
+                g_mutex_unlock (&registering);
         }
         return type;
 }
diff --git a/tools/tools-favorites.c b/tools/tools-favorites.c
index 404e0e9..92b2379 100644
--- a/tools/tools-favorites.c
+++ b/tools/tools-favorites.c
@@ -56,7 +56,7 @@ gda_tools_favorites_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (ToolsFavoritesClass),
                        (GBaseInitFunc) NULL,
@@ -71,10 +71,10 @@ gda_tools_favorites_get_type (void)
                };
 
 
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "ToolsFavorites", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
        return type;
 }
diff --git a/tools/web-server.c b/tools/web-server.c
index 1e01921..354749d 100644
--- a/tools/web-server.c
+++ b/tools/web-server.c
@@ -118,7 +118,7 @@ web_server_get_type (void)
        static GType type = 0;
 
        if (G_UNLIKELY (type == 0)) {
-               static GStaticMutex registering = G_STATIC_MUTEX_INIT;
+               static GMutex registering;
                static const GTypeInfo info = {
                        sizeof (WebServerClass),
                        (GBaseInitFunc) NULL,
@@ -132,10 +132,10 @@ web_server_get_type (void)
                        0
                };
                
-               g_static_mutex_lock (&registering);
+               g_mutex_lock (&registering);
                if (type == 0)
                        type = g_type_register_static (G_TYPE_OBJECT, "WebServer", &info, 0);
-               g_static_mutex_unlock (&registering);
+               g_mutex_unlock (&registering);
        }
 
        return type;


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