gda-config.h   gda-config.h 
/* /*
* Copyright (C) 2000 Reinhard Müller <reinhard@src.gnome.org> * Copyright (C) 2000 Reinhard Müller <reinhard@src.gnome.org>
* Copyright (C) 2000 - 2005 Rodrigo Moya <rodrigo@gnome-db.org> * Copyright (C) 2000 - 2005 Rodrigo Moya <rodrigo@gnome-db.org>
* Copyright (C) 2001 - 2011 Vivien Malerba <malerba@gnome-db.org> * Copyright (C) 2001 - 2011 Vivien Malerba <malerba@gnome-db.org>
* Copyright (C) 2002 Gonzalo Paniagua Javier <gonzalo@gnome-db.org> * Copyright (C) 2002 Gonzalo Paniagua Javier <gonzalo@gnome-db.org>
* Copyright (C) 2003 Laurent Sansonetti <laurent@datarescue.be> * Copyright (C) 2003 Laurent Sansonetti <laurent@datarescue.be>
* Copyright (C) 2003 - 2007 Murray Cumming <murrayc@murrayc.com> * Copyright (C) 2003 - 2007 Murray Cumming <murrayc@murrayc.com>
* Copyright (C) 2005 Andrew Hill <andru@src.gnome.org> * Copyright (C) 2005 Andrew Hill <andru@src.gnome.org>
* Copyright (C) 2013 Daniel Espinosa <despinosa@src.gnome.org>
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details. * Lesser General Public License for more details.
skipping to change at line 82 skipping to change at line 83
gboolean is_system; gboolean is_system;
/*< private >*/ /*< private >*/
/* Padding for future expansion */ /* Padding for future expansion */
gpointer _gda_reserved1; gpointer _gda_reserved1;
gpointer _gda_reserved2; gpointer _gda_reserved2;
gpointer _gda_reserved3; gpointer _gda_reserved3;
gpointer _gda_reserved4; gpointer _gda_reserved4;
}; };
#define GDA_TYPE_DSN_INFO (gda_dsn_info_get_type ())
GType gda_dsn_info_get_type (void) G_GNUC_CONST;
GdaDsnInfo* gda_dsn_info_new (void);
GdaDsnInfo* gda_dsn_info_copy (GdaDsnInfo *source);
void gda_dsn_info_free (GdaDsnInfo *dsn);
/** /**
* GdaProviderInfo: * GdaProviderInfo:
* @id: the unique identifier of the database provider * @id: the unique identifier of the database provider
* @location: the complete path to the shared library implementing the data base provider * @location: the complete path to the shared library implementing the data base provider
* @description: provider's description * @description: provider's description
* @dsn_params: a #GdaSet containing all the parameters which can/must be s pecified when opening a connection or defining a named data source (DSN) * @dsn_params: a #GdaSet containing all the parameters which can/must be s pecified when opening a connection or defining a named data source (DSN)
* @auth_params: a #GdaSet containing all the authentication parameters * @auth_params: a #GdaSet containing all the authentication parameters
* *
* This structure holds the information associated to a database provider a s discovered by Libgda. * This structure holds the information associated to a database provider a s discovered by Libgda.
*/ */
 End of changes. 2 change blocks. 
0 lines changed or deleted 8 lines changed or added


 gda-connection.h   gda-connection.h 
skipping to change at line 300 skipping to change at line 300
GdaServerProvider *gda_connection_get_provider (GdaConnection *cn c); GdaServerProvider *gda_connection_get_provider (GdaConnection *cn c);
const gchar *gda_connection_get_provider_name (GdaConnection *cn c); const gchar *gda_connection_get_provider_name (GdaConnection *cn c);
GdaServerOperation *gda_connection_create_operation (GdaConnection *cn c, GdaServerOperationType type, GdaServerOperation *gda_connection_create_operation (GdaConnection *cn c, GdaServerOperationType type,
GdaSet *options, GError **error); GdaSet *options, GError **error);
gboolean gda_connection_perform_operation (GdaConnection *cn c, GdaServerOperation *op, GError **error); gboolean gda_connection_perform_operation (GdaConnection *cn c, GdaServerOperation *op, GError **error);
const gchar *gda_connection_get_dsn (GdaConnection *cn c); const gchar *gda_connection_get_dsn (GdaConnection *cn c);
const gchar *gda_connection_get_cnc_string (GdaConnection *cn c); const gchar *gda_connection_get_cnc_string (GdaConnection *cn c);
const gchar *gda_connection_get_authentication (GdaConnection *cn c); const gchar *gda_connection_get_authentication (GdaConnection *cn c);
gboolean gda_connection_get_date_format (GdaConnection *cn
c, GDateDMY *out_first,
GDateDMY *out_seco
nd, GDateDMY *out_third, gchar *out_sep,
GError **error);
GdaStatement *gda_connection_parse_sql_string (GdaConnection *cn c, const gchar *sql, GdaSet **params, GdaStatement *gda_connection_parse_sql_string (GdaConnection *cn c, const gchar *sql, GdaSet **params,
GError **error); GError **error);
/* /*
* Quick commands execution * Quick commands execution
*/ */
GdaDataModel* gda_connection_execute_select_command (GdaConnec tion *cnc, const gchar *sql, GError **error); GdaDataModel* gda_connection_execute_select_command (GdaConnec tion *cnc, const gchar *sql, GError **error);
gint gda_connection_execute_non_select_command (GdaConnec tion *cnc, const gchar *sql, GError **error); gint gda_connection_execute_non_select_command (GdaConnec tion *cnc, const gchar *sql, GError **error);
 End of changes. 1 change blocks. 
0 lines changed or deleted 5 lines changed or added


 gda-decl.h   gda-decl.h 
skipping to change at line 26 skipping to change at line 26
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the * License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA. * Boston, MA 02110-1301, USA.
*/ */
#ifndef __GLOBAL_DECL_H_ #ifndef __GLOBAL_DECL_H_
#define __GLOBAL_DECL_H_ #define __GLOBAL_DECL_H_
#include <glib.h> #include <glib.h>
#include <libgda/gda-debug-macros.h>
typedef struct _GdaConfig GdaConfig; typedef struct _GdaConfig GdaConfig;
typedef struct _GdaConfigClass GdaConfigClass; typedef struct _GdaConfigClass GdaConfigClass;
typedef struct _GdaConnection GdaConnection; typedef struct _GdaConnection GdaConnection;
typedef struct _GdaConnectionClass GdaConnectionClass; typedef struct _GdaConnectionClass GdaConnectionClass;
typedef struct _GdaConnectionPrivate GdaConnectionPrivate; typedef struct _GdaConnectionPrivate GdaConnectionPrivate;
typedef struct _GdaConnectionEvent GdaConnectionEvent; typedef struct _GdaConnectionEvent GdaConnectionEvent;
typedef struct _GdaConnectionEventClass GdaConnectionEventClass; typedef struct _GdaConnectionEventClass GdaConnectionEventClass;
 End of changes. 1 change blocks. 
1 lines changed or deleted 0 lines changed or added


 gda-meta-store.h   gda-meta-store.h 
skipping to change at line 69 skipping to change at line 69
typedef enum { typedef enum {
GDA_META_STORE_ADD, GDA_META_STORE_ADD,
GDA_META_STORE_REMOVE, GDA_META_STORE_REMOVE,
GDA_META_STORE_MODIFY GDA_META_STORE_MODIFY
} GdaMetaStoreChangeType; } GdaMetaStoreChangeType;
/** /**
* GdaMetaStoreChange: * GdaMetaStoreChange:
* @c_type: * @c_type:
* @table_name: * @table_name:
* @keys: (element-type utf8 GLib.Value): * @keys: (element-type utf8 GObject.Value):
*/ */
typedef struct { typedef struct {
/* change general information */ /* change general information */
GdaMetaStoreChangeType c_type; GdaMetaStoreChangeType c_type;
gchar *table_name; gchar *table_name;
GHashTable *keys; /* key = ('+' or '-') and a column pos ition in @table (string) starting at 0, GHashTable *keys; /* key = ('+' or '-') and a column pos ition in @table (string) starting at 0,
* value = a GValue pointer */ * value = a GValue pointer */
} GdaMetaStoreChange; } GdaMetaStoreChange;
/* Pointer type for GdaMetaContext */ /* Pointer type for GdaMetaContext */
#define GDA_TYPE_META_CONTEXT (gda_meta_context_get_type()) #define GDA_TYPE_META_CONTEXT (gda_meta_context_get_type())
/** /**
* GdaMetaContext: * GdaMetaContext:
* @table_name: the name of the table <emphasis>in the GdaMetaStore's inter nal database</emphasis> * @table_name: the name of the table <emphasis>in the GdaMetaStore's inter nal database</emphasis>
* @size: the size of the @column_names and @column_values arrays * @size: the size of the @column_names and @column_values arrays
* @column_names: (array length=size): an array of column names (columns of * @column_names: (array length=size) (transfer container): an array of col
the @table_name table) umn names (columns of the @table_name table)
* @column_values: (array length=size): an array of values, one for each co * @column_values: (array length=size) (transfer container): an array of v
lumn named in @column_names alues, one for each column named in @column_names
* @columns: (element-type utf8 GLib.Value): A #GHashTable storing columns' * @columns: (element-type utf8 GObject.Value): A #GHashTable storing colum
name as key and #GValue as column's ns' name as key and #GValue as column's
* value. * value.
* *
* The <structname>GdaMetaContext</structname> represents a meta data modif ication * The <structname>GdaMetaContext</structname> represents a meta data modif ication
* context: the <emphasis>how</emphasis> when used with gda_meta_store_modi fy_with_context(), * context: the <emphasis>how</emphasis> when used with gda_meta_store_modi fy_with_context(),
* and the <emphasis>what</emphasis> when used with gda_connection_update_m eta_store(). * and the <emphasis>what</emphasis> when used with gda_connection_update_m eta_store().
* *
* To create a new #GdaMetaContext use #gda_meta_context_new. * To create a new #GdaMetaContext use #gda_meta_context_new.
* *
* To add a new column/value pair use #gda_meta_context_add_column. * To add a new column/value pair use #gda_meta_context_add_column.
* *
 End of changes. 2 change blocks. 
7 lines changed or deleted 7 lines changed or added


 gda-mutex.h   gda-mutex.h 
/* /*
* Copyright (C) 2000 Reinhard Müller <reinhard@src.gnome.org> * Copyright (C) 2000 Reinhard Müller <reinhard@src.gnome.org>
* Copyright (C) 2000 - 2002 Rodrigo Moya <rodrigo@gnome-db.org> * Copyright (C) 2000 - 2002 Rodrigo Moya <rodrigo@gnome-db.org>
* Copyright (C) 2001 Carlos Perell * Copyright (C) 2001 Carlos Perell
* Copyright (C) 2001 - 2011 Vivien Malerba <malerba@gnome-db.org> * Copyright (C) 2001 - 2013 Vivien Malerba <malerba@gnome-db.org>
* Copyright (C) 2002 Gonzalo Paniagua Javier <gonzalo@src.gnome.org> * Copyright (C) 2002 Gonzalo Paniagua Javier <gonzalo@src.gnome.org>
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
skipping to change at line 31 skipping to change at line 31
* Boston, MA 02110-1301, USA. * Boston, MA 02110-1301, USA.
*/ */
#ifndef __GDA_MUTEX_H__ #ifndef __GDA_MUTEX_H__
#define __GDA_MUTEX_H__ #define __GDA_MUTEX_H__
#include <glib.h> #include <glib.h>
G_BEGIN_DECLS G_BEGIN_DECLS
#if GLIB_CHECK_VERSION(2,31,7)
typedef GRecMutex GdaMutex; typedef GRecMutex GdaMutex;
#else
typedef struct _GdaMutex GdaMutex;
#endif
/** /**
* SECTION:gda-mutex * SECTION:gda-mutex
* @short_description: Recursive mutex implementation * @short_description: Recursive mutex implementation
* @title: GdaMutex * @title: GdaMutex
* @stability: Stable * @stability: Stable
* @see_also: #GdaLockable and #GMutex * @see_also: #GdaLockable and #GMutex
* *
* #GdaMutex implements a recursive mutex (unlike the #GMutex implementatio n which offers no * #GdaMutex implements a recursive mutex (unlike the #GMutex implementatio n which offers no
* guarantee about recursiveness). A recursive mutex is a mutex which can b e locked several * guarantee about recursiveness). A recursive mutex is a mutex which can b e locked several
 End of changes. 3 change blocks. 
5 lines changed or deleted 1 lines changed or added


 gda-pstmt.h   gda-pstmt.h 
skipping to change at line 45 skipping to change at line 45
typedef struct _GdaPStmt GdaPStmt; typedef struct _GdaPStmt GdaPStmt;
typedef struct _GdaPStmtPrivate GdaPStmtPrivate; typedef struct _GdaPStmtPrivate GdaPStmtPrivate;
typedef struct _GdaPStmtClass GdaPStmtClass; typedef struct _GdaPStmtClass GdaPStmtClass;
/** /**
* GdaPStmt: * GdaPStmt:
* @sql: actual SQL code used for this prepared statement, mem freed by Gda PStmt * @sql: actual SQL code used for this prepared statement, mem freed by Gda PStmt
* @param_ids: (element-type utf8): list of parameters' IDs (as gchar *), m em freed by GdaPStmt * @param_ids: (element-type utf8): list of parameters' IDs (as gchar *), m em freed by GdaPStmt
* @ncols: number of types in array * @ncols: number of types in array
* @types: (array length=ncols) (element-type GLib.Type): array of ncols ty pes * @types: (array length=ncols) (element-type GLib.Type): array of ncols ty pes
* @tmpl_columns: (element-type Gda.Colum): list of #GdaColumn objects whic h data models created from this prep. statement can copy * @tmpl_columns: (element-type Gda.Column): list of #GdaColumn objects whi ch data models created from this prep. statement can copy
* *
*/ */
struct _GdaPStmt { struct _GdaPStmt {
GObject object; GObject object;
GdaPStmtPrivate *priv; GdaPStmtPrivate *priv;
gchar *sql; /* actual SQL code used for this prepared stateme nt, mem freed by GdaPStmt */ gchar *sql; /* actual SQL code used for this prepared stateme nt, mem freed by GdaPStmt */
GSList *param_ids; /* list of parameters' IDs (as gchar *), m em freed by GdaPStmt */ GSList *param_ids; /* list of parameters' IDs (as gchar *), m em freed by GdaPStmt */
/* meta data */ /* meta data */
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 gda-server-provider-extra.h   gda-server-provider-extra.h 
skipping to change at line 79 skipping to change at line 79
GdaConnection *cnc; GdaConnection *cnc;
GType g_type; GType g_type;
gchar *dbms_type; gchar *dbms_type;
} GdaServerProviderHandlerInfo; } GdaServerProviderHandlerInfo;
GdaDataHandler *gda_server_provider_handler_find (GdaServerProvi der *prov, GdaConnection *cnc, GdaDataHandler *gda_server_provider_handler_find (GdaServerProvi der *prov, GdaConnection *cnc,
GType g_type, c onst gchar *dbms_type); GType g_type, c onst gchar *dbms_type);
void gda_server_provider_handler_declare (GdaServerProvi der *prov, GdaDataHandler *dh, void gda_server_provider_handler_declare (GdaServerProvi der *prov, GdaDataHandler *dh,
GdaConnection * cnc, GdaConnection * cnc,
GType g_type, c onst gchar *dbms_type); GType g_type, c onst gchar *dbms_type);
void _gda_server_provider_handlers_clear_for_cnc (GdaServerProvi der *prov, GdaConnection *cnc);
/* /*
* misc * misc
*/ */
gchar *gda_server_provider_find_file (GdaServerProvi der *prov, const gchar *inst_dir, const gchar *filename); gchar *gda_server_provider_find_file (GdaServerProvi der *prov, const gchar *inst_dir, const gchar *filename);
gchar *gda_server_provider_load_file_contents (const gchar *i nst_dir, const gchar *data_dir, const gchar *filename); gchar *gda_server_provider_load_file_contents (const gchar *i nst_dir, const gchar *data_dir, const gchar *filename);
G_END_DECLS G_END_DECLS
#endif #endif
 End of changes. 1 change blocks. 
0 lines changed or deleted 1 lines changed or added


 gda-server-provider.h   gda-server-provider.h 
skipping to change at line 127 skipping to change at line 127
* @indexes_tab: * @indexes_tab:
* @_index_cols: * @_index_cols:
* @index_cols: * @index_cols:
* *
* These methods must be implemented by providers to update a connection's associated metadata (in a * 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 met hods for providers/Methods - metadata</link> * #GdaMetaStore object), see the <link linkend="prov-metadata">Virtual met hods for providers/Methods - metadata</link>
* for more information. * for more information.
*/ */
typedef struct { typedef struct {
/* _information_schema_catalog_name */ /* _information_schema_catalog_name */
gboolean (*_info) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *, GError **); gboolean (*_info) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
/* _builtin_data_types */ /* _builtin_data_types */
gboolean (*_btypes) (GdaServerProvider *, GdaConnection *, GdaMetaStore *, GdaMetaContext *, GError **); gboolean (*_btypes) (GdaServerProvider *prov, GdaConnection *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
/* _udt */ /* _udt */
gboolean (*_udt) (GdaServerProvider *, GdaConnection *, gboolean (*_udt) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*udt) (GdaServerProvider *, GdaConnection *, gboolean (*udt) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *udt_catalog, const GValu e *udt_schema); const GValue *udt_catalog, const GValu e *udt_schema);
/* _udt_columns */ /* _udt_columns */
gboolean (*_udt_cols) (GdaServerProvider *, GdaConnection *, gboolean (*_udt_cols) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*udt_cols) (GdaServerProvider *, GdaConnection *, gboolean (*udt_cols) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *udt_catalog, const GValu e *udt_schema, const GValue *udt_name); const GValue *udt_catalog, const GValu e *udt_schema, const GValue *udt_name);
/* _enums */ /* _enums */
gboolean (*_enums) (GdaServerProvider *, GdaConnection *, gboolean (*_enums) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*enums) (GdaServerProvider *, GdaConnection *, gboolean (*enums) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *udt_catalog, const GValu e *udt_schema, const GValue *udt_name); const GValue *udt_catalog, const GValu e *udt_schema, const GValue *udt_name);
/* _domains */ /* _domains */
gboolean (*_domains) (GdaServerProvider *, GdaConnection *, gboolean (*_domains) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*domains) (GdaServerProvider *, GdaConnection *, gboolean (*domains) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *domain_catalog, const GV alue *domain_schema); const GValue *domain_catalog, const GV alue *domain_schema);
/* _domain_constraints */ /* _domain_constraints */
gboolean (*_constraints_dom) (GdaServerProvider *, GdaConnection *, gboolean (*_constraints_dom) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*constraints_dom) (GdaServerProvider *, GdaConnection *, gboolean (*constraints_dom) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *domain_catalog, const GV alue *domain_schema, const GValue *domain_name); const GValue *domain_catalog, const GV alue *domain_schema, const GValue *domain_name);
/* _element_types */ /* _element_types */
gboolean (*_el_types) (GdaServerProvider *, GdaConnection *, gboolean (*_el_types) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*el_types) (GdaServerProvider *, GdaConnection *, gboolean (*el_types) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *specific_name); const GValue *specific_name);
/* _collations */ /* _collations */
gboolean (*_collations) (GdaServerProvider *, GdaConnection *, gboolean (*_collations) (GdaServerProvider *prov, GdaConnectio
GdaMetaStore *, GdaMetaContext *, GError **); n *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*collations) (GdaServerProvider *, GdaConnection *, gboolean (*collations) (GdaServerProvider *prov, GdaConnectio
GdaMetaStore *, GdaMetaContext *, GError **, n *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *collation_catalog, cons t GValue *collation_schema, const GValue *collation_catalog, cons t GValue *collation_schema,
const GValue *collation_name_n); const GValue *collation_name_n);
/* _character_sets */ /* _character_sets */
gboolean (*_character_sets) (GdaServerProvider *, GdaConnection *, gboolean (*_character_sets) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*character_sets) (GdaServerProvider *, GdaConnection *, gboolean (*character_sets) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *chset_catalog, const GVa lue *chset_schema, const GValue *chset_name_n); const GValue *chset_catalog, const GVa lue *chset_schema, const GValue *chset_name_n);
/* _schemata */ /* _schemata */
gboolean (*_schemata) (GdaServerProvider *, GdaConnection *, gboolean (*_schemata) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*schemata) (GdaServerProvider *, GdaConnection *, gboolean (*schemata) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *catalog_name, const GVal ue *schema_name_n); const GValue *catalog_name, const GVal ue *schema_name_n);
/* _tables or _views */ /* _tables or _views */
gboolean (*_tables_views) (GdaServerProvider *, GdaConnection *, gboolean (*_tables_views) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*tables_views) (GdaServerProvider *, GdaConnection *, gboolean (*tables_views) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name_n); const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name_n);
/* _columns */ /* _columns */
gboolean (*_columns) (GdaServerProvider *, GdaConnection *, gboolean (*_columns) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*columns) (GdaServerProvider *, GdaConnection *, gboolean (*columns) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name); const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name);
/* _view_column_usage */ /* _view_column_usage */
gboolean (*_view_cols) (GdaServerProvider *, GdaConnection *, gboolean (*_view_cols) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*view_cols) (GdaServerProvider *, GdaConnection *, gboolean (*view_cols) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *view_catalog, const GVal ue *view_schema, const GValue *view_name); const GValue *view_catalog, const GVal ue *view_schema, const GValue *view_name);
/* _table_constraints */ /* _table_constraints */
gboolean (*_constraints_tab) (GdaServerProvider *, GdaConnection *, gboolean (*_constraints_tab) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*constraints_tab) (GdaServerProvider *, GdaConnection *, gboolean (*constraints_tab) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name, const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name,
const GValue *constraint_name_n); const GValue *constraint_name_n);
/* _referential_constraints */ /* _referential_constraints */
gboolean (*_constraints_ref) (GdaServerProvider *, GdaConnection *, gboolean (*_constraints_ref) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*constraints_ref) (GdaServerProvider *, GdaConnection *, gboolean (*constraints_ref) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name, const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name,
const GValue *constraint_name); const GValue *constraint_name);
/* _key_column_usage */ /* _key_column_usage */
gboolean (*_key_columns) (GdaServerProvider *, GdaConnection *, gboolean (*_key_columns) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*key_columns) (GdaServerProvider *, GdaConnection *, gboolean (*key_columns) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name, const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name,
const GValue *constraint_name); const GValue *constraint_name);
/* _check_column_usage */ /* _check_column_usage */
gboolean (*_check_columns) (GdaServerProvider *, GdaConnection *, gboolean (*_check_columns) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*check_columns) (GdaServerProvider *, GdaConnection *, gboolean (*check_columns) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name, const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name,
const GValue *constraint_name); const GValue *constraint_name);
/* _triggers */ /* _triggers */
gboolean (*_triggers) (GdaServerProvider *, GdaConnection *, gboolean (*_triggers) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*triggers) (GdaServerProvider *, GdaConnection *, gboolean (*triggers) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name); const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name);
/* _routines */ /* _routines */
gboolean (*_routines) (GdaServerProvider *, GdaConnection *, G gboolean (*_routines) (GdaServerProvider *prov, GdaConnection
daMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*routines) (GdaServerProvider *, GdaConnection *, G gboolean (*routines) (GdaServerProvider *prov, GdaConnection
daMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *routine_catalog, const GV alue *routine_schema, const GValue *routine_catalog, const GV alue *routine_schema,
const GValue *routine_name_n); const GValue *routine_name_n);
/* _routine_columns */ /* _routine_columns */
gboolean (*_routine_col) (GdaServerProvider *, GdaConnection *, gboolean (*_routine_col) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*routine_col) (GdaServerProvider *, GdaConnection *, gboolean (*routine_col) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *rout_catalog, const GVal ue *rout_schema, const GValue *rout_name); const GValue *rout_catalog, const GVal ue *rout_schema, const GValue *rout_name);
/* _parameters */ /* _parameters */
gboolean (*_routine_par) (GdaServerProvider *, GdaConnection *, gboolean (*_routine_par) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*routine_par) (GdaServerProvider *, GdaConnection *, gboolean (*routine_par) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *rout_catalog, const GVal ue *rout_schema, const GValue *rout_name); const GValue *rout_catalog, const GVal ue *rout_schema, const GValue *rout_name);
/* _table_indexes */ /* _table_indexes */
gboolean (*_indexes_tab) (GdaServerProvider *, GdaConnection *, gboolean (*_indexes_tab) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*indexes_tab) (GdaServerProvider *, GdaConnection *, gboolean (*indexes_tab) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name, const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name,
const GValue *index_name_n); const GValue *index_name_n);
/* _index_column_usage */ /* _index_column_usage */
gboolean (*_index_cols) (GdaServerProvider *, GdaConnection *, gboolean (*_index_cols) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **); *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error);
gboolean (*index_cols) (GdaServerProvider *, GdaConnection *, gboolean (*index_cols) (GdaServerProvider *prov, GdaConnection
GdaMetaStore *, GdaMetaContext *, GError **, *cnc, GdaMetaStore *meta, GdaMetaContext *ctx, GError **error,
const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name, const GValue *index_name); const GValue *table_catalog, const GVa lue *table_schema, const GValue *table_name, const GValue *index_name);
/*< private >*/ /*< private >*/
/* Padding for future expansion */ /* Padding for future expansion */
void (*_gda_reserved5) (void); void (*_gda_reserved5) (void);
void (*_gda_reserved6) (void); void (*_gda_reserved6) (void);
void (*_gda_reserved7) (void); void (*_gda_reserved7) (void);
void (*_gda_reserved8) (void); void (*_gda_reserved8) (void);
void (*_gda_reserved9) (void); void (*_gda_reserved9) (void);
void (*_gda_reserved10) (void); void (*_gda_reserved10) (void);
skipping to change at line 267 skipping to change at line 267
void (*_gda_reserved12) (void); void (*_gda_reserved12) (void);
void (*_gda_reserved13) (void); void (*_gda_reserved13) (void);
void (*_gda_reserved14) (void); void (*_gda_reserved14) (void);
void (*_gda_reserved15) (void); void (*_gda_reserved15) (void);
void (*_gda_reserved16) (void); void (*_gda_reserved16) (void);
} GdaServerProviderMeta; } GdaServerProviderMeta;
/* distributed transaction support */ /* distributed transaction support */
typedef struct { typedef struct {
gboolean (*xa_start) (GdaServerProvider *, GdaConnection *, const GdaXaTransactionId *, GError **); gboolean (*xa_start) (GdaServerProvider *prov, GdaConnection *cnc , const GdaXaTransactionId *trx, GError **error);
gboolean (*xa_end) (GdaServerProvider *, GdaConnection *, const gboolean (*xa_end) (GdaServerProvider *prov, GdaConnection *cnc
GdaXaTransactionId *, GError **); , const GdaXaTransactionId *trx, GError **error);
gboolean (*xa_prepare) (GdaServerProvider *, GdaConnection *, const gboolean (*xa_prepare) (GdaServerProvider *prov, GdaConnection *cnc
GdaXaTransactionId *, GError **); , const GdaXaTransactionId *trx, GError **error);
gboolean (*xa_commit) (GdaServerProvider *, GdaConnection *, const gboolean (*xa_commit) (GdaServerProvider *prov, GdaConnection *cnc
GdaXaTransactionId *, GError **); , const GdaXaTransactionId *trx, GError **error);
gboolean (*xa_rollback) (GdaServerProvider *, GdaConnection *, const gboolean (*xa_rollback) (GdaServerProvider *prov, GdaConnection *cnc
GdaXaTransactionId *, GError **); , const GdaXaTransactionId *trx, GError **error);
GList *(*xa_recover) (GdaServerProvider *, GdaConnection *, GErro r **); GList *(*xa_recover) (GdaServerProvider *prov, GdaConnection *cnc , GError **error);
} GdaServerProviderXa; } GdaServerProviderXa;
/** /**
* GdaServerProviderAsyncCallback: * GdaServerProviderAsyncCallback:
* @provider: * @provider:
* @cnc: * @cnc:
* @task_id: * @task_id:
* @result_status: * @result_status:
* @error: * @error:
* @data: * @data:
 End of changes. 28 change blocks. 
100 lines changed or deleted 100 lines changed or added


 gda-set.h   gda-set.h 
/* /*
* Copyright (C) 2008 - 2011 Vivien Malerba <malerba@gnome-db.org> * Copyright (C) 2008 - 2011 Vivien Malerba <malerba@gnome-db.org>
* Copyright (C) 2013 Daniel Espinosa <esodan@gmail.com>
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details. * Lesser General Public License for more details.
skipping to change at line 28 skipping to change at line 29
*/ */
#ifndef __GDA_SET_H_ #ifndef __GDA_SET_H_
#define __GDA_SET_H_ #define __GDA_SET_H_
#include "gda-value.h" #include "gda-value.h"
#include <libxml/tree.h> #include <libxml/tree.h>
G_BEGIN_DECLS G_BEGIN_DECLS
#define GDA_TYPE_SET (gda_set_get_type())
#define GDA_SET(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gda_set_get_
type(), GdaSet)
#define GDA_SET_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gda_set_get_t
ype (), GdaSetClass)
#define GDA_IS_SET(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_set_get_
type ())
/* error reporting */ /* error reporting */
extern GQuark gda_set_error_quark (void); extern GQuark gda_set_error_quark (void);
#define GDA_SET_ERROR gda_set_error_quark () #define GDA_SET_ERROR gda_set_error_quark ()
typedef enum typedef enum
{ {
GDA_SET_XML_SPEC_ERROR, GDA_SET_XML_SPEC_ERROR,
GDA_SET_HOLDER_NOT_FOUND_ERROR, GDA_SET_HOLDER_NOT_FOUND_ERROR,
GDA_SET_INVALID_ERROR, GDA_SET_INVALID_ERROR,
GDA_SET_READ_ONLY_ERROR, GDA_SET_READ_ONLY_ERROR,
GDA_SET_IMPLEMENTATION_ERROR GDA_SET_IMPLEMENTATION_ERROR
} GdaSetError; } GdaSetError;
#ifdef GSEAL_ENABLE
#else
struct _GdaSetNode { struct _GdaSetNode {
GdaHolder *holder; /* Can't be NULL */ GdaHolder* GSEAL(holder);
GdaDataModel *source_model; /* may be NULL */ GdaDataModel* GSEAL(source_model);
gint source_column; /* unused if @source_model is NULL */ gint GSEAL(source_column);
/*< private >*/ /*< private >*/
/* Padding for future expansion */ /* Padding for future expansion */
gpointer _gda_reserved1; gpointer GSEAL(_gda_reserved1);
gpointer _gda_reserved2; gpointer GSEAL(_gda_reserved2);
}; };
#endif
/** #define GDA_TYPE_SET_NODE (gda_set_node_get_type ())
* GdaSetGroup: #define GDA_SET_NODE(x) ((GdaSetNode *)(x))
* @nodes: (element-type Gda.SetNode): list of GdaSetNode, at least one ent GType gda_set_node_get_type (void) G_GNUC_CONST;
ry GdaSetNode *gda_set_node_new (GdaHolder *holder);
* @nodes_source: (allow-none): if NULL, then @nodes contains exactly one void gda_set_node_free (GdaSetNode *node);
entry GdaSetNode *gda_set_node_copy (GdaSetNode *node);
*/ GdaHolder *gda_set_node_get_holder (GdaSetNode *node);
void gda_set_node_set_holder (GdaSetNode *node, GdaHolder *
holder);
GdaDataModel *gda_set_node_get_data_model (GdaSetNode *node);
void gda_set_node_set_data_model (GdaSetNode *node, GdaDataMode
l *model);
gint gda_set_node_get_source_column (GdaSetNode *node);
void gda_set_node_set_source_column (GdaSetNode *node, gint column
);
#ifdef GSEAL_ENABLE
#else
struct _GdaSetGroup { struct _GdaSetGroup {
GSList *nodes; /* list of GdaSetNode, at least one entry GSList* GSEAL(nodes); /* list of GdaSetNode, at least on
*/ e entry */
GdaSetSource *nodes_source; /* if NULL, then @nodes contains exactly GdaSetSource* GSEAL(nodes_source); /* if NULL, then @nodes contains
one entry */ exactly one entry */
/*< private >*/ /*< private >*/
/* Padding for future expansion */ /* Padding for future expansion */
gpointer _gda_reserved1; gpointer GSEAL(_gda_reserved1);
gpointer _gda_reserved2; gpointer GSEAL(_gda_reserved2);
}; };
#endif
/** #define GDA_TYPE_SET_GROUP (gda_set_group_get_type ())
* GdaSetSource: #define GDA_SET_GROUP(x) ((GdaSetGroup *)(x))
* @data_model: Can't be NULL GType gda_set_group_get_type (void) G_GNUC_CONST;
* @nodes: (element-type Gda.SetNode): list of #GdaSetNode for which source GdaSetGroup *gda_set_group_new (GdaSetNode *node);
_model == @data_model void gda_set_group_free (GdaSetGroup *sg);
* GdaSetGroup *gda_set_group_copy (GdaSetGroup *sg);
**/ void gda_set_group_add_node (GdaSetGroup *sg, GdaSetNode *n
ode);
GdaSetNode *gda_set_group_get_node (GdaSetGroup *sg);
GSList *gda_set_group_get_nodes (GdaSetGroup *sg);
gint gda_set_group_get_n_nodes (GdaSetGroup *sg);
void gda_set_group_set_source (GdaSetGroup *sg, GdaSetSource
*source);
GdaSetSource *gda_set_group_get_source (GdaSetGroup *sg);
#ifdef GSEAL_ENABLE
#else
struct _GdaSetSource { struct _GdaSetSource {
GdaDataModel *data_model; /* Can't be NULL */ GdaDataModel* GSEAL(data_model); /* Can't be NULL */
GSList *nodes; /* list of #GdaSetNode for which sourc GSList* GSEAL(nodes); /* list of #GdaSetNode for whic
e_model == @data_model */ h source_model == @data_model */
/*< private >*/ /*< private >*/
/* Padding for future expansion */ /* Padding for future expansion */
gpointer _gda_reserved1; gpointer GSEAL(_gda_reserved1);
gpointer _gda_reserved2; gpointer GSEAL(_gda_reserved2);
gpointer _gda_reserved3; gpointer GSEAL(_gda_reserved3);
gpointer _gda_reserved4; gpointer GSEAL(_gda_reserved4);
}; };
#endif
#define GDA_SET_NODE(x) ((GdaSetNode *)(x)) #define GDA_TYPE_SET_SOURCE (gda_set_source_get_type ())
#define GDA_SET_SOURCE(x) ((GdaSetSource *)(x)) #define GDA_SET_SOURCE(x) ((GdaSetSource *)(x))
#define GDA_SET_GROUP(x) ((GdaSetGroup *)(x)) GType gda_set_source_get_type (void) G_GNUC_CONST;
GdaSetSource *gda_set_source_new (GdaDataModel *model);
void gda_set_source_free (GdaSetSource *s);
GdaSetSource *gda_set_source_copy (GdaSetSource *s);
void gda_set_source_add_node (GdaSetSource *s, GdaSetNode *n
ode);
GSList *gda_set_source_get_nodes (GdaSetSource *s);
gint gda_set_source_get_n_nodes (GdaSetSource *s);
GdaDataModel *gda_set_source_get_data_model (GdaSetSource *s);
void gda_set_source_set_data_model (GdaSetSource *s, GdaDataModel
*model);
/* struct for the object's data */ /* struct for the object's data */
#define GDA_TYPE_SET (gda_set_get_type())
#define GDA_SET(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gda_set_get_
type(), GdaSet)
#define GDA_SET_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gda_set_get_t
ype (), GdaSetClass)
#define GDA_IS_SET(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_set_get_
type ())
/* FIXME: public members of GdaSet must be SEALED! */
/** /**
* GdaSet: * GdaSet:
* @holders: (element-type Gda.Holder): list of GdaHolder objects * @holders: (element-type Gda.Holder): list of GdaHolder objects
* @nodes_list: (element-type Gda.SetNode): list of GdaSetNode * @nodes_list: (element-type Gda.SetNode): list of GdaSetNode
* @sources_list: (element-type Gda.SetSource): list of GdaSetSource * @sources_list: (element-type Gda.SetSource): list of GdaSetSource
* @groups_list: (element-type Gda.SetGroup): list of GdaSetGroup * @groups_list: (element-type Gda.SetGroup): list of GdaSetGroup
* *
*/ */
struct _GdaSet struct _GdaSet
{ {
 End of changes. 17 change blocks. 
42 lines changed or deleted 80 lines changed or added


 gda-sql-parser.h   gda-sql-parser.h 
skipping to change at line 85 skipping to change at line 85
gpointer _gda_reserved1; gpointer _gda_reserved1;
gpointer _gda_reserved2; gpointer _gda_reserved2;
} GdaSqlParserIface; } GdaSqlParserIface;
/* struct for the object's class */ /* struct for the object's class */
struct _GdaSqlParserClass struct _GdaSqlParserClass
{ {
GObjectClass parent_class; GObjectClass parent_class;
/* virtual methods and data for sub classed parsers */ /* virtual methods and data for sub classed parsers */
void *(*delim_alloc) (void*(*)(size_t)); void *(*delim_alloc) (void *(*f) (size_t s));
void (*delim_free) (void*, void(*)(void*)); void (*delim_free) (void *d, void(*f) (void *d));
void (*delim_trace) (void*, char *); void (*delim_trace) (void *d, char *s);
void (*delim_parse) (void*, int, GValue *, GdaSqlParserIface *); void (*delim_parse) (void *d, int i, GValue *v, GdaSqlParserIface *i
face);
gint *delim_tokens_trans; gint *delim_tokens_trans;
void *(*parser_alloc) (void*(*)(size_t)); void *(*parser_alloc) (void *(*f)(size_t s));
void (*parser_free) (void*, void(*)(void*)); void (*parser_free) (void *p, void(*f)(void *p));
void (*parser_trace) (void*, char *); void (*parser_trace) (void *p, char *s);
void (*parser_parse) (void*, int, GValue *, GdaSqlParserIface *); void (*parser_parse) (void *p, int i, GValue *v, GdaSqlParserIface *
iface);
gint *parser_tokens_trans; gint *parser_tokens_trans;
/*< private >*/ /*< private >*/
/* Padding for future expansion */ /* Padding for future expansion */
void (*_gda_reserved1) (void); void (*_gda_reserved1) (void);
void (*_gda_reserved2) (void); void (*_gda_reserved2) (void);
void (*_gda_reserved3) (void); void (*_gda_reserved3) (void);
void (*_gda_reserved4) (void); void (*_gda_reserved4) (void);
}; };
 End of changes. 2 change blocks. 
8 lines changed or deleted 10 lines changed or added


 gda-statement-struct-decl.h   gda-statement-struct-decl.h 
skipping to change at line 250 skipping to change at line 250
/** /**
* GdaSqlStatementContentsInfo: (skip) * GdaSqlStatementContentsInfo: (skip)
* *
* Contents' infos * Contents' infos
*/ */
typedef struct { typedef struct {
GdaSqlStatementType type; GdaSqlStatementType type;
gchar *name; gchar *name;
gpointer (*construct) (void); gpointer (*construct) (void);
void (*free) (gpointer); void (*free) (gpointer stm);
gpointer (*copy) (gpointer); gpointer (*copy) (gpointer stm);
gchar *(*serialize) (gpointer); gchar *(*serialize) (gpointer stm);
/* augmenting information precision using a dictionary */ /* augmenting information precision using a dictionary */
GdaSqlForeachFunc check_structure_func; GdaSqlForeachFunc check_structure_func;
GdaSqlForeachFunc check_validity_func; GdaSqlForeachFunc check_validity_func;
/*< private >*/ /*< private >*/
/* Padding for future expansion */ /* Padding for future expansion */
gpointer _gda_reserved1; gpointer _gda_reserved1;
gpointer _gda_reserved2; gpointer _gda_reserved2;
gpointer _gda_reserved3; gpointer _gda_reserved3;
 End of changes. 1 change blocks. 
3 lines changed or deleted 3 lines changed or added


 gda-statement.h   gda-statement.h 
skipping to change at line 88 skipping to change at line 88
/** /**
* GdaStatementSqlFlag: * GdaStatementSqlFlag:
* @GDA_STATEMENT_SQL_PARAMS_AS_VALUES: rendering will replace parameters w ith their values * @GDA_STATEMENT_SQL_PARAMS_AS_VALUES: rendering will replace parameters w ith their values
* @GDA_STATEMENT_SQL_PRETTY: rendering will include newlines and indentati on to make it easy to read * @GDA_STATEMENT_SQL_PRETTY: rendering will include newlines and indentati on to make it easy to read
* @GDA_STATEMENT_SQL_PARAMS_LONG: parameters will be rendered using the "/ &ast; name:&lt;param_name&gt; ... &ast;/" syntax * @GDA_STATEMENT_SQL_PARAMS_LONG: parameters will be rendered using the "/ &ast; name:&lt;param_name&gt; ... &ast;/" syntax
* @GDA_STATEMENT_SQL_PARAMS_SHORT: parameters will be rendered using the " ##&lt;param_name&gt;..." syntax * @GDA_STATEMENT_SQL_PARAMS_SHORT: parameters will be rendered using the " ##&lt;param_name&gt;..." syntax
* @GDA_STATEMENT_SQL_PARAMS_AS_COLON: parameters will be rendered using th e ":&lt;param_name&gt;" syntax * @GDA_STATEMENT_SQL_PARAMS_AS_COLON: parameters will be rendered using th e ":&lt;param_name&gt;" syntax
* @GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR: parameters will be rendered using t he "$&lt;param_number&gt;" syntax where parameters are numbered starting fr om 1 * @GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR: parameters will be rendered using t he "$&lt;param_number&gt;" syntax where parameters are numbered starting fr om 1
* @GDA_STATEMENT_SQL_PARAMS_AS_QMARK: parameters will be rendered using th e "?&lt;param_number&gt;" syntax where parameters are numbered starting fro m 1 * @GDA_STATEMENT_SQL_PARAMS_AS_QMARK: parameters will be rendered using th e "?&lt;param_number&gt;" syntax where parameters are numbered starting fro m 1
* @GDA_STATEMENT_SQL_PARAMS_AS_UQMARK: parameters will be rendered using t he "?" syntax * @GDA_STATEMENT_SQL_PARAMS_AS_UQMARK: parameters will be rendered using t he "?" syntax
* @GDA_STATEMENT_SQL_TIMEZONE_TO_GMT: time and timestamp with a timezone i nformation are converted to GMT before rendering, and rendering does not sh ow the timezone information
* *
* Specifies rendering options * Specifies rendering options
*/ */
typedef enum { typedef enum {
GDA_STATEMENT_SQL_PARAMS_AS_VALUES = 0, GDA_STATEMENT_SQL_PARAMS_AS_VALUES = 0,
GDA_STATEMENT_SQL_PRETTY = 1 << 0, GDA_STATEMENT_SQL_PRETTY = 1 << 0,
GDA_STATEMENT_SQL_PARAMS_LONG = 1 << 1, GDA_STATEMENT_SQL_PARAMS_LONG = 1 << 1,
GDA_STATEMENT_SQL_PARAMS_SHORT = 1 << 2, GDA_STATEMENT_SQL_PARAMS_SHORT = 1 << 2,
GDA_STATEMENT_SQL_PARAMS_AS_COLON = 1 << 3, GDA_STATEMENT_SQL_PARAMS_AS_COLON = 1 << 3,
GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR = 1 << 4, GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR = 1 << 4,
GDA_STATEMENT_SQL_PARAMS_AS_QMARK = 1 << 5, GDA_STATEMENT_SQL_PARAMS_AS_QMARK = 1 << 5,
GDA_STATEMENT_SQL_PARAMS_AS_UQMARK = 1 << 6 GDA_STATEMENT_SQL_PARAMS_AS_UQMARK = 1 << 6,
GDA_STATEMENT_SQL_TIMEZONE_TO_GMT = 1 << 7
} GdaStatementSqlFlag; } GdaStatementSqlFlag;
/* struct for the object's data */ /* struct for the object's data */
struct _GdaStatement struct _GdaStatement
{ {
GObject object; GObject object;
GdaStatementPrivate *priv; GdaStatementPrivate *priv;
}; };
/* struct for the object's class */ /* struct for the object's class */
 End of changes. 2 change blocks. 
1 lines changed or deleted 3 lines changed or added


 gda-util.h   gda-util.h 
/* /*
* Copyright (C) 2000 Reinhard Müller <reinhard@src.gnome.org> * Copyright (C) 2000 Reinhard Müller <reinhard@src.gnome.org>
* Copyright (C) 2000 - 2002 Rodrigo Moya <rodrigo@gnome-db.org> * Copyright (C) 2000 - 2002 Rodrigo Moya <rodrigo@gnome-db.org>
* Copyright (C) 2001 Carlos Perell * Copyright (C) 2001 Carlos Perell
* Copyright (C) 2001 - 2012 Vivien Malerba <malerba@gnome-db.org> * Copyright (C) 2001 - 2013 Vivien Malerba <malerba@gnome-db.org>
* Copyright (C) 2002 Gonzalo Paniagua Javier <gonzalo@src.gnome.org> * Copyright (C) 2002 Gonzalo Paniagua Javier <gonzalo@src.gnome.org>
* Copyright (C) 2006 - 2007 Murray Cumming <murrayc@murrayc.com> * Copyright (C) 2006 - 2007 Murray Cumming <murrayc@murrayc.com>
* Copyright (C) 2007 Armin Burgmeier <armin@openismus.com> * Copyright (C) 2007 Armin Burgmeier <armin@openismus.com>
* Copyright (C) 2008 Przemysław Grzegorczyk <pgrzegorczyk@gmail.com> * Copyright (C) 2008 Przemysław Grzegorczyk <pgrzegorczyk@gmail.com>
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
skipping to change at line 123 skipping to change at line 123
gchar **out_username, gchar **out_ password); gchar **out_username, gchar **out_ password);
void gda_connection_string_split (const gchar *string, gchar **out_ cnc_params, gchar **out_provider, void gda_connection_string_split (const gchar *string, gchar **out_ cnc_params, gchar **out_provider,
gchar **out_username, gchar **out_ password); gchar **out_username, gchar **out_ password);
/* /*
* Date and time parsing from ISO 8601 (well, part of it) * Date and time parsing from ISO 8601 (well, part of it)
*/ */
gboolean gda_parse_iso8601_date (GDate *gdate, const gchar *value); gboolean gda_parse_iso8601_date (GDate *gdate, const gchar *value);
gboolean gda_parse_iso8601_time (GdaTime *timegda, const gchar *value); gboolean gda_parse_iso8601_time (GdaTime *timegda, const gchar *value);
gboolean gda_parse_iso8601_timestamp (GdaTimestamp *timestamp, const gc har *value); gboolean gda_parse_iso8601_timestamp (GdaTimestamp *timestamp, const gc har *value);
gboolean gda_parse_formatted_date (GDate *gdate, const gchar *value,
GDateDMY first, GDateDMY second, GDat
eDMY third, gchar sep);
gboolean gda_parse_formatted_time (GdaTime *timegda, const gchar *value
, gchar sep);
gboolean gda_parse_formatted_timestamp (GdaTimestamp *timestamp, const
gchar *value,
GDateDMY first, GDateDMY second,
GDateDMY third, gchar sep);
G_END_DECLS G_END_DECLS
#endif #endif
 End of changes. 2 change blocks. 
1 lines changed or deleted 10 lines changed or added


 gda-value.h   gda-value.h 
/* /*
* Copyright (C) 2001 - 2003 Rodrigo Moya <rodrigo@gnome-db.org> * Copyright (C) 2001 - 2003 Rodrigo Moya <rodrigo@gnome-db.org>
* Copyright (C) 2002 - 2003 Gonzalo Paniagua Javier <gonzalo@gnome-db.org> * Copyright (C) 2002 - 2003 Gonzalo Paniagua Javier <gonzalo@gnome-db.org>
* Copyright (C) 2002 - 2011 Vivien Malerba <malerba@gnome-db.org> * Copyright (C) 2002 - 2013 Vivien Malerba <malerba@gnome-db.org>
* Copyright (C) 2003 Akira TAGOH <tagoh@gnome-db.org> * Copyright (C) 2003 Akira TAGOH <tagoh@gnome-db.org>
* Copyright (C) 2003 Danilo Schoeneberg <dschoene@src.gnome.org> * Copyright (C) 2003 Danilo Schoeneberg <dschoene@src.gnome.org>
* Copyright (C) 2003 Laurent Sansonetti <laurent@datarescue.be> * Copyright (C) 2003 Laurent Sansonetti <laurent@datarescue.be>
* Copyright (C) 2004 - 2011 Murray Cumming <murrayc@murrayc.com> * Copyright (C) 2004 - 2011 Murray Cumming <murrayc@murrayc.com>
* Copyright (C) 2004 Paisa Seeluangsawat <paisa@users.sf.net> * Copyright (C) 2004 Paisa Seeluangsawat <paisa@users.sf.net>
* Copyright (C) 2008 Przemysław Grzegorczyk <pgrzegorczyk@gmail.com> * Copyright (C) 2008 Przemysław Grzegorczyk <pgrzegorczyk@gmail.com>
* Copyright (C) 2009 Bas Driessen <bas.driessen@xobas.com> * Copyright (C) 2009 Bas Driessen <bas.driessen@xobas.com>
* Copyright (C) 2011 Daniel Espinosa <despinosa@src.gnome.org> * Copyright (C) 2011 Daniel Espinosa <despinosa@src.gnome.org>
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
skipping to change at line 80 skipping to change at line 80
* @y: * @y:
*/ */
typedef struct { typedef struct {
gdouble x; gdouble x;
gdouble y; gdouble y;
} GdaGeometricPoint; } GdaGeometricPoint;
typedef struct _GdaNumeric GdaNumeric; typedef struct _GdaNumeric GdaNumeric;
# ifdef GSEAL_ENABLE # ifdef GSEAL_ENABLE
# else # else
/**
* GdaNumeric:
* @number: a string representing a number
* @precision: precision to use when @number is converted (not implemented
jet)
* @width: not implemented jet
*
* Holds numbers represented as strings.
*
* This struct must be considered as opaque. Any access to its members must
use its
* accessors added since version 5.0.2.
*
* Set value func: gda_value_set_numeric
* Get value func: gda_value_get_numeric
*/
struct _GdaNumeric { struct _GdaNumeric {
gchar* GSEAL(number); gchar* GSEAL(number);
glong GSEAL(precision); glong GSEAL(precision);
glong GSEAL(width); glong GSEAL(width);
/*< private >*/ /*< private >*/
gpointer reserved; /* reserved for future usage with GMP (http://gmp lib.org/) */ gpointer reserved; /* reserved for future usage with GMP (http://gmp lib.org/) */
}; };
#endif #endif
/** /**
* GdaTime: * GdaTime:
* @hour: * @hour: hour representation of the time, as a number between 0 and 23
* @minute: * @minute: minute representation of the time, as a number between 0 and 59
* @second: * @second: second representation of the time, as a number between 0 and 59
* @fraction: * @fraction: fractionnal part of the seconds, in millionth' of second
* @timezone: * @timezone: number of seconds added to the GMT timezone
*
* Represents a time information.
*/ */
typedef struct { typedef struct {
gushort hour; gushort hour;
gushort minute; gushort minute;
gushort second; gushort second;
gulong fraction; gulong fraction;
glong timezone; /* # of seconds to the east UTC */ glong timezone;
} GdaTime; } GdaTime;
/** /**
* GdaTimestamp: * GdaTimestamp:
* @year: representation of the date * @year: year representation of the time stamp
* @month: month representation of the date, as a number between 1 and 12 * @month: month representation of the time stamp, as a number between 1 an
* @day: day representation of the date, as a number between 1 and 31 d 12
* @hour: * @day: day representation of the time stamp, as a number between 1 and 31
* @minute: * @hour: hour representation of the time stamp, as a number between 0 and
* @second: 23
* @fraction: * @minute: minute representation of the time stamp, as a number between 0
* @timezone: and 59
* @second: second representation of the time stamp, as a number between 0
and 59
* @fraction: fractionnal part of the seconds, in millionth' of second
* @timezone: number of seconds added to the GMT timezone
*
* Represents an instant (a time stamp)
*/ */
typedef struct { typedef struct {
gshort year; gshort year;
gushort month; gushort month;
gushort day; gushort day;
gushort hour; gushort hour;
gushort minute; gushort minute;
gushort second; gushort second;
gulong fraction; gulong fraction;
glong timezone; /* # of seconds to the east UTC */ glong timezone;
} GdaTimestamp; } GdaTimestamp;
/** /**
* GdaBinary: * GdaBinary:
* @data: * @data:
* @binary_length: * @binary_length:
*/ */
typedef struct { typedef struct {
guchar *data; guchar *data;
glong binary_length; glong binary_length;
skipping to change at line 283 skipping to change at line 273
glong gda_numeric_get_precision (GdaNumeric *nu meric); glong gda_numeric_get_precision (GdaNumeric *nu meric);
void gda_numeric_set_width (GdaNumeric *numeri c, glong width); void gda_numeric_set_width (GdaNumeric *numeri c, glong width);
glong gda_numeric_get_width (GdaNumeric *numeri c); glong gda_numeric_get_width (GdaNumeric *numeri c);
gchar* gda_numeric_get_string (GdaNumeric *numer ic); gchar* gda_numeric_get_string (GdaNumeric *numer ic);
void gda_numeric_free (GdaNumeric *numeric); void gda_numeric_free (GdaNumeric *numeric);
GType gda_time_get_type (void) G_GNUC_CONST; GType gda_time_get_type (void) G_GNUC_CONST;
gpointer gda_time_copy (gpointer boxed); gpointer gda_time_copy (gpointer boxed);
void gda_time_free (gpointer boxed); void gda_time_free (gpointer boxed);
gboolean gda_time_valid (const GdaTime *time); gboolean gda_time_valid (const GdaTime *time);
void gda_time_change_timezone (GdaTime *time, glong ntz);
GType gda_timestamp_get_type (void) G_GNUC_CONS T; GType gda_timestamp_get_type (void) G_GNUC_CONS T;
gpointer gda_timestamp_copy (gpointer boxed); gpointer gda_timestamp_copy (gpointer boxed);
void gda_timestamp_free (gpointer boxed); void gda_timestamp_free (gpointer boxed);
gboolean gda_timestamp_valid (const GdaTimestamp * timestamp); gboolean gda_timestamp_valid (const GdaTimestamp * timestamp);
void gda_timestamp_change_timezone (GdaTimesta mp *ts, glong ntz);
GType gda_geometricpoint_get_type (void) G_GNUC _CONST; GType gda_geometricpoint_get_type (void) G_GNUC _CONST;
gpointer gda_geometricpoint_copy (gpointer boxed); gpointer gda_geometricpoint_copy (gpointer boxed);
void gda_geometricpoint_free (gpointer boxed); void gda_geometricpoint_free (gpointer boxed);
GType gda_binary_get_type (void) G_GNUC_CONST; GType gda_binary_get_type (void) G_GNUC_CONST;
gpointer gda_binary_copy (gpointer boxed); gpointer gda_binary_copy (gpointer boxed);
void gda_binary_free (gpointer boxed); void gda_binary_free (gpointer boxed);
GType gda_blob_get_type (void) G_GNUC_CONST; GType gda_blob_get_type (void) G_GNUC_CONST;
 End of changes. 8 change blocks. 
32 lines changed or deleted 26 lines changed or added


 gdaui-plugin.h   gdaui-plugin.h 
skipping to change at line 30 skipping to change at line 30
#ifndef __GDAUI_PLUGIN__ #ifndef __GDAUI_PLUGIN__
#define __GDAUI_PLUGIN__ #define __GDAUI_PLUGIN__
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include <libgda/gda-value.h> #include <libgda/gda-value.h>
#include <libgda-ui/gdaui-data-entry.h> #include <libgda-ui/gdaui-data-entry.h>
#include "gdaui-decl.h" #include "gdaui-decl.h"
/** /**
* GdauiEntryCreateFunc: * GdauiEntryCreateFunc:
* @None: a #GdaDataHandler * @handler: a #GdaDataHandler
* @None: a #GType * @type: a #GType
* @None: (allow-none): options, or %NULL * @options: (allow-none): options, or %NULL
* @Returns: a new #GdauiDataEntry * @Returns: a new #GdauiDataEntry
* *
* Defines a function which creates a #GdauiDataEntry widget * Defines a function which creates a #GdauiDataEntry widget
*/ */
typedef GdauiDataEntry *(*GdauiEntryCreateFunc)(GdaDataHandler *, GType, const gchar *); typedef GdauiDataEntry *(*GdauiEntryCreateFunc)(GdaDataHandler *handler, GType type, const gchar *options);
/** /**
* GdauiCellCreateFunc: * GdauiCellCreateFunc:
* @None: a #GdaDataHandler * @handler: a #GdaDataHandler
* @None: a #GType * @type: a #GType
* @None: (allow-none): options, or %NULL * @options: (allow-none): options, or %NULL
* @Returns:a new #GtkCellRenderer * @Returns:a new #GtkCellRenderer
* *
* Defines a function which creates a #GtkCellRenderer object * Defines a function which creates a #GtkCellRenderer object
*/ */
typedef GtkCellRenderer *(*GdauiCellCreateFunc) (GdaDataHandler *, GType, const gchar *); typedef GtkCellRenderer *(*GdauiCellCreateFunc) (GdaDataHandler *handler, GType type, const gchar *options);
/** /**
* GdauiPlugin: * GdauiPlugin:
* @plugin_name: the name of the plugin * @plugin_name: the name of the plugin
* @plugin_descr: (allow-none): a description for the plugin, or %NULL * @plugin_descr: (allow-none): a description for the plugin, or %NULL
* @plugin_file: (allow-none): the shared object implementing the plugin, c an be %NULL for internal plugins * @plugin_file: (allow-none): the shared object implementing the plugin, c an be %NULL for internal plugins
* @nb_g_types: number of types the plugin can handle, or %0 for any type * @nb_g_types: number of types the plugin can handle, or %0 for any type
* @valid_g_types: (allow-none): an array of #GType, containing the accepte d types, its size is @nb_g_types, or %NULL if @nb_g_types is %0 * @valid_g_types: (allow-none): an array of #GType, containing the accepte d types, its size is @nb_g_types, or %NULL if @nb_g_types is %0
* @options_xml_spec: (allow-none): a string describing the plugin's option s, or %NULL * @options_xml_spec: (allow-none): a string describing the plugin's option s, or %NULL
* @entry_create_func: (allow-none): the function called to create a #Gdaui DataEntry, or %NULL * @entry_create_func: (allow-none): the function called to create a #Gdaui DataEntry, or %NULL
 End of changes. 4 change blocks. 
8 lines changed or deleted 8 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/