[libgda/LIBGDA_4.2] Fixes to build using GI 1.36 at least
- From: Daniel Espinosa Ortiz <despinosa src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [libgda/LIBGDA_4.2] Fixes to build using GI 1.36 at least
- Date: Wed, 31 Jul 2013 20:50:10 +0000 (UTC)
commit 9483e71285f98be8e72466f15ca46a95b704199c
Author: Daniel Espinosa <esodan gmail com>
Date: Wed Jul 31 15:31:37 2013 -0500
Fixes to build using GI 1.36 at least
libgda/Makefile.am | 15 +-
libgda/gda-data-model-dir.c | 2 +-
libgda/gda-data-model-import.c | 2 +-
libgda/gda-data-model.c | 6 +-
libgda/gda-meta-store.c | 2 +-
libgda/gda-server-provider.h | 322 ++++++++++++++++++-------
libgda/gda-sql-builder.h | 2 +-
libgda/providers-support/gda-pstmt.h | 4 +-
libgda/sql-parser/gda-sql-parser.h | 16 +-
libgda/sql-parser/gda-statement-struct-decl.h | 6 +-
10 files changed, 257 insertions(+), 120 deletions(-)
---
diff --git a/libgda/Makefile.am b/libgda/Makefile.am
index 027be4f..c0f0d3f 100644
--- a/libgda/Makefile.am
+++ b/libgda/Makefile.am
@@ -123,13 +123,9 @@ gda_sources= \
$(GDA_LDAP_S) \
gda-data-model.c \
gda-data-model-dir.c \
- gda-data-model-dsn-list.c \
- gda-data-model-dsn-list.h \
gda-data-model-import.c \
gda-data-model-iter.c \
gda-data-access-wrapper.c \
- gda-data-meta-wrapper.c \
- gda-data-meta-wrapper.h \
gda-data-proxy.c \
gda-data-select.c \
gda-easy.c \
@@ -146,7 +142,6 @@ gda_sources= \
gda-row.c \
gda-set.c \
gda-server-operation.c \
- gda-server-operation-private.h \
gda-server-provider.c \
gda-server-provider-extra.c \
gda-statement.c \
@@ -179,8 +174,13 @@ libgda_sources = \
gda-types.c \
gda-types.h \
gda-marshal.c \
+ gda-data-meta-wrapper.c \
+ gda-data-meta-wrapper.h \
+ gda-data-model-dsn-list.c \
+ gda-data-model-dsn-list.h \
gda-meta-store-extra.h \
gda-meta-struct-private.h \
+ gda-server-operation-private.h \
gda-statement-priv.h \
global.h \
md5.h \
@@ -334,9 +334,8 @@ handlers = \
handlers/gda-handler-time.c \
handlers/gda-handler-type.c
-introspection_sources = $(gda_sources) \
- gda-types.c \
- gda-types.h \
+introspection_sources = \
+ $(gda_sources) \
$(gda_headers) \
$(psupport) \
$(threadwrapper) \
diff --git a/libgda/gda-data-model-dir.c b/libgda/gda-data-model-dir.c
index 7f22798..4b75f1b 100644
--- a/libgda/gda-data-model-dir.c
+++ b/libgda/gda-data-model-dir.c
@@ -688,7 +688,7 @@ gda_data_model_dir_new (const gchar *basedir)
*
* Get the list of errors which have occurred while using @model
*
- * Returns: (transfer none) (element-type GObject.Error) : a read-only list of #GError pointers, or %NULL if
no error has occurred
+ * Returns: (transfer none) (element-type GLib.Error) : a read-only list of #GError pointers, or %NULL if no
error has occurred
*/
const GSList *
gda_data_model_dir_get_errors (GdaDataModelDir *model)
diff --git a/libgda/gda-data-model-import.c b/libgda/gda-data-model-import.c
index 84e1c32..df1c2d6 100644
--- a/libgda/gda-data-model-import.c
+++ b/libgda/gda-data-model-import.c
@@ -1693,7 +1693,7 @@ add_error (GdaDataModelImport *model, const gchar *err)
* Get the list of errors which @model has to report. The returned list is a list of
* #GError structures, and must not be modified
*
- * Returns: (transfer none) (element-type GObject.Error): the list of errors (which must not be modified),
or %NULL
+ * Returns: (transfer none) (element-type GLib.Error): the list of errors (which must not be modified), or
%NULL
*/
GSList *
gda_data_model_import_get_errors (GdaDataModelImport *model)
diff --git a/libgda/gda-data-model.c b/libgda/gda-data-model.c
index d571035..c7e8413 100644
--- a/libgda/gda-data-model.c
+++ b/libgda/gda-data-model.c
@@ -787,7 +787,7 @@ gda_data_model_set_value_at (GdaDataModel *model, gint col, gint row, const GVal
* gda_data_model_set_values:
* @model: a #GdaDataModel object.
* @row: row number.
- * @values: (element-type GLib.Value) (transfer none) (allow-none): a list of #GValue (or %NULL), one for at
most the number of columns of @model
+ * @values: (element-type GObject.Value) (transfer none) (allow-none): a list of #GValue (or %NULL), one for
at most the number of columns of @model
* @error: a place to store errors, or %NULL
*
* In a similar way to gda_data_model_set_value_at(), this method modifies a data model's contents
@@ -886,7 +886,7 @@ gda_data_model_create_iter (GdaDataModel *model)
/**
* gda_data_model_append_values:
* @model: a #GdaDataModel object.
- * @values: (element-type GLib.Value) (allow-none): #GList of #GValue* representing the row to add. The
+ * @values: (element-type GObject.Value) (allow-none): #GList of #GValue* representing the row to add. The
* length must match model's column count. These #GValue
* are value-copied (the user is still responsible for freeing them).
* @error: a place to store errors, or %NULL
@@ -992,7 +992,7 @@ gda_data_model_remove_row (GdaDataModel *model, gint row, GError **error)
/**
* gda_data_model_get_row_from_values:
* @model: a #GdaDataModel object.
- * @values: (element-type GLib.Value): a list of #GValue values (no %NULL is allowed)
+ * @values: (element-type GObject.Value): a list of #GValue values (no %NULL is allowed)
* @cols_index: (array): an array of #gint containing the column number to match each value of @values
*
* Returns the first row where all the values in @values at the columns identified at
diff --git a/libgda/gda-meta-store.c b/libgda/gda-meta-store.c
index e815765..d0ae89d 100644
--- a/libgda/gda-meta-store.c
+++ b/libgda/gda-meta-store.c
@@ -395,7 +395,7 @@ gda_meta_store_class_init (GdaMetaStoreClass *klass)
G_STRUCT_OFFSET (GdaMetaStoreClass, suggest_update),
suggest_update_accumulator, NULL,
_gda_marshal_ERROR__METACONTEXT, GDA_TYPE_ERROR,
- 1, GDA_TYPE_META_CONTEXT);
+ 1, G_TYPE_POINTER);
/**
* GdaMetaStore::meta-changed
* @store: the #GdaMetaStore instance that emitted the signal
diff --git a/libgda/gda-server-provider.h b/libgda/gda-server-provider.h
index 7322c08..0da8654 100644
--- a/libgda/gda-server-provider.h
+++ b/libgda/gda-server-provider.h
@@ -46,6 +46,9 @@ G_BEGIN_DECLS
extern GQuark gda_server_provider_error_quark (void);
#define GDA_SERVER_PROVIDER_ERROR gda_server_provider_error_quark ()
+/**
+ * GdaServerProviderError:
+ */
typedef enum
{
GDA_SERVER_PROVIDER_METHOD_NON_IMPLEMENTED_ERROR,
@@ -64,134 +67,226 @@ typedef enum
GDA_SERVER_PROVIDER_FILE_NOT_FOUND_ERROR
} GdaServerProviderError;
+/**
+ * GdaServerProvider:
+ */
struct _GdaServerProvider {
GObject object;
GdaServerProviderPrivate *priv;
};
+
+/**
+ * GdaServerProviderMeta: (skip)
+ * @_info:
+ * @_btypes:
+ * @_udt:
+ * @udt:
+ * @_udt_cols:
+ * @udt_cols:
+ * @_enums:
+ * @enums:
+ * @_domains:
+ * @domains:
+ * @_constraints_dom:
+ * @constraints_dom:
+ * @_el_types:
+ * @el_types:
+ * @_collations:
+ * @collations:
+ * @_character_sets:
+ * @character_sets:
+ * @_schemata:
+ * @schemata:
+ * @_tables_views:
+ * @tables_views:
+ * @_columns:
+ * @columns:
+ * @_view_cols:
+ * @view_cols:
+ * @_constraints_tab:
+ * @constraints_tab:
+ * @_constraints_ref:
+ * @constraints_ref:
+ * @_key_columns:
+ * @key_columns:
+ * @_check_columns:
+ * @check_columns:
+ * @_triggers:
+ * @triggers:
+ * @_routines:
+ * @routines:
+ * @_routine_col:
+ * @routine_col:
+ * @_routine_par:
+ * @routine_par:
+ * @_indexes_tab:
+ * @indexes_tab:
+ * @_index_cols:
+ * @index_cols:
+ *
+ * These methods must be implemented by providers to update a connection's associated metadata (in a
+ * #GdaMetaStore object), see the <link linkend="prov-metadata">Virtual methods for providers/Methods -
metadata</link>
+ * for more information.
+ */
typedef struct {
/* _information_schema_catalog_name */
- gboolean (*_info) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
+ gboolean (*_info) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
/* _builtin_data_types */
- gboolean (*_btypes) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
+ gboolean (*_btypes) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
/* _udt */
- gboolean (*_udt) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*udt) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *udt_catalog, const GValue *udt_schema);
+ gboolean (*_udt) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*udt) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *udt_catalog, const GValue *udt_schema);
/* _udt_columns */
- gboolean (*_udt_cols) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*udt_cols) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *udt_catalog, const GValue *udt_schema, const GValue
*udt_name);
+ gboolean (*_udt_cols) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*udt_cols) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *udt_catalog, const GValue *udt_schema,
+ const GValue *udt_name);
/* _enums */
- gboolean (*_enums) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*enums) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *udt_catalog, const GValue *udt_schema, const GValue
*udt_name);
+ gboolean (*_enums) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*enums) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *udt_catalog, const GValue *udt_schema,
+ const GValue *udt_name);
/* _domains */
- gboolean (*_domains) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*domains) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *domain_catalog, const GValue *domain_schema);
+ gboolean (*_domains) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*domains) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *domain_catalog, const GValue *domain_schema);
/* _domain_constraints */
- gboolean (*_constraints_dom) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*constraints_dom) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *domain_catalog, const GValue *domain_schema, const GValue
*domain_name);
+ gboolean (*_constraints_dom) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*constraints_dom) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *domain_catalog, const GValue *domain_schema, const GValue *domain_name);
/* _element_types */
- gboolean (*_el_types) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*el_types) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *specific_name);
+ gboolean (*_el_types) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*el_types) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *specific_name);
/* _collations */
- gboolean (*_collations) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext
*, GError **);
- gboolean (*collations) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext
*, GError **,
- const GValue *collation_catalog, const GValue *collation_schema,
- const GValue *collation_name_n);
+ gboolean (*_collations) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*collations) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *collation_catalog, const GValue
*collation_schema,
+ const GValue *collation_name_n);
/* _character_sets */
- gboolean (*_character_sets) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*character_sets) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *chset_catalog, const GValue *chset_schema, const GValue
*chset_name_n);
+ gboolean (*_character_sets) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*character_sets) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *chset_catalog, const GValue *chset_schema,
+ const GValue *chset_name_n);
/* _schemata */
- gboolean (*_schemata) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*schemata) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *catalog_name, const GValue *schema_name_n);
+ gboolean (*_schemata) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*schemata) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *catalog_name, const GValue
*schema_name_n);
/* _tables or _views */
- gboolean (*_tables_views) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*tables_views) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *table_catalog, const GValue *table_schema, const GValue
*table_name_n);
+ gboolean (*_tables_views) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*tables_views) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *table_catalog, const GValue *table_schema,
+ const GValue *table_name_n);
/* _columns */
- gboolean (*_columns) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*columns) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *table_catalog, const GValue *table_schema, const GValue
*table_name);
+ gboolean (*_columns) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*columns) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *table_catalog, const GValue *table_schema,
+ const GValue *table_name);
/* _view_column_usage */
- gboolean (*_view_cols) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*view_cols) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *view_catalog, const GValue *view_schema, const GValue
*view_name);
+ gboolean (*_view_cols) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*view_cols) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *view_catalog, const GValue *view_schema,
+ const GValue *view_name);
/* _table_constraints */
- gboolean (*_constraints_tab) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*constraints_tab) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *table_catalog, const GValue *table_schema, const GValue
*table_name,
- const GValue *constraint_name_n);
+ gboolean (*_constraints_tab) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*constraints_tab) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *table_catalog, const GValue *table_schema,
+ const GValue *table_name, const GValue *constraint_name_n);
/* _referential_constraints */
- gboolean (*_constraints_ref) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*constraints_ref) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *table_catalog, const GValue *table_schema, const GValue
*table_name,
- const GValue *constraint_name);
+ gboolean (*_constraints_ref) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*constraints_ref) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *table_catalog, const GValue *table_schema,
+ const GValue *table_name, const GValue *constraint_name);
/* _key_column_usage */
- gboolean (*_key_columns) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*key_columns) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *table_catalog, const GValue *table_schema, const GValue
*table_name,
- const GValue *constraint_name);
+ gboolean (*_key_columns) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*key_columns) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *table_catalog, const GValue *table_schema,
+ const GValue *table_name, const GValue *constraint_name);
/* _check_column_usage */
- gboolean (*_check_columns) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*check_columns) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *table_catalog, const GValue *table_schema, const GValue
*table_name,
- const GValue *constraint_name);
+ gboolean (*_check_columns) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*check_columns) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *table_catalog, const GValue *table_schema,
+ const GValue *table_name, const GValue *constraint_name);
/* _triggers */
- gboolean (*_triggers) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*triggers) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *table_catalog, const GValue *table_schema, const GValue
*table_name);
+ gboolean (*_triggers) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*triggers) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *table_catalog, const GValue *table_schema,
+ const GValue *table_name);
/* _routines */
- gboolean (*_routines) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*routines) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *routine_catalog, const GValue *routine_schema,
- const GValue *routine_name_n);
+ gboolean (*_routines) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*routines) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *routine_catalog, const GValue
*routine_schema,
+ const GValue *routine_name_n);
/* _routine_columns */
- gboolean (*_routine_col) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*routine_col) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *rout_catalog, const GValue *rout_schema, const GValue
*rout_name);
+ gboolean (*_routine_col) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*routine_col) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *rout_catalog, const GValue *rout_schema,
+ const GValue *rout_name);
/* _parameters */
- gboolean (*_routine_par) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*routine_par) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *rout_catalog, const GValue *rout_schema, const GValue
*rout_name);
+ gboolean (*_routine_par) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*routine_par) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *rout_catalog, const GValue *rout_schema,
+ const GValue *rout_name);
/* _table_indexes */
- gboolean (*_indexes_tab) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*indexes_tab) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *table_catalog, const GValue *table_schema, const GValue
*table_name,
- const GValue *index_name_n);
+ gboolean (*_indexes_tab) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*indexes_tab) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *table_catalog, const GValue *table_schema,
+ const GValue *table_name, const GValue *index_name_n);
/* _index_column_usage */
- gboolean (*_index_cols) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **);
- gboolean (*index_cols) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *,
GError **,
- const GValue *table_catalog, const GValue *table_schema, const GValue
*table_name, const GValue *index_name);
+ gboolean (*_index_cols) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error);
+ gboolean (*index_cols) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *store,
GdaMetaContext *cxt,
+ GError **error, const GValue *table_catalog, const GValue *table_schema,
+ const GValue *table_name, const GValue *index_name);
+ /*< private >*/
/* Padding for future expansion */
void (*_gda_reserved5) (void);
void (*_gda_reserved6) (void);
@@ -209,23 +304,51 @@ typedef struct {
} GdaServerProviderMeta;
/* distributed transaction support */
+/**
+ * GdaServerProviderXa: (skip)
+ */
typedef struct {
- gboolean (*xa_start) (GdaServerProvider *, GdaConnection *, const GdaXaTransactionId *, GError **);
+ gboolean (*xa_start) (GdaServerProvider *prov, GdaConnection *cnc, const GdaXaTransactionId *trid,
GError **error);
- gboolean (*xa_end) (GdaServerProvider *, GdaConnection *, const GdaXaTransactionId *, GError **);
- gboolean (*xa_prepare) (GdaServerProvider *, GdaConnection *, const GdaXaTransactionId *, GError **);
+ gboolean (*xa_end) (GdaServerProvider *prov, GdaConnection *cnc, const GdaXaTransactionId *trid,
GError **error);
+ gboolean (*xa_prepare) (GdaServerProvider *prov, GdaConnection *cnc, const GdaXaTransactionId *trid,
GError **error);
- gboolean (*xa_commit) (GdaServerProvider *, GdaConnection *, const GdaXaTransactionId *, GError **);
- gboolean (*xa_rollback) (GdaServerProvider *, GdaConnection *, const GdaXaTransactionId *, GError **);
+ gboolean (*xa_commit) (GdaServerProvider *prov, GdaConnection *cnc, const GdaXaTransactionId *trid,
GError **error);
+ gboolean (*xa_rollback) (GdaServerProvider *prov, GdaConnection *cnc, const GdaXaTransactionId *trid,
GError **error);
- GList *(*xa_recover) (GdaServerProvider *, GdaConnection *, GError **);
+ GList *(*xa_recover) (GdaServerProvider *prov, GdaConnection *cnc, GError **error);
} GdaServerProviderXa;
+/**
+ * GdaServerProviderAsyncCallback:
+ * @provider:
+ * @cnc:
+ * @task_id:
+ * @result_status:
+ * @error:
+ * @data:
+ *
+ * Function to be called by Libgda when the associated asynchronous method invoked finishes.
+ */
typedef void (*GdaServerProviderAsyncCallback) (GdaServerProvider *provider, GdaConnection *cnc, guint
task_id,
gboolean result_status, const GError *error, gpointer data);
+/**
+ * GdaServerProviderExecCallback:
+ * @provider:
+ * @cnc:
+ * @task_id:
+ * @result_obj:
+ * @error:
+ * @data:
+ *
+ * Function to be called by Libgda when the associated asynchronous method invoked finishes
+ */
typedef void (*GdaServerProviderExecCallback) (GdaServerProvider *provider, GdaConnection *cnc, guint
task_id,
GObject *result_obj, const GError *error, gpointer data);
+/**
+ * GDA_SERVER_PROVIDER_UNDEFINED_LIMITING_THREAD: (skip)
+ */
#define GDA_SERVER_PROVIDER_UNDEFINED_LIMITING_THREAD ((gpointer)0x1)
struct _GdaServerProviderClass {
GObjectClass parent_class;
@@ -281,14 +404,15 @@ struct _GdaServerProviderClass {
/* GdaStatement */
GdaSqlParser *(* create_parser) (GdaServerProvider *provider, GdaConnection *cnc);
-
- /**
- * statement_to_sql:
- * @cnc: a #GdaConnection object
- * @stmt: a #GdaStatement object
- * @params: (allow-none): a #GdaSet object (which can be obtained using
gda_statement_get_parameters()), or %NULL
- * @flags: SQL rendering flags, as #GdaStatementSqlFlag OR'ed values
- * @params_used: (allow-none) (element-type Gda.Holder) (out) (transfer container): a place to store
the list of individual #GdaHolder objects within @params which have been used
+
+/**
+ * statement_to_sql:
+ * @provider: a #GdaServerProvider object
+ * @cnc: a #GdaConnection object
+ * @stmt: a #GdaStatement object
+ * @params: (allow-none): a #GdaSet object (which can be obtained using gda_statement_get_parameters()), or
%NULL
+ * @flags: SQL rendering flags, as #GdaStatementSqlFlag OR'ed values
+ * @params_used: (allow-none) (element-type Gda.Holder) (out) (transfer container): a place to store the
list of individual #GdaHolder objects within @params which have been used
* @error: a place to store errors, or %NULL
*
* Renders @stmt as an SQL statement, adapted to the SQL dialect used by @cnc
@@ -308,7 +432,8 @@ struct _GdaServerProviderClass {
gpointer cb_data, GError **error);
/* Misc */
- gboolean (* is_busy) (GdaServerProvider *provider, GdaConnection *cnc,
GError **error);
+ gboolean (* is_busy) (GdaServerProvider *provider, GdaConnection *cnc,
+ GError **error);
gboolean (* cancel) (GdaServerProvider *provider, GdaConnection *cnc,
guint task_id, GError **error);
GdaConnection *(* create_connection) (GdaServerProvider *provider);
@@ -321,8 +446,7 @@ struct _GdaServerProviderClass {
/* SQL identifiers quoting */
gchar *(* identifier_quote) (GdaServerProvider *provider, GdaConnection *cnc,
- const gchar *id,
- gboolean for_meta_store, gboolean force_quotes);
+ const gchar *id, gboolean for_meta_store, gboolean
force_quotes);
/* Async. handling */
gboolean (*handle_async) (GdaServerProvider *provider, GdaConnection *cnc,
GError **error);
@@ -336,6 +460,20 @@ struct _GdaServerProviderClass {
void (*_gda_reserved6) (void);
};
+/**
+ * SECTION:gda-server-provider
+ * @short_description: Base class for all the DBMS providers
+ * @title: GdaServerProvider
+ * @stability: Stable
+ * @see_also: #GdaConnection
+ *
+ * The #GdaServerProvider class is a virtual class which all the DBMS providers
+ * must inherit, and implement its virtual methods.
+ *
+ * See the <link linkend="libgda-provider-class">Virtual methods for providers</link> section for more
information
+ * about how to implement the virtual methods.
+ */
+
GType gda_server_provider_get_type (void) G_GNUC_CONST;
/* provider information */
diff --git a/libgda/gda-sql-builder.h b/libgda/gda-sql-builder.h
index 5d342a7..ad4ae2b 100644
--- a/libgda/gda-sql-builder.h
+++ b/libgda/gda-sql-builder.h
@@ -75,7 +75,7 @@ GdaStatement *gda_sql_builder_get_statement (GdaSqlBuilder *builder, GError
GdaSqlStatement *gda_sql_builder_get_sql_statement (GdaSqlBuilder *builder);
/* Expression API */
-GdaSqlBuilderId gda_sql_builder_add_id (GdaSqlBuilder *builder, const gchar *string);
+GdaSqlBuilderId gda_sql_builder_add_id (GdaSqlBuilder *builder, const gchar *str);
GdaSqlBuilderId gda_sql_builder_add_field_id (GdaSqlBuilder *builder, const gchar *field_name, const gchar
*table_name);
GdaSqlBuilderId gda_sql_builder_add_expr (GdaSqlBuilder *builder, GdaDataHandler *dh, GType type, ...);
GdaSqlBuilderId gda_sql_builder_add_expr_value (GdaSqlBuilder *builder, GdaDataHandler *dh, const GValue
*value);
diff --git a/libgda/providers-support/gda-pstmt.h b/libgda/providers-support/gda-pstmt.h
index 3caedeb..3763810 100644
--- a/libgda/providers-support/gda-pstmt.h
+++ b/libgda/providers-support/gda-pstmt.h
@@ -38,10 +38,10 @@ typedef struct _GdaPStmtClass GdaPStmtClass;
/**
* GdaPStmt:
* @sql: actual SQL code used for this prepared statement, mem freed by GdaPStmt
- * @param_ids: (element-type string): list of parameters' IDs (as gchar *), mem freed by GdaPStmt
+ * @param_ids: (element-type utf8): list of parameters' IDs (as gchar *), mem freed by GdaPStmt
* @ncols: number of types in array
* @types: (array length=ncols) (element-type GLib.Type): array of ncols types
- * @tmpl_columns: (element-type Gda.Colum): list of #GdaColumn objects which data models created from this
prep. statement can copy
+ * @tmpl_columns: (element-type Gda.Column): list of #GdaColumn objects which data models created from this
prep. statement can copy
*
*/
struct _GdaPStmt {
diff --git a/libgda/sql-parser/gda-sql-parser.h b/libgda/sql-parser/gda-sql-parser.h
index f4da417..d567ceb 100644
--- a/libgda/sql-parser/gda-sql-parser.h
+++ b/libgda/sql-parser/gda-sql-parser.h
@@ -82,16 +82,16 @@ struct _GdaSqlParserClass
GObjectClass parent_class;
/* virtual methods and data for sub classed parsers */
- void *(*delim_alloc) (void*(*)(size_t));
- void (*delim_free) (void*, void(*)(void*));
- void (*delim_trace) (void*, char *);
- void (*delim_parse) (void*, int, GValue *, GdaSqlParserIface *);
+ void *(*delim_alloc) (void *(*f)(size_t s));
+ void (*delim_free) (void *d, void (*f) (void*param));
+ void (*delim_trace) (void *d, char *s);
+ void (*delim_parse) (void *d, int i, GValue *v, GdaSqlParserIface *iface);
gint *delim_tokens_trans;
- void *(*parser_alloc) (void*(*)(size_t));
- void (*parser_free) (void*, void(*)(void*));
- void (*parser_trace) (void*, char *);
- void (*parser_parse) (void*, int, GValue *, GdaSqlParserIface *);
+ void *(*parser_alloc) (void *(*f)(size_t s));
+ void (*parser_free) (void *p, void (*f) (void *param));
+ void (*parser_trace) (void *p, char *s);
+ void (*parser_parse) (void *p, int i, GValue *v, GdaSqlParserIface *iface);
gint *parser_tokens_trans;
/* Padding for future expansion */
diff --git a/libgda/sql-parser/gda-statement-struct-decl.h b/libgda/sql-parser/gda-statement-struct-decl.h
index 73b7920..bf44c45 100644
--- a/libgda/sql-parser/gda-statement-struct-decl.h
+++ b/libgda/sql-parser/gda-statement-struct-decl.h
@@ -250,9 +250,9 @@ typedef struct {
GdaSqlStatementType type;
gchar *name;
gpointer (*construct) (void);
- void (*free) (gpointer);
- gpointer (*copy) (gpointer);
- gchar *(*serialize) (gpointer);
+ void (*free) (gpointer stm);
+ gpointer (*copy) (gpointer stm);
+ gchar *(*serialize) (gpointer stm);
/* augmenting information precision using a dictionary */
GdaSqlForeachFunc check_structure_func;
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
