libgda: headers diff between 3.99.2 and 3.99.3 versions

	gda-batch.h	gda-batch.h

	skipping to change at line 56	skipping to change at line 56
	struct _GdaBatchClass	struct _GdaBatchClass
	{	{
	GObjectClass parent_class;	GObjectClass parent_class;

	/* signals */	/* signals */
	void (changed) (GdaBatch batch, GdaStatement *changed_stmt);	void (changed) (GdaBatch batch, GdaStatement *changed_stmt);
	};	};

	GType gda_batch_get_type (void) G_GNUC_CONST;	GType gda_batch_get_type (void) G_GNUC_CONST;
	GdaBatch *gda_batch_new (void);	GdaBatch *gda_batch_new (void);

	GdaBatch gda_batch_new_copy (GdaBatch orig);	GdaBatch gda_batch_copy (GdaBatch orig);
	void gda_batch_add_statement (GdaBatch batch, GdaSt atement stmt);	void gda_batch_add_statement (GdaBatch batch, GdaSt atement stmt);
	void gda_batch_remove_statement (GdaBatch batch, GdaSt atement stmt);	void gda_batch_remove_statement (GdaBatch batch, GdaSt atement stmt);

	gchar gda_batch_serialize (GdaBatch batch);	gchar gda_batch_serialize (GdaBatch batch);
	const GSList gda_batch_get_statements (GdaBatch batch);	const GSList gda_batch_get_statements (GdaBatch batch);

		gboolean gda_batch_get_parameters (GdaBatch batch, GdaSe t out_params, GError *error);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

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

	gda-config.h	gda-config.h

	skipping to change at line 53	skipping to change at line 53
	#define GDA_CONFIG_ERROR gda_config_error_quark ()	#define GDA_CONFIG_ERROR gda_config_error_quark ()

	typedef enum {	typedef enum {
	GDA_CONFIG_DSN_NOT_FOUND_ERROR,	GDA_CONFIG_DSN_NOT_FOUND_ERROR,
	GDA_CONFIG_PERMISSION_ERROR,	GDA_CONFIG_PERMISSION_ERROR,
	GDA_CONFIG_PROVIDER_NOT_FOUND_ERROR,	GDA_CONFIG_PROVIDER_NOT_FOUND_ERROR,
	GDA_CONFIG_PROVIDER_CREATION_ERROR	GDA_CONFIG_PROVIDER_CREATION_ERROR
	} GdaConfigError;	} GdaConfigError;

	struct _GdaDataSourceInfo {	struct _GdaDataSourceInfo {

	gchar *name;	gchar name; / plain text, not RFC 1738 encoded */
	gchar *provider;	gchar provider; / plain text, not RFC 1738 encoded */
	gchar *description;	gchar description; / plain text, not RFC 1738 encoded */
	gchar *cnc_string;	gchar cnc_string; / semi-colon separated <key>=<value> list w
	gchar *auth_string;	here <key> and <value> are RFC 1738 encoded */
		gchar auth_string; / semi-colon separated <key>=<value> list w
		here <key> and <value> are RFC 1738 encoded */
	gboolean is_system;	gboolean is_system;
	};	};

	struct _GdaProviderInfo {	struct _GdaProviderInfo {
	gchar *id;	gchar *id;
	gchar *location;	gchar *location;
	gchar *description;	gchar *description;
	GdaSet dsn_params; / Specs to create a DSN */	GdaSet dsn_params; / Specs to create a DSN */
	GdaSet auth_params; / Specs to authenticate a client */	GdaSet auth_params; / Specs to authenticate a client */
	};	};

	skipping to change at line 90	skipping to change at line 90
	void (dsn_removed) (GdaConfig conf, GdaDataSourceI nfo *old_dsn);	void (dsn_removed) (GdaConfig conf, GdaDataSourceI nfo *old_dsn);
	void (dsn_changed) (GdaConfig conf, GdaDataSourceI nfo *dsn);	void (dsn_changed) (GdaConfig conf, GdaDataSourceI nfo *dsn);
	};	};

	GType gda_config_get_type (void) G_GNUC_CONST;	GType gda_config_get_type (void) G_GNUC_CONST;
	GdaConfig* gda_config_get (void);	GdaConfig* gda_config_get (void);

	GdaDataSourceInfo gda_config_get_dsn (const gchar dsn_name);	GdaDataSourceInfo gda_config_get_dsn (const gchar dsn_name);
	gboolean gda_config_define_dsn (const GdaDataSourceInfo info, GError *error);	gboolean gda_config_define_dsn (const GdaDataSourceInfo info, GError *error);
	gboolean gda_config_remove_dsn (const gchar dsn_name, G Error *error);	gboolean gda_config_remove_dsn (const gchar dsn_name, G Error *error);

		gboolean gda_config_dsn_needs_authentication (const gchar *dsn_na me);
	GdaDataModel *gda_config_list_dsn (void);	GdaDataModel *gda_config_list_dsn (void);
	gboolean gda_config_can_modify_system_config (void);	gboolean gda_config_can_modify_system_config (void);

	gint gda_config_get_nb_dsn (void);	gint gda_config_get_nb_dsn (void);
	gint gda_config_get_dsn_index (const gchar *dsn_name);	gint gda_config_get_dsn_index (const gchar *dsn_name);
	GdaDataSourceInfo *gda_config_get_dsn_at_index (gint index);	GdaDataSourceInfo *gda_config_get_dsn_at_index (gint index);

	GdaProviderInfo gda_config_get_provider_info (const gchar provider_na me);	GdaProviderInfo gda_config_get_provider_info (const gchar provider_na me);
	GdaServerProvider gda_config_get_provider_object (const gchar provider_na me, GError **error);	GdaServerProvider gda_config_get_provider_object (const gchar provider_na me, GError **error);
	GdaDataModel *gda_config_list_providers (void);	GdaDataModel *gda_config_list_providers (void);

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

	gda-easy.h	gda-easy.h
	/* GDA library	/* GDA library
	* Copyright (C) 2008 The GNOME Foundation.	* Copyright (C) 2008 The GNOME Foundation.
	*	*
	* AUTHORS:	* AUTHORS:
	* Vivien Malerba <malerba@gnome-db.org>	* Vivien Malerba <malerba@gnome-db.org>

		* Daniel Espinosa <esodan@gmail.com>
	*	*
	* This Library is free software; you can redistribute it and/or	* This Library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public License as	* modify it under the terms of the GNU Library General Public License as
	* published by the Free Software Foundation; either version 2 of the	* published by the Free Software Foundation; either version 2 of the
	* License, or (at your option) any later version.	* License, or (at your option) any later version.
	*	*
	* This Library is distributed in the hope that it will be useful,	* This Library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.	* Library General Public License for more details.

	skipping to change at line 37	skipping to change at line 38
	#include <libgda/gda-server-operation.h>	#include <libgda/gda-server-operation.h>
	#include <libgda/handlers/gda-handler-bin.h>	#include <libgda/handlers/gda-handler-bin.h>
	#include <libgda/handlers/gda-handler-boolean.h>	#include <libgda/handlers/gda-handler-boolean.h>
	#include <libgda/handlers/gda-handler-numerical.h>	#include <libgda/handlers/gda-handler-numerical.h>
	#include <libgda/handlers/gda-handler-string.h>	#include <libgda/handlers/gda-handler-string.h>
	#include <libgda/handlers/gda-handler-time.h>	#include <libgda/handlers/gda-handler-time.h>
	#include <libgda/handlers/gda-handler-type.h>	#include <libgda/handlers/gda-handler-type.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS


	extern GQuark gda_general_error_quark (void);	extern GQuark gda_easy_error_quark (void);
	#define GDA_GENERAL_ERROR gda_general_error_quark ()	#define GDA_EASY_ERROR gda_easy_error_quark ()

	typedef enum {	typedef enum {

	GDA_GENERAL_OBJECT_NAME_ERROR,	GDA_EASY_OBJECT_NAME_ERROR,
	GDA_GENERAL_INCORRECT_VALUE_ERROR,	GDA_EASY_INCORRECT_VALUE_ERROR,
	GDA_GENERAL_OPERATION_ERROR	GDA_EASY_OPERATION_ERROR
	} GdaGeneralError;	} GdaEasyError;

		typedef enum
		{
		GDA_EASY_CREATE_TABLE_PKEY_FLAG = 1 << 0,
		GDA_EASY_CREATE_TABLE_NOT_NULL_FLAG = 1 << 1,
		GDA_EASY_CREATE_TABLE_UNIQUE_FLAG = 1 << 2,
		GDA_EASY_CREATE_TABLE_AUTOINC_FLAG = 1 << 3,
		/* Flags combinations */
		GDA_EASY_CREATE_TABLE_PKEY_AUTOINC_FLAG = GDA_EASY_CREATE_TABLE_PKEY
		_FLAG \| GDA_EASY_CREATE_TABLE_AUTOINC_FLAG
		} GdaEasyCreateTableFlag;

	/*	/*
	* Convenient Functions	* Convenient Functions
	*/	*/
	GdaDataHandler *gda_get_default_handler (GType for_type);	GdaDataHandler *gda_get_default_handler (GType for_type);

	/*	/*
	* Quick commands execution	* Quick commands execution
	*/	*/
	GdaDataModel* gda_execute_select_command (GdaConnection cnc, const gchar sql, GError **error);	GdaDataModel* gda_execute_select_command (GdaConnection cnc, const gchar sql, GError **error);

	skipping to change at line 68	skipping to change at line 79
	* Database creation and destruction	* Database creation and destruction
	*/	*/
	GdaServerOperation gda_prepare_create_database (const gchar provide r, const gchar db_name, GError *error);	GdaServerOperation gda_prepare_create_database (const gchar provide r, const gchar db_name, GError *error);
	gboolean gda_perform_create_database (GdaServerOperation * op, GError **error);	gboolean gda_perform_create_database (GdaServerOperation * op, GError **error);
	GdaServerOperation gda_prepare_drop_database (const gchar provide r, const gchar db_name, GError *error);	GdaServerOperation gda_prepare_drop_database (const gchar provide r, const gchar db_name, GError *error);
	gboolean gda_perform_drop_database (GdaServerOperation * op, GError **error);	gboolean gda_perform_drop_database (GdaServerOperation * op, GError **error);

	/*	/*
	* Tables creation and destruction	* Tables creation and destruction
	*/	*/

	gboolean gda_create_table (GdaConnection *cnc,	GdaServerOperation gda_prepare_create_table (GdaConnection cnc, c
	const gchar table_name, GError *error, ...);	onst gchar table_name, GError *error, ...);
	gboolean gda_drop_table (GdaConnection *cnc,	gboolean gda_perform_create_table (GdaServerOperation *
	const gchar table_name, GError *error);	op, GError **error);
		GdaServerOperation gda_prepare_drop_table (GdaConnection cnc,
		const gchar table_name, GError *error);
		gboolean gda_perform_drop_table (GdaServerOperation *
		op, GError **error);

	/*	/*
	* Data in tables manipulation	* Data in tables manipulation
	*/	*/
	gboolean gda_insert_row_into_table (GdaConnection cnc, const gchar table_name, GError **error, ...);	gboolean gda_insert_row_into_table (GdaConnection cnc, const gchar table_name, GError **error, ...);
	gboolean gda_insert_row_into_table_from_string (GdaConnection * cnc, const gchar table_name, GError *error, ...);	gboolean gda_insert_row_into_table_from_string (GdaConnection * cnc, const gchar table_name, GError *error, ...);
	gboolean gda_update_value_in_table (GdaConnection cnc, const gchar table_name,	gboolean gda_update_value_in_table (GdaConnection cnc, const gchar table_name,
	const gchar *search_f or_column,	const gchar *search_f or_column,
	const GValue *conditi on,	const GValue *conditi on,
	const gchar *column_n ame,	const gchar *column_n ame,

End of changes. 4 change blocks.
	10 lines changed or deleted	26 lines changed or added

	gda-marshal.h	gda-marshal.h

	skipping to change at line 141	skipping to change at line 141
	gpointer marshal_data);	gpointer marshal_data);

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


		/* BOOLEAN:POINTER (gda-marshal.list:44) */
		extern void gda_marshal_BOOLEAN__POINTER (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-meta-struct.h	gda-meta-struct.h

	skipping to change at line 49	skipping to change at line 49

	typedef enum {	typedef enum {
	GDA_META_STRUCT_UNKNOWN_OBJECT_ERROR,	GDA_META_STRUCT_UNKNOWN_OBJECT_ERROR,
	GDA_META_STRUCT_DUPLICATE_OBJECT_ERROR,	GDA_META_STRUCT_DUPLICATE_OBJECT_ERROR,
	GDA_META_STRUCT_INCOHERENCE_ERROR	GDA_META_STRUCT_INCOHERENCE_ERROR
	} GdaMetaStructError;	} GdaMetaStructError;

	/* struct for the object's data */	/* struct for the object's data */
	struct _GdaMetaStruct	struct _GdaMetaStruct
	{	{

	GObject object;	GObject object;
	GSList db_objects; / list of GdaMetaDbObject struct
	ures */
	GdaMetaStructPrivate *priv;	GdaMetaStructPrivate *priv;
	};	};

	/* struct for the object's class */	/* struct for the object's class */
	struct _GdaMetaStructClass	struct _GdaMetaStructClass
	{	{
	GObjectClass parent_class;	GObjectClass parent_class;
	};	};

	/*	/*

	skipping to change at line 102	skipping to change at line 101
	*/	*/
	typedef struct {	typedef struct {
	GSList columns; / list of GdaMetaTableColumn */	GSList columns; / list of GdaMetaTableColumn */

	/* PK fields index */	/* PK fields index */
	gint *pk_cols_array;	gint *pk_cols_array;
	gint pk_cols_nb;	gint pk_cols_nb;

	/* Foreign keys */	/* Foreign keys */
	GSList reverse_fk_list; / list of GdaMetaTableForeignKey whe re @depend_on == this GdaMetaDbObject */	GSList reverse_fk_list; / list of GdaMetaTableForeignKey whe re @depend_on == this GdaMetaDbObject */

	GSList fk_list; / list of GdaMetaTableForeignKey where @gda_ meta_table == this GdaMetaDbObject */	GSList fk_list; / list of GdaMetaTableForeignKey where @meta _table == this GdaMetaDbObject */
	} GdaMetaTable;	} GdaMetaTable;

	/**	/**
	* Complements the GdaMetaDbObject structure, for views only	* Complements the GdaMetaDbObject structure, for views only
	* contains more information than for tables	* contains more information than for tables
	*/	*/
	typedef struct {	typedef struct {
	GdaMetaTable table;	GdaMetaTable table;
	gchar *view_def;	gchar *view_def;
	gboolean is_updatable;	gboolean is_updatable;
	} GdaMetaView;	} GdaMetaView;

	/*	/*
	* Struture to hold information about each object	* Struture to hold information about each object
	* which can be created in the internal GdaMetaStore's connection.	* which can be created in the internal GdaMetaStore's connection.
	* It is available for tables, views, triggers, ...	* It is available for tables, views, triggers, ...

		*
		* Note: @obj_catalog, @obj_schema, @obj_name, @obj_short_name and @obj_ful
		l_name are case sensitive:
		* one must call _identifier_needs_quotes() to know is it is necessar
		y to surround by double quotes
		* before using in an SQL statement
	*/	*/
	typedef struct {	typedef struct {

		union {
		GdaMetaTable meta_table;
		GdaMetaView meta_view;
		} extra;
	GdaMetaDbObjectType obj_type;	GdaMetaDbObjectType obj_type;

		gboolean outdated;
	gchar *obj_catalog;	gchar *obj_catalog;
	gchar *obj_schema;	gchar *obj_schema;
	gchar *obj_name;	gchar *obj_name;
	gchar *obj_short_name;	gchar *obj_short_name;
	gchar *obj_full_name;	gchar *obj_full_name;
	gchar *obj_owner;	gchar *obj_owner;


	union {
	GdaMetaTable meta_table;
	GdaMetaView meta_view;
	} extra;

	GSList depend_list; / list of GdaMetaDbObject poin ters on which this object depends */	GSList depend_list; / list of GdaMetaDbObject poin ters on which this object depends */
	} GdaMetaDbObject;	} GdaMetaDbObject;
	#define GDA_META_DB_OBJECT(x) ((GdaMetaDbObject*)(x))	#define GDA_META_DB_OBJECT(x) ((GdaMetaDbObject*)(x))

	#define GDA_META_DB_OBJECT_GET_TABLE(dbobj) (&((dbobj)->extra.meta_table))	#define GDA_META_TABLE(dbobj) (&((dbobj)->extra.meta_table))
	#define GDA_META_DB_OBJECT_GET_VIEW(dbobj) (&((dbobj)->extra.meta_view))	#define GDA_META_VIEW(dbobj) (&((dbobj)->extra.meta_view))

	typedef struct {	typedef struct {
	gchar *column_name;	gchar *column_name;
	gchar *column_type;	gchar *column_type;
	GType gtype;	GType gtype;
	gboolean pkey;	gboolean pkey;
	gboolean nullok;	gboolean nullok;
	gchar *default_value;	gchar *default_value;
	} GdaMetaTableColumn;	} GdaMetaTableColumn;
	#define GDA_META_TABLE_COLUMN(x) ((GdaMetaTableColumn*)(x))	#define GDA_META_TABLE_COLUMN(x) ((GdaMetaTableColumn*)(x))

	skipping to change at line 162	skipping to change at line 165
	GdaMetaDbObject *depend_on;	GdaMetaDbObject *depend_on;

	gint cols_nb;	gint cols_nb;
	gint fk_cols_array; / FK fields index */	gint fk_cols_array; / FK fields index */
	gchar *fk_names_array; / FK fields names */	gchar *fk_names_array; / FK fields names */
	gint ref_pk_cols_array; / Ref PK fields index */	gint ref_pk_cols_array; / Ref PK fields index */
	gchar *ref_pk_names_array; / Ref PK fields names */	gchar *ref_pk_names_array; / Ref PK fields names */
	} GdaMetaTableForeignKey;	} GdaMetaTableForeignKey;
	#define GDA_META_TABLE_FOREIGN_KEY(x) ((GdaMetaTableForeignKey*)(x))	#define GDA_META_TABLE_FOREIGN_KEY(x) ((GdaMetaTableForeignKey*)(x))


	GType gda_meta_struct_get_type (void) G_GNUC_CONST;	GType gda_meta_struct_get_type (void) G_GNUC_CONST;
	GdaMetaStruct *gda_meta_struct_new (GdaMetaStructFeature	GdaMetaStruct gda_meta_struct_new (GdaMetaStore store
	features);	, GdaMetaStructFeature features);
	GdaMetaDbObject gda_meta_struct_complement (GdaMetaStruct mstruc	GdaMetaDbObject gda_meta_struct_complement (GdaMetaStruct mstr
	t, GdaMetaStore *store, GdaMetaDbObjectType type,	uct, GdaMetaDbObjectType type,
	const GValue *catalog	const GValue *catalo
	, const GValue schema, const GValue name,	g, const GValue schema, const GValue name,
	GError **error);	GError **error);
	gboolean gda_meta_struct_sort_db_objects (GdaMetaStruct *mstruc	gboolean gda_meta_struct_complement_schema (GdaMetaStruct *mstr
	t, GdaMetaSortType sort_type, GError **error);	uct,
	GdaMetaDbObject gda_meta_struct_get_db_object (GdaMetaStruct mstruc	const GValue *catalo
	t,	g, const GValue schema, GError *error);
	const GValue *catalog	gboolean gda_meta_struct_complement_default (GdaMetaStruct *mstr
	, const GValue schema, const GValue name);	uct, GError **error);
	GdaMetaTableColumn gda_meta_struct_get_table_column (GdaMetaStruct mstruc	gboolean gda_meta_struct_complement_depend (GdaMetaStruct *mstr
	t, GdaMetaTable *table,	uct, GdaMetaDbObject *dbo,
	const GValue *col_nam	GError **error);
	e);
		gboolean gda_meta_struct_sort_db_objects (GdaMetaStruct *mstr
		uct, GdaMetaSortType sort_type, GError **error);
		GSList gda_meta_struct_get_all_db_objects (GdaMetaStruct mstr
		uct);
		GdaMetaDbObject gda_meta_struct_get_db_object (GdaMetaStruct mstr
		uct,
		const GValue *catalo
		g, const GValue schema, const GValue name);
		GdaMetaTableColumn gda_meta_struct_get_table_column (GdaMetaStruct mstr
		uct, GdaMetaTable *table,
		const GValue *col_na
		me);

	typedef enum {	typedef enum {
	GDA_META_GRAPH_COLUMNS = 1 << 0	GDA_META_GRAPH_COLUMNS = 1 << 0
	} GdaMetaGraphInfo;	} GdaMetaGraphInfo;


	gchar gda_meta_struct_dump_as_graph (GdaMetaStruct mstruc t, GdaMetaGraphInfo info, GError **error);	gchar gda_meta_struct_dump_as_graph (GdaMetaStruct mstr uct, GdaMetaGraphInfo info, GError **error);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

End of changes. 9 change blocks.
	30 lines changed or deleted	46 lines changed or added

	gda-pmodel.h	gda-pmodel.h

	skipping to change at line 49	skipping to change at line 49
	typedef struct _GdaPModelClass GdaPModelClass;	typedef struct _GdaPModelClass GdaPModelClass;
	typedef struct _GdaPModelPrivate GdaPModelPrivate;	typedef struct _GdaPModelPrivate GdaPModelPrivate;

	struct _GdaPModel {	struct _GdaPModel {
	GObject object;	GObject object;
	GdaPModelPrivate *priv;	GdaPModelPrivate *priv;
	/* read only information */	/* read only information */
	GdaPStmt prep_stmt; / use the "prepared-stmt" property to set this */	GdaPStmt prep_stmt; / use the "prepared-stmt" property to set this */
	gint nb_stored_rows; /* number of GdaPRow objects curre ntly stored */	gint nb_stored_rows; /* number of GdaPRow objects curre ntly stored */
	gint advertized_nrows; /* set when the number of rows b ecomes known */	gint advertized_nrows; /* set when the number of rows b ecomes known */

		GdaConnection *cnc;
	};	};

	/*	/*
	* Depending on model access flags, the implementations are:	* Depending on model access flags, the implementations are:
	*	*
	* if GDA_DATA_MODEL_ACCESS_RANDOM:	* if GDA_DATA_MODEL_ACCESS_RANDOM:
	* REQUIRED: fetch_nb_rows, fetch_random	* REQUIRED: fetch_nb_rows, fetch_random
	* if GDA_STATEMENT_MODEL_CURSOR_FORWARD:	* if GDA_STATEMENT_MODEL_CURSOR_FORWARD:
	* REQUIRED: fetch_next	* REQUIRED: fetch_next
	* OPTIONAL: fetch_at	* OPTIONAL: fetch_at

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

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

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

	#ifndef __GDA_SERVER_PROVIDER_H__	#ifndef __GDA_SERVER_PROVIDER_H__
	#define __GDA_SERVER_PROVIDER_H__	#define __GDA_SERVER_PROVIDER_H__

	#include <libgda/gda-server-operation.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-quark-list.h>	#include <libgda/gda-quark-list.h>
	#include <libgda/gda-statement.h>	#include <libgda/gda-statement.h>
	#include <libgda/gda-meta-store.h>	#include <libgda/gda-meta-store.h>

		#include <libgda/gda-xa-transaction.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

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

	/* error reporting */	/* error reporting */

	skipping to change at line 58	skipping to change at line 58
	typedef enum	typedef enum
	{	{
	GDA_SERVER_PROVIDER_METHOD_NON_IMPLEMENTED_ERROR,	GDA_SERVER_PROVIDER_METHOD_NON_IMPLEMENTED_ERROR,
	GDA_SERVER_PROVIDER_PREPARE_STMT_ERROR,	GDA_SERVER_PROVIDER_PREPARE_STMT_ERROR,
	GDA_SERVER_PROVIDER_EMPTY_STMT_ERROR,	GDA_SERVER_PROVIDER_EMPTY_STMT_ERROR,
	GDA_SERVER_PROVIDER_MISSING_PARAM_ERROR,	GDA_SERVER_PROVIDER_MISSING_PARAM_ERROR,
	GDA_SERVER_PROVIDER_STATEMENT_EXEC_ERROR,	GDA_SERVER_PROVIDER_STATEMENT_EXEC_ERROR,
	GDA_SERVER_PROVIDER_OPERATION_ERROR,	GDA_SERVER_PROVIDER_OPERATION_ERROR,
	GDA_SERVER_PROVIDER_INTERNAL_ERROR,	GDA_SERVER_PROVIDER_INTERNAL_ERROR,
	GDA_SERVER_PROVIDER_BUSY_ERROR,	GDA_SERVER_PROVIDER_BUSY_ERROR,

	GDA_SERVER_PROVIDER_NON_SUPPORTED_ERROR	GDA_SERVER_PROVIDER_NON_SUPPORTED_ERROR,
		GDA_SERVER_PROVIDER_SERVER_VERSION_ERROR
	} GdaServerProviderError;	} GdaServerProviderError;

	struct _GdaServerProvider {	struct _GdaServerProvider {
	GObject object;	GObject object;
	GdaServerProviderPrivate *priv;	GdaServerProviderPrivate *priv;
	};	};

	typedef struct {	typedef struct {
	/* _information_schema_catalog_name */	/* _information_schema_catalog_name */
	gboolean (_info) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);	gboolean (_info) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);

	skipping to change at line 100	skipping to change at line 101
	gboolean (domains) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,	gboolean (domains) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,
	const GValue domain_catalog, const GV alue domain_schema);	const GValue domain_catalog, const GV alue domain_schema);

	/* _domain_constraints */	/* _domain_constraints */
	gboolean (_constraints_dom) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);	gboolean (_constraints_dom) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);
	gboolean (constraints_dom) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,	gboolean (constraints_dom) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,
	const GValue domain_catalog, const GV alue domain_schema, const GValue *domain_name);	const GValue domain_catalog, const GV alue domain_schema, const GValue *domain_name);

	/* _element_types */	/* _element_types */
	gboolean (_el_types) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);	gboolean (_el_types) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);

		gboolean (el_types) (GdaServerProvider , GdaConnection *,
		GdaMetaStore , GdaMetaContext , GError **,
		const GValue *specific_name);

	/* _collations */	/* _collations */
	gboolean (_collations) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);	gboolean (_collations) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);
	gboolean (collations) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,	gboolean (collations) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,
	const GValue collation_catalog, cons t GValue collation_schema,	const GValue collation_catalog, cons t GValue collation_schema,
	const GValue *collation_name_n);	const GValue *collation_name_n);

	/* _character_sets */	/* _character_sets */
	gboolean (_character_sets) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);	gboolean (_character_sets) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);
	gboolean (character_sets) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,	gboolean (character_sets) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,

	skipping to change at line 179	skipping to change at line 182
	gboolean (routine_col) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,	gboolean (routine_col) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,
	const GValue rout_catalog, const GVal ue rout_schema, const GValue *rout_name);	const GValue rout_catalog, const GVal ue rout_schema, const GValue *rout_name);

	/* _parameters */	/* _parameters */
	gboolean (_routine_par) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);	gboolean (_routine_par) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);
	gboolean (routine_par) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,	gboolean (routine_par) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *,
	const GValue rout_catalog, const GVal ue rout_schema, const GValue *rout_name);	const GValue rout_catalog, const GVal ue rout_schema, const GValue *rout_name);

	} GdaServerProviderMeta;	} GdaServerProviderMeta;


		/* distributed transaction support */
		typedef struct {
		gboolean (xa_start) (GdaServerProvider , GdaConnection *, const
		GdaXaTransactionId , GError *);

		gboolean (xa_end) (GdaServerProvider , GdaConnection *, const
		GdaXaTransactionId , GError *);
		gboolean (xa_prepare) (GdaServerProvider , GdaConnection *, const
		GdaXaTransactionId , GError *);

		gboolean (xa_commit) (GdaServerProvider , GdaConnection *, const
		GdaXaTransactionId , GError *);
		gboolean (xa_rollback) (GdaServerProvider , GdaConnection *, const
		GdaXaTransactionId , GError *);

		GList (xa_recover) (GdaServerProvider , GdaConnection , GErro
		r **);
		} GdaServerProviderXa;

	typedef void (GdaServerProviderAsyncCallback) (GdaServerProvider provider , GdaConnection *cnc, guint task_id,	typedef void (GdaServerProviderAsyncCallback) (GdaServerProvider provider , GdaConnection *cnc, guint task_id,
	gboolean result_status, gpoi nter data);	gboolean result_status, gpoi nter data);

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

	/* provider information */	/* provider information */
	const gchar ( get_name) (GdaServerProvider *provider);	const gchar ( get_name) (GdaServerProvider *provider);
	const gchar ( get_version) (GdaServerProvider *provider);	const gchar ( get_version) (GdaServerProvider *provider);
	const gchar ( get_server_version) (GdaServerProvider provider, GdaConnection cnc);	const gchar ( get_server_version) (GdaServerProvider provider, GdaConnection cnc);

	skipping to change at line 252	skipping to change at line 268
	GdaStatementModelU sage model_usage,	GdaStatementModelU sage model_usage,
	GType col_types, GdaSet *last_inserted_row,	GType col_types, GdaSet *last_inserted_row,
	guint *task_id, Gd aServerProviderAsyncCallback async_cb,	guint *task_id, Gd aServerProviderAsyncCallback async_cb,
	gpointer cb_data, GError **error);	gpointer cb_data, GError **error);

	/* Misc */	/* Misc */
	gboolean (* is_busy) (GdaServerProvider provider, GdaConnection cnc, GError **error);	gboolean (* is_busy) (GdaServerProvider provider, GdaConnection cnc, GError **error);
	gboolean (* cancel) (GdaServerProvider provider, GdaConnection cnc,	gboolean (* cancel) (GdaServerProvider provider, GdaConnection cnc,
	guint task_id, GEr ror **error);	guint task_id, GEr ror **error);
	GdaConnection ( create_connection) (GdaServerProvider *provider);	GdaConnection ( create_connection) (GdaServerProvider *provider);


		/* meta data reporting */
	GdaServerProviderMeta meta_funcs;	GdaServerProviderMeta meta_funcs;


		/* distributed transaction */
		GdaServerProviderXa xa_funcs; / it is a pointer! => set to %
		NULL if unsupported by provider */

	/* Padding for future expansion */	/* Padding for future expansion */
	void (*_gda_reserved1) (void);	void (*_gda_reserved1) (void);
	void (*_gda_reserved2) (void);	void (*_gda_reserved2) (void);
	void (*_gda_reserved3) (void);	void (*_gda_reserved3) (void);
	void (*_gda_reserved4) (void);	void (*_gda_reserved4) (void);
	void (*_gda_reserved5) (void);	void (*_gda_reserved5) (void);
	void (*_gda_reserved6) (void);	void (*_gda_reserved6) (void);
	};	};

	GType gda_server_provider_get_type (void) G_GNUC_CONST;	GType gda_server_provider_get_type (void) G_GNUC_CONST;

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

	gda-statement-struct-decl.h	gda-statement-struct-decl.h

	skipping to change at line 25	skipping to change at line 25
	* 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.
	*/	*/

	#ifndef _GDA_STATEMENT_STRUCT_DECL_H	#ifndef _GDA_STATEMENT_STRUCT_DECL_H
	#define _GDA_STATEMENT_STRUCT_DECL_H	#define _GDA_STATEMENT_STRUCT_DECL_H

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

		#include <libgda/gda-decl.h>
		#include <libgda/gda-meta-store.h>
		#include <libgda/gda-meta-struct.h>

	/* error reporting */	/* error reporting */
	extern GQuark gda_sql_error_quark (void);	extern GQuark gda_sql_error_quark (void);
	#define GDA_SQL_ERROR gda_sql_error_quark ()	#define GDA_SQL_ERROR gda_sql_error_quark ()

	typedef enum {	typedef enum {
	GDA_SQL_STRUCTURE_CONTENTS_ERROR,	GDA_SQL_STRUCTURE_CONTENTS_ERROR,
	GDA_SQL_MALFORMED_IDENTIFIER_ERROR,	GDA_SQL_MALFORMED_IDENTIFIER_ERROR,

	GDA_SQL_DICT_ELEMENT_MISSING_ERROR	GDA_SQL_MISSING_IDENTIFIER_ERROR,
		GDA_SQL_VALIDATION_ERROR
	} GdaSqlErrorType;	} GdaSqlErrorType;

	/*	/*
	* Struct declarations	* Struct declarations
	*/	*/
	typedef struct _GdaSqlAnyPart GdaSqlAnyPart;	typedef struct _GdaSqlAnyPart GdaSqlAnyPart;
	typedef struct _GdaSqlStatement GdaSqlStatement;	typedef struct _GdaSqlStatement GdaSqlStatement;
	typedef struct _GdaSqlStatementUnknown GdaSqlStatementUnknown;	typedef struct _GdaSqlStatementUnknown GdaSqlStatementUnknown;
	typedef struct _GdaSqlStatementTransaction GdaSqlStatementTransaction;	typedef struct _GdaSqlStatementTransaction GdaSqlStatementTransaction;
	typedef struct _GdaSqlStatementSelect GdaSqlStatementSelect;	typedef struct _GdaSqlStatementSelect GdaSqlStatementSelect;

	skipping to change at line 139	skipping to change at line 143
	typedef struct {	typedef struct {
	GdaSqlStatementType type;	GdaSqlStatementType type;
	gchar *name;	gchar *name;
	gpointer (*construct) (void);	gpointer (*construct) (void);
	void (*free) (gpointer);	void (*free) (gpointer);
	gpointer (*copy) (gpointer);	gpointer (*copy) (gpointer);
	gchar (serialize) (gpointer);	gchar (serialize) (gpointer);

	/* augmenting information precision using a dictionary */	/* augmenting information precision using a dictionary */
	GdaSqlForeachFunc check_structure_func;	GdaSqlForeachFunc check_structure_func;

		GdaSqlForeachFunc check_validity_func;
	} GdaSqlStatementContentsInfo;	} GdaSqlStatementContentsInfo;


		/*
		* Validation against a dictionary
		*/

		typedef struct {
		GdaConnection *cnc;
		GdaMetaStore *store;
		GdaMetaStruct *mstruct;
		} GdaSqlStatementCheckValidityData;

	#endif	#endif

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

	gda-statement-struct-parts.h	gda-statement-struct-parts.h

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

	#ifndef _GDA_STATEMENT_STRUCT_PARTS_H	#ifndef _GDA_STATEMENT_STRUCT_PARTS_H
	#define _GDA_STATEMENT_STRUCT_PARTS_H	#define _GDA_STATEMENT_STRUCT_PARTS_H

	#include <glib.h>	#include <glib.h>
	#include <glib-object.h>	#include <glib-object.h>
	#include <sql-parser/gda-statement-struct.h>	#include <sql-parser/gda-statement-struct.h>
	#include <sql-parser/gda-statement-struct-pspec.h>	#include <sql-parser/gda-statement-struct-pspec.h>
	#include <sql-parser/gda-statement-struct-decl.h>	#include <sql-parser/gda-statement-struct-decl.h>

		#include <libgda/gda-meta-struct.h>

	typedef struct _GdaSqlExpr GdaSqlExpr;	typedef struct _GdaSqlExpr GdaSqlExpr;
	typedef struct _GdaSqlField GdaSqlField;	typedef struct _GdaSqlField GdaSqlField;
	typedef struct _GdaSqlTable GdaSqlTable;	typedef struct _GdaSqlTable GdaSqlTable;
	typedef struct _GdaSqlFunction GdaSqlFunction;	typedef struct _GdaSqlFunction GdaSqlFunction;
	typedef struct _GdaSqlOperation GdaSqlOperation;	typedef struct _GdaSqlOperation GdaSqlOperation;
	typedef struct _GdaSqlCase GdaSqlCase;	typedef struct _GdaSqlCase GdaSqlCase;
	typedef struct _GdaSqlSelectField GdaSqlSelectField;	typedef struct _GdaSqlSelectField GdaSqlSelectField;
	typedef struct _GdaSqlSelectTarget GdaSqlSelectTarget;	typedef struct _GdaSqlSelectTarget GdaSqlSelectTarget;
	typedef struct _GdaSqlSelectJoin GdaSqlSelectJoin;	typedef struct _GdaSqlSelectJoin GdaSqlSelectJoin;

	skipping to change at line 69	skipping to change at line 70
	void gda_sql_expr_check_clean (GdaSqlExpr *expr);	void gda_sql_expr_check_clean (GdaSqlExpr *expr);

	void gda_sql_expr_take_select (GdaSqlExpr expr, GdaSqlState ment stmt);	void gda_sql_expr_take_select (GdaSqlExpr expr, GdaSqlState ment stmt);

	/*	/*
	* Any Table's field	* Any Table's field
	*/	*/
	struct _GdaSqlField {	struct _GdaSqlField {
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	gchar *field_name;	gchar *field_name;


		/* validity check with a connection */
		GdaMetaTableColumn *validity_meta_table_column;
	};	};
	GdaSqlField gda_sql_field_new (GdaSqlAnyPart parent);	GdaSqlField gda_sql_field_new (GdaSqlAnyPart parent);
	void gda_sql_field_free (GdaSqlField *field);	void gda_sql_field_free (GdaSqlField *field);
	GdaSqlField gda_sql_field_copy (GdaSqlField field);	GdaSqlField gda_sql_field_copy (GdaSqlField field);
	gchar gda_sql_field_serialize (GdaSqlField field);	gchar gda_sql_field_serialize (GdaSqlField field);
	void gda_sql_field_check_clean (GdaSqlField *field);	void gda_sql_field_check_clean (GdaSqlField *field);

	void gda_sql_field_take_name (GdaSqlField field, GValue value);	void gda_sql_field_take_name (GdaSqlField field, GValue value);

	/*	/*
	* Any table	* Any table
	*/	*/
	struct _GdaSqlTable	struct _GdaSqlTable
	{	{
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	gchar *table_name;	gchar *table_name;


	/* GdaMetaStore check */	/* validity check with a connection */
	gpointer full_table_name;	GdaMetaDbObject *validity_meta_object;
	};	};

	GdaSqlTable gda_sql_table_new (GdaSqlAnyPart parent);	GdaSqlTable gda_sql_table_new (GdaSqlAnyPart parent);
	void gda_sql_table_free (GdaSqlTable *table);	void gda_sql_table_free (GdaSqlTable *table);
	GdaSqlTable gda_sql_table_copy (GdaSqlTable table);	GdaSqlTable gda_sql_table_copy (GdaSqlTable table);
	gchar gda_sql_table_serialize (GdaSqlTable table);	gchar gda_sql_table_serialize (GdaSqlTable table);
	void gda_sql_table_check_clean (GdaSqlTable *table);	void gda_sql_table_check_clean (GdaSqlTable *table);

	void gda_sql_table_take_name (GdaSqlTable table, GValue value);	void gda_sql_table_take_name (GdaSqlTable table, GValue value);

	/*	/*
	* A function with any number of arguments	* A function with any number of arguments
	*/	*/
	struct _GdaSqlFunction {	struct _GdaSqlFunction {
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	gchar *function_name;	gchar *function_name;
	GSList *args_list;	GSList *args_list;


	/* GdaDict check */	/* validity check with a connection */
	gchar *full_function_name;	gpointer validity_meta_function; /* to be replaced with a
		pointer to a structure representing a DBMS data type in GdaMetaStruct */
	};	};

	GdaSqlFunction gda_sql_function_new (GdaSqlAnyPart parent);	GdaSqlFunction gda_sql_function_new (GdaSqlAnyPart parent);
	void gda_sql_function_free (GdaSqlFunction *function) ;	void gda_sql_function_free (GdaSqlFunction *function) ;
	GdaSqlFunction gda_sql_function_copy (GdaSqlFunction function) ;	GdaSqlFunction gda_sql_function_copy (GdaSqlFunction function) ;
	gchar gda_sql_function_serialize (GdaSqlFunction function) ;	gchar gda_sql_function_serialize (GdaSqlFunction function) ;
	void gda_sql_function_check_clean (GdaSqlFunction *function) ;	void gda_sql_function_check_clean (GdaSqlFunction *function) ;

	void gda_sql_function_take_name (GdaSqlFunction function, GValue value);	void gda_sql_function_take_name (GdaSqlFunction function, GValue value);
	void gda_sql_function_take_args_list (GdaSqlFunction function, GSList args);	void gda_sql_function_take_args_list (GdaSqlFunction function, GSList args);

	/*	/*
	* An operation on one or more expressions	* An operation on one or more expressions
	*/	*/
	typedef enum {	typedef enum {

	GDA_SQL_OPERATOR_AND,	GDA_SQL_OPERATOR_TYPE_AND,
	GDA_SQL_OPERATOR_OR,	GDA_SQL_OPERATOR_TYPE_OR,


	GDA_SQL_OPERATOR_EQ,	GDA_SQL_OPERATOR_TYPE_EQ,
	GDA_SQL_OPERATOR_IS,	GDA_SQL_OPERATOR_TYPE_IS,
	GDA_SQL_OPERATOR_LIKE,	GDA_SQL_OPERATOR_TYPE_LIKE,
	GDA_SQL_OPERATOR_BETWEEN,	GDA_SQL_OPERATOR_TYPE_BETWEEN,
	GDA_SQL_OPERATOR_GT,	GDA_SQL_OPERATOR_TYPE_GT,
	GDA_SQL_OPERATOR_LT,	GDA_SQL_OPERATOR_TYPE_LT,
	GDA_SQL_OPERATOR_GEQ,	GDA_SQL_OPERATOR_TYPE_GEQ,
	GDA_SQL_OPERATOR_LEQ,	GDA_SQL_OPERATOR_TYPE_LEQ,
	GDA_SQL_OPERATOR_DIFF,	GDA_SQL_OPERATOR_TYPE_DIFF,
	GDA_SQL_OPERATOR_REGEXP,	GDA_SQL_OPERATOR_TYPE_REGEXP,
	GDA_SQL_OPERATOR_REGEXP_CI,	GDA_SQL_OPERATOR_TYPE_REGEXP_CI,
	GDA_SQL_OPERATOR_NOT_REGEXP,	GDA_SQL_OPERATOR_TYPE_NOT_REGEXP,
	GDA_SQL_OPERATOR_NOT_REGEXP_CI,	GDA_SQL_OPERATOR_TYPE_NOT_REGEXP_CI,
	GDA_SQL_OPERATOR_SIMILAR,	GDA_SQL_OPERATOR_TYPE_SIMILAR,
	GDA_SQL_OPERATOR_ISNULL,	GDA_SQL_OPERATOR_TYPE_ISNULL,
	GDA_SQL_OPERATOR_ISNOTNULL,	GDA_SQL_OPERATOR_TYPE_ISNOTNULL,
	GDA_SQL_OPERATOR_NOT,	GDA_SQL_OPERATOR_TYPE_NOT,
	GDA_SQL_OPERATOR_IN,	GDA_SQL_OPERATOR_TYPE_IN,
	GDA_SQL_OPERATOR_NOTIN,	GDA_SQL_OPERATOR_TYPE_NOTIN,


	GDA_SQL_OPERATOR_CONCAT,	GDA_SQL_OPERATOR_TYPE_CONCAT,
	GDA_SQL_OPERATOR_PLUS,	GDA_SQL_OPERATOR_TYPE_PLUS,
	GDA_SQL_OPERATOR_MINUS,	GDA_SQL_OPERATOR_TYPE_MINUS,
	GDA_SQL_OPERATOR_STAR,	GDA_SQL_OPERATOR_TYPE_STAR,
	GDA_SQL_OPERATOR_DIV,	GDA_SQL_OPERATOR_TYPE_DIV,
	GDA_SQL_OPERATOR_REM,	GDA_SQL_OPERATOR_TYPE_REM,
	GDA_SQL_OPERATOR_BITAND,	GDA_SQL_OPERATOR_TYPE_BITAND,
	GDA_SQL_OPERATOR_BITOR,	GDA_SQL_OPERATOR_TYPE_BITOR,
	GDA_SQL_OPERATOR_BITNOT	GDA_SQL_OPERATOR_TYPE_BITNOT
	} GdaSqlOperator;	} GdaSqlOperatorType;

	struct _GdaSqlOperation {	struct _GdaSqlOperation {

	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GdaSqlOperator operator;	GdaSqlOperatorType operator;
	GSList *operands;	GSList *operands;
	};	};

	GdaSqlOperation gda_sql_operation_new (GdaSqlAnyPart parent);	GdaSqlOperation gda_sql_operation_new (GdaSqlAnyPart parent);
	void gda_sql_operation_free (GdaSqlOperation *operat ion);	void gda_sql_operation_free (GdaSqlOperation *operat ion);
	GdaSqlOperation gda_sql_operation_copy (GdaSqlOperation operat ion);	GdaSqlOperation gda_sql_operation_copy (GdaSqlOperation operat ion);
	gchar gda_sql_operation_serialize (GdaSqlOperation operat ion);	gchar gda_sql_operation_serialize (GdaSqlOperation operat ion);

	const gchar *gda_sql_operation_operator_to_string (GdaSqlOperator op);	const gchar *gda_sql_operation_operator_to_string (GdaSqlOperatorType
	GdaSqlOperator gda_sql_operation_operator_from_string (const gchar *op);	op);
		GdaSqlOperatorType gda_sql_operation_operator_from_string (const gchar *
		op);

	/*	/*
	* A CASE expression	* A CASE expression
	*/	*/
	struct _GdaSqlCase	struct _GdaSqlCase
	{	{
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GdaSqlExpr *base_expr;	GdaSqlExpr *base_expr;
	GSList *when_expr_list;	GSList *when_expr_list;
	GSList *then_expr_list;	GSList *then_expr_list;
	GdaSqlExpr *else_expr;	GdaSqlExpr *else_expr;
	};	};

	GdaSqlCase gda_sql_case_new (GdaSqlAnyPart parent);	GdaSqlCase gda_sql_case_new (GdaSqlAnyPart parent);
	void gda_sql_case_free (GdaSqlCase *scase);	void gda_sql_case_free (GdaSqlCase *scase);
	GdaSqlCase gda_sql_case_copy (GdaSqlCase scase);	GdaSqlCase gda_sql_case_copy (GdaSqlCase scase);
	gchar gda_sql_case_serialize (GdaSqlCase scase);	gchar gda_sql_case_serialize (GdaSqlCase scase);

	/*	/*

	* Any expression in a SELECT ... before the FROM	* Any expression in a SELECT ... before the FROM clause
	*/	*/
	struct _GdaSqlSelectField	struct _GdaSqlSelectField
	{	{
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GdaSqlExpr *expr;	GdaSqlExpr *expr;
	gchar field_name; / may be NULL if expr does not refe r to a table.field, can also be "" /	gchar field_name; / may be NULL if expr does not refe r to a table.field, can also be "" /
	gchar table_name; / may be NULL if expr does not refe r to a table.field */	gchar table_name; / may be NULL if expr does not refe r to a table.field */
	gchar *as;	gchar *as;


	/* GdaDict check */	/* validity check with a connection */
	gchar *full_table_name;	GdaMetaDbObject *validity_meta_object;
		GdaMetaTableColumn *validity_meta_table_column;
	};	};

	GdaSqlSelectField gda_sql_select_field_new (GdaSqlAnyPart pare nt);	GdaSqlSelectField gda_sql_select_field_new (GdaSqlAnyPart pare nt);
	void gda_sql_select_field_free (GdaSqlSelectField * field);	void gda_sql_select_field_free (GdaSqlSelectField * field);
	GdaSqlSelectField gda_sql_select_field_copy (GdaSqlSelectField field);	GdaSqlSelectField gda_sql_select_field_copy (GdaSqlSelectField field);
	gchar gda_sql_select_field_serialize (GdaSqlSelectField field);	gchar gda_sql_select_field_serialize (GdaSqlSelectField field);
	void gda_sql_select_field_check_clean (GdaSqlSelectField * field);	void gda_sql_select_field_check_clean (GdaSqlSelectField * field);

	void gda_sql_select_field_take_star_value(GdaSqlSelectField * field, GValue *value);	void gda_sql_select_field_take_star_value(GdaSqlSelectField * field, GValue *value);
	void gda_sql_select_field_take_expr (GdaSqlSelectField * field, GdaSqlExpr *expr);	void gda_sql_select_field_take_expr (GdaSqlSelectField * field, GdaSqlExpr *expr);

	skipping to change at line 222	skipping to change at line 227
	/*	/*
	* Any TARGET ... in a SELECT statement	* Any TARGET ... in a SELECT statement
	*/	*/
	struct _GdaSqlSelectTarget	struct _GdaSqlSelectTarget
	{	{
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GdaSqlExpr *expr;	GdaSqlExpr *expr;
	gchar table_name; / may be NULL if expr does not refe r to a table */	gchar table_name; / may be NULL if expr does not refe r to a table */
	gchar *as;	gchar *as;


	/* GdaDict check */	/* validity check with a connection */
	gchar *full_table_name;	GdaMetaDbObject *validity_meta_object;
	};	};

	GdaSqlSelectTarget gda_sql_select_target_new (GdaSqlAnyPart pa rent);	GdaSqlSelectTarget gda_sql_select_target_new (GdaSqlAnyPart pa rent);
	void gda_sql_select_target_free (GdaSqlSelectTarge t *target);	void gda_sql_select_target_free (GdaSqlSelectTarge t *target);
	GdaSqlSelectTarget gda_sql_select_target_copy (GdaSqlSelectTarge t target);	GdaSqlSelectTarget gda_sql_select_target_copy (GdaSqlSelectTarge t target);
	gchar gda_sql_select_target_serialize (GdaSqlSelectTarge t target);	gchar gda_sql_select_target_serialize (GdaSqlSelectTarge t target);
	void gda_sql_select_target_check_clean (GdaSqlSelectTarge t *target);	void gda_sql_select_target_check_clean (GdaSqlSelectTarge t *target);

	void gda_sql_select_target_take_table_name (GdaSqlSelectTarg et target, GValue value);	void gda_sql_select_target_take_table_name (GdaSqlSelectTarg et target, GValue value);
	void gda_sql_select_target_take_select (GdaSqlSelectTarget * target, GdaSqlStatement *stmt);	void gda_sql_select_target_take_select (GdaSqlSelectTarget * target, GdaSqlStatement *stmt);

End of changes. 12 change blocks.
	45 lines changed or deleted	53 lines changed or added

	gda-statement-struct-pspec.h	gda-statement-struct-pspec.h

	skipping to change at line 40	skipping to change at line 40
	*/	*/
	struct _GdaSqlParamSpec	struct _GdaSqlParamSpec
	{	{
	gchar *name;	gchar *name;
	gchar *descr;	gchar *descr;
	gchar *type;	gchar *type;
	gboolean is_param;	gboolean is_param;
	gboolean nullok;	gboolean nullok;

	GType g_type;	GType g_type;

	gpointer dict_type;	gpointer validity_meta_dict; /* to be replaced with a pointer to a structure representing a DBMS data type in GdaMetaStruct */
	};	};
	GdaSqlParamSpec gda_sql_param_spec_new (GValue simple_spec);	GdaSqlParamSpec gda_sql_param_spec_new (GValue simple_spec);
	GdaSqlParamSpec gda_sql_param_spec_copy (GdaSqlParamSpec pspec);	GdaSqlParamSpec gda_sql_param_spec_copy (GdaSqlParamSpec pspec);
	void gda_sql_param_spec_take_name (GdaSqlParamSpec pspec, GVa lue value);	void gda_sql_param_spec_take_name (GdaSqlParamSpec pspec, GVa lue value);
	void gda_sql_param_spec_take_type (GdaSqlParamSpec pspec, GVa lue value);	void gda_sql_param_spec_take_type (GdaSqlParamSpec pspec, GVa lue value);
	void gda_sql_param_spec_take_descr (GdaSqlParamSpec pspec, GVa lue value);	void gda_sql_param_spec_take_descr (GdaSqlParamSpec pspec, GVa lue value);
	void gda_sql_param_spec_take_nullok(GdaSqlParamSpec pspec, GVa lue value);	void gda_sql_param_spec_take_nullok(GdaSqlParamSpec pspec, GVa lue value);

	void gda_sql_param_spec_free (GdaSqlParamSpec *pspec);	void gda_sql_param_spec_free (GdaSqlParamSpec *pspec);
	gchar gda_sql_param_spec_serialize (GdaSqlParamSpec pspec);	gchar gda_sql_param_spec_serialize (GdaSqlParamSpec pspec);

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

	gda-statement-struct-util.h	gda-statement-struct-util.h
	/*	/*

	* Copyright (C) 2007 Vivien Malerba	* Copyright (C) 2007 - 2008 Vivien Malerba
	*	*
	* This Library is free software; you can redistribute it and/or	* This Library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public License as	* modify it under the terms of the GNU Library General Public License as
	* published by the Free Software Foundation; either version 2 of the	* published by the Free Software Foundation; either version 2 of the
	* License, or (at your option) any later version.	* License, or (at your option) any later version.
	*	*
	* This Library is distributed in the hope that it will be useful,	* This Library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.	* Library General Public License for more details.

	skipping to change at line 30	skipping to change at line 30
	#ifndef _GDA_STATEMENT_STRUCT_UTIL_H	#ifndef _GDA_STATEMENT_STRUCT_UTIL_H
	#define _GDA_STATEMENT_STRUCT_UTIL_H	#define _GDA_STATEMENT_STRUCT_UTIL_H

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

	/* utility functions */	/* utility functions */
	gchar _remove_quotes (gchar str);	gchar _remove_quotes (gchar str);
	gchar _add_quotes (const gchar str);	gchar _add_quotes (const gchar str);


	gchar _json_quote_string (const gchar str);	gchar _json_quote_string (const gchar str);
	gboolean _string_is_identifier (const gchar *str);
		gboolean _string_is_identifier (const gchar *str);
		gboolean _identifier_needs_quotes (const gchar *str);
		gboolean _split_identifier_string (gchar str, gchar remain, gchar *las
		t);
		gchar _identifier_unquote (gchar str);

	/* to be removed, only here for debug */	/* to be removed, only here for debug */
	gchar gda_sql_value_stringify (const GValue value);	gchar gda_sql_value_stringify (const GValue value);

	#endif	#endif

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

	gda-statement-struct.h	gda-statement-struct.h

	skipping to change at line 32	skipping to change at line 32

	#include <glib.h>	#include <glib.h>
	#include <glib-object.h>	#include <glib-object.h>
	#include <sql-parser/gda-statement-struct-decl.h>	#include <sql-parser/gda-statement-struct-decl.h>
	#include <libgda/gda-meta-store.h>	#include <libgda/gda-meta-store.h>

	struct _GdaSqlStatement {	struct _GdaSqlStatement {
	gchar *sql;	gchar *sql;
	GdaSqlStatementType stmt_type;	GdaSqlStatementType stmt_type;
	gpointer contents; /* depends on stmt_type */	gpointer contents; /* depends on stmt_type */

		GdaMetaStruct validity_meta_struct; / set when gda_sql_state ment_check_validity() was last called */
	};	};

	GdaSqlStatement *gda_sql_statement_new (GdaSqlStatementTy pe type);	GdaSqlStatement *gda_sql_statement_new (GdaSqlStatementTy pe type);
	GdaSqlStatement gda_sql_statement_copy (GdaSqlStatement stmt);	GdaSqlStatement gda_sql_statement_copy (GdaSqlStatement stmt);
	void gda_sql_statement_free (GdaSqlStatement * stmt);	void gda_sql_statement_free (GdaSqlStatement * stmt);
	gchar gda_sql_statement_serialize (GdaSqlStatement stmt);	gchar gda_sql_statement_serialize (GdaSqlStatement stmt);

	const gchar *gda_sql_statement_type_to_string (GdaSqlStatem entType type);	const gchar *gda_sql_statement_type_to_string (GdaSqlStatem entType type);
	GdaSqlStatementType gda_sql_statement_string_to_type (const gchar *type);	GdaSqlStatementType gda_sql_statement_string_to_type (const gchar *type);

	gboolean gda_sql_statement_check_structure (GdaSqlState ment stmt, GError *error);	gboolean gda_sql_statement_check_structure (GdaSqlState ment stmt, GError *error);

	gboolean gda_sql_statement_check_connection(GdaSqlState ment stmt, GdaConnection cnc, GError **error);	gboolean gda_sql_statement_check_validity (GdaSqlState ment stmt, GdaConnection cnc, GError **error);
	void gda_sql_statement_check_clean (GdaSqlState ment *stmt);	void gda_sql_statement_check_clean (GdaSqlState ment *stmt);

		gboolean gda_sql_statement_normalize (GdaSqlState ment stmt, GdaConnection cnc, GError **error);

	GdaSqlStatementContentsInfo *gda_sql_statement_get_contents_infos (GdaSqlSt atementType type) ;	GdaSqlStatementContentsInfo *gda_sql_statement_get_contents_infos (GdaSqlSt atementType type) ;

	#endif	#endif

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

	gda-statement.h	gda-statement.h

	skipping to change at line 62	skipping to change at line 62
	GDA_STATEMENT_MODEL_CURSOR_BACKWARD = 1 << 2,	GDA_STATEMENT_MODEL_CURSOR_BACKWARD = 1 << 2,
	GDA_STATEMENT_MODEL_CURSOR = GDA_STATEMENT_MODEL_CURSOR_FOR WARD \| GDA_STATEMENT_MODEL_CURSOR_BACKWARD	GDA_STATEMENT_MODEL_CURSOR = GDA_STATEMENT_MODEL_CURSOR_FOR WARD \| GDA_STATEMENT_MODEL_CURSOR_BACKWARD
	} GdaStatementModelUsage;	} GdaStatementModelUsage;

	typedef enum {	typedef enum {
	GDA_STATEMENT_SQL_PRETTY = 1 << 0,	GDA_STATEMENT_SQL_PRETTY = 1 << 0,
	GDA_STATEMENT_SQL_PARAMS_LONG = 1 << 1,	GDA_STATEMENT_SQL_PARAMS_LONG = 1 << 1,
	GDA_STATEMENT_SQL_PARAMS_SHORT = 1 << 2,	GDA_STATEMENT_SQL_PARAMS_SHORT = 1 << 2,
	GDA_STATEMENT_SQL_PARAMS_AS_COLON = 1 << 3,	GDA_STATEMENT_SQL_PARAMS_AS_COLON = 1 << 3,
	GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR = 1 << 4,	GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR = 1 << 4,

	GDA_STATEMENT_SQL_PARAMS_AS_QMARK = 1 << 5	GDA_STATEMENT_SQL_PARAMS_AS_QMARK = 1 << 5,
		GDA_STATEMENT_SQL_PARAMS_AS_UQMARK = 1 << 6
	} GdaStatementSqlFlag;	} GdaStatementSqlFlag;

	/* struct for the object's data */	/* struct for the object's data */
	struct _GdaStatement	struct _GdaStatement
	{	{
	GObject object;	GObject object;
	GdaStatementPrivate *priv;	GdaStatementPrivate *priv;
	};	};

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

	skipping to change at line 98	skipping to change at line 99

	gboolean gda_statement_get_parameters (GdaStatement stm t, GdaSet out_params, GError *error);	gboolean gda_statement_get_parameters (GdaStatement stm t, GdaSet out_params, GError *error);
	#define gda_statement_to_sql(stmt,params,error) gda_statement_t o_sql_extended ((stmt), NULL, (params), GDA_STATEMENT_SQL_PARAMS_SHORT, NUL L, (error))	#define gda_statement_to_sql(stmt,params,error) gda_statement_t o_sql_extended ((stmt), NULL, (params), GDA_STATEMENT_SQL_PARAMS_SHORT, NUL L, (error))
	gchar gda_statement_to_sql_extended (GdaStatement stm t, GdaConnection *cnc,	gchar gda_statement_to_sql_extended (GdaStatement stm t, GdaConnection *cnc,
	GdaSet *params, Gd aStatementSqlFlag flags,	GdaSet *params, Gd aStatementSqlFlag flags,
	GSList params_us ed, GError error);	GSList params_us ed, GError error);

	GdaSqlStatementType gda_statement_get_statement_type (GdaStatement *stm t);	GdaSqlStatementType gda_statement_get_statement_type (GdaStatement *stm t);
	gboolean gda_statement_is_useless (GdaStatement *stm t);	gboolean gda_statement_is_useless (GdaStatement *stm t);
	gboolean gda_statement_check_structure (GdaStatement stm t, GError *error);	gboolean gda_statement_check_structure (GdaStatement stm t, GError *error);

	gboolean gda_statement_check_connection (GdaStatement *stm	gboolean gda_statement_check_validity (GdaStatement *stm
	t, GdaConnection cnc, GError *error);	t, GdaConnection cnc, GError *error);
		gboolean gda_statement_normalize (GdaStatement *stm
	/*	t, GdaConnection cnc, GError *error);
	GdaObject gda_statement_execute (GdaStatement stmt,
	GdaConnection *cnc,
	GdaParameterList *par
	ams,
	GdaStatementModelUsag
	e usage, GError **error);
	*/

	G_END_DECLS	G_END_DECLS

	#endif	#endif

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

	gda-util.h	gda-util.h

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

	G_BEGIN_DECLS	G_BEGIN_DECLS

	/*	/*
	* Type utilities	* Type utilities
	*/	*/
	const gchar *gda_g_type_to_string (GType type);	const gchar *gda_g_type_to_string (GType type);
	GType gda_g_type_from_string (const gchar *str);	GType gda_g_type_from_string (const gchar *str);


	GList gda_string_hash_to_list (GHashTable hash_table);

	/*	/*
	* SQL escaping	* SQL escaping
	*/	*/
	gchar gda_default_escape_string (const gchar string);	gchar gda_default_escape_string (const gchar string);
	gchar gda_default_unescape_string (const gchar string);	gchar gda_default_unescape_string (const gchar string);

		guint gda_identifier_hash (const gchar *id);
		gboolean gda_identifier_equal (const gchar id1, const gchar id2);
		gchar *gda_completion_list_get (GdaConnection cnc, const gchar *text
		, gint start, gint end);

	/*	/*

	* File management utility functions	* Param & model utilities
	*/	*/

	gchar gda_file_load (const gchar filename);	gboolean gda_utility_check_data_model (GdaDataModel *model, gint nbcols
	gboolean gda_file_save (const gchar filename, const gchar buffer, gint l	, ...);
	en);	void gda_utility_data_model_dump_data_to_xml (GdaDataModel *model,
		xmlNodePtr parent,
		const gint *cols, gint nb_cols
		, const gint *rows, gint nb_rows,
		gboolean use_col_ids);
		void gda_utility_holder_load_attributes (GdaHolder *holder, xmlNode
		Ptr node, GSList *sources);

	/*	/*

	* XML Id encoding and decoding	* translate any text to an alphanumerical text
	*/	*/

	gchar gda_utility_build_encoded_id (const gchar prefix, const gchar *id);	gchar gda_text_to_alphanum (const gchar text);
	gchar gda_utility_build_decoded_id (const gchar prefix, const gchar *id);	gchar gda_alphanum_to_text (gchar text);

	/*	/*

	* Param & model utilities	* Statement computation from meta store
	*/	*/

	gboolean gda_utility_check_data_model (GdaDataModel *model, gint nbcols, ..	gboolean gda_compute_dml_statements (GdaConnection cnc, GdaStatement
	.);	select_stmt, gboolean require_pk,
	void gda_utility_data_model_dump_data_to_xml (GdaDataModel *model, xmlN	GdaStatement **insert_stmt, GdaStat
	odePtr parent,	ement update_stmt, GdaStatement delete_stmt,
	const gint *cols, gint nb_cols	GError **error);
	, const gint *rows, gint nb_rows,
	gboolean use_col_ids);
	void gda_utility_holder_load_attributes (GdaHolder *holder, xmlNodePtr
	node, GSList *sources);

	/* translate any text to an alphanumerical text */
	gchar gda_text_to_alphanum (const gchar text);
	gchar gda_alphanum_to_text (gchar text);


		/*
		* DSN and connection string manipulations
		*/
		gchar gda_rfc1738_encode (const gchar string);
		gboolean gda_rfc1738_decode (gchar *string);
		void gda_dsn_split (const gchar string, gchar *out_
		dsn,
		gchar out_username, gchar out_
		password);
		void gda_connection_string_split (const gchar string, gchar *out_
		cnc_params, gchar **out_provider,
		gchar out_username, gchar out_
		password);
	G_END_DECLS	G_END_DECLS

	#endif	#endif

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

	libgda-xslt.h	libgda-xslt.h
	/* GDA common library	/* GDA common library
	* Copyright (C) 2007 - 2008 The GNOME Foundation.	* Copyright (C) 2007 - 2008 The GNOME Foundation.
	*	*
	* AUTHORS:	* AUTHORS:

	* Pawe³ Cesar Sanjuan Szklarz <paweld2@gmail.com>	* Paweł Cesar Sanjuan Szklarz <paweld2@gmail.com>
	*	*
	* This Library is free software; you can redistribute it and/or	* This Library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public License as	* modify it under the terms of the GNU Library General Public License as
	* published by the Free Software Foundation; either version 2 of the	* published by the Free Software Foundation; either version 2 of the
	* License, or (at your option) any later version.	* License, or (at your option) any later version.
	*	*
	* This Library is distributed in the hope that it will be useful,	* This Library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.	* Library General Public License for more details.

	skipping to change at line 31	skipping to change at line 31
	*/	*/

	#ifndef _LIBGDA_XSLT_H	#ifndef _LIBGDA_XSLT_H
	#define _LIBGDA_XSLT_H	#define _LIBGDA_XSLT_H

	#include <glib.h>	#include <glib.h>
	#include <libgda/libgda.h>	#include <libgda/libgda.h>
	#include <libxslt/transform.h>	#include <libxslt/transform.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_XSLT_EXTENSION_URI "http://www.gnome-db.org/ns/gda-sql-ext"	#define GDA_XSLT_EXTENSION_URI "http://www.gnome-db.org/ns/gda-sql-ext-v4"
	struct _GdaXsltExCont	struct _GdaXsltExCont
	{	{
	int init;	int init;
	GdaConnection *cnc;	GdaConnection *cnc;
	GHashTable *query_hash;	GHashTable *query_hash;
	GError *error;	GError *error;
	};	};
	typedef struct _GdaXsltExCont GdaXsltExCont;	typedef struct _GdaXsltExCont GdaXsltExCont;

	void gda_xslt_register (void);	void gda_xslt_register (void);

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

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

	* Copyright (C) 1998 - 2006 The GNOME Foundation.	* Copyright (C) 1998 - 2008 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 30	skipping to change at line 30
	* 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.
	*/	*/

	#ifndef __LIBGDA_H__	#ifndef __LIBGDA_H__
	#define __LIBGDA_H__	#define __LIBGDA_H__

	#include <libgda/gda-easy.h>	#include <libgda/gda-easy.h>

	#include <libgda/gda-column-index.h>
	#include <libgda/gda-column.h>	#include <libgda/gda-column.h>
	#include <libgda/gda-config.h>	#include <libgda/gda-config.h>
	#include <libgda/gda-connection-event.h>	#include <libgda/gda-connection-event.h>
	#include <libgda/gda-connection.h>	#include <libgda/gda-connection.h>
	#include <libgda/gda-connection-private.h>	#include <libgda/gda-connection-private.h>

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

	#include <libgda/gda-data-model-index.h>
	#include <libgda/gda-data-model-query.h>	#include <libgda/gda-data-model-query.h>
	#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-model-dir.h>	#include <libgda/gda-data-model-dir.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-quark-list.h>	#include <libgda/gda-quark-list.h>
	#include <libgda/gda-row.h>	#include <libgda/gda-row.h>
	#include <libgda/gda-server-operation.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-xa-transaction.h>
	#include <libgda/gda-transaction-status.h>	#include <libgda/gda-transaction-status.h>
	#include <libgda/gda-transaction-status-private.h>	#include <libgda/gda-transaction-status-private.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-enums.h>	#include <libgda/gda-enums.h>
	#include <libgda/gda-data-handler.h>	#include <libgda/gda-data-handler.h>
	#include <libgda/handlers/gda-handler-bin.h>	#include <libgda/handlers/gda-handler-bin.h>
	#include <libgda/handlers/gda-handler-boolean.h>	#include <libgda/handlers/gda-handler-boolean.h>
	#include <libgda/handlers/gda-handler-numerical.h>	#include <libgda/handlers/gda-handler-numerical.h>

	skipping to change at line 77	skipping to change at line 77

	#include <libgda/gda-statement.h>	#include <libgda/gda-statement.h>
	#include <libgda/gda-batch.h>	#include <libgda/gda-batch.h>
	#include <libgda/gda-holder.h>	#include <libgda/gda-holder.h>
	#include <libgda/gda-set.h>	#include <libgda/gda-set.h>

	#include <libgda/gda-meta-store.h>	#include <libgda/gda-meta-store.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS


	void gda_init (const gchar app_id, const gchar version, g	void gda_init (void);
	int nargs, gchar *args[]);

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

	G_END_DECLS	G_END_DECLS

	#endif	#endif

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

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

	gda-connection-event.h	gda-connection-event.h

	skipping to change at line 84	skipping to change at line 84
	GDA_CONNECTION_EVENT_CODE_DUPLICATE_OBJECT,	GDA_CONNECTION_EVENT_CODE_DUPLICATE_OBJECT,
	GDA_CONNECTION_EVENT_CODE_SYNTAX_ERROR,	GDA_CONNECTION_EVENT_CODE_SYNTAX_ERROR,
	GDA_CONNECTION_EVENT_CODE_UNKNOWN	GDA_CONNECTION_EVENT_CODE_UNKNOWN
	} GdaConnectionEventCode;	} GdaConnectionEventCode;

	#define GDA_SQLSTATE_NO_ERROR "00000"	#define GDA_SQLSTATE_NO_ERROR "00000"
	#define GDA_SQLSTATE_GENERAL_ERROR "HY000"	#define GDA_SQLSTATE_GENERAL_ERROR "HY000"

	GType gda_connection_event_get_type (void) G_GNUC_CONST;	GType gda_connection_event_get_type (void) G_GNUC_CONST;
	GdaConnectionEvent *gda_connection_event_new (GdaConnectionEventType ty pe);	GdaConnectionEvent *gda_connection_event_new (GdaConnectionEventType ty pe);

	void gda_connection_event_free (GdaConnectionEvent * eve
	nt);
	GList gda_connection_event_list_copy (const GList event
	s);
	void gda_connection_event_list_free (GList * events);

	void gda_connection_event_set_event_type (GdaConnectionE vent *event, GdaConnectionEventType type);	void gda_connection_event_set_event_type (GdaConnectionE vent *event, GdaConnectionEventType type);
	GdaConnectionEventType gda_connection_event_get_event_type (GdaConnectionE vent *event);	GdaConnectionEventType gda_connection_event_get_event_type (GdaConnectionE vent *event);

	const gchar gda_connection_event_get_description (GdaConnection Event event);	const gchar gda_connection_event_get_description (GdaConnection Event event);
	void gda_connection_event_set_description (GdaConnection Event event, const gchar description);	void gda_connection_event_set_description (GdaConnection Event event, const gchar description);
	glong gda_connection_event_get_code (GdaConnectionEvent * event);	glong gda_connection_event_get_code (GdaConnectionEvent * event);
	void gda_connection_event_set_code (GdaConnectionEvent * event, glong code);	void gda_connection_event_set_code (GdaConnectionEvent * event, glong code);
	GdaConnectionEventCode gda_connection_event_get_gda_code (GdaConnectionEve nt *event);	GdaConnectionEventCode gda_connection_event_get_gda_code (GdaConnectionEve nt *event);
	void gda_connection_event_set_gda_code (GdaConnectionEve nt *event, GdaConnectionEventCode code);	void gda_connection_event_set_gda_code (GdaConnectionEve nt *event, GdaConnectionEventCode code);

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

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

	skipping to change at line 26	skipping to change at line 26
	*	*
	* 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.
	*/	*/

	#ifndef __GDA_DATA_MODEL_BDB_H__	#ifndef __GDA_DATA_MODEL_BDB_H__
	#define __GDA_DATA_MODEL_BDB_H__	#define __GDA_DATA_MODEL_BDB_H__


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

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_TYPE_DATA_MODEL_BDB (gda_data_model_bdb_get_type())	#define GDA_TYPE_DATA_MODEL_BDB (gda_data_model_bdb_get_type())
	#define GDA_DATA_MODEL_BDB(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj , GDA_TYPE_DATA_MODEL_BDB, GdaDataModelBdb))	#define GDA_DATA_MODEL_BDB(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj , GDA_TYPE_DATA_MODEL_BDB, GdaDataModelBdb))
	#define GDA_DATA_MODEL_BDB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_BDB, GdaDataModelBdbClass))	#define GDA_DATA_MODEL_BDB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_BDB, GdaDataModelBdbClass))
	#define GDA_IS_DATA_MODEL_BDB(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_DATA_MODEL_BDB))	#define GDA_IS_DATA_MODEL_BDB(obj) (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_DATA_MODEL_BDB))
	#define GDA_IS_DATA_MODEL_BDB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) , GDA_TYPE_DATA_MODEL_BDB))	#define GDA_IS_DATA_MODEL_BDB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) , GDA_TYPE_DATA_MODEL_BDB))


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

	gda-data-proxy.h	gda-data-proxy.h

	skipping to change at line 108	skipping to change at line 108
	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);

	gboolean gda_data_proxy_set_filter_expr (GdaDataProxy pr oxy, const gchar filter_expr, GError **error);	gboolean gda_data_proxy_set_filter_expr (GdaDataProxy pr oxy, const gchar filter_expr, GError **error);
	const gchar gda_data_proxy_get_filter_expr (GdaDataProxy pr oxy);	const gchar gda_data_proxy_get_filter_expr (GdaDataProxy pr oxy);

		gboolean gda_data_proxy_set_ordering_column (GdaDataProxy pr oxy, gint col, GError *error);
	gint gda_data_proxy_get_filtered_n_rows (GdaDataProxy *pr oxy);	gint gda_data_proxy_get_filtered_n_rows (GdaDataProxy *pr oxy);

	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-enum-types.h	gda-enum-types.h

	#ifndef __LIBGDA_ENUM_TYPES_H__	#ifndef __LIBGDA_ENUM_TYPES_H__
	#define __LIBGDA_ENUM_TYPES_H__	#define __LIBGDA_ENUM_TYPES_H__

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

	G_BEGIN_DECLS	G_BEGIN_DECLS

	/* enumerations from "gda-column-index.h" */
	GType gda_sorting_get_type (void);
	#define GDA_TYPE_SORTING (gda_sorting_get_type())
	/* enumerations from "gda-config.h" */	/* enumerations from "gda-config.h" */
	GType gda_config_error_get_type (void);	GType gda_config_error_get_type (void);
	#define GDA_TYPE_CONFIG_ERROR (gda_config_error_get_type())	#define GDA_TYPE_CONFIG_ERROR (gda_config_error_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);
	#define GDA_TYPE_CONNECTION_EVENT_TYPE (gda_connection_event_type_get_type( ))	#define GDA_TYPE_CONNECTION_EVENT_TYPE (gda_connection_event_type_get_type( ))
	GType gda_connection_event_code_get_type (void);	GType gda_connection_event_code_get_type (void);
	#define GDA_TYPE_CONNECTION_EVENT_CODE (gda_connection_event_code_get_type( ))	#define GDA_TYPE_CONNECTION_EVENT_CODE (gda_connection_event_code_get_type( ))
	/* enumerations from "gda-connection.h" */	/* enumerations from "gda-connection.h" */
	GType gda_connection_error_get_type (void);	GType gda_connection_error_get_type (void);
	#define GDA_TYPE_CONNECTION_ERROR (gda_connection_error_get_type())	#define GDA_TYPE_CONNECTION_ERROR (gda_connection_error_get_type())
	GType gda_connection_options_get_type (void);	GType gda_connection_options_get_type (void);
	#define GDA_TYPE_CONNECTION_OPTIONS (gda_connection_options_get_type())	#define GDA_TYPE_CONNECTION_OPTIONS (gda_connection_options_get_type())
	GType gda_connection_feature_get_type (void);	GType gda_connection_feature_get_type (void);
	#define GDA_TYPE_CONNECTION_FEATURE (gda_connection_feature_get_type())	#define GDA_TYPE_CONNECTION_FEATURE (gda_connection_feature_get_type())
	GType gda_connection_schema_get_type (void);	GType gda_connection_schema_get_type (void);
	#define GDA_TYPE_CONNECTION_SCHEMA (gda_connection_schema_get_type())	#define GDA_TYPE_CONNECTION_SCHEMA (gda_connection_schema_get_type())
	GType gda_connection_meta_type_get_type (void);	GType gda_connection_meta_type_get_type (void);
	#define GDA_TYPE_CONNECTION_META_TYPE (gda_connection_meta_type_get_type())	#define GDA_TYPE_CONNECTION_META_TYPE (gda_connection_meta_type_get_type())

		/* enumerations from "gda-data-comparator.h" */
		GType gda_data_comparator_error_get_type (void);
		#define GDA_TYPE_DATA_COMPARATOR_ERROR (gda_data_comparator_error_get_type(
		))
		GType gda_diff_type_get_type (void);
		#define GDA_TYPE_DIFF_TYPE (gda_diff_type_get_type())
	/* enumerations from "gda-data-model.h" */	/* enumerations from "gda-data-model.h" */
	GType gda_data_model_access_flags_get_type (void);	GType gda_data_model_access_flags_get_type (void);
	#define GDA_TYPE_DATA_MODEL_ACCESS_FLAGS (gda_data_model_access_flags_get_t ype())	#define GDA_TYPE_DATA_MODEL_ACCESS_FLAGS (gda_data_model_access_flags_get_t ype())
	GType gda_data_model_hint_get_type (void);	GType gda_data_model_hint_get_type (void);
	#define GDA_TYPE_DATA_MODEL_HINT (gda_data_model_hint_get_type())	#define GDA_TYPE_DATA_MODEL_HINT (gda_data_model_hint_get_type())
	GType gda_data_model_io_format_get_type (void);	GType gda_data_model_io_format_get_type (void);
	#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-data-model-iter.h" */	/* enumerations from "gda-data-model-iter.h" */
	GType gda_data_model_iter_error_get_type (void);	GType gda_data_model_iter_error_get_type (void);
	#define GDA_TYPE_DATA_MODEL_ITER_ERROR (gda_data_model_iter_error_get_type( ))	#define GDA_TYPE_DATA_MODEL_ITER_ERROR (gda_data_model_iter_error_get_type( ))
	/* enumerations from "gda-data-model-query.h" */	/* enumerations from "gda-data-model-query.h" */
	GType gda_data_model_query_error_get_type (void);	GType gda_data_model_query_error_get_type (void);
	#define GDA_TYPE_DATA_MODEL_QUERY_ERROR (gda_data_model_query_error_get_typ e())	#define GDA_TYPE_DATA_MODEL_QUERY_ERROR (gda_data_model_query_error_get_typ e())
	GType gda_data_model_query_options_get_type (void);	GType gda_data_model_query_options_get_type (void);
	#define GDA_TYPE_DATA_MODEL_QUERY_OPTIONS (gda_data_model_query_options_get _type())	#define GDA_TYPE_DATA_MODEL_QUERY_OPTIONS (gda_data_model_query_options_get _type())
	/* enumerations from "gda-data-proxy.h" */	/* enumerations from "gda-data-proxy.h" */
	GType gda_data_proxy_error_get_type (void);	GType gda_data_proxy_error_get_type (void);
	#define GDA_TYPE_DATA_PROXY_ERROR (gda_data_proxy_error_get_type())	#define GDA_TYPE_DATA_PROXY_ERROR (gda_data_proxy_error_get_type())
	/* enumerations from "gda-easy.h" */	/* enumerations from "gda-easy.h" */

	GType gda_general_error_get_type (void);	GType gda_easy_error_get_type (void);
	#define GDA_TYPE_GENERAL_ERROR (gda_general_error_get_type())	#define GDA_TYPE_EASY_ERROR (gda_easy_error_get_type())
		GType gda_easy_create_table_flag_get_type (void);
		#define GDA_TYPE_EASY_CREATE_TABLE_FLAG (gda_easy_create_table_flag_get_typ
		e())
	/* enumerations from "gda-enums.h" */	/* enumerations from "gda-enums.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( ))
	GType gda_value_attribute_get_type (void);	GType gda_value_attribute_get_type (void);
	#define GDA_TYPE_VALUE_ATTRIBUTE (gda_value_attribute_get_type())	#define GDA_TYPE_VALUE_ATTRIBUTE (gda_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_query_field_state_get_type (void);	GType gda_query_field_state_get_type (void);
	#define GDA_TYPE_QUERY_FIELD_STATE (gda_query_field_state_get_type())	#define GDA_TYPE_QUERY_FIELD_STATE (gda_query_field_state_get_type())
	/* enumerations from "gda-holder.h" */	/* enumerations from "gda-holder.h" */

	skipping to change at line 106	skipping to change at line 110
	#define GDA_TYPE_STATEMENT_ERROR (gda_statement_error_get_type())	#define GDA_TYPE_STATEMENT_ERROR (gda_statement_error_get_type())
	GType gda_statement_model_usage_get_type (void);	GType gda_statement_model_usage_get_type (void);
	#define GDA_TYPE_STATEMENT_MODEL_USAGE (gda_statement_model_usage_get_type( ))	#define GDA_TYPE_STATEMENT_MODEL_USAGE (gda_statement_model_usage_get_type( ))
	GType gda_statement_sql_flag_get_type (void);	GType gda_statement_sql_flag_get_type (void);
	#define GDA_TYPE_STATEMENT_SQL_FLAG (gda_statement_sql_flag_get_type())	#define GDA_TYPE_STATEMENT_SQL_FLAG (gda_statement_sql_flag_get_type())
	/* enumerations from "gda-transaction-status.h" */	/* enumerations from "gda-transaction-status.h" */
	GType gda_transaction_status_event_type_get_type (void);	GType gda_transaction_status_event_type_get_type (void);
	#define GDA_TYPE_TRANSACTION_STATUS_EVENT_TYPE (gda_transaction_status_even t_type_get_type())	#define GDA_TYPE_TRANSACTION_STATUS_EVENT_TYPE (gda_transaction_status_even t_type_get_type())
	GType gda_transaction_status_state_get_type (void);	GType gda_transaction_status_state_get_type (void);
	#define GDA_TYPE_TRANSACTION_STATUS_STATE (gda_transaction_status_state_get _type())	#define GDA_TYPE_TRANSACTION_STATUS_STATE (gda_transaction_status_state_get _type())

		/* enumerations from "gda-xa-transaction.h" */
		GType gda_xa_transaction_error_get_type (void);
		#define GDA_TYPE_XA_TRANSACTION_ERROR (gda_xa_transaction_error_get_type())
	G_END_DECLS	G_END_DECLS

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

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

	gda-server-operation.h	gda-server-operation.h

	skipping to change at line 59	skipping to change at line 59

	GDA_SERVER_OPERATION_ADD_COLUMN,	GDA_SERVER_OPERATION_ADD_COLUMN,
	GDA_SERVER_OPERATION_DROP_COLUMN,	GDA_SERVER_OPERATION_DROP_COLUMN,

	GDA_SERVER_OPERATION_CREATE_INDEX,	GDA_SERVER_OPERATION_CREATE_INDEX,
	GDA_SERVER_OPERATION_DROP_INDEX,	GDA_SERVER_OPERATION_DROP_INDEX,

	GDA_SERVER_OPERATION_CREATE_VIEW,	GDA_SERVER_OPERATION_CREATE_VIEW,
	GDA_SERVER_OPERATION_DROP_VIEW,	GDA_SERVER_OPERATION_DROP_VIEW,


	GDA_SERVER_OPERATION_NB	GDA_SERVER_OPERATION_LAST
	} GdaServerOperationType;	} GdaServerOperationType;

	typedef enum {	typedef enum {
	GDA_SERVER_OPERATION_NODE_PARAMLIST,	GDA_SERVER_OPERATION_NODE_PARAMLIST,
	GDA_SERVER_OPERATION_NODE_DATA_MODEL,	GDA_SERVER_OPERATION_NODE_DATA_MODEL,
	GDA_SERVER_OPERATION_NODE_PARAM,	GDA_SERVER_OPERATION_NODE_PARAM,
	GDA_SERVER_OPERATION_NODE_SEQUENCE,	GDA_SERVER_OPERATION_NODE_SEQUENCE,
	GDA_SERVER_OPERATION_NODE_SEQUENCE_ITEM,	GDA_SERVER_OPERATION_NODE_SEQUENCE_ITEM,

	GDA_SERVER_OPERATION_NODE_DATA_MODEL_COLUMN,	GDA_SERVER_OPERATION_NODE_DATA_MODEL_COLUMN,

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

	gda-set.h	gda-set.h

	skipping to change at line 142	skipping to change at line 142
	GdaSet gda_set_copy (GdaSet set);	GdaSet gda_set_copy (GdaSet set);
	GdaSet *gda_set_new_inline (gint nb, ...);	GdaSet *gda_set_new_inline (gint nb, ...);

	GdaSet gda_set_new_from_spec_string (const gchar xml_spec, GErr or **error);	GdaSet gda_set_new_from_spec_string (const gchar xml_spec, GErr or **error);
	GdaSet gda_set_new_from_spec_node (xmlNodePtr xml_spec, GError *error);	GdaSet gda_set_new_from_spec_node (xmlNodePtr xml_spec, GError *error);
	gchar gda_set_get_spec (GdaSet set);	gchar gda_set_get_spec (GdaSet set);

	gboolean gda_set_set_holder_value (GdaSet set, const gchar h older_id, ...);	gboolean gda_set_set_holder_value (GdaSet set, const gchar h older_id, ...);
	const GValue gda_set_get_holder_value (GdaSet set, const gchar *h older_id);	const GValue gda_set_get_holder_value (GdaSet set, const gchar *h older_id);
	GdaHolder gda_set_get_holder (GdaSet set, const gchar *h older_id);	GdaHolder gda_set_get_holder (GdaSet set, const gchar *h older_id);

	void gda_set_add_holder (GdaSet set, GdaHolder hol der);	gboolean gda_set_add_holder (GdaSet set, GdaHolder hol der);
	void gda_set_remove_holder (GdaSet set, GdaHolder hol der);	void gda_set_remove_holder (GdaSet set, GdaHolder hol der);
	void gda_set_merge_with_set (GdaSet set, GdaSet set_to _merge);	void gda_set_merge_with_set (GdaSet set, GdaSet set_to _merge);
	gboolean gda_set_is_valid (GdaSet *set);	gboolean gda_set_is_valid (GdaSet *set);

	/* public data lookup functions */	/* public data lookup functions */
	GdaSetNode gda_set_get_node (GdaSet set, GdaHolder *par am);	GdaSetNode gda_set_get_node (GdaSet set, GdaHolder *par am);
	GdaSetSource gda_set_get_source_for_model (GdaSet set, GdaDataModel * model);	GdaSetSource gda_set_get_source_for_model (GdaSet set, GdaDataModel * model);
	GdaSetSource gda_set_get_source (GdaSet set, GdaHolder *par am);	GdaSetSource gda_set_get_source (GdaSet set, GdaHolder *par am);
	GdaSetGroup gda_set_get_group (GdaSet set, GdaHolder *par am);	GdaSetGroup gda_set_get_group (GdaSet set, GdaHolder *par am);


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

	gda-value.h	gda-value.h

	skipping to change at line 153	skipping to change at line 153
	G_CONST_RETURN GdaTime gda_value_get_time (const GValue value);	G_CONST_RETURN GdaTime gda_value_get_time (const GValue value);
	void gda_value_set_time (GValue value, const GdaTime val);	void gda_value_set_time (GValue value, const GdaTime val);
	G_CONST_RETURN GdaTimestamp gda_value_get_timestamp (const GValue va lue);	G_CONST_RETURN GdaTimestamp gda_value_get_timestamp (const GValue va lue);
	void gda_value_set_timestamp (GValue value, c onst GdaTimestamp val);	void gda_value_set_timestamp (GValue value, c onst GdaTimestamp val);

	gboolean gda_value_set_from_string (GValue *value,	gboolean gda_value_set_from_string (GValue *value,
	const gchar *as _string,	const gchar *as _string,
	GType type);	GType type);
	gboolean gda_value_set_from_value (GValue value, const GValue from);	gboolean gda_value_set_from_value (GValue value, const GValue from);


		gint gda_value_bcompare (const GValue value1, const GValue value2);
	gint gda_value_compare (const GValue value1, const GValue value2);	gint gda_value_compare (const GValue value1, const GValue value2);
	gint gda_value_compare_ext (const GValue valu e1, const GValue value2);	gint gda_value_compare_ext (const GValue valu e1, const GValue value2);
	gchar gda_value_stringify (const GValue value) ;	gchar gda_value_stringify (const GValue value) ;
	xmlNodePtr gda_value_to_xml (const GValue *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);

	gchar gda_blob_to_string (GdaBlob blob, guint maxlen);	gchar gda_blob_to_string (GdaBlob blob, guint maxlen);
	gboolean gda_string_to_blob (const gchar str, Gda Blob blob);	gboolean gda_string_to_blob (const gchar str, Gda Blob blob);

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