gda-client.h		gda-client.h
	skipping to change at line 25		skipping to change at line 25
	* 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_client_h__)		#ifndef __GDA_CLIENT_H__
	# define __gda_client_h__		#define __GDA_CLIENT_H__
	#include <libgda/gda-connection.h>		#include <libgda/gda-connection.h>
			#include <libgda/gda-server-operation.h>
	G_BEGIN_DECLS		G_BEGIN_DECLS
	#define GDA_TYPE_CLIENT (gda_client_get_type())		#define GDA_TYPE_CLIENT (gda_client_get_type())
	#define GDA_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TY PE_CLIENT, GdaClient))		#define GDA_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TY PE_CLIENT, GdaClient))
	#define GDA_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYP E_CLIENT, GdaClientClass))		#define GDA_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYP E_CLIENT, GdaClientClass))
	#define GDA_IS_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYP E_CLIENT))		#define GDA_IS_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYP E_CLIENT))
	#define GDA_IS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TY PE_CLIENT))		#define GDA_IS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TY PE_CLIENT))
	typedef enum {		typedef enum {
	skipping to change at line 53		skipping to change at line 54
	or committed via a BEGIN/COMMIT command directly sent to the		or committed via a BEGIN/COMMIT command directly sent to the
	execute_command method on the provider */		execute_command method on the provider */
	GDA_CLIENT_EVENT_ERROR, /* params: "error" */		GDA_CLIENT_EVENT_ERROR, /* params: "error" */
	GDA_CLIENT_EVENT_CONNECTION_OPENED, /* params: */		GDA_CLIENT_EVENT_CONNECTION_OPENED, /* params: */
	GDA_CLIENT_EVENT_CONNECTION_CLOSED, /* params: */		GDA_CLIENT_EVENT_CONNECTION_CLOSED, /* params: */
	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 {
	GDA_CLIENT_SPECS_CREATE_DATABASE,
	GDA_CLIENT_SPECS_DROP_DATABASE
	} GdaClientSpecsType;
	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,
	skipping to change at line 90		skipping to change at line 86
	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);		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,
			const gchar *u
			sername,
			const gchar *p
			assword,
	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);
	void gda_client_close_all_connections (GdaClient *cl ient);		void gda_client_close_all_connections (GdaClient *cl ient);
	void gda_client_notify_event (GdaClient *cl ient, GdaConnection *cnc,		void gda_client_notify_event (GdaClient *cl ient, GdaConnection *cnc,
	skipping to change at line 122		skipping to change at line 120
	GdaTransaction *xaction);		GdaTransaction *xaction);
	/*		/*
	* General provider information		* General provider information
	*/		*/
	gchar *gda_client_get_dsn_specs (GdaClient *cl ient, const gchar *provider);		gchar *gda_client_get_dsn_specs (GdaClient *cl ient, const gchar *provider);
	/*		/*
	* Database creation and destruction functions		* Database creation and destruction functions
	*/		*/
	gchar *gda_client_get_provider_specs (GdaClient *cl		GdaServerOperation *gda_client_prepare_create_database (GdaClient *cl
	ient, const gchar *provider,		ient, const gchar *provider);
	GdaClientSpecs		gboolean gda_client_perform_create_database (GdaClient *cl
	Type type);		ient, const gchar *provider,
	gboolean gda_client_create_database (GdaClient *cl		GdaServerOpera
	ient, const gchar *provider,		tion *op, GError **error);
	GdaParameterLi		GdaServerOperation *gda_client_prepare_drop_database (GdaClient *cl
	st *params, GError **error);		ient, const gchar *provider);
	gboolean gda_client_drop_database (GdaClient *cl		gboolean gda_client_perform_drop_database (GdaClient *cl
	ient, const gchar *provider,		ient, const gchar *provider,
	GdaParameterLi		GdaServerOpera
	st *params, GError **error);		tion *op, GError **error);
	/*		/*
	* Connection stack functions		* Connection stack functions
	*/		*/
	gboolean gda_client_begin_transaction (GdaClient *cl ient, GdaTransaction *xaction);		gboolean gda_client_begin_transaction (GdaClient *cl ient, GdaTransaction *xaction);
	gboolean gda_client_commit_transaction (GdaClient *cl ient, GdaTransaction *xaction);		gboolean gda_client_commit_transaction (GdaClient *cl ient, GdaTransaction *xaction);
	gboolean gda_client_rollback_transaction (GdaClient *cl ient, GdaTransaction *xaction);		gboolean gda_client_rollback_transaction (GdaClient *cl ient, GdaTransaction *xaction);
	G_END_DECLS		G_END_DECLS
End of changes. 5 change blocks.
	19 lines changed or deleted		19 lines changed or added

	gda-column.h		gda-column.h
	/* GDA library		/* GDA library
	* Copyright (C) 1998 - 2002 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>
	*		*
			* 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(__gda_column_h__)		#ifndef __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/gda-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))
	skipping to change at line 51		skipping to change at line 52
	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) ;
	void (* gda_type_changed) (GdaColumn *column, GdaValueType old_type, GdaValueType new_type);		void (* gda_type_changed) (GdaColumn *column, GType old_type, GType new_type);
	};		};
	GType gda_column_get_type (void);		GType gda_column_get_type (void);
	GdaColumn *gda_column_new (void);		GdaColumn *gda_column_new (void);
	GdaColumn *gda_column_copy (GdaColumn *column);		GdaColumn *gda_column_copy (GdaColumn *column);
	gboolean gda_column_equal (const GdaColumn *lhs, const GdaColumn *rhs);
	const gchar *gda_column_get_title (GdaColumn *column);		const gchar *gda_column_get_title (GdaColumn *column);
	void gda_column_set_title (GdaColumn *column, const gch ar *title);		void gda_column_set_title (GdaColumn *column, const gch ar *title);
	glong gda_column_get_defined_size (GdaColumn *column);		glong gda_column_get_defined_size (GdaColumn *column);
	void gda_column_set_defined_size (GdaColumn *column, glong siz e);		void gda_column_set_defined_size (GdaColumn *column, glong siz e);
	const gchar *gda_column_get_name (GdaColumn *column);		const gchar *gda_column_get_name (GdaColumn *column);
	void gda_column_set_name (GdaColumn *column, const gch ar *name);		void gda_column_set_name (GdaColumn *column, const gch ar *name);
	skipping to change at line 80		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_gda_type (GdaColumn *column);		GType gda_column_get_gda_type (GdaColumn *column);
	void gda_column_set_gda_type (GdaColumn *column, GdaValue		void gda_column_set_gda_type (GdaColumn *column, GType ty
	Type type);		pe);
	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);
	const gchar *gda_column_get_references (GdaColumn *column);		const gchar *gda_column_get_references (GdaColumn *column);
	void gda_column_set_references (GdaColumn *column, const gch ar *ref);		void gda_column_set_references (GdaColumn *column, const gch ar *ref);
	gboolean gda_column_get_auto_increment (GdaColumn *column);		gboolean gda_column_get_auto_increment (GdaColumn *column);
	void gda_column_set_auto_increment (GdaColumn *column, gboolean is_auto);		void gda_column_set_auto_increment (GdaColumn *column, gboolean is_auto);
	gint gda_column_get_position (GdaColumn *column);		gint gda_column_get_position (GdaColumn *column);
	void gda_column_set_position (GdaColumn *column, gint posi tion);		void gda_column_set_position (GdaColumn *column, gint posi tion);
	const GdaValue *gda_column_get_default_value (GdaColumn *column);		const GValue *gda_column_get_default_value (GdaColumn *column);
	void gda_column_set_default_value (GdaColumn *column, const Gda		void gda_column_set_default_value (GdaColumn *column, const GVa
	Value *default_value);		lue *default_value);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 7 change blocks.
	11 lines changed or deleted		11 lines changed or added

	gda-connection.h		gda-connection.h
	/* GDA client library		/* GDA client 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>		* 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
	skipping to change at line 26		skipping to change at line 26
	* 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_connection_h__)		#ifndef __GDA_CONNECTION_H__
	#define __gda_connection_h__		#define __GDA_CONNECTION_H__
	#include "gda-decl.h"		#include "gda-decl.h"
	#include <libgda/gda-object.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))
			/* error reporting */
			extern GQuark gda_connection_error_quark (void);
			#define GDA_CONNECTION_ERROR gda_connection_error_quark ()
			enum {
			GDA_CONNECTION_CONN_OPEN_ERROR,
			GDA_CONNECTION_DO_QUERY_ERROR,
			GDA_CONNECTION_NONEXIST_DSN_ERROR,
			GDA_CONNECTION_NO_CNC_SPEC_ERROR,
			GDA_CONNECTION_NO_PROVIDER_SPEC_ERROR,
			GDA_CONNECTION_OPEN_ERROR,
			GDA_CONNECTION_EXECUTE_COMMAND_ERROR
			};
	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, GdaConnecti onEvent *error);		void (*error) (GdaConnection *cnc, GdaConnecti onEvent *error);
	skipping to change at line 99		skipping to change at line 113
	GDA_CONNECTION_SCHEMA_LANGUAGES,		GDA_CONNECTION_SCHEMA_LANGUAGES,
	GDA_CONNECTION_SCHEMA_NAMESPACES,		GDA_CONNECTION_SCHEMA_NAMESPACES,
	GDA_CONNECTION_SCHEMA_PARENT_TABLES,		GDA_CONNECTION_SCHEMA_PARENT_TABLES,
	GDA_CONNECTION_SCHEMA_PROCEDURES,		GDA_CONNECTION_SCHEMA_PROCEDURES,
	GDA_CONNECTION_SCHEMA_SEQUENCES,		GDA_CONNECTION_SCHEMA_SEQUENCES,
	GDA_CONNECTION_SCHEMA_TABLES,		GDA_CONNECTION_SCHEMA_TABLES,
	GDA_CONNECTION_SCHEMA_TRIGGERS,		GDA_CONNECTION_SCHEMA_TRIGGERS,
	GDA_CONNECTION_SCHEMA_TYPES,		GDA_CONNECTION_SCHEMA_TYPES,
	GDA_CONNECTION_SCHEMA_USERS,		GDA_CONNECTION_SCHEMA_USERS,
	GDA_CONNECTION_SCHEMA_VIEWS,		GDA_CONNECTION_SCHEMA_VIEWS,
	GDA_CONNECTION_SCHEMA_CONSTRAINTS		GDA_CONNECTION_SCHEMA_CONSTRAINTS,
			GDA_CONNECTION_SCHEMA_TABLE_CONTENTS
	} GdaConnectionSchema;		} GdaConnectionSchema;
	/* errors */		GType gda_connection_get_type (void);
	enum		GdaConnection *gda_connection_new (GdaClient *client,
	{		GdaServerProvider *
	GDA_CONNECTION_CONN_OPEN_ERROR,		provider,
	GDA_CONNECTION_DO_QUERY_ERROR,		const gchar *dsn,
	};		const gchar *userna
			me,
	GType gda_connection_get_type (void);		const gchar *passwo
	GdaConnection *gda_connection_new (GdaClient *client,		rd,
	GdaServerProvider *provider,		guint options);
	const gchar *dsn,		gboolean gda_connection_open (GdaConnection *cn
	const gchar *username,		c, GError **error);
	const gchar *password,		void gda_connection_close (GdaConnection *cn
	GdaConnectionOptions options);		c);
	gboolean gda_connection_open (GdaConnection *cnc, GError **erro		void gda_connection_close_no_warning (GdaConnection *cn
	r);		c);
	gboolean gda_connection_reset (GdaConnection *cnc);		gboolean gda_connection_is_opened (GdaConnection *cn
	void gda_connection_close (GdaConnection *cnc);		c);
	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 *cn
	void gda_connection_set_client (GdaConnection *cnc, GdaClie		c);
	nt *client);
	const gchar *gda_connection_get_provider (GdaConnection *cnc);		const gchar *gda_connection_get_provider (GdaConnection *cn
	GdaServerProvider *gda_connection_get_provider_obj (GdaConnection *cnc);		c);
	GdaServerProviderInfo *gda_connection_get_infos (GdaConnection *cnc);		GdaServerProvider *gda_connection_get_provider_obj (GdaConnection *cn
	GdaConnectionOptions gda_connection_get_options (GdaConnection *cnc);		c);
			GdaServerProviderInfo *gda_connection_get_infos (GdaConnection *cn
			c);
			guint gda_connection_get_options (GdaConnection *cn
			c);
	const gchar *gda_connection_get_server_version (GdaConnection *cnc)		const gchar *gda_connection_get_server_version (GdaConnection *cn
	;		c);
	const gchar *gda_connection_get_database (GdaConnection *cnc);		const gchar *gda_connection_get_database (GdaConnection *cn
	const gchar *gda_connection_get_dsn (GdaConnection *cnc);		c);
	gboolean gda_connection_set_dsn (GdaConnection *cnc, const gcha		const gchar *gda_connection_get_dsn (GdaConnection *cn
	r *datasource);		c);
	const gchar *gda_connection_get_cnc_string (GdaConnection *cnc);		gboolean gda_connection_set_dsn (GdaConnection *cn
	const gchar *gda_connection_get_username (GdaConnection *cnc);		c, const gchar *datasource);
	gboolean gda_connection_set_username (GdaConnection *srv, const		const gchar *gda_connection_get_cnc_string (GdaConnection *cn
	gchar *username);		c);
	const gchar *gda_connection_get_password (GdaConnection *cnc);		const gchar *gda_connection_get_username (GdaConnection *cn
	gboolean gda_connection_set_password (GdaConnection *srv, const		c);
	gchar *password);		gboolean gda_connection_set_username (GdaConnection *sr
			v, const gchar *username);
			const gchar *gda_connection_get_password (GdaConnection *cn
			c);
			gboolean gda_connection_set_password (GdaConnection *sr
			v, const gchar *password);
	void gda_connection_add_event (GdaConnection *cnc, GdaConne		void gda_connection_add_event (GdaConnection *cn
	ctionEvent *error);		c, GdaConnectionEvent *error);
	void gda_connection_add_event_string (GdaConnection *cnc, c		void gda_connection_add_event_string (GdaConnection *cn
	onst gchar *str, ...);		c, const gchar *str, ...);
	void gda_connection_add_events_list (GdaConnection *cnc, GL		void gda_connection_add_events_list (GdaConnection *cn
	ist *events_list);		c, GList *events_list);
	void gda_connection_clear_events_list (GdaConnection *cnc);		void gda_connection_clear_events_list (GdaConnection *cn
	const GList *gda_connection_get_events (GdaConnection *cnc);		c);
			const GList *gda_connection_get_events (GdaConnection *cn
			c);
	gboolean gda_connection_change_database (GdaConnection *cnc, co		gboolean gda_connection_change_database (GdaConnection *cn
	nst gchar *name);		c, const gchar *name);
	gboolean gda_connection_create_table (GdaConnection *cnc, const
	gchar *table_name,
	const GList *attributes_li
	st,
	const GList *index_list);
	gboolean gda_connection_drop_table (GdaConnection *cnc, const g
	char *table_name);
	gboolean gda_connection_create_index (GdaConnection *cnc, const
	GdaDataModelIndex *index,
	const gchar *table_name);
	gboolean gda_connection_drop_index (GdaConnection *cnc, const g
	char *index_name,
	gboolean primary_key, const
	gchar *table_name);
	GList *gda_connection_execute_command (GdaConnection *cnc,		#define GDA_CONNECTION_EXEC_FAILED ((void *) -1)
	GdaCommand *cmd,		GdaDataModel *gda_connection_execute_command (GdaConnection *cn
	GdaParameterList *param		c, GdaCommand *cmd,
	s,		GdaParameterList *
	GError **error);		params, GError **error);
	gchar *gda_connection_get_last_insert_id (GdaConnection *cnc,		GList *gda_connection_execute_command_l (GdaConnection *cn
	GdaDataModel *recset);		c, GdaCommand *cmd,
	GdaDataModel *gda_connection_execute_single_command (GdaConnection *		GdaParameterList *
	cnc,		params, GError **error);
	GdaCommand *cmd,		gchar *gda_connection_get_last_insert_id (GdaConnection *cn
	GdaParameterList		c, GdaDataModel *recset);
	*params,
	GError **error);
	gint gda_connection_execute_non_query (GdaConnection *cnc,
	GdaCommand *cmd,
	GdaParameterList *par
	ams,
	GError **error);
	gboolean gda_connection_begin_transaction (GdaConnection *cnc,		gboolean gda_connection_begin_transaction (GdaConnection *cn
	GdaTransaction *xaction);		c, GdaTransaction *xaction);
	gboolean gda_connection_commit_transaction (GdaConnection *cnc,		gboolean gda_connection_commit_transaction (GdaConnection *cn
	GdaTransaction *xaction);		c, 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 *cn
	GdaBlob *gda_connection_fetch_blob_by_id (GdaConnection *cnc, c		c);
	onst gchar *sql_id);		GdaBlob *gda_connection_fetch_blob_by_id (GdaConnection *cn
			c, const gchar *sql_id);
	gchar *gda_connection_value_to_sql_string (GdaConnection *cnc , GdaValue *from);		gchar *gda_connection_value_to_sql_string (GdaConnection *cn c, GValue *from);
	gboolean gda_connection_supports (GdaConnection *cnc, GdaConnec		gboolean gda_connection_supports_feature (GdaConnec
	tionFeature feature);		tion *cnc, GdaConnectionFeature feature);
	GdaDataModel *gda_connection_get_schema (GdaConnection *cnc, GdaConn		GdaDataModel *gda_connection_get_schema (GdaConnection *cn
	ectionSchema schema,		c, GdaConnectionSchema schema,
	GdaParameterList *params, GE		GdaParameterList *
	rror **error);		params, GError **error);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 15 change blocks.
	100 lines changed or deleted		103 lines changed or added

	gda-data-access-wrapper.h		gda-data-access-wrapper.h
	skipping to change at line 52		skipping to change at line 52
	GdaObject object;		GdaObject object;
	GdaDataAccessWrapperPrivate *priv;		GdaDataAccessWrapperPrivate *priv;
	};		};
	struct _GdaDataAccessWrapperClass {		struct _GdaDataAccessWrapperClass {
	GdaObjectClass parent_class;		GdaObjectClass parent_class;
	};		};
	GType gda_data_access_wrapper_get_type (void);		GType gda_data_access_wrapper_get_type (void);
	GdaDataModel *gda_data_access_wrapper_new (GdaDataModel *model);		GdaDataModel *gda_data_access_wrapper_new (GdaDataModel *model);
			gboolean gda_data_access_wrapper_row_exists (GdaDataAccessWrapper *wr apper, gint row);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 1 change blocks.
	0 lines changed or deleted		1 lines changed or added

	gda-data-handler.h		gda-data-handler.h
	skipping to change at line 41		skipping to change at line 41
	#define GDA_DATA_HANDLER(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, GDA _TYPE_DATA_HANDLER, GdaDataHandler)		#define GDA_DATA_HANDLER(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, GDA _TYPE_DATA_HANDLER, GdaDataHandler)
	#define GDA_IS_DATA_HANDLER(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA _TYPE_DATA_HANDLER)		#define GDA_IS_DATA_HANDLER(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA _TYPE_DATA_HANDLER)
	#define GDA_DATA_HANDLER_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((ob j), GDA_TYPE_DATA_HANDLER, GdaDataHandlerIface))		#define GDA_DATA_HANDLER_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((ob j), GDA_TYPE_DATA_HANDLER, GdaDataHandlerIface))
	/* struct for the interface */		/* struct for the interface */
	struct _GdaDataHandlerIface		struct _GdaDataHandlerIface
	{		{
	GTypeInterface g_iface;		GTypeInterface g_iface;
	/* virtual table */		/* virtual table */
	gchar *(* get_sql_from_value) (GdaDataHandler *dh, const		gchar *(* get_sql_from_value) (GdaDataHandler *dh, const G
	GdaValue *value);		Value *value);
	gchar *(* get_str_from_value) (GdaDataHandler *dh, const		gchar *(* get_str_from_value) (GdaDataHandler *dh, const G
	GdaValue *value);		Value *value);
	GdaValue *(* get_value_from_sql) (GdaDataHandler *dh, const		GValue *(* get_value_from_sql) (GdaDataHandler *dh, const g
	gchar *sql, GdaValueType type);		char *sql, GType type);
	GdaValue *(* get_value_from_str) (GdaDataHandler *dh, const		GValue *(* get_value_from_str) (GdaDataHandler *dh, const g
	gchar *str, GdaValueType type);		char *str, GType type);
	GdaValue *(* get_sane_init_value) (GdaDataHandler *dh, GdaVa		GValue *(* get_sane_init_value) (GdaDataHandler *dh, GType t
	lueType type);		ype);
	guint (* get_nb_gda_types) (GdaDataHandler * dh);		guint (* get_nb_gda_types) (GdaDataHandler * dh);
	GdaValueType (* get_gda_type_index) (GdaDataHandler * dh, guin		GType (* get_gda_type_index) (GdaDataHandler * dh, guint
	t index);		index);
	gboolean (* accepts_gda_type) (GdaDataHandler * dh, GdaV		gboolean (* accepts_gda_type) (GdaDataHandler * dh, GType
	alueType type);		type);
	const gchar *(* get_descr) (GdaDataHandler * dh);		const gchar *(* get_descr) (GdaDataHandler * dh);
	};		};
	GType gda_data_handler_get_type (void);		GType gda_data_handler_get_type (void);
	/* Simple data manipulation */		/* Simple data manipulation */
	gchar *gda_data_handler_get_sql_from_value (GdaDataHandler *		gchar *gda_data_handler_get_sql_from_value (GdaDataHandler * dh
	dh, const GdaValue *value);		, const GValue *value);
	gchar *gda_data_handler_get_str_from_value (GdaDataHandler *		gchar *gda_data_handler_get_str_from_value (GdaDataHandler * dh
	dh, const GdaValue *value);		, const GValue *value);
	GdaValue *gda_data_handler_get_value_from_sql (GdaDataHandler *		GValue *gda_data_handler_get_value_from_sql (GdaDataHandler * dh
	dh, const gchar *sql, GdaValueType type);		, const gchar *sql, GType type);
	GdaValue *gda_data_handler_get_value_from_str (GdaDataHandler *		GValue *gda_data_handler_get_value_from_str (GdaDataHandler * dh
	dh, const gchar *str, GdaValueType type);		, const gchar *str, GType type);
	GdaValue *gda_data_handler_get_sane_init_value (GdaDataHandler *		GValue *gda_data_handler_get_sane_init_value (GdaDataHandler * dh
	dh, GdaValueType type);		, GType type);
	/* information about the data handler itself */		/* information about the data handler itself */
	guint gda_data_handler_get_nb_gda_types (GdaDataHandler *		guint gda_data_handler_get_nb_gda_types (GdaDataHandler * dh
	dh);		);
	GdaValueType gda_data_handler_get_gda_type_index (GdaDataHandler *		GType gda_data_handler_get_gda_type_index (GdaDataHandler * dh
	dh, guint index);		, guint index);
	gboolean gda_data_handler_accepts_gda_type (GdaDataHandler *		gboolean gda_data_handler_accepts_gda_type (GdaDataHandler * dh
	dh, GdaValueType type);		, GType type);
	const gchar *gda_data_handler_get_descr (GdaDataHandler *		const gchar *gda_data_handler_get_descr (GdaDataHandler * dh
	dh);		);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 4 change blocks.
	34 lines changed or deleted		34 lines changed or added

	gda-data-model-array.h		gda-data-model-array.h
	skipping to change at line 52		skipping to change at line 52
	struct _GdaDataModelArray {		struct _GdaDataModelArray {
	GdaDataModelRow model;		GdaDataModelRow model;
	GdaDataModelArrayPrivate *priv;		GdaDataModelArrayPrivate *priv;
	};		};
	struct _GdaDataModelArrayClass {		struct _GdaDataModelArrayClass {
	GdaDataModelRowClass 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_with_types (gint cols, ...);
	GdaDataModel *gda_data_model_array_new (gint cols);		GdaDataModel *gda_data_model_array_new (gint cols);
	GdaDataModel *gda_data_model_array_copy_model (GdaDataModel *src, GE rror **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. 1 change blocks.
	0 lines changed or deleted		1 lines changed or added

	gda-data-model-row.h		gda-data-model-row.h
	skipping to change at line 56		skipping to change at line 56
	GdaDataModelRowPrivate *priv;		GdaDataModelRowPrivate *priv;
	};		};
	struct _GdaDataModelRowClass {		struct _GdaDataModelRowClass {
	GdaObjectClass parent_class;		GdaObjectClass parent_class;
	/* virtual methods */		/* virtual methods */
	gint (* get_n_rows) (GdaDataModelRow *model);		gint (* get_n_rows) (GdaDataModelRow *model);
	gint (* get_n_columns) (GdaDataModelRow *model);		gint (* get_n_columns) (GdaDataModelRow *model);
	GdaRow *(* get_row) (GdaDataModelRow *model, gin t row, GError **error);		GdaRow *(* get_row) (GdaDataModelRow *model, gin t row, GError **error);
	const GdaValue *(* get_value_at) (GdaDataModelRow *model, gin t col, gint row);		const GValue *(* get_value_at) (GdaDataModelRow *model, gin t col, gint row);
	gboolean (* is_updatable) (GdaDataModelRow *model);		gboolean (* is_updatable) (GdaDataModelRow *model);
	GdaRow *(* append_values) (GdaDataModelRow *model, con st GList *values, GError **error);		GdaRow *(* append_values) (GdaDataModelRow *model, con st GList *values, GError **error);
	gboolean (* append_row) (GdaDataModelRow *model, Gda Row *row, GError **error);		gboolean (* append_row) (GdaDataModelRow *model, Gda Row *row, GError **error);
	gboolean (* update_row) (GdaDataModelRow *model, Gda Row *row, GError **error);		gboolean (* update_row) (GdaDataModelRow *model, Gda Row *row, GError **error);
	gboolean (* remove_row) (GdaDataModelRow *model, Gda Row *row, GError **error);		gboolean (* remove_row) (GdaDataModelRow *model, Gda Row *row, GError **error);
	};		};
	GType gda_data_model_row_get_type (void);		GType gda_data_model_row_get_type (void);
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	gda-data-model.h		gda-data-model.h
	skipping to change at line 82		skipping to change at line 82
	struct _GdaDataModelClass {		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, gi nt col);		GdaColumn *(* i_describe_column) (GdaDataModel *model, gi nt col);
	guint (* i_get_access_flags) (GdaDataModel *model);		guint (* i_get_access_flags) (GdaDataModel *model);
	const GdaValue *(* i_get_value_at) (GdaDataModel *model, gi nt col, gint row);		const GValue *(* i_get_value_at) (GdaDataModel *model, gi nt col, gint row);
	guint (* i_get_attributes_at)(GdaDataModel *model, gi nt col, gint row);		guint (* i_get_attributes_at)(GdaDataModel *model, gi nt col, gint row);
	GdaDataModelIter *(* i_create_iter) (GdaDataModel *model);		GdaDataModelIter *(* i_create_iter) (GdaDataModel *model);
	gboolean (* i_iter_at_row) (GdaDataModel *model, Gd aDataModelIter *iter, gint row);		gboolean (* i_iter_at_row) (GdaDataModel *model, Gd aDataModelIter *iter, gint row);
	gboolean (* i_iter_next) (GdaDataModel *model, Gd aDataModelIter *iter);		gboolean (* i_iter_next) (GdaDataModel *model, Gd aDataModelIter *iter);
	gboolean (* i_iter_prev) (GdaDataModel *model, Gd aDataModelIter *iter);		gboolean (* i_iter_prev) (GdaDataModel *model, Gd aDataModelIter *iter);
	gboolean (* i_set_value_at) (GdaDataModel *model, gi nt col, gint row,		gboolean (* i_set_value_at) (GdaDataModel *model, gi nt col, gint row,
	const GdaValue *value, GError **error);		const GValue *value, GE rror **error);
	gboolean (* i_set_values) (GdaDataModel *model, gi nt row, GList *values,		gboolean (* i_set_values) (GdaDataModel *model, gi nt row, GList *values,
	GError **error);		GError **error);
	gint (* i_append_values) (GdaDataModel *model, co nst 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);		gint (* i_append_row) (GdaDataModel *model, GE rror **error);
	gboolean (* i_remove_row) (GdaDataModel *model, gi nt row, GError **error);		gboolean (* i_remove_row) (GdaDataModel *model, gi nt row, GError **error);
	gint (* i_find_row) (GdaDataModel *model, GS List *values, gint *cols_index);		gint (* i_find_row) (GdaDataModel *model, GS List *values, gint *cols_index);
	void (* i_set_notify) (GdaDataModel *model, gb oolean do_notify_changes);		void (* i_set_notify) (GdaDataModel *model, gb oolean do_notify_changes);
	gboolean (* i_get_notify) (GdaDataModel *model);		gboolean (* i_get_notify) (GdaDataModel *model);
	void (* i_send_hint) (GdaDataModel *model, Gd aDataModelHint hint, const GdaValue *hint_value);		void (* i_send_hint) (GdaDataModel *model, Gd aDataModelHint hint, const GValue *hint_value);
	/* signals */		/* signals */
	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);
	};		};
	GType gda_data_model_get_type (void);		GType gda_data_model_get_type (void);
	gboolean gda_data_model_is_updatable (GdaDataModel *mo del);		gboolean gda_data_model_is_updatable (GdaDataModel *mo del);
	guint gda_data_model_get_access_flags (GdaDataModel *mo del);		guint gda_data_model_get_access_flags (GdaDataModel *mo del);
	gint gda_data_model_get_n_rows (GdaDataModel *mo del);		gint gda_data_model_get_n_rows (GdaDataModel *mo del);
	gint gda_data_model_get_n_columns (GdaDataModel *mo del);		gint gda_data_model_get_n_columns (GdaDataModel *mo del);
	GdaColumn *gda_data_model_describe_column (GdaDataModel *mo del, gint col);		GdaColumn *gda_data_model_describe_column (GdaDataModel *mo del, gint col);
	const gchar *gda_data_model_get_column_title (GdaDataModel *mo del, gint col);		const gchar *gda_data_model_get_column_title (GdaDataModel *mo del, gint col);
	void gda_data_model_set_column_title (GdaDataModel *mo del, gint col, const gchar *title);		void gda_data_model_set_column_title (GdaDataModel *mo del, gint col, const gchar *title);
	const GdaValue *gda_data_model_get_value_at (GdaDataModel *mo del, gint col, gint row);		const GValue *gda_data_model_get_value_at (GdaDataModel *mo del, gint col, gint row);
	guint gda_data_model_get_attributes_at (GdaDataModel *mo del, gint col, gint row);		guint gda_data_model_get_attributes_at (GdaDataModel *mo del, gint col, gint row);
	GdaDataModelIter *gda_data_model_create_iter (GdaDataModel *mo del);		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_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_next (GdaDataModel *mo del, GdaDataModelIter *iter);
	gboolean gda_data_model_move_iter_prev (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_freeze (GdaDataModel *mo del);
	void gda_data_model_thaw (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,		gboolean gda_data_model_set_value_at (GdaDataModel *mo del, gint col, gint row,
	const GdaValue *v alue, GError **error);		const GValue *val ue, GError **error);
	gboolean gda_data_model_set_values (GdaDataModel *mo del, gint row,		gboolean gda_data_model_set_values (GdaDataModel *mo del, gint row,
	GList *values, GE rror **error);		GList *values, GE rror **error);
	gint gda_data_model_append_row (GdaDataModel *mo del, GError **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);		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);		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);		gint gda_data_model_get_row_from_values (GdaDataModel *mo del, GSList *values, gint *cols_index);
	void gda_data_model_send_hint (GdaDataModel *mo del, GdaDataModelHint hint, const GdaValue *hint_value);		void gda_data_model_send_hint (GdaDataModel *mo del, GdaDataModelHint hint, const GValue *hint_value);
	/* contents saving and loading */		/* contents saving and loading */
	gchar *gda_data_model_export_to_string (GdaDataModel *mo del, GdaDataModelIOFormat format,		gchar *gda_data_model_export_to_string (GdaDataModel *mo del, GdaDataModelIOFormat format,
	const gint *cols, gint nb_cols, GdaParameterList *options);		const gint *cols, gint nb_cols, GdaParameterList *options);
	gboolean gda_data_model_export_to_file (GdaDataModel *mo del, GdaDataModelIOFormat format,		gboolean gda_data_model_export_to_file (GdaDataModel *mo del, GdaDataModelIOFormat format,
	const gchar *file ,		const gchar *file ,
	const gint *cols, gint nb_cols,		const gint *cols, gint nb_cols,
	GdaParameterList *options, GError **error);		GdaParameterList *options, GError **error);
	gboolean gda_data_model_import_from_model (GdaDataModel *to , GdaDataModel *from,		gboolean gda_data_model_import_from_model (GdaDataModel *to , GdaDataModel *from,
End of changes. 6 change blocks.
	6 lines changed or deleted		6 lines changed or added

	gda-data-proxy.h		gda-data-proxy.h
	skipping to change at line 76		skipping to change at line 76
	gboolean gda_data_proxy_is_read_only (GdaDataProxy *pr oxy);		gboolean gda_data_proxy_is_read_only (GdaDataProxy *pr oxy);
	GSList *gda_data_proxy_get_values (GdaDataProxy *pr oxy, gint proxy_row,		GSList *gda_data_proxy_get_values (GdaDataProxy *pr oxy, gint proxy_row,
	gint *cols_index, gint n_cols);		gint *cols_index, gint n_cols);
	guint gda_data_proxy_get_value_attributes (GdaDataProxy *pr oxy, gint proxy_row, gint col);		guint gda_data_proxy_get_value_attributes (GdaDataProxy *pr oxy, gint proxy_row, gint col);
	void gda_data_proxy_alter_value_attributes (GdaDataProxy *pr oxy, gint proxy_row, gint col, guint alter_flags);		void gda_data_proxy_alter_value_attributes (GdaDataProxy *pr oxy, gint proxy_row, gint col, guint alter_flags);
	gint gda_data_proxy_get_proxied_model_row (GdaDataProxy *pr oxy, gint proxy_row);		gint gda_data_proxy_get_proxied_model_row (GdaDataProxy *pr oxy, gint proxy_row);
	void gda_data_proxy_delete (GdaDataProxy *pr oxy, gint proxy_row);		void gda_data_proxy_delete (GdaDataProxy *pr oxy, gint proxy_row);
	void gda_data_proxy_undelete (GdaDataProxy *pr oxy, gint proxy_row);		void gda_data_proxy_undelete (GdaDataProxy *pr oxy, gint proxy_row);
	gboolean gda_data_proxy_row_is_deleted (GdaDataProxy *pr oxy, gint proxy_row);		gboolean gda_data_proxy_row_is_deleted (GdaDataProxy *pr oxy, gint proxy_row);
			gboolean gda_data_proxy_row_is_inserted (GdaDataProxy *pr oxy, gint proxy_row);
	gint gda_data_proxy_find_row_from_values (GdaDataProxy *pr oxy, GSList *values,		gint gda_data_proxy_find_row_from_values (GdaDataProxy *pr oxy, GSList *values,
	gint *cols_index) ;		gint *cols_index) ;
	gboolean gda_data_proxy_row_has_changed (GdaDataProxy *pr oxy, gint proxy_row);		gboolean gda_data_proxy_row_has_changed (GdaDataProxy *pr oxy, gint proxy_row);
	gboolean gda_data_proxy_has_changed (GdaDataProxy *pr oxy);		gboolean gda_data_proxy_has_changed (GdaDataProxy *pr oxy);
	gint gda_data_proxy_get_n_new_rows (GdaDataProxy *pr oxy);		gint gda_data_proxy_get_n_new_rows (GdaDataProxy *pr oxy);
	gboolean gda_data_proxy_apply_row_changes (GdaDataProxy *pr oxy, gint proxy_row, GError **error);		gboolean gda_data_proxy_apply_row_changes (GdaDataProxy *pr oxy, gint proxy_row, GError **error);
	void gda_data_proxy_cancel_row_changes (GdaDataProxy *pr oxy, gint proxy_row, gint col);		void gda_data_proxy_cancel_row_changes (GdaDataProxy *pr oxy, gint proxy_row, gint col);
	gboolean gda_data_proxy_apply_all_changes (GdaDataProxy *pr oxy, GError **error);		gboolean gda_data_proxy_apply_all_changes (GdaDataProxy *pr oxy, GError **error);
	gboolean gda_data_proxy_cancel_all_changes (GdaDataProxy *pr oxy);		gboolean gda_data_proxy_cancel_all_changes (GdaDataProxy *pr oxy);
	void gda_data_proxy_set_sample_size (GdaDataProxy *pr oxy, gint sample_size);		void gda_data_proxy_set_sample_size (GdaDataProxy *pr oxy, gint sample_size);
	gint gda_data_proxy_get_sample_size (GdaDataProxy *pr oxy);		gint gda_data_proxy_get_sample_size (GdaDataProxy *pr oxy);
	void gda_data_proxy_set_sample_start (GdaDataProxy *pr oxy, gint sample_start);		void gda_data_proxy_set_sample_start (GdaDataProxy *pr oxy, gint sample_start);
	gint gda_data_proxy_get_sample_start (GdaDataProxy *pr oxy);		gint gda_data_proxy_get_sample_start (GdaDataProxy *pr oxy);
	gint gda_data_proxy_get_sample_end (GdaDataProxy *pr oxy);		gint gda_data_proxy_get_sample_end (GdaDataProxy *pr oxy);
	void gda_data_proxy_set_model_row_value (GdaDataProxy *pr oxy, GdaDataModel *model,		void gda_data_proxy_set_model_row_value (GdaDataProxy *pr oxy, GdaDataModel *model,
	gint proxy_row, g int extra_col, const GdaValue *value);		gint proxy_row, g int extra_col, const GValue *value);
	void gda_data_proxy_clear_model_row_value (GdaDataProxy *pr oxy, GdaDataModel *model,		void gda_data_proxy_clear_model_row_value (GdaDataProxy *pr oxy, GdaDataModel *model,
	gint proxy_row, g int extra_col);		gint proxy_row, g int extra_col);
	const GdaValue *gda_data_proxy_get_model_row_value (GdaDataProxy *pr oxy, GdaDataModel *model,		const GValue *gda_data_proxy_get_model_row_value (GdaDataProxy *pr oxy, GdaDataModel *model,
	gint proxy_row, g int extra_col);		gint proxy_row, g int extra_col);
	void gda_data_proxy_assign_model_col (GdaDataProxy *pr oxy, GdaDataModel *model,		void gda_data_proxy_assign_model_col (GdaDataProxy *pr oxy, GdaDataModel *model,
	gint proxy_col, g int model_col);		gint proxy_col, g int model_col);
	gint gda_data_proxy_get_assigned_model_col (GdaDataProxy *pr oxy, GdaDataModel *model, gint model_col);		gint gda_data_proxy_get_assigned_model_col (GdaDataProxy *pr oxy, GdaDataModel *model, gint model_col);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 3 change blocks.
	2 lines changed or deleted		3 lines changed or added

	gda-decl.h		gda-decl.h
	/* gda-decl.h		/* gda-decl.h
	*		*
	* Copyright (C) 2004 - 2005 Vivien Malerba		* Copyright (C) 2004 - 2006 Vivien Malerba
	*		*
	* This program 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 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 program 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		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.		* GNU General Public License for more details.
	skipping to change at line 34		skipping to change at line 34
	typedef struct _GdaObject GdaObject;		typedef struct _GdaObject GdaObject;
	typedef struct _GdaObjectClass GdaObjectClass;		typedef struct _GdaObjectClass GdaObjectClass;
	typedef struct _GdaObjectPrivate GdaObjectPrivate;		typedef struct _GdaObjectPrivate GdaObjectPrivate;
	typedef struct _GdaConnection GdaConnection;		typedef struct _GdaConnection GdaConnection;
	typedef struct _GdaConnectionClass GdaConnectionClass;		typedef struct _GdaConnectionClass GdaConnectionClass;
	typedef struct _GdaConnectionPrivate GdaConnectionPrivate;		typedef struct _GdaConnectionPrivate GdaConnectionPrivate;
	typedef struct _GdaDataHandler GdaDataHandler;		typedef struct _GdaDataHandler GdaDataHandler;
	typedef struct _GdaDataHandlerIface GdaDataHandlerIface;		typedef struct _GdaDataHandlerIface GdaDataHandlerIface;
	extern GdaDataHandler *default_handlers [];
	typedef struct _GdaServerProvider GdaServerProvider; /* defined in g da-server-provider.h */		typedef struct _GdaServerProvider GdaServerProvider;
	typedef struct _GdaServerProviderClass GdaServerProviderClass;		typedef struct _GdaServerProviderClass GdaServerProviderClass;
	typedef struct _GdaServerProviderPrivate GdaServerProviderPrivate;		typedef struct _GdaServerProviderPrivate GdaServerProviderPrivate;
	typedef struct _GdaServerProviderInfo GdaServerProviderInfo;		typedef struct _GdaServerProviderInfo GdaServerProviderInfo;
			typedef struct _GdaServerOperation GdaServerOperation;
			typedef struct _GdaServerOperationClass GdaServerOperationClass;
			typedef struct _GdaServerOperationPrivate GdaServerOperationPrivate;
	typedef struct _GdaClient GdaClient;		typedef struct _GdaClient GdaClient;
	typedef struct _GdaClientClass GdaClientClass;		typedef struct _GdaClientClass GdaClientClass;
	typedef struct _GdaClientPrivate GdaClientPrivate;		typedef struct _GdaClientPrivate GdaClientPrivate;
	typedef struct _GdaEntity GdaEntity;		typedef struct _GdaEntity GdaEntity;
	typedef struct _GdaEntityIface GdaEntityIface;		typedef struct _GdaEntityIface GdaEntityIface;
	typedef struct _GdaEntityField GdaEntityField;		typedef struct _GdaEntityField GdaEntityField;
	typedef struct _GdaEntityFieldIface GdaEntityFieldIface;		typedef struct _GdaEntityFieldIface GdaEntityFieldIface;
	skipping to change at line 97		skipping to change at line 100
	typedef struct _GdaDictDatabasePrivate GdaDictDatabasePrivate;		typedef struct _GdaDictDatabasePrivate GdaDictDatabasePrivate;
	typedef struct _GdaDictTable GdaDictTable;		typedef struct _GdaDictTable GdaDictTable;
	typedef struct _GdaDictTableClass GdaDictTableClass;		typedef struct _GdaDictTableClass GdaDictTableClass;
	typedef struct _GdaDictTablePrivate GdaDictTablePrivate;		typedef struct _GdaDictTablePrivate GdaDictTablePrivate;
	typedef struct _GdaDictField GdaDictField;		typedef struct _GdaDictField GdaDictField;
	typedef struct _GdaDictFieldClass GdaDictFieldClass;		typedef struct _GdaDictFieldClass GdaDictFieldClass;
	typedef struct _GdaDictFieldPrivate GdaDictFieldPrivate;		typedef struct _GdaDictFieldPrivate GdaDictFieldPrivate;
	typedef struct _GdaDictSequence GdaDictSequence;
	typedef struct _GdaDictSequenceClass GdaDictSequenceClass;
	typedef struct _GdaDictSequencePrivate GdaDictSequencePrivate;
	typedef struct _GdaDictConstraint GdaDictConstraint;		typedef struct _GdaDictConstraint GdaDictConstraint;
	typedef struct _GdaDictConstraintClass GdaDictConstraintClass;		typedef struct _GdaDictConstraintClass GdaDictConstraintClass;
	typedef struct _GdaDictConstraintPrivate GdaDictConstraintPrivate;		typedef struct _GdaDictConstraintPrivate GdaDictConstraintPrivate;
	typedef struct _GdaParameter GdaParameter;		typedef struct _GdaParameter GdaParameter;
	typedef struct _GdaParameterClass GdaParameterClass;		typedef struct _GdaParameterClass GdaParameterClass;
	typedef struct _GdaParameterPrivate GdaParameterPrivate;		typedef struct _GdaParameterPrivate GdaParameterPrivate;
	typedef struct _GdaParameterList GdaParameterList;		typedef struct _GdaParameterList GdaParameterList;
	typedef struct _GdaParameterListClass GdaParameterListClass;		typedef struct _GdaParameterListClass GdaParameterListClass;
End of changes. 5 change blocks.
	7 lines changed or deleted		6 lines changed or added

	gda-dict-database.h		gda-dict-database.h
	skipping to change at line 70		skipping to change at line 70
	/* signals */		/* signals */
	void (*table_added) (GdaDictDatabase *obj, GdaDictTa ble *table);		void (*table_added) (GdaDictDatabase *obj, GdaDictTa ble *table);
	void (*table_removed) (GdaDictDatabase *obj, GdaDictTa ble *table);		void (*table_removed) (GdaDictDatabase *obj, GdaDictTa ble *table);
	void (*table_updated) (GdaDictDatabase *obj, GdaDictTa ble *table);		void (*table_updated) (GdaDictDatabase *obj, GdaDictTa ble *table);
	void (*field_added) (GdaDictDatabase *obj, GdaDictFi eld *field);		void (*field_added) (GdaDictDatabase *obj, GdaDictFi eld *field);
	void (*field_removed) (GdaDictDatabase *obj, GdaDictFi eld *field);		void (*field_removed) (GdaDictDatabase *obj, GdaDictFi eld *field);
	void (*field_updated) (GdaDictDatabase *obj, GdaDictFi eld *field);		void (*field_updated) (GdaDictDatabase *obj, GdaDictFi eld *field);
	void (*sequence_added) (GdaDictDatabase *obj, GdaDictSe
	quence *seq);
	void (*sequence_removed) (GdaDictDatabase *obj, GdaDictSe
	quence *seq);
	void (*sequence_updated) (GdaDictDatabase *obj, GdaDictSe
	quence *seq);
	void (*constraint_added) (GdaDictDatabase *obj, GdaDictCo nstraint *cstr);		void (*constraint_added) (GdaDictDatabase *obj, GdaDictCo nstraint *cstr);
	void (*constraint_removed) (GdaDictDatabase *obj, GdaDictCo nstraint *cstr);		void (*constraint_removed) (GdaDictDatabase *obj, GdaDictCo nstraint *cstr);
	void (*constraint_updated) (GdaDictDatabase *obj, GdaDictCo nstraint *cstr);		void (*constraint_updated) (GdaDictDatabase *obj, GdaDictCo nstraint *cstr);
	void (*fs_link_added) (GdaDictDatabase *obj, GdaDictSe
	quence *seq, GdaDictField *field);
	void (*fs_link_removed) (GdaDictDatabase *obj, GdaDictSe
	quence *seq, GdaDictField *field);
	void (*data_update_started) (GdaDictDatabase *obj);		void (*data_update_started) (GdaDictDatabase *obj);
	void (*update_progress) (GdaDictDatabase *obj, gchar * m sg, guint now, guint total);		void (*update_progress) (GdaDictDatabase *obj, gchar * m sg, guint now, guint total);
	void (*data_update_finished) (GdaDictDatabase *obj);		void (*data_update_finished) (GdaDictDatabase *obj);
			gpointer reserved1;
			gpointer reserved2;
	};		};
	GType gda_dict_database_get_type (void);		GType gda_dict_database_get_type (void);
	GObject *gda_dict_database_new (GdaDict *di ct);		GObject *gda_dict_database_new (GdaDict *di ct);
	GdaDict *gda_dict_database_get_dict (GdaDictDat		GdaDict *gda_dict_database_get_dict (GdaDictDat
	abase *mgdb);		abase *db);
	gboolean gda_dict_database_update_dbms_data (GdaDictData
	base *mgdb, GError **error);
	void gda_dict_database_stop_update_dbms_data (GdaDictData
	base *mgdb);
	GSList *gda_dict_database_get_tables (GdaDictData		gboolean gda_dict_database_update_dbms_data (GdaDictData
	base *mgdb);		base *db,
	GdaDictTable *gda_dict_database_get_table_by_name (GdaDictData		GType limit_
	base *mgdb, const gchar *name);		to_type, const gchar *limit_obj_name,
	GdaDictTable *gda_dict_database_get_table_by_xml_id (GdaDictData		GError **err
	base *mgdb, const gchar *xml_id);		or);
	GdaDictField *gda_dict_database_get_field_by_name (GdaDictData		void gda_dict_database_stop_update_dbms_data (GdaDictData
	base *mgdb, const gchar *fullname);		base *db);
	GdaDictField *gda_dict_database_get_field_by_xml_id (GdaDictData
	base *mgdb, const gchar *xml_id);
	GdaDictSequence *gda_dict_database_get_sequence_by_name (GdaDictData		GSList *gda_dict_database_get_tables (GdaDictData
	base *mgdb, const gchar *name);		base *db);
	GdaDictSequence *gda_dict_database_get_sequence_by_xml_id (GdaDictData		GdaDictTable *gda_dict_database_get_table_by_name (GdaDictData
	base *mgdb, const gchar *xml_id);		base *db, const gchar *name);
	GdaDictSequence *gda_dict_database_get_sequence_to_field (GdaDictData		GdaDictTable *gda_dict_database_get_table_by_xml_id (GdaDictData
	base *mgdb, GdaDictField *field);		base *db, const gchar *xml_id);
	void gda_dict_database_link_sequence (GdaDictData		GdaDictField *gda_dict_database_get_field_by_name (GdaDictData
	base *mgdb,		base *db, const gchar *fullname);
	GdaDictSeque		GdaDictField *gda_dict_database_get_field_by_xml_id (GdaDictData
	nce *seq, GdaDictField *field);		base *db, const gchar *xml_id);
	void gda_dict_database_unlink_sequence (GdaDictData
	base *mgdb,
	GdaDictSeque
	nce *seq, GdaDictField *field);
	void gda_dict_database_add_constraint (GdaDictData		void gda_dict_database_add_constraint (GdaDictData
	base *mgdb, GdaDictConstraint *cstr);		base *db, GdaDictConstraint *cstr);
	GSList *gda_dict_database_get_all_constraints (GdaDictData		GSList *gda_dict_database_get_all_constraints (GdaDictData
	base *mgdb);		base *db);
	GSList *gda_dict_database_get_all_fk_constraints (GdaDictData		GSList *gda_dict_database_get_all_fk_constraints (GdaDictData
	base *mgdb);		base *db);
	GSList *gda_dict_database_get_table_constraints (GdaDictData		GSList *gda_dict_database_get_table_constraints (GdaDictData
	base *mgdb, GdaDictTable *table);		base *db, GdaDictTable *table);
	GSList *gda_dict_database_get_tables_fk_constraints (GdaDictData		GSList *gda_dict_database_get_tables_fk_constraints (GdaDictData
	base *mgdb, GdaDictTable *table1,		base *db, GdaDictTable *table1,
	GdaDictTable		GdaDictTable
	*table2,		*table2, gboolean table1_has_fk);
	gboolean tab
	le1_has_fk);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 7 change blocks.
	57 lines changed or deleted		35 lines changed or added

	gda-dict-field.h		gda-dict-field.h
	skipping to change at line 69		skipping to change at line 69
	} GdaDictFieldAttribute;		} GdaDictFieldAttribute;
	GType gda_dict_field_get_type (void);		GType gda_dict_field_get_type (void);
	GObject *gda_dict_field_new (GdaDict *dict, GdaDictTyp e *type);		GObject *gda_dict_field_new (GdaDict *dict, GdaDictTyp e *type);
	void gda_dict_field_set_length (GdaDictField *field, gint length);		void gda_dict_field_set_length (GdaDictField *field, gint length);
	gint gda_dict_field_get_length (GdaDictField *field);		gint gda_dict_field_get_length (GdaDictField *field);
	void gda_dict_field_set_scale (GdaDictField *field, gint length);		void gda_dict_field_set_scale (GdaDictField *field, gint length);
	gint gda_dict_field_get_scale (GdaDictField *field);		gint gda_dict_field_get_scale (GdaDictField *field);
	GSList *gda_dict_field_get_constraints (GdaDictField *field);		GSList *gda_dict_field_get_constraints (GdaDictField *field);
	void gda_dict_field_set_data_type (GdaDictField *field, GdaD ictType *type);		void gda_dict_field_set_dict_type (GdaDictField *field, GdaD ictType *type);
	void gda_dict_field_set_default_value (GdaDictField *field, cons		void gda_dict_field_set_default_value (GdaDictField *field, cons
	t GdaValue *value);		t GValue *value);
	const GdaValue *gda_dict_field_get_default_value (GdaDictField *field);		const GValue *gda_dict_field_get_default_value (GdaDictField *field);
	gboolean gda_dict_field_is_null_allowed (GdaDictField *field);		gboolean gda_dict_field_is_null_allowed (GdaDictField *field);
	gboolean gda_dict_field_is_pkey_part (GdaDictField *field);		gboolean gda_dict_field_is_pkey_part (GdaDictField *field);
	gboolean gda_dict_field_is_pkey_alone (GdaDictField *field);		gboolean gda_dict_field_is_pkey_alone (GdaDictField *field);
	gboolean gda_dict_field_is_fkey_part (GdaDictField *field);		gboolean gda_dict_field_is_fkey_part (GdaDictField *field);
	gboolean gda_dict_field_is_fkey_alone (GdaDictField *field);		gboolean gda_dict_field_is_fkey_alone (GdaDictField *field);
	void gda_dict_field_set_attributes (GdaDictField *field, guin t attributes);		void gda_dict_field_set_attributes (GdaDictField *field, guin t attributes);
	guint gda_dict_field_get_attributes (GdaDictField *field);		guint gda_dict_field_get_attributes (GdaDictField *field);
End of changes. 2 change blocks.
	4 lines changed or deleted		4 lines changed or added

	gda-dict-type.h		gda-dict-type.h
	skipping to change at line 62		skipping to change at line 62
	{		{
	GdaObjectClass parent_class;		GdaObjectClass parent_class;
	};		};
	GType gda_dict_type_get_type (void);		GType gda_dict_type_get_type (void);
	GdaDictType *gda_dict_type_new (GdaDict *dict);		GdaDictType *gda_dict_type_new (GdaDict *dict);
	void gda_dict_type_set_sqlname (GdaDictType *dt, const gch ar *sqlname);		void gda_dict_type_set_sqlname (GdaDictType *dt, const gch ar *sqlname);
	const gchar *gda_dict_type_get_sqlname (GdaDictType *dt);		const gchar *gda_dict_type_get_sqlname (GdaDictType *dt);
	void gda_dict_type_set_gda_type (GdaDictType *dt, GdaValueT		void gda_dict_type_set_gda_type (GdaDictType *dt, GType gda
	ype gda_type);		_type);
	GdaValueType gda_dict_type_get_gda_type (GdaDictType *dt);		GType gda_dict_type_get_gda_type (GdaDictType *dt);
	void gda_dict_type_add_synonym (GdaDictType *dt, const gch ar *synonym);		void gda_dict_type_add_synonym (GdaDictType *dt, const gch ar *synonym);
	const GSList *gda_dict_type_get_synonyms (GdaDictType *dt);		const GSList *gda_dict_type_get_synonyms (GdaDictType *dt);
	void gda_dict_type_clear_synonyms(GdaDictType *dt);		void gda_dict_type_clear_synonyms(GdaDictType *dt);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 1 change blocks.
	3 lines changed or deleted		3 lines changed or added

	gda-dict.h		gda-dict.h
	skipping to change at line 21		skipping to change at line 21
	* 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		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.		* GNU General Public License for more details.
	*		*
	* You should have received a copy of the GNU General Public License		* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software		* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307		* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	* USA		* USA
	*/		*/
	/*
	* This object manages the objects used my mergeant (for tables, queries, e
	tc),
	* but not what is specific to Mergeant's own GUI.
	*/
	#ifndef __GDA_DICT_H_		#ifndef __GDA_DICT_H_
	#define __GDA_DICT_H_		#define __GDA_DICT_H_
	#include <glib-object.h>		#include <glib-object.h>
	#include "gda-decl.h"		#include "gda-decl.h"
	#include "gda-value.h"		#include "gda-value.h"
	#include "gda-enums.h"		#include "gda-enums.h"
	G_BEGIN_DECLS		G_BEGIN_DECLS
	skipping to change at line 51		skipping to change at line 46
	/* error reporting */		/* error reporting */
	extern GQuark gda_dict_error_quark (void);		extern GQuark gda_dict_error_quark (void);
	#define GDA_DICT_ERROR gda_dict_error_quark ()		#define GDA_DICT_ERROR gda_dict_error_quark ()
	enum {		enum {
	GDA_DICT_META_DATA_UPDATE_ERROR,		GDA_DICT_META_DATA_UPDATE_ERROR,
	GDA_DICT_META_DATA_UPDATE_USER_STOPPED,		GDA_DICT_META_DATA_UPDATE_USER_STOPPED,
	GDA_DICT_LOAD_FILE_NOT_EXIST_ERROR,		GDA_DICT_LOAD_FILE_NOT_EXIST_ERROR,
	GDA_DICT_FILE_LOAD_ERROR,		GDA_DICT_FILE_LOAD_ERROR,
	GDA_DICT_FILE_SAVE_ERROR,		GDA_DICT_FILE_SAVE_ERROR,
	GDA_DICT_PROPOSED_FILE,
	GDA_DICT_DATATYPE_ERROR,		GDA_DICT_DATATYPE_ERROR,
	GDA_DICT_FUNCTIONS_ERROR,		GDA_DICT_FUNCTIONS_ERROR,
	GDA_DICT_AGGREGATES_ERROR,		GDA_DICT_AGGREGATES_ERROR,
	};		};
	/* struct for the object's data */		/* struct for the object's data */
	struct _GdaDict		struct _GdaDict
	{		{
	GObject object;		GObject object;
	GdaDictPrivate *priv;		GdaDictPrivate *priv;
	};		};
	/* struct for the object's class */		/* struct for the object's class */
	struct _GdaDictClass		struct _GdaDictClass
	{		{
	GObjectClass parent_class;		GObjectClass parent_class;
	/* signal the addition or removal of a query in the queries list */		/* signals the addition, removal or update of objects */
	void (*query_added) (GdaDict * dict, GdaQuery *new_query);		void (*object_added) (GdaDict *dict, GdaObject *obj);
	void (*query_removed) (GdaDict * dict, GdaQuery *old_query);		void (*object_removed) (GdaDict *dict, GdaObject *obj);
	void (*query_updated) (GdaDict * dict, GdaQuery *query);		void (*object_updated) (GdaDict *dict, GdaObject *obj);
			void (*object_act_changed) (GdaDict *dict, GdaObject *obj);
	/* signal the addition or removal of a graph in the graphs list */
	void (*graph_added) (GdaDict * dict, GdaGraph *new_graph);
	void (*graph_removed) (GdaDict * dict, GdaGraph *old_graph);
	void (*graph_updated) (GdaDict * dict, GdaGraph *graph);
	void (*data_type_added) (GdaDict *obj, GdaDictType *type);
	void (*data_type_removed) (GdaDict *obj, GdaDictType *type);
	void (*data_type_updated) (GdaDict *obj, GdaDictType *type);
	void (*function_added) (GdaDict *obj, GdaDictFunction *functi
	on);
	void (*function_removed) (GdaDict *obj, GdaDictFunction *functi
	on);
	void (*function_updated) (GdaDict *obj, GdaDictFunction *functi
	on);
	void (*aggregate_added) (GdaDict *obj, GdaDictAggregate *aggre		void (*data_update_started) (GdaDict *dict);
	gate);		void (*update_progress) (GdaDict *dict, gchar * msg, guint
	void (*aggregate_removed) (GdaDict *obj, GdaDictAggregate *aggre		now, guint total);
	gate);		void (*data_update_finished) (GdaDict *dict);
	void (*aggregate_updated) (GdaDict *obj, GdaDictAggregate *aggre
	gate);
	void (*data_update_started) (GdaDict *obj);		/* signal that a change in the whole dictionary has occurred */
	void (*update_progress) (GdaDict *obj, gchar * msg, guint		void (*changed) (GdaDict * dict);
	now, guint total);
	void (*data_update_finished) (GdaDict *obj);
	/* signal that a change in the whole dictionary has occured */		/* class variable */
	void (*changed) (GdaDict * dict);		GSList *class_registry_list; /* list of GdaDictRegFunc functions *
			/
			gpointer reserved1;
			gpointer reserved2;
	};		};
	GType gda_dict_get_type (void);		GType gda_dict_get_type (void);
	GObject *gda_dict_new (void);		GObject *gda_dict_new (void);
			void gda_dict_extend_with_functions (GdaDict *dict);
	void gda_dict_set_connection (GdaDict *dict, GdaConnection		void gda_dict_set_connection (GdaDict *dict,
	*cnc);		GdaConnection *cnc);
	GdaConnection *gda_dict_get_connection (GdaDict *dict);		GdaConnection *gda_dict_get_connection (GdaDict *dict);
			GdaDictDatabase *gda_dict_get_database (GdaDict *dict);
	guint gda_dict_get_id_serial (GdaDict *dict);		void gda_dict_declare_object_string_id_change (GdaDict *dict,
	void gda_dict_set_id_serial (GdaDict *dict, guint value);		GdaObject *obj, const gchar *oldid);
			GdaObject *gda_dict_get_object_by_string_id (GdaDict *dict,
			const gchar *strid);
	void gda_dict_declare_object_string_id_change (GdaDict *dict, Gd		gboolean gda_dict_update_dbms_data (GdaDict *dict,
	aObject *obj, const gchar *oldid);		GType limit_to_type, const gchar *limit_obj_name,
	GdaObject *gda_dict_get_object_by_string_id (GdaDict *dict, const gcha		GError **error);
	r *strid);		void gda_dict_stop_update_dbms_data (GdaDict *dict);
	gboolean gda_dict_update_dbms_data (GdaDict *dict, GError **error		gchar *gda_dict_compute_xml_filename (GdaDict *dict,
	);		const gchar *datasource,
	void gda_dict_stop_update_dbms_data (GdaDict *dict);		const gchar *app
			_id, GError **error);
			void gda_dict_set_xml_filename (GdaDict *dict,
			const gchar *xmlfile);
			const gchar *gda_dict_get_xml_filename (GdaDict *dict);
			gboolean gda_dict_load (GdaDict *dict,
			GError **error);
			gboolean gda_dict_save (GdaDict *dict,
			GError **error);
			gboolean gda_dict_load_xml_file (GdaDict *dict,
			const gchar *xmlfile, GError **error);
			gboolean gda_dict_save_xml_file (GdaDict *dict,
			const gchar *xmlfile, GError **error);
	gchar *gda_dict_compute_xml_filename(GdaDict *dict, const gchar *d		GdaDataHandler *gda_dict_get_handler (GdaDict *dict,
	atasource,		GType for_type);
	const gchar *app_id, GError **		GdaDataHandler *gda_dict_get_default_handler (GdaDict *dict,
	error);		GType for_type);
	void gda_dict_set_xml_filename (GdaDict *dict, const gchar *x
	mlfile);		/* GdaQuery manipulations */
	const gchar *gda_dict_get_xml_filename (GdaDict *dict);		#define gda_dict_get_queries(dict) gda_dict_get_objects((dict), GDA_TYPE_QU
	gboolean gda_dict_load (GdaDict *dict, GError **error		ERY)
	);		#define gda_dict_get_query_by_xml_id(dict,xml_id) ((GdaQuery*)gda_dict_get_
	gboolean gda_dict_save (GdaDict *dict, GError **error		object_by_xml_id((dict), GDA_TYPE_QUERY, (xml_id)))
	);
	gboolean gda_dict_load_xml_file (GdaDict *dict, const gchar *x
	mlfile, GError **error);
	gboolean gda_dict_save_xml_file (GdaDict *dict, const gchar *x
	mlfile, GError **error);
	/* GdaDictType manipulations */		/* GdaDictType manipulations */
	GSList *gda_dict_get_data_types (GdaDict *dict);		#define gda_dict_get_dict_types(dict) gda_dict_get_objects((dict), GDA_TYPE
	GdaDictType *gda_dict_get_data_type_by_name (GdaDict *dict, const gc		_DICT_TYPE)
	har *type_name);		#define gda_dict_get_dict_type_by_name(dict,type_name) ((GdaDictType*)gda_d
	GdaDictType *gda_dict_get_data_type_by_xml_id (GdaDict *dict, const gc		ict_get_object_by_name((dict), GDA_TYPE_DICT_TYPE, (type_name)))
	har *xml_id);		#define gda_dict_get_dict_type_by_xml_id(dict,xml_id) ((GdaDictType*)gda_di
	gboolean gda_dict_declare_custom_data_type (GdaDict *dict, GdaDictT		ct_get_object_by_xml_id((dict), GDA_TYPE_DICT_TYPE, (xml_id)))
	ype *type);
	/* GdaDictFunction manipulations */		/* GdaDictFunction manipulations */
	GSList *gda_dict_get_functions (GdaDict *dict);		#define gda_dict_get_functions(dict) gda_dict_get_objects ((dict), GDA_TYPE
	GSList *gda_dict_get_functions_by_name (GdaDict *dict, const		_DICT_FUNCTION)
	gchar *funcname);		#define gda_dict_get_functions_by_name(dict,funcname) gda_functions_get_by_
	GdaDictFunction *gda_dict_get_function_by_name_arg (GdaDict *dict, const		name ((dict), (funcname))
	gchar *funcname,		#define gda_dict_get_function_by_name_arg(dict,funcname,argtypes) gda_funct
	const GSList *argtypes		ions_get_by_name_arg ((dict), (funcname), (argtypes))
	);		#define gda_dict_get_function_by_xml_id(dict,xml_id) gda_dict_get_object_by
	GdaDictFunction *gda_dict_get_function_by_xml_id (GdaDict *dict, const		_xml_id ((dict), GDA_TYPE_DICT_FUNCTION, (xml_id))
	gchar *xml_id);		#define gda_dict_get_function_by_dbms_id(dict,dbms_id) gda_functions_get_by
	GdaDictFunction *gda_dict_get_function_by_dbms_id (GdaDict *dict, const		_dbms_id ((dict), (dbms_id))
	gchar *dbms_id);
	/* GdaDictAggregate manipulations */		/* GdaDictAggregate manipulations */
	GSList *gda_dict_get_aggregates (GdaDict *dict);		#define gda_dict_get_aggregates(dict) gda_dict_get_objects((dict), GDA_TYPE
	GSList *gda_dict_get_aggregates_by_name (GdaDict *dict, const		_DICT_AGGREGATE)
	gchar *aggname);		#define gda_dict_get_aggregates_by_name(dict,aggname) gda_aggregates_get_by
	GdaDictAggregate *gda_dict_get_aggregate_by_name_arg (GdaDict *dict, const		_name((dict), (aggname))
	gchar *aggname,		#define gda_dict_get_aggregate_by_name_arg(dict,argname,argtype) gda_aggreg
	GdaDictType		ates_get_by_name_arg ((dict), (argname), (argtype))
	*argtype);		#define gda_dict_get_aggregate_by_xml_id(dict,xml_id) gda_dict_get_object_b
	GdaDictAggregate *gda_dict_get_aggregate_by_xml_id (GdaDict *dict, const		y_xml_id((dict), GDA_TYPE_DICT_AGGREGATE, (xml_id))
	gchar *xml_id);		#define gda_dict_get_aggregate_by_dbms_id(dict,dbmsid) gda_aggregates_get_b
	GdaDictAggregate *gda_dict_get_aggregate_by_dbms_id (GdaDict *dict, const		y_dbms_id((dict),(dbmsid))
	gchar *dbms_id);
	/* GdaQuery manipulations */
	void gda_dict_declare_query (GdaDict *dict, GdaQuery *quer
	y);
	void gda_dict_assume_query (GdaDict *dict, GdaQuery *quer
	y);
	void gda_dict_unassume_query (GdaDict *dict, GdaQuery *quer
	y);
	GSList *gda_dict_get_queries (GdaDict *dict);
	GdaQuery *gda_dict_get_query_by_xml_id (GdaDict *dict, const gchar *
	xml_id);
	/* GdaGraph manipulations */
	void gda_dict_declare_graph (GdaDict *dict, GdaGraph *grap
	h);
	void gda_dict_assume_graph (GdaDict *dict, GdaGraph *grap
	h);
	void gda_dict_unassume_graph (GdaDict *dict, GdaGraph *grap
	h);
	GSList *gda_dict_get_graphs (GdaDict *dict, GdaGraphType t
	ype_of_graphs);
	GdaGraph *gda_dict_get_graph_by_xml_id (GdaDict *dict, const gchar *
	xml_id);
	GdaGraph *gda_dict_get_graph_for_object(GdaDict *dict, GObject *obj)
	;
	GdaDictDatabase *gda_dict_get_database (GdaDict *dict);
	GSList *gda_dict_get_entities_fk_constraints (GdaDict *dict, GdaEnt
	ity *entity1, GdaEntity *entity2,
	gboolean entity1_has_fk
	);
	GdaDataHandler * gda_dict_get_default_handler (GdaDict *dict, GdaValueTy		void gda_dict_declare_object (GdaDict *dict,
	pe for_type);		GdaObject *object);
			void gda_dict_declare_object_as (GdaDict *dict,
			GdaObject *object, GType as_type);
			void gda_dict_assume_object (GdaDict *dict,
			GdaObject *object);
			void gda_dict_assume_object_as (GdaDict *dict,
			GdaObject *object, GType as_type);
			void gda_dict_unassume_object (GdaDict *dict,
			GdaObject *object);
			GSList *gda_dict_get_objects (GdaDict *dict,
			GType type);
			GdaObject *gda_dict_get_object_by_name (GdaDict *dict,
			GType type, const gchar *name);
			GdaObject *gda_dict_get_object_by_xml_id (GdaDict *dict,
			GType type, const gchar *xml_id);
	#ifdef GDA_DEBUG		#ifdef GDA_DEBUG
	void gda_dict_dump (GdaDict *dict);		void gda_dict_dump (GdaDict *dict);
	#endif		#endif
	G_END_DECLS		G_END_DECLS
	void gda_connection_add_data_type (GdaDict *dict, GdaDictType *d
	atatype);
	#endif		#endif
End of changes. 18 change blocks.
	135 lines changed or deleted		99 lines changed or added

	gda-entity-field.h		gda-entity-field.h
	skipping to change at line 42		skipping to change at line 42
	#define GDA_IS_ENTITY_FIELD(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA _TYPE_ENTITY_FIELD)		#define GDA_IS_ENTITY_FIELD(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA _TYPE_ENTITY_FIELD)
	#define GDA_ENTITY_FIELD_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((o bj), GDA_TYPE_ENTITY_FIELD, GdaEntityFieldIface))		#define GDA_ENTITY_FIELD_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((o bj), GDA_TYPE_ENTITY_FIELD, GdaEntityFieldIface))
	/* struct for the interface */		/* struct for the interface */
	struct _GdaEntityFieldIface		struct _GdaEntityFieldIface
	{		{
	GTypeInterface g_iface;		GTypeInterface g_iface;
	/* virtual table */		/* virtual table */
	GdaEntity *(* get_entity) (GdaEntityField *iface);		GdaEntity *(* get_entity) (GdaEntityField *iface);
	GdaValueType (* get_gda_type) (GdaEntityField *iface);		GType (* get_gda_type) (GdaEntityField *iface);
	GdaDictType *(* get_data_type) (GdaEntityField *iface);		GdaDictType *(* get_data_type) (GdaEntityField *iface);
	const gchar *(* get_alias) (GdaEntityField *iface);		const gchar *(* get_alias) (GdaEntityField *iface);
	};		};
	GType gda_entity_field_get_type (void) G_GNUC_CONST;		GType gda_entity_field_get_type (void) G_GNUC_CONST;
	GdaEntity *gda_entity_field_get_entity (GdaEntityField *iface);		GdaEntity *gda_entity_field_get_entity (GdaEntityField *iface);
	GdaValueType gda_entity_field_get_gda_type (GdaEntityField *iface);		GType gda_entity_field_get_gda_type (GdaEntityField *iface);
	GdaDictType *gda_entity_field_get_data_type (GdaEntityField *iface);		GdaDictType *gda_entity_field_get_dict_type (GdaEntityField *iface);
	const gchar *gda_entity_field_get_name (GdaEntityField *iface);		const gchar *gda_entity_field_get_name (GdaEntityField *iface);
	const gchar *gda_entity_field_get_description (GdaEntityField *iface);		const gchar *gda_entity_field_get_description (GdaEntityField *iface);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 2 change blocks.
	3 lines changed or deleted		3 lines changed or added

	gda-entity.h		gda-entity.h
	/* gda-entity.h		/* gda-entity.h
	*		*
	* Copyright (C) 2003 - 2005 Vivien Malerba		* Copyright (C) 2003 - 2006 Vivien Malerba
	*		*
	* This program 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 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 program 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		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.		* GNU General Public License for more details.
	skipping to change at line 51		skipping to change at line 51
	GSList *(*get_fields) (GdaEntity *iface);		GSList *(*get_fields) (GdaEntity *iface);
	GdaEntityField *(*get_field_by_name) (GdaEntity *iface, const gc har *name);		GdaEntityField *(*get_field_by_name) (GdaEntity *iface, const gc har *name);
	GdaEntityField *(*get_field_by_xml_id) (GdaEntity *iface, const gc har *xml_id);		GdaEntityField *(*get_field_by_xml_id) (GdaEntity *iface, const gc har *xml_id);
	GdaEntityField *(*get_field_by_index) (GdaEntity *iface, gint ind ex);		GdaEntityField *(*get_field_by_index) (GdaEntity *iface, gint ind ex);
	gint (*get_field_index) (GdaEntity *iface, GdaEntit yField *field);		gint (*get_field_index) (GdaEntity *iface, GdaEntit yField *field);
	void (*add_field) (GdaEntity *iface, GdaEntit yField *field);		void (*add_field) (GdaEntity *iface, GdaEntit yField *field);
	void (*add_field_before) (GdaEntity *iface, GdaEntit yField *field, GdaEntityField *field_before);		void (*add_field_before) (GdaEntity *iface, GdaEntit yField *field, GdaEntityField *field_before);
	void (*swap_fields) (GdaEntity *iface, GdaEntit yField *field1, GdaEntityField *field2);		void (*swap_fields) (GdaEntity *iface, GdaEntit yField *field1, GdaEntityField *field2);
	void (*remove_field) (GdaEntity *iface, GdaEntit yField *field);		void (*remove_field) (GdaEntity *iface, GdaEntit yField *field);
	gboolean (*is_writable) (GdaEntity *iface);		gboolean (*is_writable) (GdaEntity *iface);
	GSList *(*get_parameters) (GdaEntity *iface);
	/* signals */		/* signals */
	void (*field_added) (GdaEntity *iface, GdaEntit yField *field);		void (*field_added) (GdaEntity *iface, GdaEntit yField *field);
	void (*field_removed) (GdaEntity *iface, GdaEntit yField *field);		void (*field_removed) (GdaEntity *iface, GdaEntit yField *field);
	void (*field_updated) (GdaEntity *iface, GdaEntit yField *field);		void (*field_updated) (GdaEntity *iface, GdaEntit yField *field);
	void (*fields_order_changed) (GdaEntity *iface);		void (*fields_order_changed) (GdaEntity *iface);
	};		};
	GType gda_entity_get_type (void) G_GNUC_CONST;		GType gda_entity_get_type (void) G_GNUC_CONST;
	skipping to change at line 75		skipping to change at line 74
	GdaEntityField *gda_entity_get_field_by_name (GdaEntity *iface, const g char *name);		GdaEntityField *gda_entity_get_field_by_name (GdaEntity *iface, const g char *name);
	GdaEntityField *gda_entity_get_field_by_xml_id (GdaEntity *iface, const g char *xml_id);		GdaEntityField *gda_entity_get_field_by_xml_id (GdaEntity *iface, const g char *xml_id);
	GdaEntityField *gda_entity_get_field_by_index (GdaEntity *iface, gint in dex);		GdaEntityField *gda_entity_get_field_by_index (GdaEntity *iface, gint in dex);
	gint gda_entity_get_field_index (GdaEntity *iface, GdaEnti tyField *field);		gint gda_entity_get_field_index (GdaEntity *iface, GdaEnti tyField *field);
	void gda_entity_add_field (GdaEntity *iface, GdaEnti tyField *field);		void gda_entity_add_field (GdaEntity *iface, GdaEnti tyField *field);
	void gda_entity_add_field_before (GdaEntity *iface, GdaEnti tyField *field, GdaEntityField *field_before);		void gda_entity_add_field_before (GdaEntity *iface, GdaEnti tyField *field, GdaEntityField *field_before);
	void gda_entity_swap_fields (GdaEntity *iface, GdaEnti tyField *field1, GdaEntityField *field2);		void gda_entity_swap_fields (GdaEntity *iface, GdaEnti tyField *field1, GdaEntityField *field2);
	void gda_entity_remove_field (GdaEntity *iface, GdaEnti tyField *field);		void gda_entity_remove_field (GdaEntity *iface, GdaEnti tyField *field);
	gboolean gda_entity_is_writable (GdaEntity *iface);		gboolean gda_entity_is_writable (GdaEntity *iface);
	GSList *gda_entity_get_parameters (GdaEntity *iface);
	GdaParameterList *gda_entity_get_param_list (GdaEntity *iface);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 3 change blocks.
	4 lines changed or deleted		1 lines changed or added

	gda-enum-types.h		gda-enum-types.h
	skipping to change at line 14		skipping to change at line 14
	#include <glib-object.h>		#include <glib-object.h>
	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);
	#define GDA_TYPE_CLIENT_SPECS_TYPE (gda_client_specs_type_get_type())
	/* enumerations from "gda-column-index.h" */		/* enumerations from "gda-column-index.h" */
	GType gda_sorting_get_type (void);		GType gda_sorting_get_type (void);
	#define GDA_TYPE_SORTING (gda_sorting_get_type())		#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" */		/* enumerations from "gda-connection-event.h" */
	GType gda_connection_event_type_get_type (void);		GType gda_connection_event_type_get_type (void);
	skipping to change at line 52		skipping to change at line 50
	#define GDA_TYPE_DATA_MODEL_IO_FORMAT (gda_data_model_io_format_get_type())		#define GDA_TYPE_DATA_MODEL_IO_FORMAT (gda_data_model_io_format_get_type())
	/* enumerations from "gda-dict-constraint.h" */		/* enumerations from "gda-dict-constraint.h" */
	GType gda_dict_constraint_type_get_type (void);		GType gda_dict_constraint_type_get_type (void);
	#define GDA_TYPE_DICT_CONSTRAINT_TYPE (gda_dict_constraint_type_get_type())		#define GDA_TYPE_DICT_CONSTRAINT_TYPE (gda_dict_constraint_type_get_type())
	GType gda_dict_constraint_fk_action_get_type (void);		GType gda_dict_constraint_fk_action_get_type (void);
	#define GDA_TYPE_DICT_CONSTRAINT_FK_ACTION (gda_dict_constraint_fk_action_g et_type())		#define GDA_TYPE_DICT_CONSTRAINT_FK_ACTION (gda_dict_constraint_fk_action_g et_type())
	/* enumerations from "gda-dict-field.h" */		/* enumerations from "gda-dict-field.h" */
	GType gda_dict_field_attribute_get_type (void);		GType gda_dict_field_attribute_get_type (void);
	#define GDA_TYPE_DICT_FIELD_ATTRIBUTE (gda_dict_field_attribute_get_type())		#define GDA_TYPE_DICT_FIELD_ATTRIBUTE (gda_dict_field_attribute_get_type())
	/* enumerations from "gda-enums.h" */		/* enumerations from "gda-enums.h" */
	GType gda_value_attribute_get_type (void);		GType g_value_attribute_get_type (void);
	#define GDA_TYPE_VALUE_ATTRIBUTE (gda_value_attribute_get_type())		#define GDA_TYPE_VALUE_ATTRIBUTE (g_value_attribute_get_type())
	GType gda_graph_type_get_type (void);		GType gda_graph_type_get_type (void);
	#define GDA_TYPE_GRAPH_TYPE (gda_graph_type_get_type())		#define GDA_TYPE_GRAPH_TYPE (gda_graph_type_get_type())
	GType gda_entity_field_state_get_type (void);		GType gda_query_field_state_get_type (void);
	#define GDA_TYPE_ENTITY_FIELD_STATE (gda_entity_field_state_get_type())		#define GDA_TYPE_QUERY_FIELD_STATE (gda_query_field_state_get_type())
	/* enumerations from "gda-object-ref.h" */		/* enumerations from "gda-object-ref.h" */
	GType gda_object_ref_type_get_type (void);		GType gda_object_ref_type_get_type (void);
	#define GDA_TYPE_OBJECT_REF_TYPE (gda_object_ref_type_get_type())		#define GDA_TYPE_OBJECT_REF_TYPE (gda_object_ref_type_get_type())
	/* enumerations from "gda-parameter-list.h" */		/* enumerations from "gda-parameter-list.h" */
	GType gda_parameter_list_param_hint_get_type (void);		GType gda_parameter_list_param_hint_get_type (void);
	#define GDA_TYPE_PARAMETER_LIST_PARAM_HINT (gda_parameter_list_param_hint_g et_type())		#define GDA_TYPE_PARAMETER_LIST_PARAM_HINT (gda_parameter_list_param_hint_g et_type())
	/* enumerations from "gda-query-condition.h" */		/* enumerations from "gda-query-condition.h" */
	GType gda_query_condition_type_get_type (void);		GType gda_query_condition_type_get_type (void);
	#define GDA_TYPE_QUERY_CONDITION_TYPE (gda_query_condition_type_get_type())		#define GDA_TYPE_QUERY_CONDITION_TYPE (gda_query_condition_type_get_type())
	GType gda_query_condition_operator_get_type (void);		GType gda_query_condition_operator_get_type (void);
	skipping to change at line 81		skipping to change at line 79
	#define GDA_TYPE_QUERY_TYPE (gda_query_type_get_type())		#define GDA_TYPE_QUERY_TYPE (gda_query_type_get_type())
	/* enumerations from "gda-query-join.h" */		/* enumerations from "gda-query-join.h" */
	GType gda_query_join_type_get_type (void);		GType gda_query_join_type_get_type (void);
	#define GDA_TYPE_QUERY_JOIN_TYPE (gda_query_join_type_get_type())		#define GDA_TYPE_QUERY_JOIN_TYPE (gda_query_join_type_get_type())
	/* enumerations from "gda-query-target.h" */		/* enumerations from "gda-query-target.h" */
	GType gda_query_target_type_get_type (void);		GType gda_query_target_type_get_type (void);
	#define GDA_TYPE_QUERY_TARGET_TYPE (gda_query_target_type_get_type())		#define GDA_TYPE_QUERY_TARGET_TYPE (gda_query_target_type_get_type())
	/* enumerations from "gda-renderer.h" */		/* enumerations from "gda-renderer.h" */
	GType gda_renderer_options_get_type (void);		GType gda_renderer_options_get_type (void);
	#define GDA_TYPE_RENDERER_OPTIONS (gda_renderer_options_get_type())		#define GDA_TYPE_RENDERER_OPTIONS (gda_renderer_options_get_type())
			/* enumerations from "gda-server-operation.h" */
			GType gda_server_operation_type_get_type (void);
			#define GDA_TYPE_SERVER_OPERATION_TYPE (gda_server_operation_type_get_type(
			))
			GType gda_server_operation_node_type_get_type (void);
			#define GDA_TYPE_SERVER_OPERATION_NODE_TYPE (gda_server_operation_node_type
			_get_type())
			GType gda_server_operation_node_status_get_type (void);
			#define GDA_TYPE_SERVER_OPERATION_NODE_STATUS (gda_server_operation_node_st
			atus_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" */
	GType gda_value_type_get_type (void);
	#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. 5 change blocks.
	9 lines changed or deleted		14 lines changed or added

	gda-enums.h		gda-enums.h
	skipping to change at line 26		skipping to change at line 26
	* along with this program; if not, write to the Free Software		* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307		* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	* USA		* USA
	*/		*/
	#ifndef __GDA_ENUMS__		#ifndef __GDA_ENUMS__
	#define __GDA_ENUMS__		#define __GDA_ENUMS__
	/* status of a value */		/* status of a value */
	typedef enum {		typedef enum {
	GDA_VALUE_ATTR_IS_NULL = 1 << 0, /* READ | WRITE */		GDA_VALUE_ATTR_IS_NULL = 1 << 0,
	GDA_VALUE_ATTR_CAN_BE_NULL = 1 << 1, /* READ | WRITE */		GDA_VALUE_ATTR_CAN_BE_NULL = 1 << 1,
	GDA_VALUE_ATTR_IS_DEFAULT = 1 << 2, /* READ | WRITE */		GDA_VALUE_ATTR_IS_DEFAULT = 1 << 2,
	GDA_VALUE_ATTR_CAN_BE_DEFAULT = 1 << 3, /* READ | WRITE */		GDA_VALUE_ATTR_CAN_BE_DEFAULT = 1 << 3,
	GDA_VALUE_ATTR_IS_UNCHANGED = 1 << 4, /* READ | WRITE */		GDA_VALUE_ATTR_IS_UNCHANGED = 1 << 4,
	GDA_VALUE_ATTR_ACTIONS_SHOWN = 1 << 5, /* READ | WRITE */		GDA_VALUE_ATTR_ACTIONS_SHOWN = 1 << 5,
	GDA_VALUE_ATTR_DATA_NON_VALID = 1 << 6, /* READ */		GDA_VALUE_ATTR_DATA_NON_VALID = 1 << 6,
	GDA_VALUE_ATTR_HAS_VALUE_ORIG = 1 << 7, /* READ */		GDA_VALUE_ATTR_HAS_VALUE_ORIG = 1 << 7,
	GDA_VALUE_ATTR_NO_MODIF = 1 << 8, /* READ | WRITE */		GDA_VALUE_ATTR_NO_MODIF = 1 << 8,
	} GdaValueAttribute;		} GValueAttribute;
	/* different possible types for a GdaGraph object */		/* different possible types for a GdaGraph object */
	typedef enum {		typedef enum {
	GDA_GRAPH_DB_RELATIONS,		GDA_GRAPH_DB_RELATIONS,
	GDA_GRAPH_QUERY_JOINS,		GDA_GRAPH_QUERY_JOINS,
	GDA_GRAPH_MODELLING /* for future extensions */		GDA_GRAPH_MODELLING /* for future extensions */
	} GdaGraphType;		} GdaGraphType;
	typedef enum {		typedef enum {
	GDA_ENTITY_FIELD_VISIBLE = 1 << 0,		GDA_ENTITY_FIELD_VISIBLE = 1 << 0,
	GDA_ENTITY_FIELD_INVISIBLE = 1 << 1,		GDA_ENTITY_FIELD_INVISIBLE = 1 << 1,
	GDA_ENTITY_FIELD_ANY = GDA_ENTITY_FIELD_VISIBLE | GDA_ENTITY_F IELD_INVISIBLE		GDA_ENTITY_FIELD_ANY = GDA_ENTITY_FIELD_VISIBLE | GDA_ENTITY_F IELD_INVISIBLE
	} GdaEntityFieldState;		} GdaQueryFieldState;
	#endif		#endif
End of changes. 2 change blocks.
	11 lines changed or deleted		11 lines changed or added

	gda-marshal.h		gda-marshal.h
	skipping to change at line 85		skipping to change at line 85
	gpointer marshal_da ta);		gpointer marshal_da ta);
	/* VOID:INT,BOOLEAN (gda-marshal.list:36) */		/* VOID:INT,BOOLEAN (gda-marshal.list:36) */
	extern void gda_marshal_VOID__INT_BOOLEAN (GClosure *closure,		extern void gda_marshal_VOID__INT_BOOLEAN (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:STRING,INT (gda-marshal.list:37) */
			extern void gda_marshal_VOID__STRING_INT (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. 1 change blocks.
	0 lines changed or deleted		8 lines changed or added

	gda-object-ref.h		gda-object-ref.h
	/* gda-object-ref.h		/* gda-object-ref.h
	*		*
	* Copyright (C) 2003 - 2005 Vivien Malerba		* Copyright (C) 2003 - 2006 Vivien Malerba
	*		*
	* This program 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 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 program 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		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.		* GNU General Public License for more details.
	skipping to change at line 73		skipping to change at line 73
	};		};
	GType gda_object_ref_get_type (void);		GType gda_object_ref_get_type (void);
	GObject *gda_object_ref_new (GdaDict *dict);		GObject *gda_object_ref_new (GdaDict *dict);
	GObject *gda_object_ref_new_no_ref_count (GdaDict *dict);		GObject *gda_object_ref_new_no_ref_count (GdaDict *dict);
	GObject *gda_object_ref_new_copy (GdaObjectRef *orig);		GObject *gda_object_ref_new_copy (GdaObjectRef *orig);
	void gda_object_ref_set_ref_name (GdaObjectRef *ref, GType ref_type,		void gda_object_ref_set_ref_name (GdaObjectRef *ref, GType ref_type,
	GdaObjectRefType type, co nst gchar *name);		GdaObjectRefType type, co nst gchar *name);
	const gchar *gda_object_ref_get_ref_name (GdaObjectRef *ref, GType *ref_type, GdaObjectRefType *type);		const gchar *gda_object_ref_get_ref_name (GdaObjectRef *ref, GType *ref_type, GdaObjectRefType *type);
			const gchar *gda_object_ref_get_ref_object_name (GdaObjectRef *ref);
	GType gda_object_ref_get_ref_type (GdaObjectRef *ref);		GType gda_object_ref_get_ref_type (GdaObjectRef *ref);
	void gda_object_ref_set_ref_object (GdaObjectRef *ref, GdaOb ject *object);		void gda_object_ref_set_ref_object (GdaObjectRef *ref, GdaOb ject *object);
	void gda_object_ref_set_ref_object_type(GdaObjectRef *ref, GdaOb ject *object, GType type);		void gda_object_ref_set_ref_object_type(GdaObjectRef *ref, GdaOb ject *object, GType type);
	void gda_object_ref_replace_ref_object (GdaObjectRef *ref, GHash Table *replacements);		void gda_object_ref_replace_ref_object (GdaObjectRef *ref, GHash Table *replacements);
	GdaObject *gda_object_ref_get_ref_object (GdaObjectRef *ref);		GdaObject *gda_object_ref_get_ref_object (GdaObjectRef *ref);
	gboolean gda_object_ref_activate (GdaObjectRef *ref);		gboolean gda_object_ref_activate (GdaObjectRef *ref);
	void gda_object_ref_deactivate (GdaObjectRef *ref);		void gda_object_ref_deactivate (GdaObjectRef *ref);
	gboolean gda_object_ref_is_active (GdaObjectRef *ref);		gboolean gda_object_ref_is_active (GdaObjectRef *ref);
End of changes. 2 change blocks.
	1 lines changed or deleted		2 lines changed or added

	gda-parameter-list.h		gda-parameter-list.h
	/* gda-parameter-list.h		/* gda-parameter-list.h
	*		*
	* Copyright (C) 2003 - 2005 Vivien Malerba		* Copyright (C) 2003 - 2006 Vivien Malerba
	*		*
	* This program 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 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 program 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		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.		* GNU General Public License for more details.
	skipping to change at line 26		skipping to change at line 26
	* along with this program; if not, write to the Free Software		* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307		* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	* USA		* USA
	*/		*/
	#ifndef __GDA_PARAMETER_LIST_H_		#ifndef __GDA_PARAMETER_LIST_H_
	#define __GDA_PARAMETER_LIST_H_		#define __GDA_PARAMETER_LIST_H_
	#include <libgda/gda-object.h>		#include <libgda/gda-object.h>
	#include "gda-value.h"		#include "gda-value.h"
			#include <libxml/tree.h>
	G_BEGIN_DECLS		G_BEGIN_DECLS
	#define GDA_TYPE_PARAMETER_LIST (gda_parameter_list_get_type())		#define GDA_TYPE_PARAMETER_LIST (gda_parameter_list_get_type())
	#define GDA_PARAMETER_LIST(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, g da_parameter_list_get_type(), GdaParameterList)		#define GDA_PARAMETER_LIST(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, g da_parameter_list_get_type(), GdaParameterList)
	#define GDA_PARAMETER_LIST_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gd a_parameter_list_get_type (), GdaParameterListClass)		#define GDA_PARAMETER_LIST_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gd a_parameter_list_get_type (), GdaParameterListClass)
	#define GDA_IS_PARAMETER_LIST(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, g da_parameter_list_get_type ())		#define GDA_IS_PARAMETER_LIST(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, g da_parameter_list_get_type ())
	/* error reporting */		/* error reporting */
	extern GQuark gda_parameter_list_error_quark (void);		extern GQuark gda_parameter_list_error_quark (void);
	skipping to change at line 122		skipping to change at line 123
	{		{
	GdaObjectClass parent_class;		GdaObjectClass parent_class;
	void (*param_changed) (GdaParameterList *paramlist, GdaParameter *param);		void (*param_changed) (GdaParameterList *paramlist, GdaParameter *param);
	void (*public_data_changed) (GdaParameterList *para mlist);		void (*public_data_changed) (GdaParameterList *para mlist);
	};		};
	GType gda_parameter_list_get_type (void);		GType gda_parameter_list_get_type (void);
	GdaParameterList *gda_parameter_list_new (GSList *params);		GdaParameterList *gda_parameter_list_new (GSList *params);
	GdaParameterList *gda_parameter_list_new_from_spec (GdaDic		GdaParameterList *gda_parameter_list_new_from_spec_string (GdaDic
	t *dict, const gchar *xml_spec, GError **error);		t *dict, const gchar *xml_spec, GError **error);
			GdaParameterList *gda_parameter_list_new_from_spec_node (GdaDic
			t *dict, xmlNodePtr xml_spec, GError **error);
	gchar *gda_parameter_list_get_spec (GdaPar ameterList *paramlist);		gchar *gda_parameter_list_get_spec (GdaPar ameterList *paramlist);
	guint gda_parameter_list_get_length (GdaPar ameterList *plist);		guint gda_parameter_list_get_length (GdaPar ameterList *plist);
	void gda_parameter_list_add_param (GdaPar		void gda_parameter_list_add_param (GdaPar
	ameterList *paramlist,		ameterList *paramlist, GdaParameter *param);
	GdaPara		GdaParameter *gda_parameter_list_add_param_from_string (GdaPar
	meter *param);		ameterList *paramlist, const gchar *name,
			GType t
			ype, const gchar *str);
			GdaParameter *gda_parameter_list_add_param_from_value (GdaPar
			ameterList *paramlist, const gchar *name,
			GValue
			*value);
	void gda_parameter_list_merge (GdaPar ameterList *paramlist,		void gda_parameter_list_merge (GdaPar ameterList *paramlist,
	GdaPara meterList *paramlist_to_merge);		GdaPara meterList *paramlist_to_merge);
	gboolean gda_parameter_list_is_coherent (GdaPar ameterList *paramlist, GError **error);		gboolean gda_parameter_list_is_coherent (GdaPar ameterList *paramlist, GError **error);
	gboolean gda_parameter_list_is_valid (GdaPar ameterList *paramlist);		gboolean gda_parameter_list_is_valid (GdaPar ameterList *paramlist);
	GdaParameter *gda_parameter_list_find_param (GdaPar ameterList *paramlist,		GdaParameter *gda_parameter_list_find_param (GdaPar ameterList *paramlist,
	const g char *param_name);		const g char *param_name);
	GdaParameter *gda_parameter_list_find_param_for_user (GdaPar ameterList *paramlist,		GdaParameter *gda_parameter_list_find_param_for_user (GdaPar ameterList *paramlist,
	GdaObje ct *user);		GdaObje ct *user);
	GdaParameterListNode *gda_parameter_list_find_node_for_param (GdaPar ameterList *paramlist,		GdaParameterListNode *gda_parameter_list_find_node_for_param (GdaPar ameterList *paramlist,
	GdaPara meter *param);		GdaPara meter *param);
	GdaParameterListSource *gda_parameter_list_find_source (GdaPar ameterList *paramlist,		GdaParameterListSource *gda_parameter_list_find_source (GdaPar ameterList *paramlist,
	GdaData Model *model);		GdaData Model *model);
	GdaParameterListSource *gda_parameter_list_find_source_for_param (GdaPar ameterList *paramlist,		GdaParameterListSource *gda_parameter_list_find_source_for_param (GdaPar ameterList *paramlist,
	GdaPara meter *param);		GdaPara meter *param);
	GdaParameterListGroup *gda_parameter_list_find_group_for_param (GdaPar ameterList *paramlist,		GdaParameterListGroup *gda_parameter_list_find_group_for_param (GdaPar ameterList *paramlist,
	GdaPara meter *param);		GdaPara meter *param);
	void gda_parameter_list_set_param_default_value (GdaPar ameterList *paramlist,		void gda_parameter_list_set_param_default_value (GdaPar ameterList *paramlist,
	GdaPara meter *param, const GdaValue *value);		GdaPara meter *param, const GValue *value);
	void gda_parameter_list_set_param_default_alias (GdaPar ameterList *paramlist,		void gda_parameter_list_set_param_default_alias (GdaPar ameterList *paramlist,
	GdaPara meter *param, GdaParameter *alias);		GdaPara meter *param, GdaParameter *alias);
	const GdaValue *gda_parameter_list_get_param_default_value (GdaPar ameterList *paramlist, GdaParameter *param);		const GValue *gda_parameter_list_get_param_default_value (GdaPar ameterList *paramlist, GdaParameter *param);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 6 change blocks.
	9 lines changed or deleted		18 lines changed or added

	gda-parameter.h		gda-parameter.h
	skipping to change at line 57		skipping to change at line 57
	};		};
	/* struct for the object's class */		/* struct for the object's class */
	struct _GdaParameterClass		struct _GdaParameterClass
	{		{
	GdaObjectClass parent_class;		GdaObjectClass parent_class;
	void (*restrict_changed) (GdaParameter * param);		void (*restrict_changed) (GdaParameter * param);
	};		};
	GType gda_parameter_get_type (void);		GType gda_parameter_get_type (void);
	GdaParameter *gda_parameter_new (GdaValueType type);		GdaParameter *gda_parameter_new (GType type);
	GdaParameter *gda_parameter_new_copy (GdaParameter *orig);		GdaParameter *gda_parameter_new_copy (GdaParameter *orig);
	GdaValueType gda_parameter_get_gda_type (GdaParameter *param);		GType gda_parameter_get_gda_type (GdaParameter *param);
	GdaParameter *gda_parameter_new_string (const gchar * name, const gchar *str);		GdaParameter *gda_parameter_new_string (const gchar * name, const gchar *str);
	GdaParameter *gda_parameter_new_boolean (const gchar * name, gboolean value);		GdaParameter *gda_parameter_new_boolean (const gchar * name, gboolean value);
	void gda_parameter_declare_param_user (GdaParameter *param, GdaObject *user);		void gda_parameter_declare_param_user (GdaParameter *param, GdaObject *user);
	GSList *gda_parameter_get_param_users (GdaParameter *param);		GSList *gda_parameter_get_param_users (GdaParameter *param);
	void gda_parameter_replace_param_users (GdaParameter *param, GHashTable *replacements);		void gda_parameter_replace_param_users (GdaParameter *param, GHashTable *replacements);
	const GdaValue *gda_parameter_get_value (GdaParameter		const GValue *gda_parameter_get_value (GdaParameter
	*param);		*param);
	void gda_parameter_set_value (GdaParameter		void gda_parameter_set_value (GdaParameter
	*param, const GdaValue *value);		*param, const GValue *value);
	gboolean gda_parameter_set_value_str (GdaParameter *param, const gchar *value);		gboolean gda_parameter_set_value_str (GdaParameter *param, const gchar *value);
	void gda_parameter_declare_invalid (GdaParameter *param);		void gda_parameter_declare_invalid (GdaParameter *param);
	gboolean gda_parameter_is_valid (GdaParameter *param);		gboolean gda_parameter_is_valid (GdaParameter *param);
	const GdaValue *gda_parameter_get_default_value (GdaParameter		const GValue *gda_parameter_get_default_value (GdaParameter
	*param);		*param);
	void gda_parameter_set_default_value (GdaParameter		void gda_parameter_set_default_value (GdaParameter
	*param, const GdaValue *value);		*param, const GValue *value);
	gboolean gda_parameter_get_exists_default_value(GdaParameter *param);		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_exists_default_value(GdaParameter *param, gboolean default_value_exists);
	void gda_parameter_set_not_null (GdaParameter *param, gboolean not_null);		void gda_parameter_set_not_null (GdaParameter *param, gboolean not_null);
	gboolean gda_parameter_get_not_null (GdaParameter *param);		gboolean gda_parameter_get_not_null (GdaParameter *param);
	gboolean gda_parameter_restrict_values (GdaParameter *param, GdaDataModel *model,		gboolean gda_parameter_restrict_values (GdaParameter *param, GdaDataModel *model,
	gint col, GErr or **error);		gint col, GErr or **error);
	gboolean gda_parameter_has_restrict_values (GdaParameter *param, GdaDataModel **model,		gboolean gda_parameter_has_restrict_values (GdaParameter *param, GdaDataModel **model,
	gint *col);		gint *col);
End of changes. 4 change blocks.
	10 lines changed or deleted		10 lines changed or added

	gda-query-field-value.h		gda-query-field-value.h
	skipping to change at line 60		skipping to change at line 60
	GdaQueryFieldValuePrivate *priv;		GdaQueryFieldValuePrivate *priv;
	};		};
	/* struct for the object's class */		/* struct for the object's class */
	struct _GdaQueryFieldValueClass		struct _GdaQueryFieldValueClass
	{		{
	GdaQueryFieldClass parent_class;		GdaQueryFieldClass parent_class;
	};		};
	GType gda_query_field_value_get_type (void);		GType gda_query_field_value_get_type (void);
	GObject *gda_query_field_value_new (GdaQuery *quer y, GdaValueType type);		GObject *gda_query_field_value_new (GdaQuery *quer y, GType type);
	void gda_query_field_value_set_value (GdaQueryFieldV		void gda_query_field_value_set_value (GdaQueryFieldV
	alue *field, const GdaValue *val);		alue *field, const GValue *val);
	const GdaValue *gda_query_field_value_get_value (GdaQueryFieldV		const GValue *gda_query_field_value_get_value (GdaQueryFieldVal
	alue *field);		ue *field);
	void gda_query_field_value_set_default_value (GdaQueryFieldV		void gda_query_field_value_set_default_value (GdaQueryFieldV
	alue *field, const GdaValue *default_val);		alue *field, const GValue *default_val);
	const GdaValue *gda_query_field_value_get_default_value (GdaQueryFieldV		const GValue *gda_query_field_value_get_default_value (GdaQueryFieldVal
	alue *field);		ue *field);
	GdaValueType gda_query_field_value_get_value_type (GdaQueryFieldV		GType gda_query_field_value_get_gda_type (GdaQueryFieldValue *fie
	alue *field);		ld);
	void gda_query_field_value_set_dict_type (GdaQueryFieldV alue *field, GdaDictType *type);		void gda_query_field_value_set_dict_type (GdaQueryFieldV alue *field, GdaDictType *type);
	GdaDictType *gda_query_field_value_get_dict_type (GdaQueryFieldV alue *field);		GdaDictType *gda_query_field_value_get_dict_type (GdaQueryFieldV alue *field);
	void gda_query_field_value_set_is_parameter (GdaQueryFieldV alue *field, gboolean is_param);		void gda_query_field_value_set_is_parameter (GdaQueryFieldV alue *field, gboolean is_param);
	gboolean gda_query_field_value_is_parameter (GdaQueryFieldV alue *field);		gboolean gda_query_field_value_is_parameter (GdaQueryFieldV alue *field);
	void gda_query_field_value_set_not_null (GdaQueryFieldV alue *field, gboolean not_null);		void gda_query_field_value_set_not_null (GdaQueryFieldV alue *field, gboolean not_null);
	gboolean gda_query_field_value_get_not_null (GdaQueryFieldV alue *field);		gboolean gda_query_field_value_get_not_null (GdaQueryFieldV alue *field);
	gboolean gda_query_field_value_is_value_null (GdaQueryFieldV alue *field, GdaParameterList *context);		gboolean gda_query_field_value_is_value_null (GdaQueryFieldV alue *field, GdaParameterList *context);
End of changes. 2 change blocks.
	11 lines changed or deleted		11 lines changed or added

	gda-query.h		gda-query.h
	skipping to change at line 61		skipping to change at line 61
	enum		enum
	{		{
	GDA_QUERY_XML_LOAD_ERROR,		GDA_QUERY_XML_LOAD_ERROR,
	GDA_QUERY_META_DATA_UPDATE,		GDA_QUERY_META_DATA_UPDATE,
	GDA_QUERY_FIELDS_ERROR,		GDA_QUERY_FIELDS_ERROR,
	GDA_QUERY_TARGETS_ERROR,		GDA_QUERY_TARGETS_ERROR,
	GDA_QUERY_RENDER_ERROR,		GDA_QUERY_RENDER_ERROR,
	GDA_QUERY_PARSE_ERROR,		GDA_QUERY_PARSE_ERROR,
	GDA_QUERY_SYNTAX_ERROR,		GDA_QUERY_SYNTAX_ERROR,
	GDA_QUERY_STRUCTURE_ERROR,		GDA_QUERY_STRUCTURE_ERROR,
	GDA_QUERY_SQL_ANALYSE_ERROR		GDA_QUERY_SQL_ANALYSE_ERROR,
			GDA_QUERY_NO_CNC_ERROR,
			GDA_QUERY_CNC_CLOSED_ERROR
	};		};
	/* struct for the object's data */		/* struct for the object's data */
	struct _GdaQuery		struct _GdaQuery
	{		{
	GdaQueryObject object;		GdaQueryObject object;
	GdaQueryPrivate *priv;		GdaQueryPrivate *priv;
	};		};
	/* struct for the object's class */		/* struct for the object's class */
	skipping to change at line 108		skipping to change at line 110
	void gda_query_set_query_type (GdaQuery *query, GdaQu eryType type);		void gda_query_set_query_type (GdaQuery *query, GdaQu eryType type);
	GdaQueryType gda_query_get_query_type (GdaQuery *query);		GdaQueryType gda_query_get_query_type (GdaQuery *query);
	const gchar *gda_query_get_query_type_string (GdaQuery *query);		const gchar *gda_query_get_query_type_string (GdaQuery *query);
	gboolean gda_query_is_select_query (GdaQuery *query);		gboolean gda_query_is_select_query (GdaQuery *query);
	gboolean gda_query_is_insert_query (GdaQuery *query);		gboolean gda_query_is_insert_query (GdaQuery *query);
	gboolean gda_query_is_update_query (GdaQuery *query);		gboolean gda_query_is_update_query (GdaQuery *query);
	gboolean gda_query_is_delete_query (GdaQuery *query);		gboolean gda_query_is_delete_query (GdaQuery *query);
	gboolean gda_query_is_modif_query (GdaQuery *query);		gboolean gda_query_is_modif_query (GdaQuery *query);
	GdaQuery *gda_query_get_parent_query (GdaQuery *query);		GdaQuery *gda_query_get_parent_query (GdaQuery *query);
			GSList *gda_query_get_parameters (GdaQuery *query);
			GdaParameterList *gda_query_get_parameters_boxed (GdaQuery *query);
			#define GDA_QUERY_EXEC_FAILED ((void *) -1)
			GdaDataModel *gda_query_execute (GdaQuery *query, GdaPa
			rameterList *params,
			gboolean iter_model_onl
			y_requested, GError **error);
	/* if SQL queries */		/* if SQL queries */
	void gda_query_set_sql_text (GdaQuery *query, const gchar *sql, GError **error);		void gda_query_set_sql_text (GdaQuery *query, const gchar *sql, GError **error);
	const gchar *gda_query_get_sql_text (GdaQuery *query);		const gchar *gda_query_get_sql_text (GdaQuery *query);
	/* for other types of queries */		/* for other types of queries */
	GSList *gda_query_get_sub_queries (GdaQuery *query);		GSList *gda_query_get_sub_queries (GdaQuery *query);
	void gda_query_add_sub_query (GdaQuery *query, GdaQu ery *sub_query);		void gda_query_add_sub_query (GdaQuery *query, GdaQu ery *sub_query);
	void gda_query_del_sub_query (GdaQuery *query, GdaQu ery *sub_query);		void gda_query_del_sub_query (GdaQuery *query, GdaQu ery *sub_query);
	void gda_query_add_param_source (GdaQuery *query, GdaDa taModel *param_source);		void gda_query_add_param_source (GdaQuery *query, GdaDa taModel *param_source);
	skipping to change at line 147		skipping to change at line 155
	void gda_query_set_order_by_field (GdaQuery *query, GdaQu eryField *field, gint order, gboolean ascendant);		void gda_query_set_order_by_field (GdaQuery *query, GdaQu eryField *field, gint order, gboolean ascendant);
	gint gda_query_get_order_by_field (GdaQuery *query, GdaQu eryField *field, gboolean *ascendant);		gint gda_query_get_order_by_field (GdaQuery *query, GdaQu eryField *field, gboolean *ascendant);
	/* utility functions */		/* utility functions */
	GdaQueryField *gda_query_add_field_from_sql (GdaQuery *query, const gchar *field, GError **error);		GdaQueryField *gda_query_add_field_from_sql (GdaQuery *query, const gchar *field, GError **error);
	GSList *gda_query_get_all_fields (GdaQuery *query);		GSList *gda_query_get_all_fields (GdaQuery *query);
	GdaQueryField *gda_query_get_field_by_sql_naming (GdaQuery *quer y, const gchar *sql_naming);		GdaQueryField *gda_query_get_field_by_sql_naming (GdaQuery *quer y, const gchar *sql_naming);
	GdaQueryField *gda_query_get_field_by_ref_field (GdaQuery *quer y, GdaQueryTarget *target, GdaEntityField *ref_field,		GdaQueryField *gda_query_get_field_by_ref_field (GdaQuery *quer y, GdaQueryTarget *target, GdaEntityField *ref_field,
	GdaEntityFi eldState field_state);		GdaQueryFie ldState field_state);
	GdaQueryField *gda_query_get_first_field_for_target (GdaQuery *quer y, GdaQueryTarget *target);		GdaQueryField *gda_query_get_first_field_for_target (GdaQuery *quer y, GdaQueryTarget *target);
	GSList *gda_query_expand_all_field (GdaQuery *quer y, GdaQueryTarget *target);		GSList *gda_query_expand_all_field (GdaQuery *quer y, GdaQueryTarget *target);
	void gda_query_order_fields_using_join_conds (GdaQuery *quer y);		void gda_query_order_fields_using_join_conds (GdaQuery *quer y);
	GSList *gda_query_get_fields_by_target (GdaQuery *quer y, GdaQueryTarget *target, gboolean visible_fields_only);		GSList *gda_query_get_fields_by_target (GdaQuery *quer y, GdaQueryTarget *target, gboolean visible_fields_only);
	void gda_query_declare_condition (GdaQuery *query, GdaQu eryCondition *cond);		void gda_query_declare_condition (GdaQuery *query, GdaQu eryCondition *cond);
	void gda_query_undeclare_condition (GdaQuery *query, GdaQu eryCondition *cond);		void gda_query_undeclare_condition (GdaQuery *query, GdaQu eryCondition *cond);
	G_END_DECLS		G_END_DECLS
End of changes. 3 change blocks.
	2 lines changed or deleted		12 lines changed or added

	gda-row.h		gda-row.h
	skipping to change at line 54		skipping to change at line 54
	struct _GdaRow {		struct _GdaRow {
	GObject object;		GObject object;
	GdaRowPrivate *priv;		GdaRowPrivate *priv;
	};		};
	struct _GdaRowClass {		struct _GdaRowClass {
	GObjectClass parent_class;		GObjectClass parent_class;
	/* signals */		/* signals */
	gboolean (* value_to_change) (GdaRow *row, gint num, const GdaValue		gboolean (* value_to_change) (GdaRow *row, gint num, const GValue *c
	*current, const GdaValue *proposed);		urrent, const GValue *proposed);
	void (* value_changed) (GdaRow *row, gint num, const GdaValue		void (* value_changed) (GdaRow *row, gint num, const GValue *o
	*old_value, const GdaValue *new_value);		ld_value, const GValue *new_value);
	};		};
	GType gda_row_get_type (void);		GType gda_row_get_type (void);
	GdaRow *gda_row_new (GdaDataModel *model, gint count);		GdaRow *gda_row_new (GdaDataModel *model, gint count);
	GdaRow *gda_row_new_from_list (GdaDataModel *model, const GList *val ues);		GdaRow *gda_row_new_from_list (GdaDataModel *model, const GList *val ues);
	GdaRow *gda_row_copy (GdaRow *row);		GdaRow *gda_row_copy (GdaRow *row);
	void gda_row_set_model (GdaRow *row, GdaDataModel *model);		void gda_row_set_model (GdaRow *row, GdaDataModel *model);
	GdaDataModel *gda_row_get_model (GdaRow *row);		GdaDataModel *gda_row_get_model (GdaRow *row);
	gint gda_row_get_length (GdaRow *row);		gint gda_row_get_length (GdaRow *row);
	gint gda_row_get_number (GdaRow *row);		gint gda_row_get_number (GdaRow *row);
	void gda_row_set_number (GdaRow *row, gint number);		void gda_row_set_number (GdaRow *row, gint number);
	const gchar *gda_row_get_id (GdaRow *row);		const gchar *gda_row_get_id (GdaRow *row);
	void gda_row_set_id (GdaRow *row, const gchar *id);		void gda_row_set_id (GdaRow *row, const gchar *id);
	GdaValue *gda_row_get_value (GdaRow *row, gint num);		GValue *gda_row_get_value (GdaRow *row, gint num);
	gboolean gda_row_set_value (GdaRow *row, gint num, const GdaValue		gboolean gda_row_set_value (GdaRow *row, gint num, const GValue *
	*value);		value);
	void gda_row_set_is_default (GdaRow *row, gint num, gboolean is_de fault);		void gda_row_set_is_default (GdaRow *row, gint num, gboolean is_de fault);
	gboolean gda_row_get_is_default (GdaRow *row, gint num);		gboolean gda_row_get_is_default (GdaRow *row, gint num);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 2 change blocks.
	7 lines changed or deleted		7 lines changed or added

	gda-server-provider-extra.h		gda-server-provider-extra.h
	skipping to change at line 43		skipping to change at line 43
	*/		*/
	gint gda_server_provider_get_schema_nb_columns (GdaConnectionSchema sc hema);		gint gda_server_provider_get_schema_nb_columns (GdaConnectionSchema sc hema);
	gboolean gda_server_provider_init_schema_model (GdaDataModel *model, G daConnectionSchema schema);		gboolean gda_server_provider_init_schema_model (GdaDataModel *model, G daConnectionSchema schema);
	gboolean gda_server_provider_test_schema_model (GdaDataModel *model, G daConnectionSchema schema, GError **error);		gboolean gda_server_provider_test_schema_model (GdaDataModel *model, G daConnectionSchema schema, GError **error);
	/*		/*
	* Help to implement the GdaDataHandler retreiving for the providers		* Help to implement the GdaDataHandler retreiving for the providers
	*/		*/
	typedef struct {		typedef struct {
	GdaConnection *cnc;		GdaConnection *cnc;
	GdaValueType gda_type;		GType gda_type;
	gchar *dbms_type;		gchar *dbms_type;
	} GdaServerProviderHandlerInfo;		} GdaServerProviderHandlerInfo;
	guint gda_server_provider_handler_info_hash_func (GdaServerProvi derHandlerInfo *key);		guint gda_server_provider_handler_info_hash_func (GdaServerProvi derHandlerInfo *key);
	gboolean gda_server_provider_handler_info_equal_func (GdaServerProvi derHandlerInfo *a,		gboolean gda_server_provider_handler_info_equal_func (GdaServerProvi derHandlerInfo *a,
	GdaServerProvid erHandlerInfo *b);		GdaServerProvid erHandlerInfo *b);
	void gda_server_provider_handler_info_free (GdaServerProvi derHandlerInfo *info);		void gda_server_provider_handler_info_free (GdaServerProvi derHandlerInfo *info);
	GdaDataHandler *gda_server_provider_handler_find (GdaServerProvi der *prov, GdaConnection *cnc,		GdaDataHandler *gda_server_provider_handler_find (GdaServerProvi der *prov, GdaConnection *cnc,
	GdaValueType gd a_type, const gchar *dbms_type);		GType gda_type, const gchar *dbms_type);
	void gda_server_provider_handler_declare (GdaServerProvi der *prov, GdaDataHandler *dh,		void gda_server_provider_handler_declare (GdaServerProvi der *prov, GdaDataHandler *dh,
	GdaConnection * cnc,		GdaConnection * cnc,
	GdaValueType gd a_type, const gchar *dbms_type);		GType gda_type, const gchar *dbms_type);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 3 change blocks.
	3 lines changed or deleted		3 lines changed or added

	gda-server-provider.h		gda-server-provider.h
	/* GDA library		/* GDA library
	* Copyright (C) 1998 - 2005 The GNOME Foundation.		* Copyright (C) 1998 - 2006 The GNOME Foundation.
	*		*
	* AUTHORS:		* AUTHORS:
	* 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>		* 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 25		skipping to change at line 25
	* 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_server_provider_h__)		#ifndef __GDA_SERVER_PROVIDER_H__
	# define __gda_server_provider_h__		#define __GDA_SERVER_PROVIDER_H__
	#include <libgda/gda-command.h>		#include <libgda/gda-command.h>
			#include <libgda/gda-server-operation.h>
	#include <libgda/gda-connection.h>		#include <libgda/gda-connection.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-quark-list.h>		#include <libgda/gda-quark-list.h>
	#include <libgda/gda-transaction.h>		#include <libgda/gda-transaction.h>
	#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() )
	skipping to change at line 66		skipping to change at line 67
	* TRUE to suppose that there are implicit casts available for data types which have		* TRUE to suppose that there are implicit casts available for data types which have
	* the same gda type		* the same gda type
	*/		*/
	gboolean implicit_data_types_casts;		gboolean implicit_data_types_casts;
	/*		/*
	* TRUE if writing "... FROM mytable AS alias..." is ok, and FALSE if we need to write this as		* TRUE if writing "... FROM mytable AS alias..." is ok, and FALSE if we need to write this as
	* "... FROM mytable alias..."		* "... FROM mytable alias..."
	*/		*/
	gboolean alias_needs_as_keyword;		gboolean alias_needs_as_keyword;
			/* TRUE is tables can be aliased in SELECT queries*/
			gboolean supports_alias;
			/* TRUE if it is possible to write "SELECT table.field ..." or if it
			is only possible
			* to write "SELECT field..."
			*/
			gboolean supports_prefixed_fields;
	};		};
	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);
			gpointer sig_reserved1;
			gpointer sig_reserved2;
			gpointer sig_reserved3;
			gpointer sig_reserved4;
	/* virtual methods */		/* virtual methods */
	/* provider information */		/* provider information */
	const gchar *(* get_version) (GdaServerProvider *provider) ;		const gchar *(* get_version) (GdaServerProvider *provider) ;
	const gchar *(* get_server_version) (GdaServerProvider *pr ovider,		const gchar *(* get_server_version) (GdaServerProvider *pr ovider,
	GdaConnection *cnc);		GdaConnection *cnc);
	GdaServerProviderInfo *(* get_info) (GdaServerProvider *provider,		GdaServerProviderInfo *(* get_info) (GdaServerProvider *provider,
	GdaConnection *cnc);		GdaConnection *cnc);
	gboolean (* supports) (GdaServerProvider *provider,		gboolean (* supports_feature) (GdaServerProvider *prov
	GdaConnection *cnc,		ider,
	GdaConnectionFeature feature);		GdaConnection *cnc,
			GdaConnectionFeature fe
			ature);
	GdaDataModel *(* get_schema) (GdaServerProvider *provider,		GdaDataModel *(* get_schema) (GdaServerProvider *provider,
	GdaConnection *cnc,		GdaConnection *cnc,
	GdaConnectionSchema schema,		GdaConnectionSchema schema,
	GdaParameterList *params);		GdaParameterList *params);
	/* types and values manipulation */		/* types and values manipulation */
	GdaDataHandler *(* get_data_handler) (GdaServerProvider *prov ider,		GdaDataHandler *(* get_data_handler) (GdaServerProvider *prov ider,
	GdaConnection *cnc,		GdaConnection *cnc,
	GdaValueType gda_type,		GType gda_type,
	const gchar *dbms_type) ;		const gchar *dbms_type) ;
	GdaValue *(* string_to_value) (GdaServerProvider *provi der,		GValue *(* string_to_value) (GdaServerProvider *provi der,
	GdaConnection *cnc,		GdaConnection *cnc,
	const gchar *string,		const gchar *string,
	GdaValueType prefered_ty pe,		GType prefered_type,
	gchar **dbms_type);		gchar **dbms_type);
	const gchar *(*get_def_dbms_type) (GdaServerProvider *prov ider,		const gchar *(*get_def_dbms_type) (GdaServerProvider *prov ider,
	GdaConnection *cnc,		GdaConnection *cnc,
	GdaValueType gda_type);		GType gda_type);
	/* connections management */		/* connections management */
	gboolean (* open_connection) (GdaServerProvider *provi der,		gboolean (* open_connection) (GdaServerProvider *provi der,
	GdaConnection *cnc,		GdaConnection *cnc,
	GdaQuarkList *params,		GdaQuarkList *params,
	const gchar *username,		const gchar *username,
	const gchar *password);		const gchar *password);
	gboolean (* reset_connection) (GdaServerProvider *prov
	ider,
	GdaConnection *cnc);
	gboolean (* close_connection) (GdaServerProvider *prov ider,		gboolean (* close_connection) (GdaServerProvider *prov ider,
	GdaConnection *cnc);		GdaConnection *cnc);
	const gchar *(* get_database) (GdaServerProvider *provider ,		const gchar *(* get_database) (GdaServerProvider *provider ,
	GdaConnection *cnc);		GdaConnection *cnc);
	gboolean (* change_database) (GdaServerProvider *provi der,		gboolean (* change_database) (GdaServerProvider *provi der,
	GdaConnection *cnc,		GdaConnection *cnc,
	const gchar *name);		const gchar *name);
	/* actions with parameters */		/* operations */
	gchar *(* get_specs) (GdaServerProvider *provider, G		gboolean (* supports_operation) (GdaServerProvider *pr
	daClientSpecsType type);		ovider, GdaConnection *cnc,
	gboolean (* perform_action_params) (GdaServerProvider		GdaServerOperationTyp
	*provider,		e type, GdaParameterList *options);
	GdaParameterList *		GdaServerOperation *(* create_operation) (GdaServerProvider *pr
	params, GdaClientSpecsType type,		ovider, GdaConnection *cnc,
	GError **error);		GdaServerOperationTyp
			e type,
	/* database creation and destruction */		GdaParameterList *opt
	gboolean (* create_database_cnc) (GdaServerProvider *p		ions, GError **error);
	rovider,		gchar *(* render_operation) (GdaServerProvider *pr
	GdaConnection *cnc,		ovider, GdaConnection *cnc,
	const gchar *name);		GdaServerOperation *o
	gboolean (* drop_database_cnc) (GdaServerProvider *pro		p, GError **error);
	vider,		gboolean (* perform_operation) (GdaServerProvider *pr
	GdaConnection *cnc, co		ovider, GdaConnection *cnc,
	nst gchar *name);		GdaServerOperation *o
			p, GError **error);
	/* tables creation and destroying */
	gboolean (* create_table) (GdaServerProvider *provider,
	GdaConnection *cnc,
	const gchar *table_name,
	const GList *attributes_list,
	const GList *index_list);
	gboolean (* drop_table) (GdaServerProvider *provider,
	GdaConnection *cnc,
	const gchar *table_name);
	/* index creation and destroying */
	gboolean (* create_index) (GdaServerProvider *provider,
	GdaConnection *cnc,
	const GdaDataModelIndex *index,
	const gchar *table_name);
	gboolean (* drop_index) (GdaServerProvider *provider,
	GdaConnection *cnc,
	const gchar *index_name,
	gboolean primary_key,
	const gchar *table_name);
	/* commands */		/* commands */
	GList *(* execute_command) (GdaServerProvider *prov ider,		GList *(* execute_command) (GdaServerProvider *prov ider,
	GdaConnection *cnc,		GdaConnection *cnc,
	GdaCommand *cmd,		GdaCommand *cmd,
	GdaParameterList *param s);		GdaParameterList *param s);
	char *(* get_last_insert_id) (GdaServerProvider *p rovider,		char *(* get_last_insert_id) (GdaServerProvider *p rovider,
	GdaConnection *cnc,		GdaConnection *cnc,
	GdaDataModel *recset );		GdaDataModel *recset );
	skipping to change at line 185		skipping to change at line 174
	gboolean (* rollback_transaction) (GdaServerProvider *provider,		gboolean (* rollback_transaction) (GdaServerProvider *provider,
	GdaConnection *cnc ,		GdaConnection *cnc ,
	GdaTransaction *xa ction);		GdaTransaction *xa ction);
	/* blobs */		/* blobs */
	GdaBlob *(* create_blob) (GdaServerProvider *provider ,		GdaBlob *(* create_blob) (GdaServerProvider *provider ,
	GdaConnection *cnc);		GdaConnection *cnc);
	GdaBlob *(* fetch_blob) (GdaServerProvider *provider,		GdaBlob *(* fetch_blob) (GdaServerProvider *provider,
	GdaConnection *cnc, const gc har *sql_id);		GdaConnection *cnc, const gc har *sql_id);
			gpointer reserved1; /* is_reserved_word() ? */
			gpointer reserved2; /* ping_or_reconnect() ? */
			gpointer reserved3;
			gpointer reserved4;
	};		};
	GType gda_server_provider_get_type (void);		GType gda_server_provider_get_type (void);
	/* provider information */		/* provider information */
	const gchar *gda_server_provider_get_version (GdaServerProvider * provider);		const gchar *gda_server_provider_get_version (GdaServerPro vider *provider);
	const gchar *gda_server_provider_get_server_version (GdaServerPro vider *provider,		const gchar *gda_server_provider_get_server_version (GdaServerPro vider *provider,
	GdaConnection *cnc);		GdaConnection *cnc);
	GdaServerProviderInfo *gda_server_provider_get_info (GdaServerProvider *pro		GdaServerProviderInfo *gda_server_provider_get_info (GdaServerPro
	vider,		vider *provider,
	GdaConnection *cnc);		GdaConnection
	gboolean gda_server_provider_supports (GdaServerProvider *pro		*cnc);
	vider,		gboolean gda_server_provider_supports_feature (GdaServerPro
	GdaConnection *cnc,		vider *provider,
	GdaConnectionFeature fe		GdaConnection
	ature);		*cnc,
	GdaDataModel *gda_server_provider_get_schema (GdaServerProvider *p		GdaConnection
	rovider,		Feature feature);
	GdaConnection *cnc,		GdaDataModel *gda_server_provider_get_schema (GdaServerPro
	GdaConnectionSchema s		vider *provider,
	chema,		GdaConnection
	GdaParameterList *par		*cnc,
	ams, GError **error);		GdaConnection
			Schema schema,
			GdaParameterL
			ist *params, GError **error);
	/* types and values manipulation */		/* types and values manipulation */
	GdaDataHandler *gda_server_provider_get_data_handler_gda (GdaServerP		GdaDataHandler *gda_server_provider_get_data_handler_gtype(GdaServer
	rovider *provider,		Provider *provider,
	GdaConnecti		GdaConnect
	on *cnc,		ion *cnc,
	GdaValueTyp		GType for_
	e for_type);		type);
	GdaDataHandler *gda_server_provider_get_data_handler_dbms (GdaServer Provider *provider,		GdaDataHandler *gda_server_provider_get_data_handler_dbms (GdaServer Provider *provider,
	GdaConnect ion *cnc,		GdaConnect ion *cnc,
	const gcha r *for_type);		const gcha r *for_type);
	GdaValue *gda_server_provider_string_to_value (GdaServerProvid		GValue *gda_server_provider_string_to_value (GdaServer
	er *provider,		Provider *provider,
	GdaConnection *c		GdaConnect
	nc,		ion *cnc,
	const gchar *str		const gcha
	ing,		r *string,
	GdaValueType pre		GType pref
	fered_type,		ered_type,
	gchar **dbms_typ		gchar **db
	e);		ms_type);
	gchar *gda_server_provider_value_to_sql_string (GdaServerPr		gchar *gda_server_provider_value_to_sql_string (GdaServer
	ovider *provider,		Provider *provider,
	GdaConnectio		GdaConnect
	n *cnc,		ion *cnc,
	GdaValue *fr		GValue *fr
	om);		om);
	const gchar *gda_server_provider_get_default_dbms_type (GdaServer Provider *provider,		const gchar *gda_server_provider_get_default_dbms_type (GdaServer Provider *provider,
	GdaConnect ion *cnc,		GdaConnect ion *cnc,
	GdaValueTy pe gda_type);		GType type );
	/* connections management */		/* connections management */
	gboolean gda_server_provider_open_connection (GdaServerProvid		gboolean gda_server_provider_open_connection (GdaServerProvi
	er *provider,		der *provider,
	GdaConnection *c		GdaConnection *
	nc,		cnc,
	GdaQuarkList *pa		GdaQuarkList *p
	rams,		arams,
	const gchar *use		const gchar *us
	rname,		ername,
	const gchar *pas		const gchar *pa
	sword);		ssword);
	gboolean gda_server_provider_reset_connection (GdaServerProvi der *provider,		gboolean gda_server_provider_reset_connection (GdaServerProvi der *provider,
	GdaConnection * cnc);		GdaConnection * cnc);
	gboolean gda_server_provider_close_connection (GdaServerProvi der *provider,		gboolean gda_server_provider_close_connection (GdaServerProvi der *provider,
	GdaConnection * cnc);		GdaConnection * cnc);
	const gchar *gda_server_provider_get_database (GdaServerProvider		const gchar *gda_server_provider_get_database (GdaServerProvi
	*provider,		der *provider,
	GdaConnection *cnc)		GdaConnection *
	;		cnc);
	gboolean gda_server_provider_change_database (GdaServerProvid		gboolean gda_server_provider_change_database (GdaServerProvi
	er *provider,		der *provider,
	GdaConnection *c		GdaConnection *
	nc,		cnc,
	const gchar *nam		const gchar *na
	e);		me);
	/* actions with parameters */		/* actions with parameters */
	gchar *gda_server_provider_get_specs (GdaServerProvider *pr		gboolean gda_server_provider_supports_operation (GdaServerPro
	ovider,		vider *provider, GdaConnection *cnc,
	GdaClientSpecsType act		GdaServerOper
	ion_type);		ationType type, GdaParameterList *options);
	gboolean gda_server_provider_perform_action_params (GdaServerP		GdaServerOperation *gda_server_provider_create_operation (GdaServerPro
	rovider *provider,		vider *provider, GdaConnection *cnc,
	GdaParamete		GdaServerOper
	rList *params,		ationType type,
	GdaClientSp		GdaParameterL
	ecsType action_type,		ist *options, GError **error);
	GError **er		gchar *gda_server_provider_render_operation (GdaServerPro
	ror);		vider *provider, GdaConnection *cnc,
	gboolean gda_server_provider_create_database_cnc (GdaServerProvider *p		GdaServerOper
	rovider,		ation *op, GError **error);
	GdaConnection *cnc, c		gboolean gda_server_provider_perform_operation (GdaServerPro
	onst gchar *name);		vider *provider, GdaConnection *cnc,
	gboolean gda_server_provider_drop_database_cnc (GdaServerProvider *pro		GdaServerOper
	vider,		ation *op, GError **error);
	GdaConnection *cnc, con
	st gchar *name);
	gboolean gda_server_provider_create_table (GdaServerProvider *provider
	,
	GdaConnection *cnc,
	const gchar *table_name,
	const GList *attributes_list
	,
	const GList *index_list);
	gboolean gda_server_provider_drop_table (GdaServerProvider *provider,
	GdaConnection *cnc,
	const gchar *table_name);
	gboolean gda_server_provider_create_index (GdaServerProvider *provider
	,
	GdaConnection *cnc,
	const GdaDataModelIndex *ind
	ex,
	const gchar *table_name);
	gboolean gda_server_provider_drop_index (GdaServerProvider *provider,
	GdaConnection *cnc,
	const gchar *index_name,
	gboolean primary_key,
	const gchar *table_name);
	GList *gda_server_provider_execute_command (GdaServerProvider *provi		/* commands */
	der,		GList *gda_server_provider_execute_command (GdaServerProvider *pr
	GdaConnection *cnc,		ovider,
	GdaCommand *cmd,		GdaConnection *cnc,
	GdaParameterList *params)		GdaCommand *cmd,
	;		GdaParameterList *para
			ms);
	gchar *gda_server_provider_get_last_insert_id (GdaServerProvider *pr ovider,		gchar *gda_server_provider_get_last_insert_id (GdaServerProvider *pr ovider,
	GdaConnection *cnc,		GdaConnection *cnc,
	GdaDataModel *recset);		GdaDataModel *recset);
	gboolean gda_server_provider_begin_transaction (GdaServerProvider *pro		/* transactions */
	vider,		gboolean gda_server_provider_begin_transaction (GdaServerProvider *
	GdaConnection *cnc,		provider,
	GdaTransaction *xaction		GdaConnection *cnc,
	);		GdaTransaction *xact
	gboolean gda_server_provider_commit_transaction (GdaServerProvider *pr		ion);
	ovider,		gboolean gda_server_provider_commit_transaction (GdaServerProvider *
	GdaConnection *cnc,		provider,
	GdaTransaction *xactio		GdaConnection *cnc,
	n);		GdaTransaction *xact
			ion);
	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);
	GdaBlob *gda_server_provider_create_blob (GdaServerProvider *provider,		/* blobs */
	GdaConnection *cnc);		GdaBlob *gda_server_provider_create_blob (GdaServerProvider *
	GdaBlob *gda_server_provider_fetch_blob_by_id (GdaServerProvider *prov		provider,
	ider,		GdaConnection *cnc);
	GdaConnection *cnc, cons		GdaBlob *gda_server_provider_fetch_blob_by_id (GdaServerProvider *
	t gchar *sql_id);		provider,
			GdaConnection *cnc,
			const gchar *sql_id);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 24 change blocks.
	176 lines changed or deleted		158 lines changed or added

	gda-sql-delimiter.h		gda-sql-delimiter.h
	skipping to change at line 40		skipping to change at line 40
	/*		/*
	* Type of parsed SQL		* Type of parsed SQL
	*/		*/
	typedef enum		typedef enum
	{		{
	GDA_DELIMITER_SQL_SELECT,		GDA_DELIMITER_SQL_SELECT,
	GDA_DELIMITER_SQL_INSERT,		GDA_DELIMITER_SQL_INSERT,
	GDA_DELIMITER_SQL_DELETE,		GDA_DELIMITER_SQL_DELETE,
	GDA_DELIMITER_SQL_UPDATE,		GDA_DELIMITER_SQL_UPDATE,
			GDA_DELIMITER_SQL_BEGIN,
			GDA_DELIMITER_SQL_COMMIT,
			GDA_DELIMITER_MULTIPLE,
	GDA_DELIMITER_UNKNOWN		GDA_DELIMITER_UNKNOWN
	}		}
	GdaDelimiterStatementType;		GdaDelimiterStatementType;
	/*		/*
	* Structure to hold a SQL statement		* Structure to hold a SQL statement
	*/		*/
	struct GdaDelimiterStatement		struct GdaDelimiterStatement
	{		{
	GdaDelimiterStatementType type;		GdaDelimiterStatementType type;
	char *full_query;
	GList *expr_list; /* list of GdaDelimiterExpr structures */		GList *expr_list; /* list of GdaDelimiterExpr structures */
	GList *params_specs;/* list of GList of GdaDelim iterParamSpec structures */		GList *params_specs;/* list of GList of GdaDelim iterParamSpec structures */
	};		};
	/*		/*
	* Structure to hold a single statement		* Structure to hold a single statement
	*/		*/
	struct GdaDelimiterExpr		struct GdaDelimiterExpr
	{		{
	GList *pspec_list; /* list of GdaDelimiterParamSpec structur es */		GList *pspec_list; /* list of GdaDelimiterParamSpec structur es */
	skipping to change at line 87		skipping to change at line 89
	/*		/*
	* Structure to hold one parameter specification		* Structure to hold one parameter specification
	*/		*/
	struct GdaDelimiterParamSpec		struct GdaDelimiterParamSpec
	{		{
	GdaDelimiterParamSpecType type;		GdaDelimiterParamSpecType type;
	char *content;		char *content;
	};		};
	#define GDA_DELIMITER_PARAM_SPEC(x) ((GdaDelimiterParamSpec *)(x))		#define GDA_DELIMITER_PARAM_SPEC(x) ((GdaDelimiterParamSpec *)(x))
	void gda_delimiter_display (GdaDelimiterStatement * statement);		void gda_delimiter_display (GdaDelimiterStat
	int gda_delimiter_destroy (GdaDelimiterStatement * statement);		ement *statement);
			gchar *gda_delimiter_to_string (GdaDelimiterStat
			ement *statement);
			int gda_delimiter_destroy (GdaDelimiterStat
			ement *statement);
	GdaDelimiterStatement *gda_delimiter_parse (const char *sql_		GList *gda_delimiter_parse (const char *sql_
	text);		text);
	GdaDelimiterStatement *gda_delimiter_parse_with_error (const char *sql_		GList *gda_delimiter_parse_with_error (const char *sql_
	text, GError ** error);		text, GError **error);
			gchar **gda_delimiter_split_sql (const char *sql_
			text);
			void gda_delimiter_free_list (GList *statement
			s);
			GdaDelimiterStatement *gda_delimiter_concat_list (GList *statement
			s);
	GdaDelimiterStatement *gda_delimiter_parse_copy_statement (GdaDelimiterStat ement *statement, GHashTable *repl);		GdaDelimiterStatement *gda_delimiter_parse_copy_statement (GdaDelimiterStat ement *statement, GHashTable *repl);
	#endif		#endif
End of changes. 4 change blocks.
	7 lines changed or deleted		20 lines changed or added

	gda-util.h		gda-util.h
	skipping to change at line 35		skipping to change at line 35
	# define __gda_util_h__		# define __gda_util_h__
	#include <glib/ghash.h>		#include <glib/ghash.h>
	#include <glib/glist.h>		#include <glib/glist.h>
	#include "gda-parameter.h"		#include "gda-parameter.h"
	#include "gda-row.h"		#include "gda-row.h"
	#include "gda-connection.h"		#include "gda-connection.h"
	G_BEGIN_DECLS		G_BEGIN_DECLS
	const gchar *gda_type_to_string (GdaValueType type);		/*
	GdaValueType gda_type_from_string (const gchar *str);		* Type utilities
			*/
			const gchar *gda_type_to_string (GType type);
			GType 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		* SQL escaping
	*/		*/
	gchar *gda_default_escape_chars (const gchar *string);		gchar *gda_default_escape_chars (const gchar *string);
	gchar *gda_default_unescape_chars (const gchar *string);		gchar *gda_default_unescape_chars (const gchar *string);
	/*		/*
	skipping to change at line 63		skipping to change at line 66
	* 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);
	/*		/*
	* utilities dealing with storing and retreiving GdaDictField's attributes		* utilities dealing with storing and retreiving GdaDictField's attributes
	* which is a list of comma separated keywords		* which is a list of comma separated keywords
	*/		*/
	gchar *utility_table_field_attrs_stringify (guint attributes);		gchar *utility_table_field_attrs_stringify (guint attributes);
	guint utility_table_field_attrs_parse (const gchar *str);		guint utility_table_field_attrs_parse (const gchar *str);
	/*		/*
	* XML Id encoding and decoding		* XML Id encoding and decoding
	*/		*/
	gchar *utility_build_encoded_id (const gchar *prefix, const gchar *id);		gchar *utility_build_encoded_id (const gchar *prefix, const gchar *id);
	gchar *utility_build_decoded_id (const gchar *prefix, const gchar *id);		gchar *utility_build_decoded_id (const gchar *prefix, const gchar *id);
	/*		/*
	* Check model columns		* Param & model utilities
	*/		*/
	gboolean utility_check_data_model (GdaDataModel *model, gint nbcols, ...);		gboolean utility_check_data_model (GdaDataModel *model, gint nbcols, ...);
			void utility_data_model_dump_data_to_xml (GdaDataModel *model, xmlNodeP
			tr parent,
			const gint *cols, gint nb_cols
			, gboolean use_col_ids);
			void utility_parameter_load_attributes (GdaParameter *param, xmlNodePtr
			node, GSList *sources);
			GdaDictType *utility_find_or_create_data_type (GdaDict *dict, GdaServerProv
			ider *prov, GdaConnection *cnc,
			const gchar *dbms_type, const
			gchar *gda_type, gboolean *created);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 4 change blocks.
	4 lines changed or deleted		17 lines changed or added

	gda-value.h		gda-value.h
	/* GDA library		/* GDA library
	* Copyright (C) 1998-2002 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>
	* Juan-Mariano de Goyeneche <jmseyas@dit.upm.es> (BLOB issues)		* Juan-Mariano de Goyeneche <jmseyas@dit.upm.es> (BLOB issues)
	* Daniel Espinosa Ortiz <esodan@gmail.com> (Port to GValue)		* Daniel Espinosa Ortiz <esodan@gmail.com> (Port to GValue)
	*		*
	* 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
	skipping to change at line 26		skipping to change at line 26
	* 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_value_h__)		#ifndef __GDA_VALUE_H__
	# define __gda_value_h__		#define __GDA_VALUE_H__
	#include <time.h>		#include <time.h>
	#include <glib/glist.h>		#include <glib/glist.h>
	#include <glib/gmacros.h>		#include <glib/gmacros.h>
	#include <glib-object.h>		#include <glib-object.h>
	#include <libxml/tree.h>		#include <libxml/tree.h>
	#include <libgda/gda-blob.h>		#include <libgda/gda-blob.h>
	G_BEGIN_DECLS		G_BEGIN_DECLS
	#define TIMEZONE_INVALID (2*12*60*60)		#define GDA_TIMEZONE_INVALID (2*12*60*60)
	/* Definition of the GType's values used in GdaValue*/
	#define G_VALUE_TYPE_NULL G_TYPE_NONE
	#define G_VALUE_TYPE_BIGINT G_TYPE_INT64
	#define G_VALUE_TYPE_BIGUINT G_TYPE_UINT64
	#define G_VALUE_TYPE_BINARY (gda_binary_get_type())
	#define G_VALUE_TYPE_BLOB (gda_blob_get_type())
	#define G_VALUE_TYPE_BOOLEAN G_TYPE_BOOLEAN
	#define G_VALUE_TYPE_DATE (gda_date_get_type())
	#define G_VALUE_TYPE_DOUBLE G_TYPE_DOUBLE
	#define G_VALUE_TYPE_GEOMETRIC_POINT (gda_geometricpoint_get_type())
	#define G_VALUE_TYPE_GOBJECT G_TYPE_OBJECT
	#define G_VALUE_TYPE_INTEGER G_TYPE_INT
	#define G_VALUE_TYPE_UINTEGER G_TYPE_UINT
	#define G_VALUE_TYPE_LIST (gda_value_list_get_type())
	#define G_VALUE_TYPE_MONEY (gda_money_get_type())
	#define G_VALUE_TYPE_NUMERIC (gda_numeric_get_type())
	#define G_VALUE_TYPE_SINGLE G_TYPE_FLOAT
	#define G_VALUE_TYPE_SMALLINT (gda_smallint_get_type())
	#define G_VALUE_TYPE_SMALLUINT (gda_smalluint_get_type())
	#define G_VALUE_TYPE_STRING G_TYPE_STRING
	#define G_VALUE_TYPE_TINYINT G_TYPE_CHAR
	#define G_VALUE_TYPE_TINYUINT G_TYPE_UCHAR
	#define G_VALUE_TYPE_TIME (gda_time_get_type())
	#define G_VALUE_TYPE_TIMESTAMP (gda_timestamp_get_type())
	#define G_VALUE_TYPE_UNKNOWN G_TYPE_INVALID
	#define G_VALUE_TYPE_TYPE (gda_gdatype_get_type())
	typedef enum {
	GDA_VALUE_TYPE_NULL,
	GDA_VALUE_TYPE_BIGINT,
	GDA_VALUE_TYPE_BIGUINT,
	GDA_VALUE_TYPE_BINARY,
	GDA_VALUE_TYPE_BLOB,
	GDA_VALUE_TYPE_BOOLEAN,
	GDA_VALUE_TYPE_DATE,
	GDA_VALUE_TYPE_DOUBLE,
	GDA_VALUE_TYPE_GEOMETRIC_POINT,
	GDA_VALUE_TYPE_GOBJECT,
	GDA_VALUE_TYPE_INTEGER,
	GDA_VALUE_TYPE_LIST,
	GDA_VALUE_TYPE_MONEY,
	GDA_VALUE_TYPE_NUMERIC,
	GDA_VALUE_TYPE_SINGLE,
	GDA_VALUE_TYPE_SMALLINT,
	GDA_VALUE_TYPE_SMALLUINT,
	GDA_VALUE_TYPE_STRING,
	GDA_VALUE_TYPE_TIME,
	GDA_VALUE_TYPE_TIMESTAMP,
	GDA_VALUE_TYPE_TINYINT,		/* Definition of the GType's values used in GValue*/
	GDA_VALUE_TYPE_TINYUINT,		#define GDA_TYPE_NULL 0
	GDA_VALUE_TYPE_TYPE,		#define GDA_TYPE_BINARY (gda_binary_get_type())
	GDA_VALUE_TYPE_UINTEGER,		#define GDA_TYPE_BLOB (gda_blob_get_type())
	GDA_VALUE_TYPE_UNKNOWN		#define GDA_TYPE_GEOMETRIC_POINT (gda_geometricpoint_get_type())
	} GdaValueType;		#define GDA_TYPE_LIST (gda_value_list_get_type())
	#define GDA_VALUE_NB_TYPES GDA_VALUE_TYPE_UNKNOWN		#define GDA_TYPE_NUMERIC (gda_numeric_get_type())
			#define GDA_TYPE_SHORT (gda_short_get_type())
			#define GDA_TYPE_USHORT (gda_ushort_get_type())
			#define GDA_TYPE_TIME (gda_time_get_type())
			#define GDA_TYPE_TIMESTAMP (gda_timestamp_get_type())
	typedef struct {		/* Definition of the GDA_VALUE_HOLDS macros */
	gshort year;		#define GDA_VALUE_HOLDS_BINARY(value) G_VALUE_HOLDS(value, GDA_TYP
	gushort month;		E_BINARY)
	gushort day;		#define GDA_VALUE_HOLDS_BLOB(value) G_VALUE_HOLDS(value, GDA_TYP
	} GdaDate;		E_BLOB)
			#define GDA_VALUE_HOLDS_GEOMETRIC_POINT(value) G_VALUE_HOLDS(value, GDA_TYP
			E_GEOMETRIC_POINT)
			#define GDA_VALUE_HOLDS_LIST(value) G_VALUE_HOLDS(value, GDA_TYP
			E_LIST)
			#define GDA_VALUE_HOLDS_NUMERIC(value) G_VALUE_HOLDS(value, GDA_TYP
			E_NUMERIC)
			#define GDA_VALUE_HOLDS_SHORT(value) G_VALUE_HOLDS(value, GDA_TYP
			E_SHORT)
			#define GDA_VALUE_HOLDS_USHORT(value) G_VALUE_HOLDS(value, GDA_TYP
			E_USHORT)
			#define GDA_VALUE_HOLDS_TIME(value) G_VALUE_HOLDS(value, GDA_TYP
			E_TIME)
			#define GDA_VALUE_HOLDS_TIMESTAMP(value) G_VALUE_HOLDS(value, GDA_TYP
			E_TIMESTAMP)
	typedef struct {		typedef struct {
	gdouble x;		gdouble x;
	gdouble y;		gdouble y;
	} GdaGeometricPoint;		} GdaGeometricPoint;
	typedef struct {		typedef struct {
	gchar *currency;
	gdouble amount;
	} GdaMoney;
	typedef struct {
	gchar *number;		gchar *number;
	glong precision;		glong precision;
	glong width;		glong width;
	} GdaNumeric;		} GdaNumeric;
	typedef struct {		typedef struct {
	gushort hour;		gushort hour;
	gushort minute;		gushort minute;
	gushort second;		gushort second;
			gulong fraction;
	glong timezone; /* # of seconds to the east UTC */		glong timezone; /* # of seconds to the east UTC */
	} GdaTime;		} GdaTime;
	typedef struct {		typedef struct {
	gshort year;		gshort year;
	gushort month;		gushort month;
	gushort day;		gushort day;
	gushort hour;		gushort hour;
	gushort minute;		gushort minute;
	gushort second;		gushort second;
	skipping to change at line 148		skipping to change at line 100
	glong timezone; /* # of seconds to the east UTC */		glong timezone; /* # of seconds to the east UTC */
	} GdaTimestamp;		} GdaTimestamp;
	typedef struct {		typedef struct {
	guchar *data;		guchar *data;
	glong binary_length;		glong binary_length;
	} GdaBinary;		} GdaBinary;
	typedef GList GdaValueList;		typedef GList GdaValueList;
	typedef GValue GdaValue;		#define gda_value_isa(value, type) (G_VALUE_HOLDS(value, type))
	#define GDA_TYPE_VALUE G_TYPE_VALUE
	#define GDA_VALUE_TYPE(value) (gda_value_get_type(value))
	#define gda_value_isa(value, type) (gda_value_get_type (value) == type)
	GdaValueType gda_value_get_type(GdaValue *value);
	GType gda_value_convert_gdatype_to_gtype (GdaVa
	lueType type);
	GdaValueType gda_value_convert_gtype_to_gdatype (GType
	type);
	gboolean gda_value_type_transformable (GdaValueTyp		GValue *gda_value_new (GType type);
	e src_type, GdaValueType dest_type, gboolean strict);
	gboolean gda_value_transform (const GdaValue *src,
	GdaValue *dest);
	GdaValue *gda_value_new_null (void);		GValue *gda_value_new_binary (guchar *val, glong
	GdaValue *gda_value_new_bigint (gint64 val);		size);
	GdaValue *gda_value_new_biguint(guint64 val);		GValue *gda_value_new_timestamp_from_timet (time_
	GdaValue *gda_value_new_binary (guchar *val, glong		t val);
	size);
	GdaValue *gda_value_new_blob (const GdaBlob *val);
	GdaValue *gda_value_new_boolean (gboolean val);
	GdaValue *gda_value_new_date (const GdaDate *val);
	GdaValue *gda_value_new_double (gdouble val);
	GdaValue *gda_value_new_geometric_point (const GdaG
	eometricPoint *val);
	GdaValue *gda_value_new_gobject (const GObject *val
	);
	GdaValue *gda_value_new_integer (gint val);
	GdaValue *gda_value_new_list (const GdaValueList *v
	al);
	GdaValue *gda_value_new_money (const GdaMoney *val)
	;
	GdaValue *gda_value_new_numeric (const GdaNumeric *
	val);
	GdaValue *gda_value_new_single (gfloat val);
	GdaValue *gda_value_new_smallint (gshort val);
	GdaValue *gda_value_new_smalluint (gushort val);
	GdaValue *gda_value_new_string (const gchar *val);
	GdaValue *gda_value_new_time (const GdaTime *val);
	GdaValue *gda_value_new_timestamp (const GdaTimesta
	mp *val);
	GdaValue *gda_value_new_timestamp_from_timet (time_
	t val);
	GdaValue *gda_value_new_tinyint (gchar val);
	GdaValue *gda_value_new_tinyuint (guchar val);
	GdaValue *gda_value_new_uinteger(guint val);
	GdaValue *gda_value_new_gdatype (GdaValueType val);
	GdaValue *gda_value_new_from_string (const gchar *a		GValue *gda_value_new_from_string (const gchar *a
	s_string, GdaValueType type);		s_string, GType type);
	GdaValue *gda_value_new_from_xml (const xmlNodePtr		GValue *gda_value_new_from_xml (const xmlNodePtr
	node);		node);
	void gda_value_free (GdaValue *value);		void gda_value_free (GValue *value);
	void gda_value_reset_with_type (GdaValue *valu		void gda_value_reset_with_type (GValue *value,
	e, GdaValueType type);		GType type);
	gboolean gda_value_is_null (GdaValue *value);		gboolean gda_value_is_null (const GValue *value);
	gboolean gda_value_is_number (GdaValue *value);		gboolean gda_value_is_number (const GValue *value)
	GdaValue *gda_value_copy (GdaValue *value);		;
			GValue *gda_value_copy (const GValue *value);
	gint64 gda_value_get_bigint (GdaValue *value);		G_CONST_RETURN GdaBinary *gda_value_get_binary (const GValue *value
	void gda_value_set_bigint (GdaValue *value, gi		);
	nt64 val);		void gda_value_set_binary (GValue *value, cons
	guint64 gda_value_get_biguint (GdaValue *value);		t GdaBinary *binary);
	void gda_value_set_biguint (GdaValue *value, g		void gda_value_take_binary (GValue *value, con
	uint64 val);		st GdaBinary *binary);
	G_CONST_RETURN GdaBinary *gda_value_get_binary (GdaValue *value);		G_CONST_RETURN GdaBlob *gda_value_get_blob (const GValue *value);
	void gda_value_set_binary (GdaValue *value, co		void gda_value_set_blob (GValue *value, const
	nst GdaBinary *binary);		GdaBlob *val);
	G_CONST_RETURN GdaBlob *gda_value_get_blob (GdaValue *value);		G_CONST_RETURN GdaGeometricPoint *gda_value_get_geometric_point (const GVal
	void gda_value_set_blob (GdaValue *value, cons		ue *value);
	t GdaBlob *val);		void gda_value_set_geometric_point (GValue *va
	gboolean gda_value_get_boolean (GdaValue *value);		lue, const GdaGeometricPoint *val);
	void gda_value_set_boolean (GdaValue *value, g		G_CONST_RETURN GdaValueList *gda_value_get_list (const GValue *value);
	boolean val);		void gda_value_set_list (GValue *value, const
	G_CONST_RETURN GdaDate *gda_value_get_date (GdaValue *value);		GdaValueList *val);
	void gda_value_set_date (GdaValue *value, cons		void gda_value_set_null (GValue *value);
	t GdaDate *val);		G_CONST_RETURN GdaNumeric *gda_value_get_numeric (const GValue *valu
	gdouble gda_value_get_double (GdaValue *value);		e);
	void gda_value_set_double (GdaValue *value, gd		void gda_value_set_numeric (GValue *value, con
	ouble val);		st GdaNumeric *val);
	G_CONST_RETURN GdaGeometricPoint *gda_value_get_geometric_point (GdaValue *		gshort gda_value_get_short (const GValue *value)
	value);		;
	void gda_value_set_geometric_point (GdaValue *		void gda_value_set_short (GValue *value, const
	value, const GdaGeometricPoint *val);		gshort val);
	G_CONST_RETURN GObject *gda_value_get_gobject (GdaValue *value);		gushort gda_value_get_ushort (const GValue *value
	void gda_value_set_gobject (GdaValue *value, c		);
	onst GObject *val);		void gda_value_set_ushort (GValue *value, cons
	gint gda_value_get_integer (GdaValue *value);		t gushort val);
	void gda_value_set_integer (GdaValue *value, g		G_CONST_RETURN GdaTime *gda_value_get_time (const GValue *value);
	int val);		void gda_value_set_time (GValue *value, const
	G_CONST_RETURN GdaValueList *gda_value_get_list (GdaValue *value);		GdaTime *val);
	void gda_value_set_list (GdaValue *value, cons		G_CONST_RETURN GdaTimestamp *gda_value_get_timestamp (const GValue *va
	t GdaValueList *val);		lue);
	void gda_value_set_null (GdaValue *value);		void gda_value_set_timestamp (GValue *value, c
	G_CONST_RETURN GdaMoney *gda_value_get_money (GdaValue *value);		onst GdaTimestamp *val);
	void gda_value_set_money (GdaValue *value, con
	st GdaMoney *val);
	G_CONST_RETURN GdaNumeric *gda_value_get_numeric (GdaValue *value);
	void gda_value_set_numeric (GdaValue *value, c
	onst GdaNumeric *val);
	gfloat gda_value_get_single (GdaValue *value);
	void gda_value_set_single (GdaValue *value, gf
	loat val);
	gshort gda_value_get_smallint (GdaValue *value);
	void gda_value_set_smallint (GdaValue *value,
	gshort val);
	gushort gda_value_get_smalluint (GdaValue *value)
	;
	void gda_value_set_smalluint (GdaValue *value,
	gushort val);
	G_CONST_RETURN gchar *gda_value_get_string (GdaValue *value);
	void gda_value_set_string (GdaValue *value, co
	nst gchar *val);
	G_CONST_RETURN GdaTime *gda_value_get_time (GdaValue *value);
	void gda_value_set_time (GdaValue *value, cons
	t GdaTime *val);
	G_CONST_RETURN GdaTimestamp *gda_value_get_timestamp (GdaValue *value)
	;
	void gda_value_set_timestamp (GdaValue *value,
	const GdaTimestamp *val);
	gchar gda_value_get_tinyint (GdaValue *value);
	void gda_value_set_tinyint (GdaValue *value, g
	char val);
	guchar gda_value_get_tinyuint (GdaValue *value);
	void gda_value_set_tinyuint (GdaValue *value,
	guchar val);
	guint gda_value_get_uinteger (GdaValue *value);
	void gda_value_set_uinteger (GdaValue *value,
	guint val);
	void gda_value_set_gdatype (GValue *value, Gda
	ValueType val);
	GdaValueType gda_value_get_gdatype (GValue *value);
	gboolean gda_value_set_from_string (GdaValue *valu e,		gboolean gda_value_set_from_string (GValue *value,
	const gchar *as _string,		const gchar *as _string,
	GdaValueType ty		GType type);
	pe);		gboolean gda_value_set_from_value (GValue *value,
	gboolean gda_value_set_from_value (GdaValue *value		const GValue *from);
	, const GdaValue *from);
	gint gda_value_compare (GdaValue *value1, GdaV		gint gda_value_compare (const GValue *value1,
	alue *value2);		const GValue *value2);
	gint gda_value_compare_ext (GdaValue *value1,		gint gda_value_compare_ext (const GValue *valu
	GdaValue *value2);		e1, const GValue *value2);
	gchar *gda_value_stringify (GdaValue *value);		gchar *gda_value_stringify (const GValue *value)
	xmlNodePtr gda_value_to_xml (GdaValue *value);		;
			xmlNodePtr gda_value_to_xml (const GValue *value);
	gchar *gda_binary_to_string (const GdaBinary *bi n, guint maxlen);		gchar *gda_binary_to_string (const GdaBinary *bi n, guint maxlen);
	gboolean gda_string_to_binary (const gchar *str, G daBinary *bin);		gboolean gda_string_to_binary (const gchar *str, G daBinary *bin);
	/* Custom data types */		/* Custom data types */
	GType gda_money_get_type (void);
	gpointer gda_money_copy (gpointer boxed);
	void gda_money_free (gpointer boxed);
	GType gda_numeric_get_type (void);		GType gda_numeric_get_type (void) G_GNUC_CONST;
	gpointer gda_numeric_copy (gpointer boxed);		gpointer gda_numeric_copy (gpointer boxed) G_GNUC_
	void gda_numeric_free (gpointer boxed);		CONST;
			void gda_numeric_free (gpointer boxed) G_GNUC_
			CONST;
	GType gda_time_get_type(void);		GType gda_time_get_type(void) G_GNUC_CONST;
	gpointer gda_time_copy (gpointer boxed);		gpointer gda_time_copy (gpointer boxed) G_GNUC_CON
	void gda_time_free (gpointer boxed);		ST;
			void gda_time_free (gpointer boxed) G_GNUC_CON
			ST;
	GType gda_timestamp_get_type(void);		GType gda_timestamp_get_type(void) G_GNUC_CONST
	gpointer gda_timestamp_copy (gpointer boxed);		;
	void gda_timestamp_free (gpointer boxed);		gpointer gda_timestamp_copy (gpointer boxed) G_GNU
			C_CONST;
			void gda_timestamp_free (gpointer boxed) G_GNU
			C_CONST;
	GType gda_date_get_type(void);		GType gda_geometricpoint_get_type(void) G_GNUC_
	gpointer gda_date_copy (gpointer boxed);		CONST;
	void gda_date_free (gpointer boxed);		gpointer gda_geometricpoint_copy (gpointer boxed)
			G_GNUC_CONST;
			void gda_geometricpoint_free (gpointer boxed)
			G_GNUC_CONST;
	GType gda_geometricpoint_get_type(void);		GType gda_binary_get_type(void) G_GNUC_CONST;
	gpointer gda_geometricpoint_copy (gpointer boxed);		gpointer gda_binary_copy (gpointer boxed) G_GNUC_C
	void gda_geometricpoint_free (gpointer boxed);		ONST;
			void gda_binary_free (gpointer boxed) G_GNUC_C
			ONST;
	GType gda_binary_get_type(void);		GType gda_value_list_get_type (void) G_GNUC_CON
	gpointer gda_binary_copy (gpointer boxed);		ST;
	void gda_binary_free (gpointer boxed);		GType gda_short_get_type (void) G_GNUC_CONST;
			GType gda_ushort_get_type (void) G_GNUC_CONST;
	GType gda_value_list_get_type (void);		/* Helper macros */
	GType gda_smallint_get_type (void);		#define gda_value_new_null() (g_new0 (GValue, 1))
	GType gda_smalluint_get_type (void);
	GType gda_gdatype_get_type (void);
	G_END_DECLS		G_END_DECLS
	#endif		#endif
End of changes. 25 change blocks.
	241 lines changed or deleted		132 lines changed or added

	libgda.h		libgda.h
	skipping to change at line 51		skipping to change at line 51
	#include <libgda/gda-data-model.h>		#include <libgda/gda-data-model.h>
	#include <libgda/gda-data-model-iter.h>		#include <libgda/gda-data-model-iter.h>
	#include <libgda/gda-data-model-import.h>		#include <libgda/gda-data-model-import.h>
	#include <libgda/gda-data-access-wrapper.h>		#include <libgda/gda-data-access-wrapper.h>
	#include <libgda/gda-data-proxy.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-data-model-filter-sql.h>		#include <libgda/gda-data-model-filter-sql.h>
			#include <libgda/gda-server-operation.h>
	#include <libgda/gda-server-provider.h>		#include <libgda/gda-server-provider.h>
	#include <libgda/gda-threader.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-decl.h>		#include <libgda/gda-decl.h>
	#include <libgda/gda-object.h>		#include <libgda/gda-object.h>
	#include <libgda/gda-dict.h>		#include <libgda/gda-dict.h>
	#include <libgda/gda-enums.h>		#include <libgda/gda-enums.h>
	#include <libgda/gda-graphviz.h>		#include <libgda/gda-graphviz.h>
End of changes. 1 change blocks.
	0 lines changed or deleted		1 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/