libgda: headers diff between 1.9.100 and 1.9.102 versions

	gda-client.h	gda-client.h

	skipping to change at line 58	skipping to change at line 58
	GDA_CLIENT_EVENT_TRANSACTION_STARTED, /* params: "transaction" */	GDA_CLIENT_EVENT_TRANSACTION_STARTED, /* params: "transaction" */
	GDA_CLIENT_EVENT_TRANSACTION_COMMITTED, /* params: "transaction" */	GDA_CLIENT_EVENT_TRANSACTION_COMMITTED, /* params: "transaction" */
	GDA_CLIENT_EVENT_TRANSACTION_CANCELLED, /* params: "transaction" */	GDA_CLIENT_EVENT_TRANSACTION_CANCELLED, /* params: "transaction" */
	} GdaClientEvent;	} GdaClientEvent;

	typedef enum {	typedef enum {
	GDA_CLIENT_SPECS_CREATE_DATABASE,	GDA_CLIENT_SPECS_CREATE_DATABASE,
	GDA_CLIENT_SPECS_DROP_DATABASE	GDA_CLIENT_SPECS_DROP_DATABASE
	} GdaClientSpecsType;	} GdaClientSpecsType;


	typedef struct _GdaClientClass GdaClientClass;
	typedef struct _GdaClientPrivate GdaClientPrivate;

	struct _GdaClient {	struct _GdaClient {

	GObject object;	GObject object;
	GdaClientPrivate *priv;	GdaClientPrivate *priv;
	};	};

	struct _GdaClientClass {	struct _GdaClientClass {

	GObjectClass parent_class;	GObjectClass parent_class;

	/* signals */	/* signals */
	void (* event_notification) (GdaClient *client,	void (* event_notification) (GdaClient *client,
	GdaConnection *cnc,	GdaConnection *cnc,
	GdaClientEvent event,	GdaClientEvent event,
	GdaParameterList *params);	GdaParameterList *params);
	};	};

	/* error reporting */	/* error reporting */
	extern GQuark gda_client_error_quark (void);	extern GQuark gda_client_error_quark (void);

	skipping to change at line 89	skipping to change at line 86

	GType gda_client_get_type (void);	GType gda_client_get_type (void);
	GdaClient *gda_client_new (void);	GdaClient *gda_client_new (void);

	GdaConnection gda_client_open_connection (GdaClient cl ient,	GdaConnection gda_client_open_connection (GdaClient cl ient,
	const gchar *d sn,	const gchar *d sn,
	const gchar *u sername,	const gchar *u sername,
	const gchar *p assword,	const gchar *p assword,
	GdaConnectionO ptions options,	GdaConnectionO ptions options,
	GError **error );	GError **error );

		void gda_client_declare_connection (GdaClient cl ient, GdaConnection cnc);
	GdaConnection gda_client_open_connection_from_string (GdaClient cl ient,	GdaConnection gda_client_open_connection_from_string (GdaClient cl ient,
	const gchar *p rovider_id,	const gchar *p rovider_id,
	const gchar *c nc_string,	const gchar *c nc_string,
	GdaConnectionO ptions options,	GdaConnectionO ptions options,
	GError **error );	GError **error );
	const GList gda_client_get_connections (GdaClient cl ient);	const GList gda_client_get_connections (GdaClient cl ient);
	GdaConnection gda_client_find_connection (GdaClient cl ient,	GdaConnection gda_client_find_connection (GdaClient cl ient,
	const gchar *d sn,	const gchar *d sn,
	const gchar *u sername,	const gchar *u sername,
	const gchar *p assword);	const gchar *p assword);

End of changes. 4 change blocks.
	5 lines changed or deleted	3 lines changed or added

	gda-column.h	gda-column.h

	skipping to change at line 31	skipping to change at line 31
	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,
	* Boston, MA 02111-1307, USA.	* Boston, MA 02111-1307, USA.
	*/	*/

	#if !defined(__gda_column_h__)	#if !defined(__gda_column_h__)
	# define __gda_column_h__	# define __gda_column_h__

	#include <glib-object.h>	#include <glib-object.h>
	#include <libgda/gda-value.h>	#include <libgda/gda-value.h>
	#include <glib/gmacros.h>	#include <glib/gmacros.h>

	#include <libgda/global-decl.h>	#include <libgda/gda-decl.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_TYPE_COLUMN (gda_column_get_type())	#define GDA_TYPE_COLUMN (gda_column_get_type())
	#define GDA_COLUMN(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TY PE_COLUMN, GdaColumn))	#define GDA_COLUMN(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TY PE_COLUMN, GdaColumn))
	#define GDA_COLUMN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYP E_COLUMN, GdaColumnClass))	#define GDA_COLUMN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYP E_COLUMN, GdaColumnClass))
	#define GDA_IS_COLUMN(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TY PE_COLUMN))	#define GDA_IS_COLUMN(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TY PE_COLUMN))
	#define GDA_IS_COLUMN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_T YPE_COLUMN))	#define GDA_IS_COLUMN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_T YPE_COLUMN))


	typedef struct _GdaColumn GdaColumn;
	typedef struct _GdaColumnClass GdaColumnClass;
	typedef struct _GdaColumnPrivate GdaColumnPrivate;

	struct _GdaColumn {	struct _GdaColumn {
	GObject object;	GObject object;
	GdaColumnPrivate *priv;	GdaColumnPrivate *priv;
	};	};

	struct _GdaColumnClass {	struct _GdaColumnClass {
	GObjectClass parent_class;	GObjectClass parent_class;

	/* signals */	/* signals */
	void (* name_changed) (GdaColumn column, const gchar old_name) ;	void (* name_changed) (GdaColumn column, const gchar old_name) ;

	skipping to change at line 84	skipping to change at line 80

	const gchar gda_column_get_caption (GdaColumn column);	const gchar gda_column_get_caption (GdaColumn column);
	void gda_column_set_caption (GdaColumn column, const gch ar caption);	void gda_column_set_caption (GdaColumn column, const gch ar caption);

	glong gda_column_get_scale (GdaColumn *column);	glong gda_column_get_scale (GdaColumn *column);
	void gda_column_set_scale (GdaColumn *column, glong sca le);	void gda_column_set_scale (GdaColumn *column, glong sca le);

	const gchar* gda_column_get_dbms_type (GdaColumn *column);	const gchar* gda_column_get_dbms_type (GdaColumn *column);
	void gda_column_set_dbms_type (GdaColumn column, const gch ar dbms_type);	void gda_column_set_dbms_type (GdaColumn column, const gch ar dbms_type);


	GdaValueType gda_column_get_gdatype (GdaColumn *column);	GdaValueType gda_column_get_gda_type (GdaColumn *column);
	void gda_column_set_gdatype (GdaColumn *column, GdaValueT	void gda_column_set_gda_type (GdaColumn *column, GdaValue
	ype type);	Type type);

	gboolean gda_column_get_allow_null (GdaColumn *column);	gboolean gda_column_get_allow_null (GdaColumn *column);
	void gda_column_set_allow_null (GdaColumn *column, gboolean allow);	void gda_column_set_allow_null (GdaColumn *column, gboolean allow);

	gboolean gda_column_get_primary_key (GdaColumn *column);	gboolean gda_column_get_primary_key (GdaColumn *column);
	void gda_column_set_primary_key (GdaColumn *column, gboolean pk);	void gda_column_set_primary_key (GdaColumn *column, gboolean pk);

	gboolean gda_column_get_unique_key (GdaColumn *column);	gboolean gda_column_get_unique_key (GdaColumn *column);
	void gda_column_set_unique_key (GdaColumn *column, gboolean uk);	void gda_column_set_unique_key (GdaColumn *column, gboolean uk);


End of changes. 3 change blocks.
	8 lines changed or deleted	4 lines changed or added

	gda-config.h	gda-config.h

	skipping to change at line 67	skipping to change at line 67
	guint gda_config_add_listener (const gchar *path, GdaConfigListenerFun c func,	guint gda_config_add_listener (const gchar *path, GdaConfigListenerFun c func,
	gpointer user_data);	gpointer user_data);
	void gda_config_remove_listener (guint id);	void gda_config_remove_listener (guint id);

	/*	/*
	* Providers configuration	* Providers configuration
	*/	*/

	typedef struct _GdaProviderInfo GdaProviderInfo;	typedef struct _GdaProviderInfo GdaProviderInfo;


	typedef struct {
	char *name;
	char *short_description;
	char *long_description;
	GdaValueType type;
	} GdaProviderParameterInfo;

	#define GDA_TYPE_PROVIDER_PARAMETER_INFO (gda_provider_parameter_info_get_t
	ype ())

	GType gda_provider_parameter_info_get_type (void);
	GdaProviderParameterInfo *gda_provider_parameter_info_new_full (const gchar
	*name,
	const gchar
	*short_description,
	const gchar
	*long_description,
	GdaValueType
	type);
	GdaProviderParameterInfo *gda_provider_parameter_info_copy (GdaProvider
	ParameterInfo *param_info);
	void gda_provider_parameter_info_free (GdaProvider
	ParameterInfo *param_info);

	/*	/*
	* REM about the @gda_params and @dsn_spec fields:	* REM about the @gda_params and @dsn_spec fields:
	*	*

	* The @gda_params lists all the parameters required to create a DSN, and i s historically the	* The @gda_params holds all the parameters required to create a DSN, and i s historically the
	* way to create a DSN. However the @dsn_spec field has been introduced to produce a more	* way to create a DSN. However the @dsn_spec field has been introduced to produce a more

	* detailled spec on what is required to create a DSN, but is not yet imple	* detailled spec on what is required to create a DSN.
	mented by all the
	* providers.
	*	*
	* When both fields are present, they are guaranted to list the _same_ para meters, using	* When both fields are present, they are guaranted to list the _same_ para meters, using
	* different representations.	* different representations.
	*/	*/
	struct _GdaProviderInfo {	struct _GdaProviderInfo {

	gchar *id;	gchar *id;
	gchar *location;	gchar *location;
	gchar *description;	gchar *description;
	GList gda_params; / A list of GdaProviderParameterInfo pointers to	GdaParameterList gda_params; / Contains a list of GdaParameter to
	create a DSN */	create a DSN */
	gchar dsn_spec; / XML string with all the parameters required to c	gchar dsn_spec; / XML string with all the parameters re
	reate a DSN */	quired to create a DSN */
	};	};

	#define GDA_TYPE_PROVIDER_INFO (gda_provider_info_get_type ())	#define GDA_TYPE_PROVIDER_INFO (gda_provider_info_get_type ())

	GType gda_provider_info_get_type (void);	GType gda_provider_info_get_type (void);
	GdaProviderInfo* gda_provider_info_copy (GdaProviderInfo *src);	GdaProviderInfo* gda_provider_info_copy (GdaProviderInfo *src);
	void gda_provider_info_free (GdaProviderInfo *provider _info);	void gda_provider_info_free (GdaProviderInfo *provider _info);

	GList *gda_config_get_provider_list (void);	GList *gda_config_get_provider_list (void);
	void gda_config_free_provider_list (GList *list);	void gda_config_free_provider_list (GList *list);

	skipping to change at line 154	skipping to change at line 136
	gboolean gda_config_save_data_source (const gchar *name,	gboolean gda_config_save_data_source (const gchar *name,
	const gchar *provider,	const gchar *provider,
	const gchar *cnc_string ,	const gchar *cnc_string ,
	const gchar *descriptio n,	const gchar *descriptio n,
	const gchar *username,	const gchar *username,
	const gchar *password,	const gchar *password,
	gboolean is_global);	gboolean is_global);
	gboolean gda_config_save_data_source_info (GdaDataSourceInfo *dsn _info);	gboolean gda_config_save_data_source_info (GdaDataSourceInfo *dsn _info);
	void gda_config_remove_data_source (const gchar *name);	void gda_config_remove_data_source (const gchar *name);


	/*
	* GDA configuration sections/keys
	*/
	#define GDA_CONFIG_BASE "/apps/libgda"
	#define GDA_CONFIG_SECTION_DATASOURCES "/apps/libgda/Datasources"
	#define GDA_CONFIG_SECTION_LAST_CONNECTIONS "/apps/libgda/LastConnections"

	#define GDA_CONFIG_KEY_MAX_LAST_CONNECTIONS "/apps/libgda/MaxLastConnectio
	ns"

	G_END_DECLS	G_END_DECLS

	#endif	#endif

End of changes. 5 change blocks.
	45 lines changed or deleted	9 lines changed or added

	gda-connection.h	gda-connection.h

	skipping to change at line 27	skipping to change at line 27
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.	* Library General Public License for more details.
	*	*
	* You should have received a copy of the GNU Library General Public	* You should have received a copy of the GNU Library General Public
	* License along with this Library; see the file COPYING.LIB. If not,	* License along with this Library; see the file COPYING.LIB. If not,
	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,
	* Boston, MA 02111-1307, USA.	* Boston, MA 02111-1307, USA.
	*/	*/

	#if !defined(__gda_connection_h__)	#if !defined(__gda_connection_h__)

	# define __gda_connection_h__	#define __gda_connection_h__


		#include "gda-decl.h"
		#include <libgda/gda-object.h>
	#include <libgda/gda-command.h>	#include <libgda/gda-command.h>
	#include <libgda/gda-data-model.h>	#include <libgda/gda-data-model.h>
	#include <libgda/gda-data-model-index.h>	#include <libgda/gda-data-model-index.h>
	#include <libgda/gda-connection-event.h>	#include <libgda/gda-connection-event.h>
	#include <libgda/gda-parameter.h>	#include <libgda/gda-parameter.h>
	#include <libgda/gda-transaction.h>	#include <libgda/gda-transaction.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_TYPE_CONNECTION (gda_connection_get_type())	#define GDA_TYPE_CONNECTION (gda_connection_get_type())
	#define GDA_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GD A_TYPE_CONNECTION, GdaConnection))	#define GDA_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GD A_TYPE_CONNECTION, GdaConnection))
	#define GDA_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA _TYPE_CONNECTION, GdaConnectionClass))	#define GDA_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA _TYPE_CONNECTION, GdaConnectionClass))
	#define GDA_IS_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA _TYPE_CONNECTION))	#define GDA_IS_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA _TYPE_CONNECTION))
	#define GDA_IS_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GD A_TYPE_CONNECTION))	#define GDA_IS_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GD A_TYPE_CONNECTION))


	typedef struct _GdaConnection GdaConnection;
	typedef struct _GdaConnectionClass GdaConnectionClass;
	typedef struct _GdaConnectionPrivate GdaConnectionPrivate;

	typedef struct _GdaServerProvider GdaServerProvider; /* defined in gda-s
	erver-provider.h */
	typedef struct _GdaClient GdaClient; /* defined in gda-client.h */

	struct _GdaConnection {	struct _GdaConnection {
	GObject object;	GObject object;
	GdaConnectionPrivate *priv;	GdaConnectionPrivate *priv;
	};	};

	struct _GdaConnectionClass {	struct _GdaConnectionClass {
	GObjectClass object_class;	GObjectClass object_class;

	/* signals */	/* signals */

	void (* error) (GdaConnection cnc, GdaConnectionEvent error);	void (error) (GdaConnection cnc, GdaConnecti
		onEvent *error);
		void (conn_opened) (GdaConnection obj);
		void (conn_to_close) (GdaConnection obj);
		void (conn_closed) (GdaConnection obj);
		void (dsn_changed) (GdaConnection obj);
	};	};


	GType gda_connection_get_type (void);

	typedef enum {	typedef enum {
	GDA_CONNECTION_OPTIONS_READ_ONLY = 1 << 0,	GDA_CONNECTION_OPTIONS_READ_ONLY = 1 << 0,
	GDA_CONNECTION_OPTIONS_DONT_SHARE = 2 << 0	GDA_CONNECTION_OPTIONS_DONT_SHARE = 2 << 0
	} GdaConnectionOptions;	} GdaConnectionOptions;


		typedef enum {
		GDA_CONNECTION_FEATURE_AGGREGATES,
		GDA_CONNECTION_FEATURE_BLOBS,
		GDA_CONNECTION_FEATURE_INDEXES,
		GDA_CONNECTION_FEATURE_INHERITANCE,
		GDA_CONNECTION_FEATURE_NAMESPACES,
		GDA_CONNECTION_FEATURE_PROCEDURES,
		GDA_CONNECTION_FEATURE_SEQUENCES,
		GDA_CONNECTION_FEATURE_SQL,
		GDA_CONNECTION_FEATURE_TRANSACTIONS,
		GDA_CONNECTION_FEATURE_TRIGGERS,
		GDA_CONNECTION_FEATURE_UPDATABLE_CURSOR,
		GDA_CONNECTION_FEATURE_USERS,
		GDA_CONNECTION_FEATURE_VIEWS,
		GDA_CONNECTION_FEATURE_XML_QUERIES
		} GdaConnectionFeature;

		typedef enum {
		GDA_CONNECTION_SCHEMA_AGGREGATES,
		GDA_CONNECTION_SCHEMA_DATABASES,
		GDA_CONNECTION_SCHEMA_FIELDS,
		GDA_CONNECTION_SCHEMA_INDEXES,
		GDA_CONNECTION_SCHEMA_LANGUAGES,
		GDA_CONNECTION_SCHEMA_NAMESPACES,
		GDA_CONNECTION_SCHEMA_PARENT_TABLES,
		GDA_CONNECTION_SCHEMA_PROCEDURES,
		GDA_CONNECTION_SCHEMA_SEQUENCES,
		GDA_CONNECTION_SCHEMA_TABLES,
		GDA_CONNECTION_SCHEMA_TRIGGERS,
		GDA_CONNECTION_SCHEMA_TYPES,
		GDA_CONNECTION_SCHEMA_USERS,
		GDA_CONNECTION_SCHEMA_VIEWS,
		GDA_CONNECTION_SCHEMA_CONSTRAINTS
		} GdaConnectionSchema;

		/* errors */
		enum
		{
		GDA_CONNECTION_CONN_OPEN_ERROR,
		GDA_CONNECTION_DO_QUERY_ERROR,
		};

		GType gda_connection_get_type (void);
	GdaConnection gda_connection_new (GdaClient client,	GdaConnection gda_connection_new (GdaClient client,
	GdaServerProvider *provider,	GdaServerProvider *provider,
	const gchar *dsn,	const gchar *dsn,
	const gchar *username,	const gchar *username,
	const gchar *password,	const gchar *password,

	GdaConnectionOptions options,	GdaConnectionOptions options);
	GError **error);	gboolean gda_connection_open (GdaConnection cnc, GError *erro
		r);
	gboolean gda_connection_reset (GdaConnection *cnc);	gboolean gda_connection_reset (GdaConnection *cnc);

	gboolean gda_connection_close (GdaConnection *cnc);	void gda_connection_close (GdaConnection *cnc);
	gboolean gda_connection_is_open (GdaConnection *cnc);	void gda_connection_close_no_warning (GdaConnection *cnc);
		gboolean gda_connection_is_opened (GdaConnection *cnc);

	GdaClient gda_connection_get_client (GdaConnection cnc);	GdaClient gda_connection_get_client (GdaConnection cnc);
	void gda_connection_set_client (GdaConnection cnc, GdaClie nt client);	void gda_connection_set_client (GdaConnection cnc, GdaClie nt client);


		const gchar gda_connection_get_provider (GdaConnection cnc);
		GdaServerProvider gda_connection_get_provider_obj (GdaConnection cnc);
		GdaServerProviderInfo gda_connection_get_infos (GdaConnection cnc);
	GdaConnectionOptions gda_connection_get_options (GdaConnection *cnc);	GdaConnectionOptions gda_connection_get_options (GdaConnection *cnc);

	const gchar gda_connection_get_server_version (GdaConnection cnc) ;	const gchar gda_connection_get_server_version (GdaConnection cnc) ;
	const gchar gda_connection_get_database (GdaConnection cnc);	const gchar gda_connection_get_database (GdaConnection cnc);
	const gchar gda_connection_get_dsn (GdaConnection cnc);	const gchar gda_connection_get_dsn (GdaConnection cnc);

		gboolean gda_connection_set_dsn (GdaConnection cnc, const gcha r datasource);
	const gchar gda_connection_get_cnc_string (GdaConnection cnc);	const gchar gda_connection_get_cnc_string (GdaConnection cnc);

	const gchar gda_connection_get_provider (GdaConnection cnc);
	const gchar gda_connection_get_username (GdaConnection cnc);	const gchar gda_connection_get_username (GdaConnection cnc);

		gboolean gda_connection_set_username (GdaConnection srv, const gchar username);
	const gchar gda_connection_get_password (GdaConnection cnc);	const gchar gda_connection_get_password (GdaConnection cnc);

		gboolean gda_connection_set_password (GdaConnection srv, const gchar password);

	void gda_connection_add_event (GdaConnection cnc, GdaConne ctionEvent error);	void gda_connection_add_event (GdaConnection cnc, GdaConne ctionEvent error);
	void gda_connection_add_event_string (GdaConnection cnc, c onst gchar str, ...);	void gda_connection_add_event_string (GdaConnection cnc, c onst gchar str, ...);
	void gda_connection_add_events_list (GdaConnection cnc, GL ist events_list);	void gda_connection_add_events_list (GdaConnection cnc, GL ist events_list);
	void gda_connection_clear_events_list (GdaConnection *cnc);	void gda_connection_clear_events_list (GdaConnection *cnc);
	const GList gda_connection_get_events (GdaConnection cnc);	const GList gda_connection_get_events (GdaConnection cnc);

	gboolean gda_connection_change_database (GdaConnection cnc, co nst gchar name);	gboolean gda_connection_change_database (GdaConnection cnc, co nst gchar name);
	gboolean gda_connection_create_table (GdaConnection cnc, const gchar table_name,	gboolean gda_connection_create_table (GdaConnection cnc, const gchar table_name,
	const GList *attributes_li st,	const GList *attributes_li st,

	skipping to change at line 133	skipping to change at line 179

	gboolean gda_connection_begin_transaction (GdaConnection cnc, GdaTransaction xaction);	gboolean gda_connection_begin_transaction (GdaConnection cnc, GdaTransaction xaction);
	gboolean gda_connection_commit_transaction (GdaConnection cnc, GdaTransaction xaction);	gboolean gda_connection_commit_transaction (GdaConnection cnc, GdaTransaction xaction);
	gboolean gda_connection_rollback_transaction (GdaConnection cn c, GdaTransaction xaction);	gboolean gda_connection_rollback_transaction (GdaConnection cn c, GdaTransaction xaction);

	GdaBlob gda_connection_create_blob (GdaConnection cnc);	GdaBlob gda_connection_create_blob (GdaConnection cnc);
	GdaBlob gda_connection_fetch_blob_by_id (GdaConnection cnc, c onst gchar *sql_id);	GdaBlob gda_connection_fetch_blob_by_id (GdaConnection cnc, c onst gchar *sql_id);

	gchar gda_connection_value_to_sql_string (GdaConnection cnc , GdaValue *from);	gchar gda_connection_value_to_sql_string (GdaConnection cnc , GdaValue *from);


	typedef enum {
	GDA_CONNECTION_FEATURE_AGGREGATES,
	GDA_CONNECTION_FEATURE_BLOBS,
	GDA_CONNECTION_FEATURE_INDEXES,
	GDA_CONNECTION_FEATURE_INHERITANCE,
	GDA_CONNECTION_FEATURE_NAMESPACES,
	GDA_CONNECTION_FEATURE_PROCEDURES,
	GDA_CONNECTION_FEATURE_SEQUENCES,
	GDA_CONNECTION_FEATURE_SQL,
	GDA_CONNECTION_FEATURE_TRANSACTIONS,
	GDA_CONNECTION_FEATURE_TRIGGERS,
	GDA_CONNECTION_FEATURE_UPDATABLE_CURSOR,
	GDA_CONNECTION_FEATURE_USERS,
	GDA_CONNECTION_FEATURE_VIEWS,
	GDA_CONNECTION_FEATURE_XML_QUERIES
	} GdaConnectionFeature;

	gboolean gda_connection_supports (GdaConnection *cnc, GdaConnec tionFeature feature);	gboolean gda_connection_supports (GdaConnection *cnc, GdaConnec tionFeature feature);

		GdaDataModel gda_connection_get_schema (GdaConnection cnc, GdaConn
	typedef enum {	ectionSchema schema,
	GDA_CONNECTION_SCHEMA_AGGREGATES,	GdaParameterList *params, GE
	GDA_CONNECTION_SCHEMA_DATABASES,	rror **error);
	GDA_CONNECTION_SCHEMA_FIELDS,
	GDA_CONNECTION_SCHEMA_INDEXES,
	GDA_CONNECTION_SCHEMA_LANGUAGES,
	GDA_CONNECTION_SCHEMA_NAMESPACES,
	GDA_CONNECTION_SCHEMA_PARENT_TABLES,
	GDA_CONNECTION_SCHEMA_PROCEDURES,
	GDA_CONNECTION_SCHEMA_SEQUENCES,
	GDA_CONNECTION_SCHEMA_TABLES,
	GDA_CONNECTION_SCHEMA_TRIGGERS,
	GDA_CONNECTION_SCHEMA_TYPES,
	GDA_CONNECTION_SCHEMA_USERS,
	GDA_CONNECTION_SCHEMA_VIEWS
	} GdaConnectionSchema;

	GdaDataModel gda_connection_get_schema (GdaConnection cnc,
	GdaConnectionSchema schema,
	GdaParameterList *params);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

End of changes. 15 change blocks.
	55 lines changed or deleted	68 lines changed or added

	gda-data-model.h	gda-data-model.h

	skipping to change at line 24	skipping to change at line 24
	* 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
	* Library General Public License for more details.	* Library General Public License for more details.
	*	*
	* You should have received a copy of the GNU Library General Public	* You should have received a copy of the GNU Library General Public
	* License along with this Library; see the file COPYING.LIB. If not,	* License along with this Library; see the file COPYING.LIB. If not,
	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,
	* Boston, MA 02111-1307, USA.	* Boston, MA 02111-1307, USA.
	*/	*/


	#if !defined(__gda_data_model_h__)	#ifndef __GDA_DATA_MODEL_H__
	# define __gda_data_model_h__	#define __GDA_DATA_MODEL_H__

	#include <glib-object.h>	#include <glib-object.h>
	#include <libxml/parser.h>	#include <libxml/parser.h>
	#include <libxml/tree.h>	#include <libxml/tree.h>
	#include <libgda/gda-command.h>	#include <libgda/gda-command.h>

	#include <libgda/global-decl.h>	#include <libgda/gda-decl.h>
	#include <libgda/gda-column.h>	#include <libgda/gda-column.h>
	#include <libgda/gda-value.h>	#include <libgda/gda-value.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_TYPE_DATA_MODEL (gda_data_model_get_type())	#define GDA_TYPE_DATA_MODEL (gda_data_model_get_type())
	#define GDA_DATA_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GD A_TYPE_DATA_MODEL, GdaDataModel))	#define GDA_DATA_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GD A_TYPE_DATA_MODEL, GdaDataModel))
	#define GDA_IS_DATA_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GD A_TYPE_DATA_MODEL))	#define GDA_IS_DATA_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GD A_TYPE_DATA_MODEL))

	#define GDA_DATA_MODEL_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj ), GDA_TYPE_DATA_MODEL, GdaDataModelIface))	#define GDA_DATA_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj ), GDA_TYPE_DATA_MODEL, GdaDataModelClass))


	typedef gboolean (* GdaDataModelForeachFunc) (GdaDataModel *model,	typedef enum {
	GdaRow *row,	GDA_DATA_MODEL_ACCESS_RANDOM = 1 << 0,
	gpointer user_data);	GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD = 1 << 1,
		GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD = 1 << 2,
		GDA_DATA_MODEL_ACCESS_INSERT = 1 << 3,
		GDA_DATA_MODEL_ACCESS_UPDATE = 1 << 4,
		GDA_DATA_MODEL_ACCESS_DELETE = 1 << 5,
		GDA_DATA_MODEL_ACCESS_WRITE = GDA_DATA_MODEL_ACCESS_INSERT \| GDA_DAT
		A_MODEL_ACCESS_UPDATE \|
		GDA_DATA_MODEL_ACCESS_DELETE,
		} GdaDataModelAccessFlags;

		typedef enum {
		GDA_DATA_MODEL_HINT_START_BATCH_UPDATE,
		GDA_DATA_MODEL_HINT_END_BATCH_UPDATE,
		GDA_DATA_MODEL_HINT_REFRESH,
		} GdaDataModelHint;

		typedef enum {
		GDA_DATA_MODEL_IO_DATA_ARRAY_XML,
		GDA_DATA_MODEL_IO_TEXT_SEPARATED,
		} GdaDataModelIOFormat;

		enum {
		GDA_DATA_MODEL_ROW_OUT_OF_RANGE_ERROR,
		GDA_DATA_MODEL_COLUMN_OUT_OF_RANGE_ERROR,
		GDA_DATA_MODEL_VALUES_LIST_ERROR,
		GDA_DATA_MODEL_ROW_NOT_FOUND_ERROR
		};

	/* struct for the interface */	/* struct for the interface */

	struct _GdaDataModelIface {	struct _GdaDataModelClass {
	GTypeInterface g_iface;	GTypeInterface g_iface;

	/* virtual table */	/* virtual table */

	gint (* i_get_n_rows) (GdaDataModel *model);	gint (* i_get_n_rows) (GdaDataModel *model);
	gint (* i_get_n_columns) (GdaDataModel *model);	gint (* i_get_n_columns) (GdaDataModel *model);

	GdaColumn ( i_describe_column) (GdaDataModel *model, gin
	t col);
	GdaRow ( i_get_row) (GdaDataModel *model, gin
	t row);
	const GdaValue ( i_get_value_at) (GdaDataModel *model, gin
	t col, gint row);

	gboolean (* i_is_updatable) (GdaDataModel *model);
	gboolean (* i_has_changed) (GdaDataModel *model);
	void (* i_begin_changes) (GdaDataModel *model);
	gboolean (* i_commit_changes) (GdaDataModel *model);
	gboolean (* i_cancel_changes) (GdaDataModel *model);


	GdaRow ( i_append_values) (GdaDataModel *model, con	GdaColumn ( i_describe_column) (GdaDataModel *model, gi
	st GList *values);	nt col);
	gboolean (* i_append_row) (GdaDataModel *model, Gda	guint (* i_get_access_flags) (GdaDataModel *model);
	Row *row);
	gboolean (* i_update_row) (GdaDataModel *model, Gda
	Row *row);
	gboolean (* i_remove_row) (GdaDataModel *model, Gda
	Row *row);


	GdaColumn ( i_append_column) (GdaDataModel *model);	const GdaValue ( i_get_value_at) (GdaDataModel *model, gi
	gboolean (* i_remove_column) (GdaDataModel *model, gin	nt col, gint row);
	t col);	guint (* i_get_attributes_at)(GdaDataModel *model, gi
		nt col, gint row);
		GdaDataModelIter ( i_create_iter) (GdaDataModel *model);
		gboolean (* i_iter_at_row) (GdaDataModel *model, Gd
		aDataModelIter *iter, gint row);
		gboolean (* i_iter_next) (GdaDataModel *model, Gd
		aDataModelIter *iter);
		gboolean (* i_iter_prev) (GdaDataModel *model, Gd
		aDataModelIter *iter);


	void (* i_set_notify) (GdaDataModel *model, gbo	gboolean (* i_set_value_at) (GdaDataModel *model, gi
	olean do_notify_changes);	nt col, gint row,
	gboolean (* i_get_notify) (GdaDataModel *model);	const GdaValue *value,
		GError **error);
		gboolean (* i_set_values) (GdaDataModel *model, gi
		nt row, GList *values,
		GError **error);
		gint (* i_append_values) (GdaDataModel *model, co
		nst GList values, GError *error);
		gint (* i_append_row) (GdaDataModel *model, GE
		rror **error);
		gboolean (* i_remove_row) (GdaDataModel *model, gi
		nt row, GError **error);
		gint (* i_find_row) (GdaDataModel *model, GS
		List values, gint cols_index);


	gboolean (* i_set_command) (GdaDataModel *model, con	void (* i_set_notify) (GdaDataModel *model, gb
	st gchar *txt, GdaCommandType type);	oolean do_notify_changes);
	const gchar ( i_get_command) (GdaDataModel *model, Gda	gboolean (* i_get_notify) (GdaDataModel *model);
	CommandType *type);	void (* i_send_hint) (GdaDataModel *model, Gd
		aDataModelHint hint, const GdaValue *hint_value);

	/* signals */	/* signals */

	void (* changed) (GdaDataModel *model);
	void (* row_inserted) (GdaDataModel *model, gint row);	void (* row_inserted) (GdaDataModel *model, gint row);
	void (* row_updated) (GdaDataModel *model, gint row);	void (* row_updated) (GdaDataModel *model, gint row);
	void (* row_removed) (GdaDataModel *model, gint row);	void (* row_removed) (GdaDataModel *model, gint row);

	void (* column_inserted) (GdaDataModel *model, gint
	col);
	void (* column_updated) (GdaDataModel *model, gint
	col);
	void (* column_removed) (GdaDataModel *model, gint
	col);

	void (* begin_update) (GdaDataModel *model);
	void (* cancel_update) (GdaDataModel *model);
	void (* commit_update) (GdaDataModel *model);
	};	};


	GType gda_data_model_get_type (void);	GType gda_data_model_get_type (void);


	void gda_data_model_freeze (GdaDat	gboolean gda_data_model_is_updatable (GdaDataModel *mo
	aModel *model);	del);
	void gda_data_model_thaw (GdaDat	guint gda_data_model_get_access_flags (GdaDataModel *mo
	aModel *model);	del);


	gint gda_data_model_get_n_rows (GdaDat	gint gda_data_model_get_n_rows (GdaDataModel *mo
	aModel *model);	del);
	gint gda_data_model_get_n_columns (GdaDat	gint gda_data_model_get_n_columns (GdaDataModel *mo
	aModel *model);	del);
	GdaColumn *gda_data_model_describe_column (GdaDat
	aModel *model, gint col);
	const gchar *gda_data_model_get_column_title (GdaDat
	aModel *model, gint col);
	void gda_data_model_set_column_title (GdaDat
	aModel model, gint col, const gchar title);
	GdaRow *gda_data_model_get_row (GdaDat
	aModel *model, gint row);
	const GdaValue *gda_data_model_get_value_at (GdaDat
	aModel *model, gint col, gint row);


	gboolean gda_data_model_is_updatable (GdaDat	GdaColumn gda_data_model_describe_column (GdaDataModel mo
	aModel *model);	del, gint col);
	GdaRow *gda_data_model_append_values (GdaDat	const gchar gda_data_model_get_column_title (GdaDataModel mo
	aModel model, const GList values);	del, gint col);
	gboolean gda_data_model_append_row (GdaDat	void gda_data_model_set_column_title (GdaDataModel *mo
	aModel model, GdaRow row);	del, gint col, const gchar *title);
	gboolean gda_data_model_update_row (GdaDat
	aModel model, GdaRow row);
	gboolean gda_data_model_remove_row (GdaDat
	aModel model, GdaRow row);
	GdaColumn *gda_data_model_append_column (GdaData
	Model *model);
	gboolean gda_data_model_remove_column (GdaData
	Model *model, gint col);


	void gda_data_model_foreach (GdaDat	const GdaValue gda_data_model_get_value_at (GdaDataModel mo
	aModel *model, GdaDataModelForeachFunc func,	del, gint col, gint row);
	gpointe	guint gda_data_model_get_attributes_at (GdaDataModel *mo
	r user_data);	del, gint col, gint row);
		GdaDataModelIter gda_data_model_create_iter (GdaDataModel mo
		del);
		gboolean gda_data_model_move_iter_at_row (GdaDataModel *mo
		del, GdaDataModelIter *iter, gint row);
		gboolean gda_data_model_move_iter_next (GdaDataModel *mo
		del, GdaDataModelIter *iter);
		gboolean gda_data_model_move_iter_prev (GdaDataModel *mo
		del, GdaDataModelIter *iter);
		void gda_data_model_freeze (GdaDataModel *mo
		del);
		void gda_data_model_thaw (GdaDataModel *mo
		del);
		gboolean gda_data_model_set_value_at (GdaDataModel *mo
		del, gint col, gint row,
		const GdaValue *v
		alue, GError **error);
		gboolean gda_data_model_set_values (GdaDataModel *mo
		del, gint row,
		GList *values, GE
		rror **error);
		gint gda_data_model_append_row (GdaDataModel *mo
		del, GError **error);
		gint gda_data_model_append_values (GdaDataModel *mo
		del, const GList values, GError *error);
		gboolean gda_data_model_remove_row (GdaDataModel *mo
		del, gint row, GError **error);
		gint gda_data_model_get_row_from_values (GdaDataModel *mo
		del, GSList values, gint cols_index);


	gboolean gda_data_model_has_changed (GdaDat	void gda_data_model_send_hint (GdaDataModel *mo
	aModel *model);	del, GdaDataModelHint hint, const GdaValue *hint_value);
	gboolean gda_data_model_begin_update (GdaDat
	aModel *model);
	gboolean gda_data_model_cancel_update (GdaDat
	aModel *model);
	gboolean gda_data_model_commit_update (GdaDat
	aModel *model);


	gchar *gda_data_model_to_text_separated (GdaDat	/* contents saving and loading */
	aModel model, const gint cols, gint nb_cols,	gchar gda_data_model_export_to_string (GdaDataModel mo
	gchar s	del, GdaDataModelIOFormat format,
	ep);	const gint *cols,
	gchar *gda_data_model_to_xml (GdaDat	gint nb_cols, GdaParameterList *options);
	aModel model, const gint cols, gint nb_cols,	gboolean gda_data_model_export_to_file (GdaDataModel *mo
	const g	del, GdaDataModelIOFormat format,
	char *name);	const gchar *file
	xmlNodePtr gda_data_model_to_xml_node (GdaDat	,
	aModel model, const gint cols, gint nb_cols,	const gint *cols,
	const g	gint nb_cols,
	char *name);	GdaParameterList
	gboolean gda_data_model_add_data_from_xml_node (GdaDat	options, GError *error);
	aModel *model, xmlNodePtr node);


	void gda_data_model_dump (GdaDat	gboolean gda_data_model_import_from_model (GdaDataModel *to
	aModel model, FILE to_stream);	, GdaDataModel *from,
	gchar *gda_data_model_dump_as_string (GdaDat	GHashTable *cols_
	aModel *model);	trans, GError **error);
		gboolean gda_data_model_import_from_string (GdaDataModel *mo
		del,
		const gchar *stri
		ng, GHashTable *cols_trans,
		GdaParameterList
		options, GError *error);
		gboolean gda_data_model_import_from_file (GdaDataModel *mo
		del,
		const gchar *file
		, GHashTable *cols_trans,
		GdaParameterList
		options, GError *error);

		/* debug functions */
		void gda_data_model_dump (GdaDataModel *mo
		del, FILE *to_stream);
		gchar gda_data_model_dump_as_string (GdaDataModel mo
		del);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

End of changes. 20 change blocks.
	115 lines changed or deleted	154 lines changed or added

	gda-enum-types.h	gda-enum-types.h

	skipping to change at line 16	skipping to change at line 16

	G_BEGIN_DECLS	G_BEGIN_DECLS
	/* enumerations from "gda-blob.h" */	/* enumerations from "gda-blob.h" */
	GType gda_blob_mode_get_type (void);	GType gda_blob_mode_get_type (void);
	#define GDA_TYPE_BLOB_MODE (gda_blob_mode_get_type())	#define GDA_TYPE_BLOB_MODE (gda_blob_mode_get_type())
	/* enumerations from "gda-client.h" */	/* enumerations from "gda-client.h" */
	GType gda_client_event_get_type (void);	GType gda_client_event_get_type (void);
	#define GDA_TYPE_CLIENT_EVENT (gda_client_event_get_type())	#define GDA_TYPE_CLIENT_EVENT (gda_client_event_get_type())
	GType gda_client_specs_type_get_type (void);	GType gda_client_specs_type_get_type (void);
	#define GDA_TYPE_CLIENT_SPECS_TYPE (gda_client_specs_type_get_type())	#define GDA_TYPE_CLIENT_SPECS_TYPE (gda_client_specs_type_get_type())

		/* enumerations from "gda-column-index.h" */
		GType gda_sorting_get_type (void);
		#define GDA_TYPE_SORTING (gda_sorting_get_type())
	/* enumerations from "gda-command.h" */	/* enumerations from "gda-command.h" */
	GType gda_command_options_get_type (void);	GType gda_command_options_get_type (void);
	#define GDA_TYPE_COMMAND_OPTIONS (gda_command_options_get_type())	#define GDA_TYPE_COMMAND_OPTIONS (gda_command_options_get_type())
	GType gda_command_type_get_type (void);	GType gda_command_type_get_type (void);
	#define GDA_TYPE_COMMAND_TYPE (gda_command_type_get_type())	#define GDA_TYPE_COMMAND_TYPE (gda_command_type_get_type())

		/* enumerations from "gda-connection-event.h" */
		GType gda_connection_event_type_get_type (void);
		#define GDA_TYPE_CONNECTION_EVENT_TYPE (gda_connection_event_type_get_type(
		))
		GType gda_connection_event_code_get_type (void);
		#define GDA_TYPE_CONNECTION_EVENT_CODE (gda_connection_event_code_get_type(
		))
	/* enumerations from "gda-connection.h" */	/* enumerations from "gda-connection.h" */
	GType gda_connection_options_get_type (void);	GType gda_connection_options_get_type (void);
	#define GDA_TYPE_CONNECTION_OPTIONS (gda_connection_options_get_type())	#define GDA_TYPE_CONNECTION_OPTIONS (gda_connection_options_get_type())
	GType gda_connection_feature_get_type (void);	GType gda_connection_feature_get_type (void);
	#define GDA_TYPE_CONNECTION_FEATURE (gda_connection_feature_get_type())	#define GDA_TYPE_CONNECTION_FEATURE (gda_connection_feature_get_type())
	GType gda_connection_schema_get_type (void);	GType gda_connection_schema_get_type (void);
	#define GDA_TYPE_CONNECTION_SCHEMA (gda_connection_schema_get_type())	#define GDA_TYPE_CONNECTION_SCHEMA (gda_connection_schema_get_type())

	/* enumerations from "gda-connection-event.h" */	/* enumerations from "gda-data-model.h" */
	GType gda_connection_event_type_get_type (void);	GType gda_data_model_access_flags_get_type (void);
	#define GDA_TYPE_CONNECTION_EVENT_TYPE (gda_connection_event_type_get_type(	#define GDA_TYPE_DATA_MODEL_ACCESS_FLAGS (gda_data_model_access_flags_get_t
	))	ype())
	GType gda_connection_event_code_get_type (void);	GType gda_data_model_hint_get_type (void);
	#define GDA_TYPE_CONNECTION_EVENT_CODE (gda_connection_event_code_get_type(	#define GDA_TYPE_DATA_MODEL_HINT (gda_data_model_hint_get_type())
	))	GType gda_data_model_io_format_get_type (void);
	/* enumerations from "gda-column-index.h" */	#define GDA_TYPE_DATA_MODEL_IO_FORMAT (gda_data_model_io_format_get_type())
	GType gda_sorting_get_type (void);	/* enumerations from "gda-dict-constraint.h" */
	#define GDA_TYPE_SORTING (gda_sorting_get_type())	GType gda_dict_constraint_type_get_type (void);
		#define GDA_TYPE_DICT_CONSTRAINT_TYPE (gda_dict_constraint_type_get_type())
		GType gda_dict_constraint_fk_action_get_type (void);
		#define GDA_TYPE_DICT_CONSTRAINT_FK_ACTION (gda_dict_constraint_fk_action_g
		et_type())
		/* enumerations from "gda-dict-field.h" */
		GType gda_dict_field_attribute_get_type (void);
		#define GDA_TYPE_DICT_FIELD_ATTRIBUTE (gda_dict_field_attribute_get_type())
		/* enumerations from "gda-enums.h" */
		GType gda_value_attribute_get_type (void);
		#define GDA_TYPE_VALUE_ATTRIBUTE (gda_value_attribute_get_type())
		GType gda_graph_type_get_type (void);
		#define GDA_TYPE_GRAPH_TYPE (gda_graph_type_get_type())
		GType gda_entity_field_state_get_type (void);
		#define GDA_TYPE_ENTITY_FIELD_STATE (gda_entity_field_state_get_type())
		/* enumerations from "gda-object-ref.h" */
		GType gda_object_ref_type_get_type (void);
		#define GDA_TYPE_OBJECT_REF_TYPE (gda_object_ref_type_get_type())
		/* enumerations from "gda-parameter-list.h" */
		GType gda_parameter_list_param_hint_get_type (void);
		#define GDA_TYPE_PARAMETER_LIST_PARAM_HINT (gda_parameter_list_param_hint_g
		et_type())
		/* enumerations from "gda-query-condition.h" */
		GType gda_query_condition_type_get_type (void);
		#define GDA_TYPE_QUERY_CONDITION_TYPE (gda_query_condition_type_get_type())
		GType gda_query_condition_operator_get_type (void);
		#define GDA_TYPE_QUERY_CONDITION_OPERATOR (gda_query_condition_operator_get
		_type())
		/* enumerations from "gda-query.h" */
		GType gda_query_type_get_type (void);
		#define GDA_TYPE_QUERY_TYPE (gda_query_type_get_type())
		/* enumerations from "gda-query-join.h" */
		GType gda_query_join_type_get_type (void);
		#define GDA_TYPE_QUERY_JOIN_TYPE (gda_query_join_type_get_type())
		/* enumerations from "gda-query-target.h" */
		GType gda_query_target_type_get_type (void);
		#define GDA_TYPE_QUERY_TARGET_TYPE (gda_query_target_type_get_type())
		/* enumerations from "gda-renderer.h" */
		GType gda_renderer_options_get_type (void);
		#define GDA_TYPE_RENDERER_OPTIONS (gda_renderer_options_get_type())
	/* enumerations from "gda-transaction.h" */	/* enumerations from "gda-transaction.h" */
	GType gda_transaction_isolation_get_type (void);	GType gda_transaction_isolation_get_type (void);
	#define GDA_TYPE_TRANSACTION_ISOLATION (gda_transaction_isolation_get_type( ))	#define GDA_TYPE_TRANSACTION_ISOLATION (gda_transaction_isolation_get_type( ))
	/* enumerations from "gda-value.h" */	/* enumerations from "gda-value.h" */
	GType gda_value_type_get_type (void);	GType gda_value_type_get_type (void);
	#define GDA_TYPE_VALUE_TYPE (gda_value_type_get_type())	#define GDA_TYPE_VALUE_TYPE (gda_value_type_get_type())
	G_END_DECLS	G_END_DECLS

	#endif /* __LIBGDA_ENUM_TYPES_H__ */	#endif /* __LIBGDA_ENUM_TYPES_H__ */

End of changes. 3 change blocks.
	10 lines changed or deleted	59 lines changed or added

	gda-marshal.h	gda-marshal.h

	#ifndef __gda_marshal_MARSHAL_H__	#ifndef __gda_marshal_MARSHAL_H__
	#define __gda_marshal_MARSHAL_H__	#define __gda_marshal_MARSHAL_H__

	#include <glib-object.h>	#include <glib-object.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS


	/* VOID:POINTER,POINTER (gda-marshal.list:25) */	/* VOID:VOID (gda-marshal.list:25) */
		#define gda_marshal_VOID__VOID g_cclosure_marshal_VOID__VOID

		/* VOID:POINTER (gda-marshal.list:26) */
		#define gda_marshal_VOID__POINTER g_cclosure_marshal_VOID__POINTER

		/* VOID:OBJECT (gda-marshal.list:27) */
		#define gda_marshal_VOID__OBJECT g_cclosure_marshal_VOID__OBJECT

		/* VOID:POINTER,POINTER (gda-marshal.list:28) */
	extern void gda_marshal_VOID__POINTER_POINTER (GClosure *closure,	extern void gda_marshal_VOID__POINTER_POINTER (GClosure *closure,
	GValue *return_value,	GValue *return_value,
	guint n_param_values ,	guint n_param_values ,
	const GValue *param_values,	const GValue *param_values,
	gpointer invocation_hin t,	gpointer invocation_hin t,
	gpointer marshal_data);	gpointer marshal_data);


	/* VOID:POINTER,INT,POINTER (gda-marshal.list:26) */	/* VOID:POINTER,INT,POINTER (gda-marshal.list:29) */
	extern void gda_marshal_VOID__POINTER_INT_POINTER (GClosure *closure,	extern void gda_marshal_VOID__POINTER_INT_POINTER (GClosure *closure,
	GValue *return_val ue,	GValue *return_val ue,
	guint n_param_va lues,	guint n_param_va lues,
	const GValue *param_valu es,	const GValue *param_valu es,
	gpointer invocation _hint,	gpointer invocation _hint,
	gpointer marshal_da ta);	gpointer marshal_da ta);


	/* VOID:POINTER,UINT (gda-marshal.list:27) */	/* VOID:POINTER,UINT (gda-marshal.list:30) */
	extern void gda_marshal_VOID__POINTER_UINT (GClosure *closure,	extern void gda_marshal_VOID__POINTER_UINT (GClosure *closure,
	GValue *return_value,	GValue *return_value,
	guint n_param_values,	guint n_param_values,
	const GValue *param_values,	const GValue *param_values,
	gpointer invocation_hint,	gpointer invocation_hint,
	gpointer marshal_data);	gpointer marshal_data);


	/* VOID:ENUM,POINTER (gda-marshal.list:28) */	/* VOID:POINTER,UINT,UINT (gda-marshal.list:31) */
		extern void gda_marshal_VOID__POINTER_UINT_UINT (GClosure *closure,
		GValue *return_value
		,
		guint n_param_valu
		es,
		const GValue *param_values
		,
		gpointer invocation_h
		int,
		gpointer marshal_data
		);

		/* VOID:ENUM,POINTER (gda-marshal.list:32) */
	extern void gda_marshal_VOID__ENUM_POINTER (GClosure *closure,	extern void gda_marshal_VOID__ENUM_POINTER (GClosure *closure,
	GValue *return_value,	GValue *return_value,
	guint n_param_values,	guint n_param_values,
	const GValue *param_values,	const GValue *param_values,
	gpointer invocation_hint,	gpointer invocation_hint,
	gpointer marshal_data);	gpointer marshal_data);


	/* VOID:UINT,POINTER (gda-marshal.list:29) */	/* VOID:UINT,POINTER (gda-marshal.list:33) */
	#define gda_marshal_VOID__UINT_POINTER g_cclosure_marshal_VOID__UINT_POINTE R	#define gda_marshal_VOID__UINT_POINTER g_cclosure_marshal_VOID__UINT_POINTE R


	/* VOID:INT,INT (gda-marshal.list:30) */	/* VOID:INT,INT (gda-marshal.list:34) */
	extern void gda_marshal_VOID__INT_INT (GClosure *closure,	extern void gda_marshal_VOID__INT_INT (GClosure *closure,
	GValue *return_value,	GValue *return_value,
	guint n_param_values,	guint n_param_values,
	const GValue *param_values,	const GValue *param_values,
	gpointer invocation_hint,	gpointer invocation_hint,
	gpointer marshal_data);	gpointer marshal_data);


	/* VOID:INT,POINTER,POINTER (gda-marshal.list:31) */	/* VOID:INT,POINTER,POINTER (gda-marshal.list:35) */
	extern void gda_marshal_VOID__INT_POINTER_POINTER (GClosure *closure,	extern void gda_marshal_VOID__INT_POINTER_POINTER (GClosure *closure,
	GValue *return_val ue,	GValue *return_val ue,
	guint n_param_va lues,	guint n_param_va lues,
	const GValue *param_valu es,	const GValue *param_valu es,
	gpointer invocation _hint,	gpointer invocation _hint,
	gpointer marshal_da ta);	gpointer marshal_da ta);


		/* VOID:INT,BOOLEAN (gda-marshal.list:36) */
		extern void gda_marshal_VOID__INT_BOOLEAN (GClosure *closure,
		GValue *return_value,
		guint n_param_values,
		const GValue *param_values,
		gpointer invocation_hint,
		gpointer marshal_data);

	G_END_DECLS	G_END_DECLS

	#endif /* __gda_marshal_MARSHAL_H__ */	#endif /* __gda_marshal_MARSHAL_H__ */

End of changes. 8 change blocks.
	7 lines changed or deleted	37 lines changed or added

	gda-parameter.h	gda-parameter.h

	/* GDA library	/* gda-parameter.h
	* Copyright (C) 1998-2002 The GNOME Foundation.
	*	*

	* AUTHORS:	* Copyright (C) 2003 - 2005 Vivien Malerba
	* Rodrigo Moya <rodrigo@gnome-db.org>
	*	*

	* This Library is free software; you can redistribute it and/or	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public License as	* modify it under the terms of the GNU General Public License as
	* published by the Free Software Foundation; either version 2 of the	* published by the Free Software Foundation; either version 2 of the
	* License, or (at your option) any later version.	* License, or (at your option) any later version.
	*	*

	* This Library is distributed in the hope that it will be useful,	* This program 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
	* Library General Public License for more details.	* GNU General Public License for more details.
	*	*

	* You should have received a copy of the GNU Library General Public	* You should have received a copy of the GNU General Public License
	* License along with this Library; see the file COPYING.LIB. If not,	* along with this program; if not, write to the Free Software
	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	,	* USA
	* Boston, MA 02111-1307, USA.
	*/	*/


	#if !defined(__gda_parameter_h__)	#ifndef __GDA_PARAMETER_H_
	# define __gda_parameter_h__	#define __GDA_PARAMETER_H_


	#include <glib/gmacros.h>	#include <libgda/gda-object.h>
	#include <libgda/gda-value.h>	#include "gda-value.h"

	G_BEGIN_DECLS	G_BEGIN_DECLS


	typedef struct _GdaParameter GdaParameter;	#define GDA_TYPE_PARAMETER (gda_parameter_get_type())
		#define GDA_PARAMETER(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gda_pa
		rameter_get_type(), GdaParameter)
		#define GDA_PARAMETER_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gda_par
		ameter_get_type (), GdaParameterClass)
		#define GDA_IS_PARAMETER(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_pa
		rameter_get_type ())


	struct _GdaParameter {	/* error reporting */
	gchar *name;	extern GQuark gda_parameter_error_quark (void);
	GdaValue *value;	#define GDA_PARAMETER_ERROR gda_parameter_error_quark ()

		enum {
		GDA_PARAMETER_QUERY_LIMIT_ERROR
	};	};


	#define GDA_TYPE_PARAMETER (gda_parameter_get_type())	/* struct for the object's data */
		struct _GdaParameter
		{
		GdaObject object;
		GdaParameterPrivate *priv;
		};


	GType gda_parameter_get_type (void);	/* struct for the object's class */
	GdaParameter gda_parameter_new_from_value (const gchar name, const GdaV	struct _GdaParameterClass
	alue *value);	{
	GdaParameter gda_parameter_new_boolean (const gchar name, gboolean valu	GdaObjectClass parent_class;
	e);	void (restrict_changed) (GdaParameter
	GdaParameter gda_parameter_new_double (const gchar name, gdouble value)	param);
	;	};
	GdaParameter gda_parameter_new_gobject (const gchar name, const GObject
	*value);
	GdaParameter gda_parameter_new_string (const gchar name, const gchar *v
	alue);
	GdaParameter gda_parameter_copy (GdaParameter param);
	void gda_parameter_free (GdaParameter *param);
	const gchar gda_parameter_get_name (GdaParameter param);
	void gda_parameter_set_name (GdaParameter param, const gchar n
	ame);
	const GdaValue gda_parameter_get_value (GdaParameter param);
	void gda_parameter_set_value (GdaParameter param, GdaValue val
	ue);


	typedef struct _GdaParameterList GdaParameterList;	GType gda_parameter_get_type (void);
		GdaParameter *gda_parameter_new (GdaValueType
		type);
		GdaParameter *gda_parameter_new_copy (GdaParameter
		*orig);
		GdaValueType gda_parameter_get_gda_type (GdaParameter
		*param);


	#define GDA_TYPE_PARAMETER_LIST (gda_parameter_list_get_type())	GdaParameter gda_parameter_new_string (const gchar
		name, const gchar *str);
		GdaParameter gda_parameter_new_boolean (const gchar
		name, gboolean value);


	GType gda_parameter_list_get_type (void);	void gda_parameter_declare_param_user (GdaParameter
	GdaParameterList *gda_parameter_list_new (void);	param, GdaObject user);
	void gda_parameter_list_free (GdaParameterList *plist);	GSList *gda_parameter_get_param_users (GdaParameter
	GdaParameterList gda_parameter_list_copy (GdaParameterList plist);	*param);
	void gda_parameter_list_add_parameter (GdaParameterList *pli	void gda_parameter_replace_param_users (GdaParameter
	st,	param, GHashTable replacements);
	GdaParameter *param);
	GList gda_parameter_list_get_names (GdaParameterList plist);	const GdaValue *gda_parameter_get_value (GdaParameter
	GdaParameter gda_parameter_list_find (GdaParameterList plist,	*param);
	const gchar *name);	void gda_parameter_set_value (GdaParameter
	void gda_parameter_list_clear (GdaParameterList *plist);	param, const GdaValue value);
	guint gda_parameter_list_get_length (GdaParameterList *plist)	gboolean gda_parameter_set_value_str (GdaParameter
	;	param, const gchar value);

		void gda_parameter_declare_invalid (GdaParameter
		*param);
		gboolean gda_parameter_is_valid (GdaParameter
		*param);

		const GdaValue *gda_parameter_get_default_value (GdaParameter
		*param);
		void gda_parameter_set_default_value (GdaParameter
		param, const GdaValue value);
		gboolean gda_parameter_get_exists_default_value(GdaParameter
		*param);
		void gda_parameter_set_exists_default_value(GdaParameter
		*param, gboolean default_value_exists);

		void gda_parameter_set_not_null (GdaParameter
		*param, gboolean not_null);
		gboolean gda_parameter_get_not_null (GdaParameter
		*param);

		gboolean gda_parameter_restrict_values (GdaParameter
		param, GdaDataModel model,
		gint col, GErr
		or **error);
		gboolean gda_parameter_has_restrict_values (GdaParameter
		param, GdaDataModel *model,
		gint *col);
		void gda_parameter_bind_to_param (GdaParameter
		param, GdaParameter bind_to);
		GdaParameter *gda_parameter_get_bind_param (GdaParameter
		*param);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

End of changes. 15 change blocks.
	57 lines changed or deleted	96 lines changed or added

	gda-row.h	gda-row.h

	skipping to change at line 31	skipping to change at line 31
	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,
	* Boston, MA 02111-1307, USA.	* Boston, MA 02111-1307, USA.
	*/	*/

	#if !defined(__gda_row_h__)	#if !defined(__gda_row_h__)
	# define __gda_row_h__	# define __gda_row_h__

	#include <glib-object.h>	#include <glib-object.h>
	#include <libgda/gda-column.h>	#include <libgda/gda-column.h>
	#include <glib/gmacros.h>	#include <glib/gmacros.h>

	#include <libgda/global-decl.h>	#include <libgda/gda-decl.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_TYPE_ROW (gda_row_get_type())	#define GDA_TYPE_ROW (gda_row_get_type())
	#define GDA_ROW(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ ROW, GdaRow))	#define GDA_ROW(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ ROW, GdaRow))
	#define GDA_ROW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_R OW, GdaRowClass))	#define GDA_ROW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_R OW, GdaRowClass))
	#define GDA_IS_ROW(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ ROW))	#define GDA_IS_ROW(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ ROW))
	#define GDA_IS_ROW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE _ROW))	#define GDA_IS_ROW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE _ROW))


		typedef struct _GdaRow GdaRow;
	typedef struct _GdaRowClass GdaRowClass;	typedef struct _GdaRowClass GdaRowClass;
	typedef struct _GdaRowPrivate GdaRowPrivate;	typedef struct _GdaRowPrivate GdaRowPrivate;

	struct _GdaRow {	struct _GdaRow {
	GObject object;	GObject object;
	GdaRowPrivate *priv;	GdaRowPrivate *priv;
	};	};

	struct _GdaRowClass {	struct _GdaRowClass {
	GObjectClass parent_class;	GObjectClass parent_class;

End of changes. 2 change blocks.
	1 lines changed or deleted	2 lines changed or added

	gda-server-provider.h	gda-server-provider.h

	skipping to change at line 44	skipping to change at line 44
	#include <libgda/gda-client.h>	#include <libgda/gda-client.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_TYPE_SERVER_PROVIDER (gda_server_provider_get_type() )	#define GDA_TYPE_SERVER_PROVIDER (gda_server_provider_get_type() )
	#define GDA_SERVER_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST (ob j, GDA_TYPE_SERVER_PROVIDER, GdaServerProvider))	#define GDA_SERVER_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST (ob j, GDA_TYPE_SERVER_PROVIDER, GdaServerProvider))
	#define GDA_SERVER_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass , GDA_TYPE_SERVER_PROVIDER, GdaServerProviderClass))	#define GDA_SERVER_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass , GDA_TYPE_SERVER_PROVIDER, GdaServerProviderClass))
	#define GDA_IS_SERVER_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj , GDA_TYPE_SERVER_PROVIDER))	#define GDA_IS_SERVER_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj , GDA_TYPE_SERVER_PROVIDER))
	#define GDA_IS_SERVER_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass ), GDA_TYPE_SERVER_PROVIDER))	#define GDA_IS_SERVER_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass ), GDA_TYPE_SERVER_PROVIDER))


	typedef struct _GdaServerProviderClass GdaServerProviderClass;	/*
	typedef struct _GdaServerProviderPrivate GdaServerProviderPrivate;	* struct to hold any information specific to the provider used
		*/
		struct _GdaServerProviderInfo {
		gchar provider_name; / equal to the return of gda_connect
		ion_get_provider() */

		/*
		* TRUE if all comparisons of names can be done on the lower case v
		ersions of the objects names
		*/
		gboolean is_case_insensitive;

		/*
		* TRUE to suppose that there are implicit casts available for data
		types which have
		* the same gda type
		*/
		gboolean implicit_data_types_casts;

		/*
		* TRUE if writing "... FROM mytable AS alias..." is ok, and FALSE
		if we need to write this as
		* "... FROM mytable alias..."
		*/
		gboolean alias_needs_as_keyword;
		};

	struct _GdaServerProvider {	struct _GdaServerProvider {

	GObject object;	GObject object;
	GdaServerProviderPrivate *priv;	GdaServerProviderPrivate *priv;
	};	};

	struct _GdaServerProviderClass {	struct _GdaServerProviderClass {
	GObjectClass parent_class;	GObjectClass parent_class;

	/* signals */	/* signals */
	void (* last_connection_gone) (GdaServerProvider *provider) ;	void (* last_connection_gone) (GdaServerProvider *provider) ;

	/* virtual methods */	/* virtual methods */

	const gchar ( get_version) (GdaServerProvider *provider);


	gboolean (* open_connection) (GdaServerProvider *provider,	/* provider information */
	GdaConnection *cnc,	const gchar ( get_version) (GdaServerProvider *provider)
	GdaQuarkList *params,	;
	const gchar *username,	const gchar ( get_server_version) (GdaServerProvider *pr
	const gchar *password);	ovider,
	gboolean (* reset_connection) (GdaServerProvider *provider,	GdaConnection *cnc);
	GdaConnection *cnc);	GdaServerProviderInfo ( get_info) (GdaServerProvider *provider,
	gboolean (* close_connection) (GdaServerProvider *provider,	GdaConnection *cnc);
	GdaConnection *cnc);	gboolean (* supports) (GdaServerProvider *provider,
		GdaConnection *cnc,
		GdaConnectionFeature feature);


	const gchar ( get_server_version) (GdaServerProvider *provider,	GdaDataModel ( get_schema) (GdaServerProvider *provider,
	GdaConnection *cnc);	GdaConnection *cnc,
	const gchar ( get_database) (GdaServerProvider *provider,	GdaConnectionSchema schema,
	GdaConnection *cnc);	GdaParameterList *params);
	gboolean (* change_database) (GdaServerProvider *provider,
	GdaConnection *cnc,	/* types and values manipulation */
	const gchar *name);	GdaDataHandler ( get_data_handler) (GdaServerProvider *prov
		ider,
		GdaConnection *cnc,
		GdaValueType gda_type,
		const gchar *dbms_type)
		;
		GdaValue ( string_to_value) (GdaServerProvider *provi
		der,
		GdaConnection *cnc,
		const gchar *string,
		GdaValueType prefered_ty
		pe,
		gchar **dbms_type);
		const gchar (get_def_dbms_type) (GdaServerProvider *prov
		ider,
		GdaConnection *cnc,
		GdaValueType gda_type);

		/* connections management */
		gboolean (* open_connection) (GdaServerProvider *provi
		der,
		GdaConnection *cnc,
		GdaQuarkList *params,
		const gchar *username,
		const gchar *password);
		gboolean (* reset_connection) (GdaServerProvider *prov
		ider,
		GdaConnection *cnc);
		gboolean (* close_connection) (GdaServerProvider *prov
		ider,
		GdaConnection *cnc);

		const gchar ( get_database) (GdaServerProvider *provider
		,
		GdaConnection *cnc);
		gboolean (* change_database) (GdaServerProvider *provi
		der,
		GdaConnection *cnc,
		const gchar *name);
	/* actions with parameters */	/* actions with parameters */

	gchar ( get_specs) (GdaServerProvider *provider, GdaClientS	gchar ( get_specs) (GdaServerProvider *provider, G
	pecsType type);	daClientSpecsType type);
	gboolean (* perform_action_params) (GdaServerProvider *provider	gboolean (* perform_action_params) (GdaServerProvider
	,	*provider,
	GdaParameterList *params, G	GdaParameterList *
	daClientSpecsType type,	params, GdaClientSpecsType type,
	GError **error);	GError **error);

	/* database creation and destruction */	/* database creation and destruction */

	gboolean (* create_database_cnc) (GdaServerProvider *provider,	gboolean (* create_database_cnc) (GdaServerProvider *p
	GdaConnection *cnc, const gch	rovider,
	ar *name);	GdaConnection *cnc,
	gboolean (* drop_database_cnc) (GdaServerProvider *provider,	const gchar *name);
	GdaConnection *cnc, const gchar	gboolean (* drop_database_cnc) (GdaServerProvider *pro
	*name);	vider,
		GdaConnection *cnc, co
		nst gchar *name);

	/* tables creation and destroying */	/* tables creation and destroying */
	gboolean (* create_table) (GdaServerProvider *provider,	gboolean (* create_table) (GdaServerProvider *provider,
	GdaConnection *cnc,	GdaConnection *cnc,
	const gchar *table_name,	const gchar *table_name,
	const GList *attributes_list,	const GList *attributes_list,
	const GList *index_list);	const GList *index_list);
	gboolean (* drop_table) (GdaServerProvider *provider,	gboolean (* drop_table) (GdaServerProvider *provider,
	GdaConnection *cnc,	GdaConnection *cnc,
	const gchar *table_name);	const gchar *table_name);

	skipping to change at line 111	skipping to change at line 159
	gboolean (* create_index) (GdaServerProvider *provider,	gboolean (* create_index) (GdaServerProvider *provider,
	GdaConnection *cnc,	GdaConnection *cnc,
	const GdaDataModelIndex *index,	const GdaDataModelIndex *index,
	const gchar *table_name);	const gchar *table_name);
	gboolean (* drop_index) (GdaServerProvider *provider,	gboolean (* drop_index) (GdaServerProvider *provider,
	GdaConnection *cnc,	GdaConnection *cnc,
	const gchar *index_name,	const gchar *index_name,
	gboolean primary_key,	gboolean primary_key,
	const gchar *table_name);	const gchar *table_name);


	GList ( execute_command) (GdaServerProvider *provider,	/* commands */
	GdaConnection *cnc,	GList ( execute_command) (GdaServerProvider *prov
	GdaCommand *cmd,	ider,
	GdaParameterList *params);	GdaConnection *cnc,
	char ( get_last_insert_id) (GdaServerProvider *provider,	GdaCommand *cmd,
	GdaConnection *cnc,	GdaParameterList *param
	GdaDataModel *recset);	s);
		char ( get_last_insert_id) (GdaServerProvider *p
		rovider,
		GdaConnection *cnc,
		GdaDataModel *recset
		);


	gboolean (* begin_transaction) (GdaServerProvider *provider,	/* transactions */
	GdaConnection *cnc,	gboolean (* begin_transaction) (GdaServerProvider *pr
	GdaTransaction *xaction);	ovider,
	gboolean (* commit_transaction) (GdaServerProvider *provider,	GdaConnection *cnc,
	GdaConnection *cnc,	GdaTransaction *xacti
	GdaTransaction *xaction);	on);
	gboolean (* rollback_transaction) (GdaServerProvider *provider,	gboolean (* commit_transaction) (GdaServerProvider *p
	GdaConnection *cnc,	rovider,
	GdaTransaction *xaction);	GdaConnection *cnc,
		GdaTransaction *xact
		ion);
		gboolean (* rollback_transaction) (GdaServerProvider
		*provider,
		GdaConnection *cnc
		,
		GdaTransaction *xa
		ction);


	gboolean (* supports) (GdaServerProvider *provider,	/* blobs */
	GdaConnection *cnc,	GdaBlob ( create_blob) (GdaServerProvider *provider
	GdaConnectionFeature feature);	,
		GdaConnection *cnc);


	GdaDataModel ( get_schema) (GdaServerProvider *provider,	GdaBlob ( fetch_blob) (GdaServerProvider *provider,
	GdaConnection *cnc,	GdaConnection *cnc, const gc
	GdaConnectionSchema schema,	har *sql_id);
	GdaParameterList *params);	};


	GdaBlob ( create_blob) (GdaServerProvider *provider,	GType gda_server_provider_get_type (void);
	GdaConnection *cnc);


	GdaBlob ( fetch_blob) (GdaServerProvider *provider,	/* provider information */
	GdaConnection cnc, const gchar sql_i	const gchar gda_server_provider_get_version (GdaServerProvider
	d);	provider);
		const gchar *gda_server_provider_get_server_version (GdaServerPro
		vider *provider,
		GdaConnection
		*cnc);
		GdaServerProviderInfo gda_server_provider_get_info (GdaServerProvider pro
		vider,
		GdaConnection *cnc);
		gboolean gda_server_provider_supports (GdaServerProvider *pro
		vider,
		GdaConnection *cnc,
		GdaConnectionFeature fe
		ature);
		GdaDataModel gda_server_provider_get_schema (GdaServerProvider p
		rovider,
		GdaConnection *cnc,
		GdaConnectionSchema s
		chema,
		GdaParameterList *par
		ams, GError **error);


	gchar ( value_to_sql_string) (GdaServerProvider *provider,	/* types and values manipulation */
	GdaConnection *cnc,	GdaDataHandler *gda_server_provider_get_data_handler_gda (GdaServerP
	GdaValue *from);	rovider *provider,
		GdaConnecti
		on *cnc,
		GdaValueTyp
		e for_type);
		GdaDataHandler *gda_server_provider_get_data_handler_dbms (GdaServer
		Provider *provider,
		GdaConnect
		ion *cnc,
		const gcha
		r *for_type);
		GdaValue *gda_server_provider_string_to_value (GdaServerProvid
		er *provider,
		GdaConnection *c
		nc,
		const gchar *str
		ing,
		GdaValueType pre
		fered_type,
		gchar **dbms_typ
		e);
		gchar *gda_server_provider_value_to_sql_string (GdaServerPr
		ovider *provider,
		GdaConnectio
		n *cnc,
		GdaValue *fr
		om);
		const gchar *gda_server_provider_get_default_dbms_type (GdaServer
		Provider *provider,
		GdaConnect
		ion *cnc,
		GdaValueTy
		pe gda_type);


	};	/* connections management */
		gboolean gda_server_provider_open_connection (GdaServerProvid
		er *provider,
		GdaConnection *c
		nc,
		GdaQuarkList *pa
		rams,
		const gchar *use
		rname,
		const gchar *pas
		sword);
		gboolean gda_server_provider_reset_connection (GdaServerProvi
		der *provider,
		GdaConnection *
		cnc);
		gboolean gda_server_provider_close_connection (GdaServerProvi
		der *provider,
		GdaConnection *
		cnc);


	GType gda_server_provider_get_type (void);	const gchar *gda_server_provider_get_database (GdaServerProvider
	const gchar gda_server_provider_get_version (GdaServerProvider provider)	*provider,
	;	GdaConnection *cnc)
	gboolean gda_server_provider_open_connection (GdaServerProvider *provi	;
	der,	gboolean gda_server_provider_change_database (GdaServerProvid
	GdaConnection *cnc,	er *provider,
	GdaQuarkList *params,	GdaConnection *c
	const gchar *username,	nc,
	const gchar *password);	const gchar *nam
	gboolean gda_server_provider_reset_connection (GdaServerProvider *prov	e);
	ider,
	GdaConnection *cnc);
	gboolean gda_server_provider_close_connection (GdaServerProvider *prov
	ider,
	GdaConnection *cnc);


	const gchar gda_server_provider_get_server_version (GdaServerProvider pr	/* actions with parameters */
	ovider,	gchar gda_server_provider_get_specs (GdaServerProvider pr
	GdaConnection *cnc);	ovider,
	const gchar gda_server_provider_get_database (GdaServerProvider provider	GdaClientSpecsType act
	,	ion_type);
	GdaConnection *cnc);	gboolean gda_server_provider_perform_action_params (GdaServerP
	gboolean gda_server_provider_change_database (GdaServerProvider *provi	rovider *provider,
	der,	GdaParamete
	GdaConnection *cnc,	rList *params,
	const gchar *name);	GdaClientSp
	gchar gda_server_provider_get_specs (GdaServerProvider provider,	ecsType action_type,
	GdaClientSpecsType action_type	GError **er
	);	ror);
	gboolean gda_server_provider_perform_action_params (GdaServerProvider
	*provider,
	GdaParameterList *p
	arams,
	GdaClientSpecsType
	action_type,
	GError **error);
	gboolean gda_server_provider_create_database_cnc (GdaServerProvider *p rovider,	gboolean gda_server_provider_create_database_cnc (GdaServerProvider *p rovider,
	GdaConnection cnc, c onst gchar name);	GdaConnection cnc, c onst gchar name);
	gboolean gda_server_provider_drop_database_cnc (GdaServerProvider *pro vider,	gboolean gda_server_provider_drop_database_cnc (GdaServerProvider *pro vider,
	GdaConnection cnc, con st gchar name);	GdaConnection cnc, con st gchar name);
	gboolean gda_server_provider_create_table (GdaServerProvider *provider ,	gboolean gda_server_provider_create_table (GdaServerProvider *provider ,
	GdaConnection *cnc,	GdaConnection *cnc,
	const gchar *table_name,	const gchar *table_name,
	const GList *attributes_list ,	const GList *attributes_list ,
	const GList *index_list);	const GList *index_list);
	gboolean gda_server_provider_drop_table (GdaServerProvider *provider,	gboolean gda_server_provider_drop_table (GdaServerProvider *provider,

	skipping to change at line 215	skipping to change at line 286
	gboolean gda_server_provider_begin_transaction (GdaServerProvider *pro vider,	gboolean gda_server_provider_begin_transaction (GdaServerProvider *pro vider,
	GdaConnection *cnc,	GdaConnection *cnc,
	GdaTransaction *xaction );	GdaTransaction *xaction );
	gboolean gda_server_provider_commit_transaction (GdaServerProvider *pr ovider,	gboolean gda_server_provider_commit_transaction (GdaServerProvider *pr ovider,
	GdaConnection *cnc,	GdaConnection *cnc,
	GdaTransaction *xactio n);	GdaTransaction *xactio n);
	gboolean gda_server_provider_rollback_transaction (GdaServerProvider * provider,	gboolean gda_server_provider_rollback_transaction (GdaServerProvider * provider,
	GdaConnection *cnc,	GdaConnection *cnc,
	GdaTransaction *xact ion);	GdaTransaction *xact ion);


	gboolean gda_server_provider_supports (GdaServerProvider *provider,
	GdaConnection *cnc,
	GdaConnectionFeature feature);

	GdaDataModel gda_server_provider_get_schema (GdaServerProvider provider,
	GdaConnection *cnc,
	GdaConnectionSchema schema,
	GdaParameterList *params);

	GdaBlob gda_server_provider_create_blob (GdaServerProvider provider,	GdaBlob gda_server_provider_create_blob (GdaServerProvider provider,
	GdaConnection *cnc);	GdaConnection *cnc);
	GdaBlob gda_server_provider_fetch_blob_by_id (GdaServerProvider prov ider,	GdaBlob gda_server_provider_fetch_blob_by_id (GdaServerProvider prov ider,
	GdaConnection cnc, cons t gchar sql_id);	GdaConnection cnc, cons t gchar sql_id);


	gchar gda_server_provider_value_to_sql_string (GdaServerProvider p
	rovider,
	GdaConnection *cnc,
	GdaValue *from);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

End of changes. 19 change blocks.
	114 lines changed or deleted	236 lines changed or added

	gda-threader.h	gda-threader.h

	skipping to change at line 28	skipping to change at line 28
	* USA	* USA
	*/	*/

	#ifndef __GDA_THREADER_H_	#ifndef __GDA_THREADER_H_
	#define __GDA_THREADER_H_	#define __GDA_THREADER_H_

	#include <glib-object.h>	#include <glib-object.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS


	#define GDA_THREADER_TYPE (gda_threader_get_type())	#define GDA_TYPE_THREADER (gda_threader_get_type())
	#define GDA_THREADER(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gda_thr eader_get_type(), GdaThreader)	#define GDA_THREADER(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gda_thr eader_get_type(), GdaThreader)
	#define GDA_THREADER_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gda_thre ader_get_type (), GdaThreaderClass)	#define GDA_THREADER_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gda_thre ader_get_type (), GdaThreaderClass)

	#define IS_GDA_THREADER(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_thr eader_get_type ())	#define GDA_IS_THREADER(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_thr eader_get_type ())

	typedef struct _GdaThreader GdaThreader;	typedef struct _GdaThreader GdaThreader;
	typedef struct _GdaThreaderClass GdaThreaderClass;	typedef struct _GdaThreaderClass GdaThreaderClass;
	typedef struct _GdaThreaderPrivate GdaThreaderPrivate;	typedef struct _GdaThreaderPrivate GdaThreaderPrivate;
	typedef void (GdaThreaderFunc) (GdaThreader , guint, gpointer);	typedef void (GdaThreaderFunc) (GdaThreader , guint, gpointer);

	/* struct for the object's data */	/* struct for the object's data */
	struct _GdaThreader	struct _GdaThreader
	{	{
	GObject object;	GObject object;
	GdaThreaderPrivate *priv;	GdaThreaderPrivate *priv;
	};	};

	/* struct for the object's class */	/* struct for the object's class */
	struct _GdaThreaderClass	struct _GdaThreaderClass
	{	{

	GObjectClass class;	GObjectClass parent_class;

	/* signals */	/* signals */
	void (finished) (GdaThreader thread, guint job_id, gp ointer arg_data);	void (finished) (GdaThreader thread, guint job_id, gp ointer arg_data);
	void (cancelled) (GdaThreader thread, guint job_id, gp ointer arg_data);	void (cancelled) (GdaThreader thread, guint job_id, gp ointer arg_data);
	};	};

	GType gda_threader_get_type (void);	GType gda_threader_get_type (void);
	GObject *gda_threader_new (void);	GObject *gda_threader_new (void);

	guint gda_threader_start_thread (GdaThreader *thread, GThreadFunc func, gpointer func_arg,	guint gda_threader_start_thread (GdaThreader *thread, GThreadFunc func, gpointer func_arg,

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	gda-util.h	gda-util.h
	/* GDA common library	/* GDA common library

	* Copyright (C) 1998-2002 The GNOME Foundation.	* Copyright (C) 1998 - 2006 The GNOME Foundation.
	*	*
	* AUTHORS:	* AUTHORS:
	* Rodrigo Moya <rodrigo@gnome-db.org>	* Rodrigo Moya <rodrigo@gnome-db.org>

		* Vivien Malerba <malerba@gnome-db.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 Library General Public License as	* modify it under the terms of the GNU Library General Public License as
	* published by the Free Software Foundation; either version 2 of the	* published by the Free Software Foundation; either version 2 of the
	* License, or (at your option) any later version.	* 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
	* Library General Public License for more details.	* Library General Public License for more details.

	skipping to change at line 40	skipping to change at line 41
	#include "gda-connection.h"	#include "gda-connection.h"

	G_BEGIN_DECLS	G_BEGIN_DECLS

	const gchar *gda_type_to_string (GdaValueType type);	const gchar *gda_type_to_string (GdaValueType type);
	GdaValueType gda_type_from_string (const gchar *str);	GdaValueType gda_type_from_string (const gchar *str);

	GList gda_string_hash_to_list (GHashTable hash_table);	GList gda_string_hash_to_list (GHashTable hash_table);

	/*	/*

		* SQL escaping
		*/
		gchar gda_default_escape_chars (const gchar string);
		gchar gda_default_unescape_chars (const gchar string);

		/*
	* SQL parsing utilities	* SQL parsing utilities
	*/	*/

	gchar gda_sql_replace_placeholders (const gchar sql, GdaParameterList *pa rams);	gchar gda_sql_replace_placeholders (const gchar sql, GdaParameterList *pa rams);

	/*	/*
	* File management utility functions	* File management utility functions
	*/	*/


	gchar gda_file_load (const gchar filename);	gchar gda_file_load (const gchar filename);
	gboolean gda_file_save (const gchar filename, const gchar buffer, gint l en);	gboolean gda_file_save (const gchar filename, const gchar buffer, gint l en);

	/*	/*

	* Help to implement providers	* utilities dealing with storing and retreiving GdaDictField's attributes
		* which is a list of comma separated keywords
	*/	*/

	gint gda_provider_get_schema_nb_columns (GdaConnectionSchema schema);	gchar *utility_table_field_attrs_stringify (guint attributes);
	gboolean gda_provider_init_schema_model (GdaDataModel *model, GdaConne	guint utility_table_field_attrs_parse (const gchar *str);
	ctionSchema schema);
		/*
		* XML Id encoding and decoding
		*/
		gchar utility_build_encoded_id (const gchar prefix, const gchar *id);
		gchar utility_build_decoded_id (const gchar prefix, const gchar *id);

		/*
		* Check model columns
		*/
		gboolean utility_check_data_model (GdaDataModel *model, gint nbcols, ...);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

End of changes. 6 change blocks.
	6 lines changed or deleted	23 lines changed or added

	gda-value.h	gda-value.h

	skipping to change at line 74	skipping to change at line 74
	#define G_VALUE_TYPE_TIMESTAMP (gda_timestamp_get_type())	#define G_VALUE_TYPE_TIMESTAMP (gda_timestamp_get_type())
	#define G_VALUE_TYPE_UNKNOWN G_TYPE_INVALID	#define G_VALUE_TYPE_UNKNOWN G_TYPE_INVALID
	#define G_VALUE_TYPE_TYPE (gda_gdatype_get_type())	#define G_VALUE_TYPE_TYPE (gda_gdatype_get_type())

	typedef enum {	typedef enum {
	GDA_VALUE_TYPE_NULL,	GDA_VALUE_TYPE_NULL,
	GDA_VALUE_TYPE_BIGINT,	GDA_VALUE_TYPE_BIGINT,
	GDA_VALUE_TYPE_BIGUINT,	GDA_VALUE_TYPE_BIGUINT,
	GDA_VALUE_TYPE_BINARY,	GDA_VALUE_TYPE_BINARY,
	GDA_VALUE_TYPE_BLOB,	GDA_VALUE_TYPE_BLOB,


	GDA_VALUE_TYPE_BOOLEAN,	GDA_VALUE_TYPE_BOOLEAN,
	GDA_VALUE_TYPE_DATE,	GDA_VALUE_TYPE_DATE,
	GDA_VALUE_TYPE_DOUBLE,	GDA_VALUE_TYPE_DOUBLE,
	GDA_VALUE_TYPE_GEOMETRIC_POINT,	GDA_VALUE_TYPE_GEOMETRIC_POINT,
	GDA_VALUE_TYPE_GOBJECT,	GDA_VALUE_TYPE_GOBJECT,


	GDA_VALUE_TYPE_INTEGER,	GDA_VALUE_TYPE_INTEGER,
	GDA_VALUE_TYPE_LIST,	GDA_VALUE_TYPE_LIST,
	GDA_VALUE_TYPE_MONEY,	GDA_VALUE_TYPE_MONEY,
	GDA_VALUE_TYPE_NUMERIC,	GDA_VALUE_TYPE_NUMERIC,
	GDA_VALUE_TYPE_SINGLE,	GDA_VALUE_TYPE_SINGLE,


	GDA_VALUE_TYPE_SMALLINT,	GDA_VALUE_TYPE_SMALLINT,
	GDA_VALUE_TYPE_SMALLUINT,	GDA_VALUE_TYPE_SMALLUINT,
	GDA_VALUE_TYPE_STRING,	GDA_VALUE_TYPE_STRING,
	GDA_VALUE_TYPE_TIME,	GDA_VALUE_TYPE_TIME,
	GDA_VALUE_TYPE_TIMESTAMP,	GDA_VALUE_TYPE_TIMESTAMP,


	GDA_VALUE_TYPE_TINYINT,	GDA_VALUE_TYPE_TINYINT,
	GDA_VALUE_TYPE_TINYUINT,	GDA_VALUE_TYPE_TINYUINT,
	GDA_VALUE_TYPE_TYPE,	GDA_VALUE_TYPE_TYPE,
	GDA_VALUE_TYPE_UINTEGER,	GDA_VALUE_TYPE_UINTEGER,
	GDA_VALUE_TYPE_UNKNOWN	GDA_VALUE_TYPE_UNKNOWN
	} GdaValueType;	} GdaValueType;

		#define GDA_VALUE_NB_TYPES GDA_VALUE_TYPE_UNKNOWN

	typedef struct {	typedef struct {
	gshort year;	gshort year;
	gushort month;	gushort month;
	gushort day;	gushort day;
	} GdaDate;	} GdaDate;

	typedef struct {	typedef struct {
	gdouble x;	gdouble x;
	gdouble y;	gdouble y;

	skipping to change at line 153	skipping to change at line 158
	typedef GValue GdaValue;	typedef GValue GdaValue;

	#define GDA_TYPE_VALUE G_TYPE_VALUE	#define GDA_TYPE_VALUE G_TYPE_VALUE
	#define GDA_VALUE_TYPE(value) (gda_value_get_type(value))	#define GDA_VALUE_TYPE(value) (gda_value_get_type(value))
	#define gda_value_isa(value, type) (gda_value_get_type (value) == type)	#define gda_value_isa(value, type) (gda_value_get_type (value) == type)

	GdaValueType gda_value_get_type(GdaValue *value);	GdaValueType gda_value_get_type(GdaValue *value);
	GType gda_value_convert_gdatype_to_gtype (GdaVa lueType type);	GType gda_value_convert_gdatype_to_gtype (GdaVa lueType type);
	GdaValueType gda_value_convert_gtype_to_gdatype (GType type);	GdaValueType gda_value_convert_gtype_to_gdatype (GType type);


		gboolean gda_value_type_transformable (GdaValueTyp
		e src_type, GdaValueType dest_type, gboolean strict);
		gboolean gda_value_transform (const GdaValue *src,
		GdaValue *dest);

	GdaValue *gda_value_new_null (void);	GdaValue *gda_value_new_null (void);
	GdaValue *gda_value_new_bigint (gint64 val);	GdaValue *gda_value_new_bigint (gint64 val);
	GdaValue *gda_value_new_biguint(guint64 val);	GdaValue *gda_value_new_biguint(guint64 val);
	GdaValue gda_value_new_binary (guchar val, glong size);	GdaValue gda_value_new_binary (guchar val, glong size);
	GdaValue gda_value_new_blob (const GdaBlob val);	GdaValue gda_value_new_blob (const GdaBlob val);
	GdaValue *gda_value_new_boolean (gboolean val);	GdaValue *gda_value_new_boolean (gboolean val);
	GdaValue gda_value_new_date (const GdaDate val);	GdaValue gda_value_new_date (const GdaDate val);
	GdaValue *gda_value_new_double (gdouble val);	GdaValue *gda_value_new_double (gdouble val);
	GdaValue gda_value_new_geometric_point (const GdaG eometricPoint val);	GdaValue gda_value_new_geometric_point (const GdaG eometricPoint val);
	GdaValue gda_value_new_gobject (const GObject val );	GdaValue gda_value_new_gobject (const GObject val );

	skipping to change at line 247	skipping to change at line 255
	gboolean gda_value_set_from_string (GdaValue *valu e,	gboolean gda_value_set_from_string (GdaValue *valu e,
	const gchar *as _string,	const gchar *as _string,
	GdaValueType ty pe);	GdaValueType ty pe);
	gboolean gda_value_set_from_value (GdaValue value , const GdaValue from);	gboolean gda_value_set_from_value (GdaValue value , const GdaValue from);

	gint gda_value_compare (GdaValue value1, GdaV alue value2);	gint gda_value_compare (GdaValue value1, GdaV alue value2);
	gint gda_value_compare_ext (GdaValue value1, GdaValue value2);	gint gda_value_compare_ext (GdaValue value1, GdaValue value2);
	gchar gda_value_stringify (GdaValue value);	gchar gda_value_stringify (GdaValue value);
	xmlNodePtr gda_value_to_xml (GdaValue *value);	xmlNodePtr gda_value_to_xml (GdaValue *value);


		gchar gda_binary_to_string (const GdaBinary bi
		n, guint maxlen);
		gboolean gda_string_to_binary (const gchar *str, G
		daBinary *bin);

	/* Custom data types */	/* Custom data types */
	GType gda_money_get_type (void);	GType gda_money_get_type (void);
	gpointer gda_money_copy (gpointer boxed);	gpointer gda_money_copy (gpointer boxed);
	void gda_money_free (gpointer boxed);	void gda_money_free (gpointer boxed);

	GType gda_numeric_get_type (void);	GType gda_numeric_get_type (void);
	gpointer gda_numeric_copy (gpointer boxed);	gpointer gda_numeric_copy (gpointer boxed);
	void gda_numeric_free (gpointer boxed);	void gda_numeric_free (gpointer boxed);

	GType gda_time_get_type(void);	GType gda_time_get_type(void);

End of changes. 7 change blocks.
	0 lines changed or deleted	15 lines changed or added

	libgda.h	libgda.h
	/* GDA library	/* GDA library

	* Copyright (C) 1998-2005 The GNOME Foundation.	* Copyright (C) 1998 - 2006 The GNOME Foundation.
	*	*
	* AUTHORS:	* AUTHORS:
	* Michael Lausch <michael@lausch.at>	* Michael Lausch <michael@lausch.at>
	* Rodrigo Moya <rodrigo@gnome-db.org>	* Rodrigo Moya <rodrigo@gnome-db.org>
	* Bas Driessen <bas.driessen@xobas.com>	* Bas Driessen <bas.driessen@xobas.com>

		* Vivien Malerba <malerba@gnome-db.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 Library General Public License as	* modify it under the terms of the GNU Library General Public License as
	* published by the Free Software Foundation; either version 2 of the	* published by the Free Software Foundation; either version 2 of the
	* License, or (at your option) any later version.	* 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
	* Library General Public License for more details.	* Library General Public License for more details.
	*	*
	* You should have received a copy of the GNU Library General Public	* You should have received a copy of the GNU Library General Public
	* License along with this Library; see the file COPYING.LIB. If not,	* License along with this Library; see the file COPYING.LIB. If not,
	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,
	* Boston, MA 02111-1307, USA.	* Boston, MA 02111-1307, USA.
	*/	*/


	#if !defined(__libgda_h__)	#ifndef __LIBGDA_H__
	# define __libgda_h__	#define __LIBGDA_H__

	#include <libgda/gda-blob.h>	#include <libgda/gda-blob.h>
	#include <libgda/gda-client.h>	#include <libgda/gda-client.h>

		#include <libgda/gda-column-index.h>
		#include <libgda/gda-column.h>
	#include <libgda/gda-command.h>	#include <libgda/gda-command.h>
	#include <libgda/gda-config.h>	#include <libgda/gda-config.h>

		#include <libgda/gda-connection-event.h>
	#include <libgda/gda-connection.h>	#include <libgda/gda-connection.h>

	#include <libgda/gda-data-model.h>
	#include <libgda/gda-data-model-array.h>	#include <libgda/gda-data-model-array.h>
	#include <libgda/gda-data-model-hash.h>	#include <libgda/gda-data-model-hash.h>

	#include <libgda/gda-data-model-list.h>
	#include <libgda/gda-connection-event.h>
	#include <libgda/gda-column.h>
	#include <libgda/gda-column-index.h>
	#include <libgda/gda-data-model-index.h>	#include <libgda/gda-data-model-index.h>

		#include <libgda/gda-data-model-query.h>
		#include <libgda/gda-data-model.h>
		#include <libgda/gda-data-model-iter.h>
		#include <libgda/gda-data-model-import.h>
		#include <libgda/gda-data-access-wrapper.h>
		#include <libgda/gda-data-proxy.h>
	#include <libgda/gda-log.h>	#include <libgda/gda-log.h>
	#include <libgda/gda-parameter.h>	#include <libgda/gda-parameter.h>
	#include <libgda/gda-quark-list.h>	#include <libgda/gda-quark-list.h>
	#include <libgda/gda-row.h>	#include <libgda/gda-row.h>

	#include <libgda/gda-select.h>	#include <libgda/gda-data-model-filter-sql.h>
		#include <libgda/gda-server-provider.h>
		#include <libgda/gda-threader.h>
	#include <libgda/gda-transaction.h>	#include <libgda/gda-transaction.h>
	#include <libgda/gda-util.h>	#include <libgda/gda-util.h>
	#include <libgda/gda-value.h>	#include <libgda/gda-value.h>

	#include <libgda/gda-enum-types.h>	#include <libgda/gda-decl.h>
		#include <libgda/gda-object.h>
		#include <libgda/gda-dict.h>
		#include <libgda/gda-enums.h>
		#include <libgda/gda-graphviz.h>
		#include <libgda/gda-data-model-private.h>
		#include <libgda/graph/gda-graph-query.h>
		#include <libgda/graph/gda-graph.h>
		#include <libgda/graph/gda-graph-item.h>
		#include <libgda/gda-data-handler.h>
		#include <libgda/handlers/gda-handler-bin.h>
		#include <libgda/handlers/gda-handler-boolean.h>
		#include <libgda/handlers/gda-handler-numerical.h>
		#include <libgda/handlers/gda-handler-string.h>
		#include <libgda/handlers/gda-handler-time.h>
		#include <libgda/handlers/gda-handler-type.h>
		#include <libgda/gda-entity-field.h>
		#include <libgda/gda-dict-database.h>
		#include <libgda/gda-dict-table.h>
		#include <libgda/gda-renderer.h>
		#include <libgda/gda-dict-field.h>
		#include <libgda/gda-object-ref.h>
		#include <libgda/gda-parameter-list.h>
		#include <libgda/gda-xml-storage.h>
		#include <libgda/gda-referer.h>
		#include <libgda/gda-dict-type.h>
		#include <libgda/gda-entity.h>
		#include <libgda/gda-dict-function.h>
		#include <libgda/gda-dict-aggregate.h>
		#include <libgda/gda-dict-constraint.h>
		#include <libgda/gda-query.h>
		#include <libgda/gda-query-object.h>
		#include <libgda/gda-query-target.h>
		#include <libgda/gda-query-join.h>
		#include <libgda/gda-query-condition.h>
		#include <libgda/gda-query-field-agg.h>
		#include <libgda/gda-query-field-all.h>
		#include <libgda/gda-query-field-field.h>
		#include <libgda/gda-query-field-func.h>
		#include <libgda/gda-query-field-value.h>
		#include <libgda/gda-query-field.h>
		#include <libgda/gda-query-parsing.h>
		#include <libgda/gda-query-private.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS


	void gda_init (const gchar app_id, const gchar version, gint nargs, gchar	void gda_init (const gchar app_id, const gchar version, g
	*args[]);	int nargs, gchar *args[]);
		GdaDict *gda_get_default_dict (void);
	typedef void (* GdaInitFunc) (gpointer user_data);


	void gda_main_run (GdaInitFunc init_func, gpointer user_data);	typedef void (* GdaInitFunc) (gpointer user_data);
	void gda_main_quit (void);	void gda_main_run (GdaInitFunc init_func, gpointer user_data);
		void gda_main_quit (void);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

End of changes. 12 change blocks.
	16 lines changed or deleted	65 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/

	gda-data-model-array.h	gda-data-model-array.h
	/* GDA common library	/* GDA common library

	* Copyright (C) 1998 - 2004 The GNOME Foundation.	* Copyright (C) 1998 - 2006 The GNOME Foundation.
	*	*
	* AUTHORS:	* AUTHORS:
	* Rodrigo Moya <rodrigo@gnome-db.org>	* Rodrigo Moya <rodrigo@gnome-db.org>
	* Vivien Malerba <malerba@gnome-db.org>	* Vivien Malerba <malerba@gnome-db.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 Library General Public License as	* modify it under the terms of the GNU Library General Public License as
	* published by the Free Software Foundation; either version 2 of the	* published by the Free Software Foundation; either version 2 of the
	* License, or (at your option) any later version.	* License, or (at your option) any later version.
	*	*

	skipping to change at line 24	skipping to change at line 24
	* 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
	* Library General Public License for more details.	* Library General Public License for more details.
	*	*
	* You should have received a copy of the GNU Library General Public	* You should have received a copy of the GNU Library General Public
	* License along with this Library; see the file COPYING.LIB. If not,	* License along with this Library; see the file COPYING.LIB. If not,
	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,
	* Boston, MA 02111-1307, USA.	* Boston, MA 02111-1307, USA.
	*/	*/


	#if !defined(__gda_data_model_array_h__)	#ifndef __GDA_DATA_MODEL_ARRAY_H__
	# define __gda_data_model_array_h__	#define __GDA_DATA_MODEL_ARRAY_H__

	#include <libgda/gda-data-model.h>	#include <libgda/gda-data-model.h>

	#include <libgda/gda-data-model-base.h>	#include <libgda/gda-data-model-row.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_TYPE_DATA_MODEL_ARRAY (gda_data_model_array_get_type ())	#define GDA_TYPE_DATA_MODEL_ARRAY (gda_data_model_array_get_type ())
	#define GDA_DATA_MODEL_ARRAY(obj) (G_TYPE_CHECK_INSTANCE_CAST (o bj, GDA_TYPE_DATA_MODEL_ARRAY, GdaDataModelArray))	#define GDA_DATA_MODEL_ARRAY(obj) (G_TYPE_CHECK_INSTANCE_CAST (o bj, GDA_TYPE_DATA_MODEL_ARRAY, GdaDataModelArray))
	#define GDA_DATA_MODEL_ARRAY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klas s, GDA_TYPE_DATA_MODEL_ARRAY, GdaDataModelArrayClass))	#define GDA_DATA_MODEL_ARRAY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klas s, GDA_TYPE_DATA_MODEL_ARRAY, GdaDataModelArrayClass))
	#define GDA_IS_DATA_MODEL_ARRAY(obj) (G_TYPE_CHECK_INSTANCE_TYPE (o bj, GDA_TYPE_DATA_MODEL_ARRAY))	#define GDA_IS_DATA_MODEL_ARRAY(obj) (G_TYPE_CHECK_INSTANCE_TYPE (o bj, GDA_TYPE_DATA_MODEL_ARRAY))
	#define GDA_IS_DATA_MODEL_ARRAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((kla ss), GDA_TYPE_DATA_MODEL_ARRAY))	#define GDA_IS_DATA_MODEL_ARRAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((kla ss), GDA_TYPE_DATA_MODEL_ARRAY))

	typedef struct _GdaDataModelArray GdaDataModelArray;	typedef struct _GdaDataModelArray GdaDataModelArray;
	typedef struct _GdaDataModelArrayClass GdaDataModelArrayClass;	typedef struct _GdaDataModelArrayClass GdaDataModelArrayClass;
	typedef struct _GdaDataModelArrayPrivate GdaDataModelArrayPrivate;	typedef struct _GdaDataModelArrayPrivate GdaDataModelArrayPrivate;

	struct _GdaDataModelArray {	struct _GdaDataModelArray {

	GdaDataModelBase model;	GdaDataModelRow model;
	GdaDataModelArrayPrivate *priv;	GdaDataModelArrayPrivate *priv;
	};	};

	struct _GdaDataModelArrayClass {	struct _GdaDataModelArrayClass {

	GdaDataModelBaseClass parent_class;	GdaDataModelRowClass parent_class;
	};	};

	GType gda_data_model_array_get_type (void);	GType gda_data_model_array_get_type (void);
	GdaDataModel *gda_data_model_array_new (gint cols);	GdaDataModel *gda_data_model_array_new (gint cols);

	GdaDataModel gda_data_model_array_new_from_xml_node (xmlNodePtr node, GErr or *error);	GdaDataModel gda_data_model_array_copy_model (GdaDataModel src, GE rror **error);
	void gda_data_model_array_set_n_columns (GdaDataModelArray *mo del, gint cols);	void gda_data_model_array_set_n_columns (GdaDataModelArray *mo del, gint cols);
	void gda_data_model_array_clear (GdaDataModelArray *mo del);	void gda_data_model_array_clear (GdaDataModelArray *mo del);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

End of changes. 6 change blocks.
	7 lines changed or deleted	7 lines changed or added

	gda-data-model-hash.h	gda-data-model-hash.h

	skipping to change at line 29	skipping to change at line 29
	* You should have received a copy of the GNU Library General Public	* You should have received a copy of the GNU Library General Public
	* License along with this Library; see the file COPYING.LIB. If not,	* License along with this Library; see the file COPYING.LIB. If not,
	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,	* write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,
	* Boston, MA 02111-1307, USA.	* Boston, MA 02111-1307, USA.
	*/	*/

	#if !defined(__gda_data_model_hash_h__)	#if !defined(__gda_data_model_hash_h__)
	# define __gda_data_model_hash_h__	# define __gda_data_model_hash_h__

	#include <libgda/gda-data-model.h>	#include <libgda/gda-data-model.h>

	#include <libgda/gda-data-model-base.h>	#include <libgda/gda-data-model-row.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_TYPE_DATA_MODEL_HASH (gda_data_model_hash_get_type() )	#define GDA_TYPE_DATA_MODEL_HASH (gda_data_model_hash_get_type() )
	#define GDA_DATA_MODEL_HASH(obj) (G_TYPE_CHECK_INSTANCE_CAST (ob j, GDA_TYPE_DATA_MODEL_HASH, GdaDataModelHash))	#define GDA_DATA_MODEL_HASH(obj) (G_TYPE_CHECK_INSTANCE_CAST (ob j, GDA_TYPE_DATA_MODEL_HASH, GdaDataModelHash))
	#define GDA_DATA_MODEL_HASH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass , GDA_TYPE_DATA_MODEL_HASH, GdaDataModelHashClass))	#define GDA_DATA_MODEL_HASH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass , GDA_TYPE_DATA_MODEL_HASH, GdaDataModelHashClass))
	#define GDA_IS_DATA_MODEL_HASH(obj) (G_TYPE_CHECK_INSTANCE_TYPE (ob j, GDA_TYPE_DATA_MODEL_HASH))	#define GDA_IS_DATA_MODEL_HASH(obj) (G_TYPE_CHECK_INSTANCE_TYPE (ob j, GDA_TYPE_DATA_MODEL_HASH))
	#define GDA_IS_DATA_MODEL_HASH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klas s), GDA_TYPE_DATA_MODEL_HASH))	#define GDA_IS_DATA_MODEL_HASH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klas s), GDA_TYPE_DATA_MODEL_HASH))

	typedef struct _GdaDataModelHash GdaDataModelHash;	typedef struct _GdaDataModelHash GdaDataModelHash;
	typedef struct _GdaDataModelHashClass GdaDataModelHashClass;	typedef struct _GdaDataModelHashClass GdaDataModelHashClass;
	typedef struct _GdaDataModelHashPrivate GdaDataModelHashPrivate;	typedef struct _GdaDataModelHashPrivate GdaDataModelHashPrivate;

	struct _GdaDataModelHash {	struct _GdaDataModelHash {

	GdaDataModelBase model;	GdaDataModelRow model;
	GdaDataModelHashPrivate *priv;	GdaDataModelHashPrivate *priv;
	};	};

	struct _GdaDataModelHashClass {	struct _GdaDataModelHashClass {

	GdaDataModelBaseClass parent_class;	GdaDataModelRowClass parent_class;
	};	};

	GType gda_data_model_hash_get_type (void);	GType gda_data_model_hash_get_type (void);
	GdaDataModel *gda_data_model_hash_new (gint cols);	GdaDataModel *gda_data_model_hash_new (gint cols);

	void gda_data_model_hash_clear (GdaDataModelHash *model);	void gda_data_model_hash_clear (GdaDataModelHash *model);
	void gda_data_model_hash_set_n_columns (GdaDataModelHash *model,	void gda_data_model_hash_set_n_columns (GdaDataModelHash *model,
	gint cols);	gint cols);

	void gda_data_model_hash_insert_row (GdaDataModelHash *model,	void gda_data_model_hash_insert_row (GdaDataModelHash *model,

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added