libgda: headers diff between 4.0.12 and 4.1.0 versions

	gda-connection.h	gda-connection.h

	skipping to change at line 56	skipping to change at line 56
	extern GQuark gda_connection_error_quark (void);	extern GQuark gda_connection_error_quark (void);
	#define GDA_CONNECTION_ERROR gda_connection_error_quark ()	#define GDA_CONNECTION_ERROR gda_connection_error_quark ()

	typedef enum {	typedef enum {
	GDA_CONNECTION_DSN_NOT_FOUND_ERROR,	GDA_CONNECTION_DSN_NOT_FOUND_ERROR,
	GDA_CONNECTION_PROVIDER_NOT_FOUND_ERROR,	GDA_CONNECTION_PROVIDER_NOT_FOUND_ERROR,
	GDA_CONNECTION_PROVIDER_ERROR,	GDA_CONNECTION_PROVIDER_ERROR,
	GDA_CONNECTION_NO_CNC_SPEC_ERROR,	GDA_CONNECTION_NO_CNC_SPEC_ERROR,
	GDA_CONNECTION_NO_PROVIDER_SPEC_ERROR,	GDA_CONNECTION_NO_PROVIDER_SPEC_ERROR,
	GDA_CONNECTION_OPEN_ERROR,	GDA_CONNECTION_OPEN_ERROR,

	GDA_CONNECTION_STATEMENT_TYPE_ERROR	GDA_CONNECTION_STATEMENT_TYPE_ERROR,
		GDA_CONNECTION_CANT_LOCK_ERROR,
		GDA_CONNECTION_TASK_NOT_FOUND_ERROR,
		GDA_CONNECTION_UNSUPPORTED_THREADS_ERROR
	} GdaConnectionError;	} GdaConnectionError;
	#define GDA_CONNECTION_NONEXIST_DSN_ERROR GDA_CONNECTION_DSN_NOT_FOUND_ERRO R	#define GDA_CONNECTION_NONEXIST_DSN_ERROR GDA_CONNECTION_DSN_NOT_FOUND_ERRO R

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

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

	skipping to change at line 83	skipping to change at line 86
	void (dsn_changed) (GdaConnection obj);	void (dsn_changed) (GdaConnection obj);
	void (transaction_status_changed)(GdaConnection obj);	void (transaction_status_changed)(GdaConnection obj);

	/* 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);
	};	};


	/**
	* GdaConnectionOptions:
	* @GDA_CONNECTION_OPTIONS_NONE: no specific aspect
	* @GDA_CONNECTION_OPTIONS_READ_ONLY: this flag specifies that the connecti
	on to open should be in a read-only mode
	* (this policy is not correctly enforce
	d at the moment)
	* @GDA_CONNECTION_OPTIONS_THREAD_SAFE: this flag specifies that the connec
	tion to open will be used
	* by several threads at once so it has
	to be thread safe
	* @GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS_CASE_SENSITIVE: this flag specif
	ies that SQL identifiers submitted as input
	* to Libgda have to keep their case sen
	sitivity.
	*
	*
	* Specifies some aspects of a connection when opening it.
	*
	* Additionnal information about the GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS
	_CASE_SENSITIVE flag:
	* <itemizedlist>
	* <listitem><para>For example without this flag, if the table
	* name specified in a #GdaServerOperation to create a table is
	* <emphasis>MyTable</emphasis>, then usually the database will creat
	e a table named
	* <emphasis>mytable</emphasis>, whereas with this flag, the table wi
	ll be created
	* as <emphasis>MyTable</emphasis> (note that in the end the database
	may still decide
	* to name the table <emphasis>mytable</emphasis> or differently if i
	t can't do
	* otherwise).</para></listitem>
	* <listitem><para>Libgda will not apply this rule when parsing SQL code,
	the SQL code being parsed
	* has to be conform to the database it will be used with</para></lis
	titem>
	* </itemizedlist>
	*/
	typedef enum {	typedef enum {
	GDA_CONNECTION_OPTIONS_NONE = 0,	GDA_CONNECTION_OPTIONS_NONE = 0,
	GDA_CONNECTION_OPTIONS_READ_ONLY = 1 << 0,	GDA_CONNECTION_OPTIONS_READ_ONLY = 1 << 0,

	GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS_CASE_SENSITIVE = 1 << 1	GDA_CONNECTION_OPTIONS_THREAD_SAFE = 1 << 1
	} GdaConnectionOptions;	} GdaConnectionOptions;

	typedef enum {	typedef enum {
	GDA_CONNECTION_FEATURE_AGGREGATES,	GDA_CONNECTION_FEATURE_AGGREGATES,
	GDA_CONNECTION_FEATURE_BLOBS,	GDA_CONNECTION_FEATURE_BLOBS,
	GDA_CONNECTION_FEATURE_INDEXES,	GDA_CONNECTION_FEATURE_INDEXES,
	GDA_CONNECTION_FEATURE_INHERITANCE,	GDA_CONNECTION_FEATURE_INHERITANCE,
	GDA_CONNECTION_FEATURE_NAMESPACES,	GDA_CONNECTION_FEATURE_NAMESPACES,
	GDA_CONNECTION_FEATURE_PROCEDURES,	GDA_CONNECTION_FEATURE_PROCEDURES,
	GDA_CONNECTION_FEATURE_SEQUENCES,	GDA_CONNECTION_FEATURE_SEQUENCES,

	skipping to change at line 155	skipping to change at line 132
	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	GDA_CONNECTION_SCHEMA_TABLE_CONTENTS
	} GdaConnectionSchema;	} GdaConnectionSchema;


	/**
	* GdaConnectionMetaType:
	* @GDA_CONNECTION_META_NAMESPACES: lists the <link linkend="GdaConnectionM
	etaTypeGDA_CONNECTION_META_NAMESPACES">namespaces</link> (or schemas for Po
	stgreSQL)
	* @GDA_CONNECTION_META_TYPES: lists the <link linkend="GdaConnectionMetaTy
	peGDA_CONNECTION_META_TYPES">database types</link>
	* @GDA_CONNECTION_META_TABLES: lists the <link linkend="GdaConnectionMetaT
	ypeGDA_CONNECTION_META_TABLES">tables</link>
	* @GDA_CONNECTION_META_VIEWS: lists the <link linkend="GdaConnectionMetaTy
	peGDA_CONNECTION_META_VIEWS">views</link>
	* @GDA_CONNECTION_META_FIELDS: lists the <link linkend="GdaConnectionMetaT
	ypeGDA_CONNECTION_META_FIELDS">table's or view's fields</link>
	* @GDA_CONNECTION_META_INDEXES: lists the <link linkend="GdaConnectionMeta
	TypeGDA_CONNECTION_META_INDEXES">table's indexes</link>
	*
	* Used with gda_connection_get_meta_store_data() to describe what meta dat
	a to extract from
	* a connection's associated #GdaMetaStore.
	*/
	typedef enum {	typedef enum {
	GDA_CONNECTION_META_NAMESPACES,	GDA_CONNECTION_META_NAMESPACES,
	GDA_CONNECTION_META_TYPES,	GDA_CONNECTION_META_TYPES,
	GDA_CONNECTION_META_TABLES,	GDA_CONNECTION_META_TABLES,
	GDA_CONNECTION_META_VIEWS,	GDA_CONNECTION_META_VIEWS,

	GDA_CONNECTION_META_FIELDS,	GDA_CONNECTION_META_FIELDS
	GDA_CONNECTION_META_INDEXES
	} GdaConnectionMetaType;	} GdaConnectionMetaType;

	GType gda_connection_get_type (void) G_GNUC_CONS T;	GType gda_connection_get_type (void) G_GNUC_CONS T;
	GdaConnection gda_connection_open_from_dsn (const gchar dsn, const gchar *auth_string,	GdaConnection gda_connection_open_from_dsn (const gchar dsn, const gchar *auth_string,
	GdaConnectionOptio ns options, GError **error);	GdaConnectionOptio ns options, GError **error);
	GdaConnection gda_connection_open_from_string (const gchar prov ider_name,	GdaConnection gda_connection_open_from_string (const gchar prov ider_name,
	const gchar cnc_s tring, const gchar auth_string,	const gchar cnc_s tring, const gchar auth_string,
	GdaConnectionOptio ns options, GError **error);	GdaConnectionOptio ns options, GError **error);
	gboolean gda_connection_open (GdaConnection cn c, GError *error);	gboolean gda_connection_open (GdaConnection cn c, GError *error);
	void gda_connection_close (GdaConnection *cn c);	void gda_connection_close (GdaConnection *cn c);

	skipping to change at line 207	skipping to change at line 171
	const gchar gda_connection_get_cnc_string (GdaConnection cn c);	const gchar gda_connection_get_cnc_string (GdaConnection cn c);
	const gchar gda_connection_get_authentication (GdaConnection cn c);	const gchar gda_connection_get_authentication (GdaConnection cn c);

	const GList gda_connection_get_events (GdaConnection cn c);	const GList gda_connection_get_events (GdaConnection cn c);

	GdaSqlParser gda_connection_create_parser (GdaConnection cn c);	GdaSqlParser gda_connection_create_parser (GdaConnection cn c);
	GSList gda_connection_batch_execute (GdaConnection cn c,	GSList gda_connection_batch_execute (GdaConnection cn c,
	GdaBatch batch, G daSet params,	GdaBatch batch, G daSet params,
	GdaStatementModelU sage model_usage, GError **error);	GdaStatementModelU sage model_usage, GError **error);


	gchar gda_connection_quote_sql_identifier (GdaConnection cn c, const gchar *id);
	gchar gda_connection_statement_to_sql (GdaConnection cn c,	gchar gda_connection_statement_to_sql (GdaConnection cn c,
	GdaStatement stmt , GdaSet params, GdaStatementSqlFlag flags,	GdaStatement stmt , GdaSet params, GdaStatementSqlFlag flags,
	GSList params_us ed, GError error);	GSList params_us ed, GError error);

		/* synchronous exec */
	gboolean gda_connection_statement_prepare (GdaConnection *cn c,	gboolean gda_connection_statement_prepare (GdaConnection *cn c,
	GdaStatement stmt , GError *error);	GdaStatement stmt , GError *error);
	GObject gda_connection_statement_execute (GdaConnection cn c, GdaStatement stmt, GdaSet params,	GObject gda_connection_statement_execute (GdaConnection cn c, GdaStatement stmt, GdaSet params,
	GdaStatementModelU sage model_usage, GdaSet **last_insert_row,	GdaStatementModelU sage model_usage, GdaSet **last_insert_row,
	GError **error);	GError **error);
	GdaDataModel gda_connection_statement_execute_select (GdaConnection cnc, GdaStatement *stmt,	GdaDataModel gda_connection_statement_execute_select (GdaConnection cnc, GdaStatement *stmt,
	GdaSet params , GError *error);	GdaSet params , GError *error);
	GdaDataModel gda_connection_statement_execute_select_fullv (GdaConn ection cnc, GdaStatement *stmt,	GdaDataModel gda_connection_statement_execute_select_fullv (GdaConn ection cnc, GdaStatement *stmt,
	GdaSet * params, GdaStatementModelUsage model_usage,	GdaSet * params, GdaStatementModelUsage model_usage,
	GError * *error, ...);	GError * *error, ...);
	GdaDataModel gda_connection_statement_execute_select_full (GdaConne ction cnc, GdaStatement *stmt,	GdaDataModel gda_connection_statement_execute_select_full (GdaConne ction cnc, GdaStatement *stmt,
	GdaSet *p arams, GdaStatementModelUsage model_usage,	GdaSet *p arams, GdaStatementModelUsage model_usage,
	GType co l_types, GError *error);	GType co l_types, GError *error);
	gint gda_connection_statement_execute_non_select (GdaConnec tion cnc, GdaStatement stmt,	gint gda_connection_statement_execute_non_select (GdaConnec tion cnc, GdaStatement stmt,
	GdaSet pa rams, GdaSet last_insert_row, GError *error);	GdaSet pa rams, GdaSet last_insert_row, GError *error);


		/* Async. execution */
		guint gda_connection_async_statement_execute (GdaConnection
		cnc, GdaStatement stmt, GdaSet *params,
		GdaStatementMod
		elUsage model_usage, GType *col_types,
		gboolean need_l
		ast_insert_row,
		GError **error)
		;
		GObject *gda_connection_async_fetch_result (GdaConnection
		cnc, guint task_id, GdaSet last_insert_row, GError *error);
		gboolean gda_connection_async_cancel (GdaConnection
		cnc, guint task_id, GError *error);

		/* repetitive statement */
		GSList *gda_connection_repetitive_statement_execute (GdaConnect
		ion cnc, GdaRepetitiveStatement rstmt,
		GdaStatemen
		tModelUsage model_usage, GType *col_types,
		gboolean st
		op_on_error, GError **error);

		/* transactions */
	gboolean gda_connection_begin_transaction (GdaConnection cn c, const gchar name,	gboolean gda_connection_begin_transaction (GdaConnection cn c, const gchar name,
	GdaTransactionIsol ation level, GError **error);	GdaTransactionIsol ation level, GError **error);
	gboolean gda_connection_commit_transaction (GdaConnection cn c, const gchar name, GError **error);	gboolean gda_connection_commit_transaction (GdaConnection cn c, const gchar name, GError **error);
	gboolean gda_connection_rollback_transaction (GdaConnection cn c, const gchar name, GError **error);	gboolean gda_connection_rollback_transaction (GdaConnection cn c, const gchar name, GError **error);

	gboolean gda_connection_add_savepoint (GdaConnection cn c, const gchar name, GError **error);	gboolean gda_connection_add_savepoint (GdaConnection cn c, const gchar name, GError **error);
	gboolean gda_connection_rollback_savepoint (GdaConnection cn c, const gchar name, GError **error);	gboolean gda_connection_rollback_savepoint (GdaConnection cn c, const gchar name, GError **error);
	gboolean gda_connection_delete_savepoint (GdaConnection cn c, const gchar name, GError **error);	gboolean gda_connection_delete_savepoint (GdaConnection cn c, const gchar name, GError **error);

	GdaTransactionStatus gda_connection_get_transaction_status (GdaConnection cnc);	GdaTransactionStatus gda_connection_get_transaction_status (GdaConnection cnc);

End of changes. 8 change blocks.
	64 lines changed or deleted	30 lines changed or added

	gda-data-select-priv.h	gda-data-select-priv.h

	skipping to change at line 41	skipping to change at line 41

	G_BEGIN_DECLS	G_BEGIN_DECLS

	GType gda_data_select_get_type (void) G_GNUC_C ONST;	GType gda_data_select_get_type (void) G_GNUC_C ONST;

	/* API reserved to provider's implementations */	/* API reserved to provider's implementations */
	void gda_data_select_take_row (GdaDataSelect model, GdaRow row, gint rownum);	void gda_data_select_take_row (GdaDataSelect model, GdaRow row, gint rownum);
	GdaRow gda_data_select_get_stored_row (GdaDataSelect model, gint rownum);	GdaRow gda_data_select_get_stored_row (GdaDataSelect model, gint rownum);
	GdaConnection gda_data_select_get_connection (GdaDataSelect model);	GdaConnection gda_data_select_get_connection (GdaDataSelect model);


		/* internal API */
		void _gda_data_select_share_private_data (GdaDataSelect *master,
		GdaDataSelect *slave);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

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

	gda-debug-macros.h	gda-debug-macros.h

	skipping to change at line 26	skipping to change at line 26
	* 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_DEBUG_MACROS_H_	#ifndef _GDA_DEBUG_MACROS_H_
	#define _GDA_DEBUG_MACROS_H_	#define _GDA_DEBUG_MACROS_H_

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


	#define TO_IMPLEMENT g_print ("Implementation missing: %s() in %s line %d\n	#ifdef GDA_DEBUG
	", __FUNCTION__, __FILE__,__LINE__)	#define D_COL_NOR "\033[0m"
		#define D_COL_H0 "\033[;34;7m"
		#define D_COL_H1 "\033[;36;7m"
		#define D_COL_H2 "\033[;36;4m"
		#define D_COL_OK "\033[;32m"
		#define D_COL_ERR "\033[;31;1m"
		#endif

		#ifndef TO_IMPLEMENT
		#ifdef GDA_DEBUG
		#define TO_IMPLEMENT g_print (D_COL_ERR "Implementation missing:" D_COL
		_NOR " %s() in %s line %d\n", __FUNCTION__, __FILE__,__LINE__)
		#else
		#define TO_IMPLEMENT g_print ("Implementation missing: %s() in %s line
		%d\n", __FUNCTION__, __FILE__,__LINE__)
		#endif
		#endif

	#endif	#endif

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

	gda-decl.h	gda-decl.h

	skipping to change at line 91	skipping to change at line 91
	*/	*/

	typedef struct _GdaBatch GdaBatch;	typedef struct _GdaBatch GdaBatch;
	typedef struct _GdaBatchClass GdaBatchClass;	typedef struct _GdaBatchClass GdaBatchClass;
	typedef struct _GdaBatchPrivate GdaBatchPrivate;	typedef struct _GdaBatchPrivate GdaBatchPrivate;

	typedef struct _GdaStatement GdaStatement;	typedef struct _GdaStatement GdaStatement;
	typedef struct _GdaStatementClass GdaStatementClass;	typedef struct _GdaStatementClass GdaStatementClass;
	typedef struct _GdaStatementPrivate GdaStatementPrivate;	typedef struct _GdaStatementPrivate GdaStatementPrivate;


		typedef struct _GdaRepetitiveStatement GdaRepetitiveStatement;
		typedef struct _GdaRepetitiveStatementClass GdaRepetitiveStatementClass;

	typedef struct _GdaSqlParser GdaSqlParser;	typedef struct _GdaSqlParser GdaSqlParser;
	typedef struct _GdaSqlParserClass GdaSqlParserClass;	typedef struct _GdaSqlParserClass GdaSqlParserClass;
	typedef struct _GdaSqlParserPrivate GdaSqlParserPrivate;	typedef struct _GdaSqlParserPrivate GdaSqlParserPrivate;

	/*	/*
	* Meta data	* Meta data
	*/	*/
	typedef struct _GdaMetaStore GdaMetaStore;	typedef struct _GdaMetaStore GdaMetaStore;
	typedef struct _GdaMetaStoreClass GdaMetaStoreClass;	typedef struct _GdaMetaStoreClass GdaMetaStoreClass;
	typedef struct _GdaMetaStorePrivate GdaMetaStorePrivate;	typedef struct _GdaMetaStorePrivate GdaMetaStorePrivate;
	typedef struct _GdaMetaStoreClassPrivate GdaMetaStoreClassPrivate;	typedef struct _GdaMetaStoreClassPrivate GdaMetaStoreClassPrivate;

	typedef struct _GdaMetaStruct GdaMetaStruct;	typedef struct _GdaMetaStruct GdaMetaStruct;
	typedef struct _GdaMetaStructClass GdaMetaStructClass;	typedef struct _GdaMetaStructClass GdaMetaStructClass;
	typedef struct _GdaMetaStructPrivate GdaMetaStructPrivate;	typedef struct _GdaMetaStructPrivate GdaMetaStructPrivate;

	/*	/*

	* Determines if @word is a reserved SQL keyword	* GdaTree
	*/	*/

	typedef gboolean (GdaSqlReservedKeywordsFunc) (const gchar word);	typedef struct _GdaTree GdaTree;
		typedef struct _GdaTreeClass GdaTreeClass;
		typedef struct _GdaTreePrivate GdaTreePrivate;

		typedef struct _GdaTreeManager GdaTreeManager;
		typedef struct _GdaTreeManagerClass GdaTreeManagerClass;
		typedef struct _GdaTreeManagerPrivate GdaTreeManagerPrivate;

		typedef struct _GdaTreeNode GdaTreeNode;
		typedef struct _GdaTreeNodeClass GdaTreeNodeClass;
		typedef struct _GdaTreeNodePrivate GdaTreeNodePrivate;

	/*	/*
	* Win32 adaptations	* Win32 adaptations
	*/	*/
	#ifdef G_OS_WIN32	#ifdef G_OS_WIN32
	#define strtok_r(s,d,p) strtok(s,d)	#define strtok_r(s,d,p) strtok(s,d)
	#endif	#endif

	#endif	#endif

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

	gda-meta-struct.h	gda-meta-struct.h

	skipping to change at line 95	skipping to change at line 95
	} GdaMetaStructFeature;	} GdaMetaStructFeature;

	/*	/*
	* Types of sorting	* Types of sorting
	*/	*/
	typedef enum {	typedef enum {
	GDA_META_SORT_ALHAPETICAL,	GDA_META_SORT_ALHAPETICAL,
	GDA_META_SORT_DEPENDENCIES	GDA_META_SORT_DEPENDENCIES
	} GdaMetaSortType;	} GdaMetaSortType;


	/**	/*
	* GdaMetaTable:	* Complements the GdaMetaDbObject structure, for tables only
	* @columns: list of #GdaMetaTableColumn structures, one for each column in	* contains predefined statements for data selection and modifications
	the table
	* @pk_cols_array: index of the columns part of the primary key for the tab
	le (WARNING: columns numbering
	* here start at 0)
	* @pk_cols_nb: size of the @pk_cols_array array
	* @reverse_fk_list: list of #GdaMetaTableForeignKey where the referenced t
	able is this table
	* @fk_list: list of #GdaMetaTableForeignKey for this table
	*
	* This structure specifies a #GdaMetaDbObject to represent a table's speci
	fic attributes,
	* its contents must not be modified.
	*/	*/
	typedef struct {	typedef struct {

	/< public >/	GSList columns; / list of GdaMetaTableColumn */
	GSList *columns;

	/* 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 @meta _table == this GdaMetaDbObject */	GSList fk_list; / list of GdaMetaTableForeignKey where @meta _table == this GdaMetaDbObject */


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	gpointer _gda_reserved3;	gpointer _gda_reserved3;
	gpointer _gda_reserved4;	gpointer _gda_reserved4;
	} GdaMetaTable;	} GdaMetaTable;

	/**	/**

	* GdaMetaView:	* Complements the GdaMetaDbObject structure, for views only
	* @table: a view is also a table as it has columns	* contains more information than for tables
	* @view_def: views' definition
	* @is_updatable: tells if the view's contents can be updated
	*
	* This structure specifies a #GdaMetaDbObject to represent a view's specif
	ic attributes,
	* its contents must not be modified.
	*/	*/
	typedef struct {	typedef struct {

	/< public >/
	GdaMetaTable table;	GdaMetaTable table;
	gchar *view_def;	gchar *view_def;
	gboolean is_updatable;	gboolean is_updatable;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	gpointer _gda_reserved3;	gpointer _gda_reserved3;
	gpointer _gda_reserved4;	gpointer _gda_reserved4;
	} GdaMetaView;	} GdaMetaView;


	/**	/*
	* GdaMetaDbObject:	* Struture to hold information about each database object (tables, views,
	* @extra: union for the actual object's contents, to be able to cast it us	triggers, ...)
	ing GDA_META_TABLE(), GDA_META_VIEW()
	* @obj_type: the type of object (table, view)
	* @outdated:
	* @obj_catalog: the catalog the object is in
	* @obj_schema: the schema the object is in
	* @obj_name: the object's name
	* @obj_short_name: the shortest way to name the object
	* @obj_full_name: the full name of the object (in the <schema>.<n
	ameagt; notation
	* @obj_owner: object's owner
	* @depend_list: list of #GdaMetaDbObject pointers on which this object dep
	ends (through foreign keys
	* or tables used for views)
	*
	* Struture to hold information about each database object (tables, views,
	...),
	* its contents must not be modified.
	*	*
	* Note: @obj_catalog, @obj_schema, @obj_name, @obj_short_name and @obj_ful l_name are case sensitive:	* Note: @obj_catalog, @obj_schema, @obj_name, @obj_short_name and @obj_ful l_name are case sensitive:

	* one must use gda_sql_identifier_quote() to know if is it is necess ary to surround by double quotes	* one must call gda_sql_identifier_needs_quotes() to know if is it i s necessary to surround by double quotes
	* before using in an SQL statement	* before using in an SQL statement
	*/	*/
	typedef struct {	typedef struct {

	/< public >/
	union {	union {
	GdaMetaTable meta_table;	GdaMetaTable meta_table;
	GdaMetaView meta_view;	GdaMetaView meta_view;
	} extra;	} extra;
	GdaMetaDbObjectType obj_type;	GdaMetaDbObjectType obj_type;
	gboolean outdated;	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;

	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 */


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	gpointer _gda_reserved3;	gpointer _gda_reserved3;
	gpointer _gda_reserved4;	gpointer _gda_reserved4;
	} GdaMetaDbObject;	} GdaMetaDbObject;
	#define GDA_META_DB_OBJECT(x) ((GdaMetaDbObject*)(x))	#define GDA_META_DB_OBJECT(x) ((GdaMetaDbObject*)(x))
	#define GDA_META_TABLE(dbobj) (&((dbobj)->extra.meta_table))	#define GDA_META_TABLE(dbobj) (&((dbobj)->extra.meta_table))
	#define GDA_META_VIEW(dbobj) (&((dbobj)->extra.meta_view))	#define GDA_META_VIEW(dbobj) (&((dbobj)->extra.meta_view))


	/**
	* GdaMetaTableColumn:
	* @column_name: the column's name
	* @column_type: the column's DBMS's type
	* @gtype: the detected column's #GType
	* @pkey: tells if the column is part of a primary key
	* @nullok: tells if the column can be %NULL
	* @default_value: the column's default value
	*
	* This structure represents a table of view's column, its contents must no
	t be modified.
	*/
	typedef struct {	typedef struct {

	/< public >/
	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;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	gpointer _gda_reserved3;	gpointer _gda_reserved3;
	gpointer _gda_reserved4;	gpointer _gda_reserved4;
	} GdaMetaTableColumn;	} GdaMetaTableColumn;
	#define GDA_META_TABLE_COLUMN(x) ((GdaMetaTableColumn*)(x))	#define GDA_META_TABLE_COLUMN(x) ((GdaMetaTableColumn*)(x))
	const GValue gda_meta_table_column_get_attribute (GdaMetaTableColumn tcol , const gchar *attribute);	const GValue gda_meta_table_column_get_attribute (GdaMetaTableColumn tcol , const gchar *attribute);
	void gda_meta_table_column_set_attribute (GdaMetaTableColumn tcol , const gchar attribute, const GValue *value,	void gda_meta_table_column_set_attribute (GdaMetaTableColumn tcol , const gchar attribute, const GValue *value,
	GDestroyNotify destroy);	GDestroyNotify destroy);

	skipping to change at line 242	skipping to change at line 196
	* @column: a #GdaMetaTableColumn	* @column: a #GdaMetaTableColumn
	* @attribute: attribute's name	* @attribute: attribute's name
	* @value: a #GValue, or %NULL	* @value: a #GValue, or %NULL
	*	*
	* This function is similar to gda_meta_table_column_set_attribute() but fo r static strings	* This function is similar to gda_meta_table_column_set_attribute() but fo r static strings
	*/	*/
	#define gda_meta_table_column_set_attribute_static(column,attribute,value) gda_meta_table_column_set_attribute((column),(attribute),(value),NULL)	#define gda_meta_table_column_set_attribute_static(column,attribute,value) gda_meta_table_column_set_attribute((column),(attribute),(value),NULL)

	void gda_meta_table_column_foreach_attribute (GdaMetaTableColumn * tcol, GdaAttributesManagerFunc func, gpointer data);	void gda_meta_table_column_foreach_attribute (GdaMetaTableColumn * tcol, GdaAttributesManagerFunc func, gpointer data);


	/**
	* GdaMetaTableForeignKey:
	* @meta_table: the #GdaMetaDbObject for which this structure represents a
	foreign key
	* @depend_on: the #GdaMetaDbObject which is referenced by the foreign key
	* @cols_nb: the size of the @fk_cols_array, @fk_names_array, @ref_pk_cols_
	array and @ref_pk_names_array arrays
	* @fk_cols_array: the columns' indexes in @meta_table which participate in
	the constraint (WARNING: columns numbering
	* here start at 1)
	* @fk_names_array: the columns' names in @meta_table which participate in
	the constraint
	* @ref_pk_cols_array: the columns' indexes in @depend_on which participate
	in the constraint (WARNING: columns numbering
	* here start at 1)
	* @ref_pk_names_array: the columns' names in @depend_on which participate
	in the constraint
	*
	* This structure represents a foreign key constraint, its contents must no
	t be modified.
	*/
	typedef struct {	typedef struct {

	/< public >/
	GdaMetaDbObject *meta_table;	GdaMetaDbObject *meta_table;
	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 */


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	gpointer _gda_reserved3;	gpointer _gda_reserved3;
	gpointer _gda_reserved4;	gpointer _gda_reserved4;
	} 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 (GdaMetaStore store , GdaMetaStructFeature features);	GdaMetaStruct gda_meta_struct_new (GdaMetaStore store , GdaMetaStructFeature features);

End of changes. 16 change blocks.
	88 lines changed or deleted	10 lines changed or added

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

	skipping to change at line 180	skipping to change at line 180

	/* _routine_columns */	/* _routine_columns */
	gboolean (_routine_col) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);	gboolean (_routine_col) (GdaServerProvider , GdaConnection , GdaMetaStore , GdaMetaContext , GError *);
	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);

	/* _table_indexes */
	gboolean (_indexes_tab) (GdaServerProvider , GdaConnection *,
	GdaMetaStore , GdaMetaContext , GError **);
	gboolean (indexes_tab) (GdaServerProvider , GdaConnection *,
	GdaMetaStore , GdaMetaContext , GError **,
	const GValue *table_catalog, const GVa
	lue table_schema, const GValue table_name,
	const GValue *index_name_n);

	/* _index_column_usage */
	gboolean (_index_cols) (GdaServerProvider , GdaConnection *,
	GdaMetaStore , GdaMetaContext , GError **);
	gboolean (index_cols) (GdaServerProvider , GdaConnection *,
	GdaMetaStore , GdaMetaContext , GError **,
	const GValue *table_catalog, const GVa
	lue table_schema, const GValue table_name, const GValue *index_name);

	/* Padding for future expansion */	/* Padding for future expansion */

		void (*_gda_reserved1) (void);
		void (*_gda_reserved2) (void);
		void (*_gda_reserved3) (void);
		void (*_gda_reserved4) (void);
	void (*_gda_reserved5) (void);	void (*_gda_reserved5) (void);
	void (*_gda_reserved6) (void);	void (*_gda_reserved6) (void);
	void (*_gda_reserved7) (void);	void (*_gda_reserved7) (void);
	void (*_gda_reserved8) (void);	void (*_gda_reserved8) (void);
	void (*_gda_reserved9) (void);	void (*_gda_reserved9) (void);
	void (*_gda_reserved10) (void);	void (*_gda_reserved10) (void);
	void (*_gda_reserved11) (void);	void (*_gda_reserved11) (void);
	void (*_gda_reserved12) (void);	void (*_gda_reserved12) (void);
	void (*_gda_reserved13) (void);	void (*_gda_reserved13) (void);
	void (*_gda_reserved14) (void);	void (*_gda_reserved14) (void);

	skipping to change at line 303	skipping to change at line 297
	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 */	/* meta data reporting */
	GdaServerProviderMeta meta_funcs;	GdaServerProviderMeta meta_funcs;

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


	/* SQL identifiers quoting */	gboolean (*handle_async) (GdaServerProvider
	gchar ( identifier_quote) (GdaServerProvider *	provider, GdaConnection cnc, GError **error);
	provider, GdaConnection *cnc,
	const gchar *id,
	gboolean for_meta_s
	tore, gboolean force_quotes);

	/* Padding for future expansion */	/* Padding for future expansion */
	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. 3 change blocks.
	22 lines changed or deleted	6 lines changed or added

	gda-set.h	gda-set.h

	skipping to change at line 50	skipping to change at line 50
	GDA_SET_XML_SPEC_ERROR,	GDA_SET_XML_SPEC_ERROR,
	GDA_SET_HOLDER_NOT_FOUND_ERROR,	GDA_SET_HOLDER_NOT_FOUND_ERROR,
	GDA_SET_INVALID_ERROR	GDA_SET_INVALID_ERROR
	} GdaSetError;	} GdaSetError;

	struct _GdaSetNode {	struct _GdaSetNode {
	GdaHolder holder; / Can't be NULL */	GdaHolder holder; / Can't be NULL */
	GdaDataModel source_model; / may be NULL */	GdaDataModel source_model; / may be NULL */
	gint source_column; /* unused if @source_model is NULL */	gint source_column; /* unused if @source_model is NULL */


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	struct _GdaSetGroup {	struct _GdaSetGroup {
	GSList nodes; / list of GdaSetNode, at least one entry */	GSList nodes; / list of GdaSetNode, at least one entry */
	GdaSetSource nodes_source; / if NULL, then @nodes contains exactly one entry */	GdaSetSource nodes_source; / if NULL, then @nodes contains exactly one entry */


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	struct _GdaSetSource {	struct _GdaSetSource {
	GdaDataModel data_model; / Can't be NULL */	GdaDataModel data_model; / Can't be NULL */
	GSList nodes; / list of #GdaSetNode for which sourc e_model == @data_model */	GSList nodes; / list of #GdaSetNode for which sourc e_model == @data_model */


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	gpointer _gda_reserved3;	gpointer _gda_reserved3;
	gpointer _gda_reserved4;	gpointer _gda_reserved4;
	};	};

	#define GDA_SET_NODE(x) ((GdaSetNode *)(x))	#define GDA_SET_NODE(x) ((GdaSetNode *)(x))
	#define GDA_SET_SOURCE(x) ((GdaSetSource *)(x))	#define GDA_SET_SOURCE(x) ((GdaSetSource *)(x))
	#define GDA_SET_GROUP(x) ((GdaSetGroup *)(x))	#define GDA_SET_GROUP(x) ((GdaSetGroup *)(x))

	/* struct for the object's data */	/* struct for the object's data */
	struct _GdaSet	struct _GdaSet
	{	{
	GObject object;	GObject object;
	GdaSetPrivate *priv;	GdaSetPrivate *priv;


	/* public READ ONLY data */	/< public >/
	GSList holders; / list of GdaHolder objects */	GSList holders; / list of GdaHolder objects */
	GSList nodes_list; / list of GdaSetNode */	GSList nodes_list; / list of GdaSetNode */
	GSList sources_list; / list of GdaSetSource */	GSList sources_list; / list of GdaSetSource */
	GSList groups_list; / list of GdaSetGroup */	GSList groups_list; / list of GdaSetGroup */
	};	};

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

	skipping to change at line 136	skipping to change at line 133
	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, GError *error );	gboolean gda_set_is_valid (GdaSet set, GError *error );

	/* public data lookup functions */	/* public data lookup functions */
	GdaSetNode gda_set_get_node (GdaSet set, GdaHolder *hol der);	GdaSetNode gda_set_get_node (GdaSet set, GdaHolder *hol der);
	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 *hol der);	GdaSetSource gda_set_get_source (GdaSet set, GdaHolder *hol der);
	GdaSetGroup gda_set_get_group (GdaSet set, GdaHolder *hol der);	GdaSetGroup gda_set_get_group (GdaSet set, GdaHolder *hol der);


	/* private */
	gboolean _gda_set_validate (GdaSet set, GError *error
	);

	G_END_DECLS	G_END_DECLS

	#endif	#endif

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

	gda-sql-parser-enum-types.h	gda-sql-parser-enum-types.h


		/* Generated data (by glib-mkenums) */

	#ifndef __LIBGDA_SQL_PARSER_ENUM_TYPES_H__	#ifndef __LIBGDA_SQL_PARSER_ENUM_TYPES_H__
	#define __LIBGDA_SQL_PARSER_ENUM_TYPES_H__	#define __LIBGDA_SQL_PARSER_ENUM_TYPES_H__

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

	G_BEGIN_DECLS	G_BEGIN_DECLS
	/* enumerations from "gda-sql-parser.h" */	/* enumerations from "gda-sql-parser.h" */
	GType gda_sql_parser_error_get_type (void);	GType gda_sql_parser_error_get_type (void);

	#define GDA_TYPE_SQL_PARSER_ERROR (gda_sql_parser_error_get_type())	#define GDA_SQL_PARSER_TYPE_SQL_PARSER_ERROR (gda_sql_parser_error_get_type ())
	GType gda_sql_parser_mode_get_type (void);	GType gda_sql_parser_mode_get_type (void);

	#define GDA_TYPE_SQL_PARSER_MODE (gda_sql_parser_mode_get_type())	#define GDA_SQL_PARSER_TYPE_SQL_PARSER_MODE (gda_sql_parser_mode_get_type() )
	GType gda_sql_parser_flavour_get_type (void);	GType gda_sql_parser_flavour_get_type (void);

	#define GDA_TYPE_SQL_PARSER_FLAVOUR (gda_sql_parser_flavour_get_type())	#define GDA_SQL_PARSER_TYPE_SQL_PARSER_FLAVOUR (gda_sql_parser_flavour_get_ type())
	/* enumerations from "gda-statement-struct-decl.h" */	/* enumerations from "gda-statement-struct-decl.h" */

	GType gda_sql_error_get_type (void);	GType gda_sql_error_type_get_type (void);
	#define GDA_TYPE_SQL_ERROR (gda_sql_error_get_type())	#define GDA_SQL_PARSER_TYPE_SQL_ERROR_TYPE (gda_sql_error_type_get_type())
	GType gda_sql_statement_type_get_type (void);	GType gda_sql_statement_type_get_type (void);

	#define GDA_TYPE_SQL_STATEMENT_TYPE (gda_sql_statement_type_get_type())	#define GDA_SQL_PARSER_TYPE_SQL_STATEMENT_TYPE (gda_sql_statement_type_get_ type())
	GType gda_sql_any_part_type_get_type (void);	GType gda_sql_any_part_type_get_type (void);

	#define GDA_TYPE_SQL_ANY_PART_TYPE (gda_sql_any_part_type_get_type())	#define GDA_SQL_PARSER_TYPE_SQL_ANY_PART_TYPE (gda_sql_any_part_type_get_ty pe())
	/* enumerations from "gda-statement-struct-compound.h" */	/* enumerations from "gda-statement-struct-compound.h" */
	GType gda_sql_statement_compound_type_get_type (void);	GType gda_sql_statement_compound_type_get_type (void);

	#define GDA_TYPE_SQL_STATEMENT_COMPOUND_TYPE (gda_sql_statement_compound_ty pe_get_type())	#define GDA_SQL_PARSER_TYPE_SQL_STATEMENT_COMPOUND_TYPE (gda_sql_statement_ compound_type_get_type())
	/* enumerations from "gda-statement-struct-parts.h" */	/* enumerations from "gda-statement-struct-parts.h" */
	GType gda_sql_operator_type_get_type (void);	GType gda_sql_operator_type_get_type (void);

	#define GDA_TYPE_SQL_OPERATOR_TYPE (gda_sql_operator_type_get_type())	#define GDA_SQL_PARSER_TYPE_SQL_OPERATOR_TYPE (gda_sql_operator_type_get_ty pe())
	GType gda_sql_select_join_type_get_type (void);	GType gda_sql_select_join_type_get_type (void);

	#define GDA_TYPE_SQL_SELECT_JOIN_TYPE (gda_sql_select_join_type_get_type())	#define GDA_SQL_PARSER_TYPE_SQL_SELECT_JOIN_TYPE (gda_sql_select_join_type_ get_type())
	G_END_DECLS	G_END_DECLS

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


	/* Content designed to maitain API/ABI */	/* Generated data ends here */

	#ifndef __LIBGDA_SQL_PARSER_ENUM_TYPES_KEEPAPI_H__
	#define __LIBGDA_SQL_PARSER_ENUM_TYPES_KEEPAPI_H__

	GType gda_sql_error_type_get_type (void);
	#define GDA_SQL_PARSER_TYPE_SQL_ERROR_TYPE (gda_sql_error_type_get_type())

	#define GDA_SQL_PARSER_TYPE_SQL_PARSER_ERROR (gda_sql_parser_error_get_type
	())
	#define GDA_SQL_PARSER_TYPE_SQL_PARSER_MODE (gda_sql_parser_mode_get_type()
	)
	#define GDA_SQL_PARSER_TYPE_SQL_PARSER_FLAVOUR (gda_sql_parser_flavour_get_
	type())
	#define GDA_SQL_PARSER_TYPE_SQL_ERROR (gda_sql_error_get_type())
	#define GDA_SQL_PARSER_TYPE_SQL_STATEMENT_TYPE (gda_sql_statement_type_get_
	type())
	#define GDA_SQL_PARSER_TYPE_SQL_ANY_PART_TYPE (gda_sql_any_part_type_get_ty
	pe())
	#define GDA_SQL_PARSER_TYPE_SQL_STATEMENT_COMPOUND_TYPE (gda_sql_statement_
	compound_type_get_type())
	#define GDA_SQL_PARSER_TYPE_SQL_OPERATOR_TYPE (gda_sql_operator_type_get_ty
	pe())
	#define GDA_SQL_PARSER_TYPE_SQL_SELECT_JOIN_TYPE (gda_sql_select_join_type_
	get_type())

	#endif

End of changes. 11 change blocks.
	10 lines changed or deleted	12 lines changed or added

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

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

	#ifndef _GDA_STATEMENT_STRUCT_COMPOUND_H_	#ifndef _GDA_STATEMENT_STRUCT_COMPOUND_H_
	#define _GDA_STATEMENT_STRUCT_COMPOUND_H_	#define _GDA_STATEMENT_STRUCT_COMPOUND_H_

	#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 <sql-parser/gda-statement-struct-select.h>	#include <sql-parser/gda-statement-struct-select.h>


	G_BEGIN_DECLS

	/*	/*
	* Kinds	* Kinds
	*/	*/
	typedef enum {	typedef enum {
	GDA_SQL_STATEMENT_COMPOUND_UNION,	GDA_SQL_STATEMENT_COMPOUND_UNION,
	GDA_SQL_STATEMENT_COMPOUND_UNION_ALL,	GDA_SQL_STATEMENT_COMPOUND_UNION_ALL,
	GDA_SQL_STATEMENT_COMPOUND_INTERSECT,	GDA_SQL_STATEMENT_COMPOUND_INTERSECT,
	GDA_SQL_STATEMENT_COMPOUND_INTERSECT_ALL,	GDA_SQL_STATEMENT_COMPOUND_INTERSECT_ALL,
	GDA_SQL_STATEMENT_COMPOUND_EXCEPT,	GDA_SQL_STATEMENT_COMPOUND_EXCEPT,
	GDA_SQL_STATEMENT_COMPOUND_EXCEPT_ALL	GDA_SQL_STATEMENT_COMPOUND_EXCEPT_ALL

	skipping to change at line 75	skipping to change at line 73
	*/	*/
	gint _gda_sql_statement_compound_get_n_cols (GdaSqlStatementCompound * compound, GError **error);	gint _gda_sql_statement_compound_get_n_cols (GdaSqlStatementCompound * compound, GError **error);
	GdaSqlAnyPart * _gda_sql_statement_compound_reduce (GdaSqlAnyPart *compound _or_select);	GdaSqlAnyPart * _gda_sql_statement_compound_reduce (GdaSqlAnyPart *compound _or_select);

	/*	/*
	* Functions used by the parser	* Functions used by the parser
	*/	*/
	void gda_sql_statement_compound_set_type (GdaSqlStatement *stmt, GdaSqlStat ementCompoundType type);	void gda_sql_statement_compound_set_type (GdaSqlStatement *stmt, GdaSqlStat ementCompoundType type);
	void gda_sql_statement_compound_take_stmt (GdaSqlStatement stmt, GdaSqlSta tement s);	void gda_sql_statement_compound_take_stmt (GdaSqlStatement stmt, GdaSqlSta tement s);


	G_END_DECLS

	#endif	#endif

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

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

	skipping to change at line 29	skipping to change at line 29

	#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-decl.h>
	#include <libgda/gda-meta-store.h>	#include <libgda/gda-meta-store.h>
	#include <libgda/gda-meta-struct.h>	#include <libgda/gda-meta-struct.h>


	G_BEGIN_DECLS

	/* 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_MISSING_IDENTIFIER_ERROR,	GDA_SQL_MISSING_IDENTIFIER_ERROR,
	GDA_SQL_VALIDATION_ERROR	GDA_SQL_VALIDATION_ERROR

	} GdaSqlError;	} GdaSqlErrorType;
	typedef GdaSqlError 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;
	typedef struct _GdaSqlStatementInsert GdaSqlStatementInsert;	typedef struct _GdaSqlStatementInsert GdaSqlStatementInsert;

	skipping to change at line 171	skipping to change at line 168
	GdaMetaStore *store;	GdaMetaStore *store;
	GdaMetaStruct *mstruct;	GdaMetaStruct *mstruct;

	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	gpointer _gda_reserved3;	gpointer _gda_reserved3;
	gpointer _gda_reserved4;	gpointer _gda_reserved4;
	} GdaSqlStatementCheckValidityData;	} GdaSqlStatementCheckValidityData;


	G_END_DECLS

	#endif	#endif

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

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

	skipping to change at line 29	skipping to change at line 29

	#ifndef _GDA_STATEMENT_STRUCT_DELETE_H_	#ifndef _GDA_STATEMENT_STRUCT_DELETE_H_
	#define _GDA_STATEMENT_STRUCT_DELETE_H_	#define _GDA_STATEMENT_STRUCT_DELETE_H_

	#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 <sql-parser/gda-statement-struct-select.h>	#include <sql-parser/gda-statement-struct-select.h>
	#include <sql-parser/gda-statement-struct-parts.h>	#include <sql-parser/gda-statement-struct-parts.h>


	G_BEGIN_DECLS

	/*	/*
	* Structure definition	* Structure definition
	*/	*/
	struct _GdaSqlStatementDelete {	struct _GdaSqlStatementDelete {
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GdaSqlTable *table;	GdaSqlTable *table;
	GdaSqlExpr *cond;	GdaSqlExpr *cond;

	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;

	skipping to change at line 55	skipping to change at line 53
	* Common operations	* Common operations
	*/	*/
	GdaSqlStatementContentsInfo *_gda_sql_statement_delete_get_infos (void);	GdaSqlStatementContentsInfo *_gda_sql_statement_delete_get_infos (void);

	/*	/*
	* Functions used by the parser	* Functions used by the parser
	*/	*/
	void gda_sql_statement_delete_take_table_name (GdaSqlStatement stmt, GValu e value);	void gda_sql_statement_delete_take_table_name (GdaSqlStatement stmt, GValu e value);
	void gda_sql_statement_delete_take_condition (GdaSqlStatement stmt, GdaSql Expr cond);	void gda_sql_statement_delete_take_condition (GdaSqlStatement stmt, GdaSql Expr cond);


	G_END_DECLS

	#endif	#endif

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

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

	skipping to change at line 29	skipping to change at line 29

	#ifndef _GDA_STATEMENT_STRUCT_INSERT_H_	#ifndef _GDA_STATEMENT_STRUCT_INSERT_H_
	#define _GDA_STATEMENT_STRUCT_INSERT_H_	#define _GDA_STATEMENT_STRUCT_INSERT_H_

	#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 <sql-parser/gda-statement-struct-select.h>	#include <sql-parser/gda-statement-struct-select.h>
	#include <sql-parser/gda-statement-struct-parts.h>	#include <sql-parser/gda-statement-struct-parts.h>


	G_BEGIN_DECLS

	/*	/*
	* Structure definition	* Structure definition
	*/	*/
	struct _GdaSqlStatementInsert {	struct _GdaSqlStatementInsert {
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	gchar on_conflict; / conflict resolution clause * /	gchar on_conflict; / conflict resolution clause * /
	GdaSqlTable *table;	GdaSqlTable *table;
	GSList fields_list; / list of GdaSqlField structur es */	GSList fields_list; / list of GdaSqlField structur es */
	GSList values_list; / list of list of GdaSqlExpr * /	GSList values_list; / list of list of GdaSqlExpr * /
	GdaSqlAnyPart select; / SELECT OR COMPOUND statements: Gd aSqlStatementSelect or GdaSqlStatementCompound */	GdaSqlAnyPart select; / SELECT OR COMPOUND statements: Gd aSqlStatementSelect or GdaSqlStatementCompound */

	skipping to change at line 63	skipping to change at line 61
	* Functions used by the parser	* Functions used by the parser
	*/	*/
	void gda_sql_statement_insert_take_table_name (GdaSqlStatement stmt, GValu e value);	void gda_sql_statement_insert_take_table_name (GdaSqlStatement stmt, GValu e value);
	void gda_sql_statement_insert_take_on_conflict (GdaSqlStatement stmt, GVal ue value);	void gda_sql_statement_insert_take_on_conflict (GdaSqlStatement stmt, GVal ue value);
	void gda_sql_statement_insert_take_fields_list (GdaSqlStatement stmt, GSLi st list);	void gda_sql_statement_insert_take_fields_list (GdaSqlStatement stmt, GSLi st list);
	void gda_sql_statement_insert_take_1_values_list (GdaSqlStatement stmt, GS List list);	void gda_sql_statement_insert_take_1_values_list (GdaSqlStatement stmt, GS List list);
	void gda_sql_statement_insert_take_extra_values_list (GdaSqlStatement stmt , GSList list);	void gda_sql_statement_insert_take_extra_values_list (GdaSqlStatement stmt , GSList list);

	void gda_sql_statement_insert_take_select (GdaSqlStatement stmt, GdaSqlSta tement select);	void gda_sql_statement_insert_take_select (GdaSqlStatement stmt, GdaSqlSta tement select);


	G_END_DECLS

	#endif	#endif

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

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

	skipping to change at line 30	skipping to change at line 30
	#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>	#include <libgda/gda-meta-struct.h>


	G_BEGIN_DECLS

	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;
	typedef struct _GdaSqlSelectFrom GdaSqlSelectFrom;	typedef struct _GdaSqlSelectFrom GdaSqlSelectFrom;

	skipping to change at line 58	skipping to change at line 56
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GValue *value;	GValue *value;
	GdaSqlParamSpec *param_spec;	GdaSqlParamSpec *param_spec;
	GdaSqlFunction *func;	GdaSqlFunction *func;
	GdaSqlOperation *cond;	GdaSqlOperation *cond;
	GdaSqlAnyPart select; / SELECT OR COMPOUND statements: GdaSqlSta tementSelect or GdaSqlStatementCompound */	GdaSqlAnyPart select; / SELECT OR COMPOUND statements: GdaSqlSta tementSelect or GdaSqlStatementCompound */
	GdaSqlCase *case_s;	GdaSqlCase *case_s;

	gchar *cast_as;	gchar *cast_as;


	gpointer value_is_ident; /* pointer to a boolean to keep ABI
	from 4.0.
	* Non NULL if @value represents an
	SQL identifier
	* Mem in _NOT_ allocated!
	*/

	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */

		gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	GdaSqlExpr gda_sql_expr_new (GdaSqlAnyPart parent);	GdaSqlExpr gda_sql_expr_new (GdaSqlAnyPart parent);
	void gda_sql_expr_free (GdaSqlExpr *expr);	void gda_sql_expr_free (GdaSqlExpr *expr);
	GdaSqlExpr gda_sql_expr_copy (GdaSqlExpr expr);	GdaSqlExpr gda_sql_expr_copy (GdaSqlExpr expr);
	gchar gda_sql_expr_serialize (GdaSqlExpr expr);	gchar gda_sql_expr_serialize (GdaSqlExpr expr);
	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);

	skipping to change at line 86	skipping to change at line 79
	/*	/*
	* 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 */	/* validity check with a connection */
	GdaMetaTableColumn *validity_meta_table_column;	GdaMetaTableColumn *validity_meta_table_column;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	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);

	skipping to change at line 111	skipping to change at line 103
	* Any table	* Any table
	*/	*/
	struct _GdaSqlTable	struct _GdaSqlTable
	{	{
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	gchar *table_name;	gchar *table_name;

	/* validity check with a connection */	/* validity check with a connection */
	GdaMetaDbObject *validity_meta_object;	GdaMetaDbObject *validity_meta_object;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	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);

	skipping to change at line 133	skipping to change at line 124
	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;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	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) ;

	skipping to change at line 191	skipping to change at line 181
	GDA_SQL_OPERATOR_TYPE_BITAND,	GDA_SQL_OPERATOR_TYPE_BITAND,
	GDA_SQL_OPERATOR_TYPE_BITOR,	GDA_SQL_OPERATOR_TYPE_BITOR,
	GDA_SQL_OPERATOR_TYPE_BITNOT	GDA_SQL_OPERATOR_TYPE_BITNOT
	} GdaSqlOperatorType;	} GdaSqlOperatorType;

	struct _GdaSqlOperation {	struct _GdaSqlOperation {
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GdaSqlOperatorType operator_type;	GdaSqlOperatorType operator_type;
	GSList *operands;	GSList *operands;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	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 (GdaSqlOperatorType op);	const gchar *gda_sql_operation_operator_to_string (GdaSqlOperatorType op);

	skipping to change at line 215	skipping to change at line 204
	* 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;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

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


	skipping to change at line 241	skipping to change at line 229
	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;

	/* validity check with a connection */	/* validity check with a connection */
	GdaMetaDbObject *validity_meta_object;	GdaMetaDbObject *validity_meta_object;
	GdaMetaTableColumn *validity_meta_table_column;	GdaMetaTableColumn *validity_meta_table_column;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	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);

	skipping to change at line 270	skipping to change at line 257
	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;

	/* validity check with a connection */	/* validity check with a connection */
	GdaMetaDbObject *validity_meta_object;	GdaMetaDbObject *validity_meta_object;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	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);

	skipping to change at line 303	skipping to change at line 289
	GDA_SQL_SELECT_JOIN_LEFT,	GDA_SQL_SELECT_JOIN_LEFT,
	GDA_SQL_SELECT_JOIN_RIGHT,	GDA_SQL_SELECT_JOIN_RIGHT,
	GDA_SQL_SELECT_JOIN_FULL	GDA_SQL_SELECT_JOIN_FULL
	} GdaSqlSelectJoinType;	} GdaSqlSelectJoinType;
	struct _GdaSqlSelectJoin	struct _GdaSqlSelectJoin
	{	{
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GdaSqlSelectJoinType type;	GdaSqlSelectJoinType type;
	gint position; /* between a target at (pos < @posit ion) and the one @position */	gint position; /* between a target at (pos < @posit ion) and the one @position */
	GdaSqlExpr *expr;	GdaSqlExpr *expr;

	GSList *use;	GSList use; / list of GdaSqlField pointers */


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	GdaSqlSelectJoin gda_sql_select_join_new (GdaSqlAnyPart paren t);	GdaSqlSelectJoin gda_sql_select_join_new (GdaSqlAnyPart paren t);
	void gda_sql_select_join_free (GdaSqlSelectJoin *jo in);	void gda_sql_select_join_free (GdaSqlSelectJoin *jo in);
	GdaSqlSelectJoin gda_sql_select_join_copy (GdaSqlSelectJoin jo in);	GdaSqlSelectJoin gda_sql_select_join_copy (GdaSqlSelectJoin jo in);
	gchar gda_sql_select_join_serialize (GdaSqlSelectJoin jo in);	gchar gda_sql_select_join_serialize (GdaSqlSelectJoin jo in);


	skipping to change at line 327	skipping to change at line 312

	/*	/*
	* Any FROM ... in a SELECT statement	* Any FROM ... in a SELECT statement
	*/	*/
	struct _GdaSqlSelectFrom	struct _GdaSqlSelectFrom
	{	{
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GSList *targets;	GSList *targets;
	GSList *joins;	GSList *joins;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	GdaSqlSelectFrom gda_sql_select_from_new (GdaSqlAnyPart paren t);	GdaSqlSelectFrom gda_sql_select_from_new (GdaSqlAnyPart paren t);
	void gda_sql_select_from_free (GdaSqlSelectFrom *fr om);	void gda_sql_select_from_free (GdaSqlSelectFrom *fr om);
	GdaSqlSelectFrom gda_sql_select_from_copy (GdaSqlSelectFrom fr om);	GdaSqlSelectFrom gda_sql_select_from_copy (GdaSqlSelectFrom fr om);
	gchar gda_sql_select_from_serialize (GdaSqlSelectFrom fr om);	gchar gda_sql_select_from_serialize (GdaSqlSelectFrom fr om);


	skipping to change at line 351	skipping to change at line 335
	/*	/*
	* Any expression in a SELECT ... after the ORDER BY	* Any expression in a SELECT ... after the ORDER BY
	*/	*/
	struct _GdaSqlSelectOrder	struct _GdaSqlSelectOrder
	{	{
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GdaSqlExpr *expr;	GdaSqlExpr *expr;
	gboolean asc;	gboolean asc;
	gchar *collation_name;	gchar *collation_name;


	/< private >/
	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;
	};	};

	GdaSqlSelectOrder gda_sql_select_order_new (GdaSqlAnyPart pare nt);	GdaSqlSelectOrder gda_sql_select_order_new (GdaSqlAnyPart pare nt);
	void gda_sql_select_order_free (GdaSqlSelectOrder * order);	void gda_sql_select_order_free (GdaSqlSelectOrder * order);
	GdaSqlSelectOrder gda_sql_select_order_copy (GdaSqlSelectOrder order);	GdaSqlSelectOrder gda_sql_select_order_copy (GdaSqlSelectOrder order);
	gchar gda_sql_select_order_serialize (GdaSqlSelectOrder order);	gchar gda_sql_select_order_serialize (GdaSqlSelectOrder order);


	G_END_DECLS

	#endif	#endif

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

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

	skipping to change at line 26	skipping to change at line 26
	* 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_PSPEC_H	#ifndef _GDA_STATEMENT_STRUCT_PSPEC_H
	#define _GDA_STATEMENT_STRUCT_PSPEC_H	#define _GDA_STATEMENT_STRUCT_PSPEC_H

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


	G_BEGIN_DECLS

	typedef struct _GdaSqlParamSpec GdaSqlParamSpec;	typedef struct _GdaSqlParamSpec GdaSqlParamSpec;

	/*	/*
	* Structure to hold one parameter specification	* Structure to hold one parameter specification
	*/	*/
	struct _GdaSqlParamSpec	struct _GdaSqlParamSpec
	{	{
	gchar *name;	gchar *name;
	gchar *descr;	gchar *descr;
	gboolean is_param;	gboolean is_param;

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


	G_END_DECLS

	#endif	#endif

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

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

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

	#ifndef _GDA_STATEMENT_STRUCT_SELECT_H_	#ifndef _GDA_STATEMENT_STRUCT_SELECT_H_
	#define _GDA_STATEMENT_STRUCT_SELECT_H_	#define _GDA_STATEMENT_STRUCT_SELECT_H_

	#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 <sql-parser/gda-statement-struct-parts.h>	#include <sql-parser/gda-statement-struct-parts.h>


	G_BEGIN_DECLS

	/*	/*
	* Structure definition	* Structure definition
	*/	*/
	struct _GdaSqlStatementSelect {	struct _GdaSqlStatementSelect {
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	gboolean distinct;	gboolean distinct;
	GdaSqlExpr *distinct_expr;	GdaSqlExpr *distinct_expr;

	GSList expr_list; / list of GdaSqlSelectField pointers */	GSList expr_list; / list of GdaSqlSelectField pointers */
	GdaSqlSelectFrom *from;	GdaSqlSelectFrom *from;

	skipping to change at line 73	skipping to change at line 71
	* Functions used by the parser	* Functions used by the parser
	*/	*/
	void gda_sql_statement_select_take_distinct (GdaSqlStatement stmt, gboolea n distinct, GdaSqlExpr distinct_expr);	void gda_sql_statement_select_take_distinct (GdaSqlStatement stmt, gboolea n distinct, GdaSqlExpr distinct_expr);
	void gda_sql_statement_select_take_expr_list (GdaSqlStatement stmt, GSList expr_list);	void gda_sql_statement_select_take_expr_list (GdaSqlStatement stmt, GSList expr_list);
	void gda_sql_statement_select_take_from (GdaSqlStatement stmt, GdaSqlSelec tFrom from);	void gda_sql_statement_select_take_from (GdaSqlStatement stmt, GdaSqlSelec tFrom from);
	void gda_sql_statement_select_take_where_cond (GdaSqlStatement stmt, GdaSq lExpr expr);	void gda_sql_statement_select_take_where_cond (GdaSqlStatement stmt, GdaSq lExpr expr);
	void gda_sql_statement_select_take_group_by (GdaSqlStatement stmt, GSList group_by);	void gda_sql_statement_select_take_group_by (GdaSqlStatement stmt, GSList group_by);
	void gda_sql_statement_select_take_having_cond (GdaSqlStatement stmt, GdaS qlExpr expr);	void gda_sql_statement_select_take_having_cond (GdaSqlStatement stmt, GdaS qlExpr expr);
	void gda_sql_statement_select_take_order_by (GdaSqlStatement stmt, GSList order_by);	void gda_sql_statement_select_take_order_by (GdaSqlStatement stmt, GSList order_by);
	void gda_sql_statement_select_take_limits (GdaSqlStatement stmt, GdaSqlExp r count, GdaSqlExpr *offset);	void gda_sql_statement_select_take_limits (GdaSqlStatement stmt, GdaSqlExp r count, GdaSqlExpr *offset);


	G_END_DECLS

	#endif	#endif

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

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

	skipping to change at line 29	skipping to change at line 29

	#ifndef _GDA_STATEMENT_STRUCT_TRANS_H_	#ifndef _GDA_STATEMENT_STRUCT_TRANS_H_
	#define _GDA_STATEMENT_STRUCT_TRANS_H_	#define _GDA_STATEMENT_STRUCT_TRANS_H_

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


	G_BEGIN_DECLS

	/*	/*
	* Structure definition	* Structure definition
	*/	*/
	struct _GdaSqlStatementTransaction {	struct _GdaSqlStatementTransaction {
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GdaTransactionIsolation isolation_level;	GdaTransactionIsolation isolation_level;
	gchar trans_mode; / DEFERRED, IMMEDIATE, EXCLUSIV E, READ_WRITE, READ_ONLY */	gchar trans_mode; / DEFERRED, IMMEDIATE, EXCLUSIV E, READ_WRITE, READ_ONLY */
	gchar *trans_name;	gchar *trans_name;

	/* Padding for future expansion */	/* Padding for future expansion */

	skipping to change at line 63	skipping to change at line 61
	GdaSqlStatementContentsInfo *_gda_sql_statement_rollback_savepoint_get_info s (void);	GdaSqlStatementContentsInfo *_gda_sql_statement_rollback_savepoint_get_info s (void);
	GdaSqlStatementContentsInfo *_gda_sql_statement_delete_savepoint_get_infos (void);	GdaSqlStatementContentsInfo *_gda_sql_statement_delete_savepoint_get_infos (void);

	/*	/*
	* Functions used by the parser	* Functions used by the parser
	*/	*/
	void gda_sql_statement_trans_take_mode (GdaSqlStatement stmt, GValue va lue);	void gda_sql_statement_trans_take_mode (GdaSqlStatement stmt, GValue va lue);
	void gda_sql_statement_trans_set_isol_level (GdaSqlStatement *stmt, GdaTr ansactionIsolation level);	void gda_sql_statement_trans_set_isol_level (GdaSqlStatement *stmt, GdaTr ansactionIsolation level);
	void gda_sql_statement_trans_take_name (GdaSqlStatement stmt, GValue va lue);	void gda_sql_statement_trans_take_name (GdaSqlStatement stmt, GValue va lue);


	G_END_DECLS

	#endif	#endif

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

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

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

	#ifndef _GDA_STATEMENT_STRUCT_UNKNOWN_H_	#ifndef _GDA_STATEMENT_STRUCT_UNKNOWN_H_
	#define _GDA_STATEMENT_STRUCT_UNKNOWN_H_	#define _GDA_STATEMENT_STRUCT_UNKNOWN_H_

	#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 <sql-parser/gda-statement-struct-parts.h>	#include <sql-parser/gda-statement-struct-parts.h>


	G_BEGIN_DECLS

	/*	/*
	* Structure definition	* Structure definition
	*/	*/
	struct _GdaSqlStatementUnknown {	struct _GdaSqlStatementUnknown {
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	GSList expressions; / list of GdaSqlExpr pointers */	GSList expressions; / list of GdaSqlExpr pointers */

	/* Padding for future expansion */	/* Padding for future expansion */
	gpointer _gda_reserved1;	gpointer _gda_reserved1;
	gpointer _gda_reserved2;	gpointer _gda_reserved2;

	skipping to change at line 52	skipping to change at line 50
	/*	/*
	* Common operations	* Common operations
	*/	*/
	GdaSqlStatementContentsInfo *_gda_sql_statement_unknown_get_infos (void);	GdaSqlStatementContentsInfo *_gda_sql_statement_unknown_get_infos (void);

	/*	/*
	* Functions used by the parser	* Functions used by the parser
	*/	*/
	void gda_sql_statement_unknown_take_expressions (GdaSqlStatement stmt, GSL ist expressions);	void gda_sql_statement_unknown_take_expressions (GdaSqlStatement stmt, GSL ist expressions);


	G_END_DECLS

	#endif	#endif

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

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

	skipping to change at line 29	skipping to change at line 29

	#ifndef _GDA_STATEMENT_STRUCT_UPDATE_H_	#ifndef _GDA_STATEMENT_STRUCT_UPDATE_H_
	#define _GDA_STATEMENT_STRUCT_UPDATE_H_	#define _GDA_STATEMENT_STRUCT_UPDATE_H_

	#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 <sql-parser/gda-statement-struct-select.h>	#include <sql-parser/gda-statement-struct-select.h>
	#include <sql-parser/gda-statement-struct-parts.h>	#include <sql-parser/gda-statement-struct-parts.h>


	G_BEGIN_DECLS

	/*	/*
	* Structure definition	* Structure definition
	*/	*/
	struct _GdaSqlStatementUpdate {	struct _GdaSqlStatementUpdate {
	GdaSqlAnyPart any;	GdaSqlAnyPart any;
	gchar on_conflict; / conflict resolution clause */	gchar on_conflict; / conflict resolution clause */
	GdaSqlTable *table;	GdaSqlTable *table;
	GSList fields_list; / list of GdaSqlField pointers */	GSList fields_list; / list of GdaSqlField pointers */
	GSList expr_list; / list of GdaSqlExpr pointers */	GSList expr_list; / list of GdaSqlExpr pointers */
	GdaSqlExpr *cond;	GdaSqlExpr *cond;

	skipping to change at line 60	skipping to change at line 58
	GdaSqlStatementContentsInfo *_gda_sql_statement_update_get_infos (void);	GdaSqlStatementContentsInfo *_gda_sql_statement_update_get_infos (void);

	/*	/*
	* Functions used by the parser	* Functions used by the parser
	*/	*/
	void gda_sql_statement_update_take_table_name (GdaSqlStatement stmt, GValu e value);	void gda_sql_statement_update_take_table_name (GdaSqlStatement stmt, GValu e value);
	void gda_sql_statement_update_take_on_conflict (GdaSqlStatement stmt, GVal ue value);	void gda_sql_statement_update_take_on_conflict (GdaSqlStatement stmt, GVal ue value);
	void gda_sql_statement_update_take_condition (GdaSqlStatement stmt, GdaSql Expr cond);	void gda_sql_statement_update_take_condition (GdaSqlStatement stmt, GdaSql Expr cond);
	void gda_sql_statement_update_take_set_value (GdaSqlStatement stmt, GValue fname, GdaSqlExpr *expr);	void gda_sql_statement_update_take_set_value (GdaSqlStatement stmt, GValue fname, GdaSqlExpr *expr);


	G_END_DECLS

	#endif	#endif

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

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

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


	G_BEGIN_DECLS

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

		gchar gda_sql_identifier_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 _split_identifier_string (gchar str, gchar remain, gchar *las
	t);


	#ifndef GDA_DISABLE_DEPRECATED	gboolean _string_is_identifier (const gchar *str);
	gboolean gda_sql_identifier_needs_quotes (const gchar *str);	gboolean gda_sql_identifier_needs_quotes (const gchar *str);

	gchar gda_sql_identifier_add_quotes (const gchar str);	gboolean _split_identifier_string (gchar str, gchar remain, gchar *las t);
	gchar gda_sql_identifier_remove_quotes (gchar str);	gchar gda_sql_identifier_remove_quotes (gchar str);

	#endif

	/* 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);


	G_END_DECLS

	#endif	#endif

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

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

	* Copyright (C) 1998 - 2009 The GNOME Foundation.	* Copyright (C) 1998 - 2008 The GNOME Foundation.
	*	*
	* AUTHORS:	* AUTHORS:
	* Rodrigo Moya <rodrigo@gnome-db.org>	* Rodrigo Moya <rodrigo@gnome-db.org>
	* Vivien Malerba <malerba@gnome-db.org>	* Vivien Malerba <malerba@gnome-db.org>
	*	*
	* This Library is free software; you can redistribute it and/or	* This Library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Library General Public License as	* modify it under the terms of the GNU Library General Public License as
	* published by the Free Software Foundation; either version 2 of the	* published by the Free Software Foundation; either version 2 of the
	* License, or (at your option) any later version.	* License, or (at your option) any later version.
	*	*

	skipping to change at line 51	skipping to change at line 51

	/*	/*
	* 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);	guint gda_identifier_hash (const gchar *id);
	gboolean gda_identifier_equal (const gchar id1, const gchar id2);	gboolean gda_identifier_equal (const gchar id1, const gchar id2);
	gchar *gda_completion_list_get (GdaConnection cnc, const gchar *sql, gint start, gint end);	gchar *gda_completion_list_get (GdaConnection cnc, const gchar *sql, gint start, gint end);
	gchar *gda_sql_identifier_split (const gchar id);	gchar *gda_sql_identifier_split (const gchar id);

	gchar gda_sql_identifier_quote (const gchar id, GdaConnection *cnc,
	GdaServerProvider *prov,
	gboolean meta_store_convention, gbool
	ean force_quotes);

	/*	/*
	* Param & model utilities	* Param & model utilities
	*/	*/
	gboolean gda_utility_check_data_model (GdaDataModel *model, gint nbcols , ...);	gboolean gda_utility_check_data_model (GdaDataModel *model, gint nbcols , ...);
	gboolean gda_utility_data_model_dump_data_to_xml (GdaDataModel *model, xmlNodePtr parent,	gboolean gda_utility_data_model_dump_data_to_xml (GdaDataModel *model, xmlNodePtr parent,
	const gint cols, gint nb_cols , const gint rows, gint nb_rows,	const gint cols, gint nb_cols , const gint rows, gint nb_rows,
	gboolean use_col_ids);	gboolean use_col_ids);
	const gchar gda_utility_data_model_find_column_description (GdaDataSelect model, const gchar *field_name);	const gchar gda_utility_data_model_find_column_description (GdaDataSelect model, const gchar *field_name);
	gboolean gda_utility_holder_load_attributes (GdaHolder holder, xmlNode Ptr node, GSList sources, GError **error);	gboolean gda_utility_holder_load_attributes (GdaHolder holder, xmlNode Ptr node, GSList sources, GError **error);

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

	gda-value.h	gda-value.h

	skipping to change at line 98	skipping to change at line 98
	gushort second;	gushort second;
	gulong fraction;	gulong fraction;
	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;


	/**
	* GdaBlob
	* @data: data buffer, as a #GdaBinary
	* @op: a pointer to a #GdaBlopOp, or %NULL
	*
	* Represents some binary data, accessed through a #GdaBlobOp object.
	* @op is generally set up by database providers when giving access to an e
	xisting BLOB in
	* a database, but can be modified if needed using gda_blob_set_op().
	*/
	typedef struct {	typedef struct {
	GdaBinary data;	GdaBinary data;

	GdaBlobOp *op;	GdaBlobOp op; / set up by providers if the GdaBlob is linked to so
		mething actually existing in the database,
		useable by anyone */
	} GdaBlob;	} GdaBlob;

	typedef GList GdaValueList;	typedef GList GdaValueList;

	#define gda_value_isa(value, type) (G_VALUE_HOLDS(value, type))	#define gda_value_isa(value, type) (G_VALUE_HOLDS(value, type))

	GValue *gda_value_new (GType type);	GValue *gda_value_new (GType type);

	GValue gda_value_new_binary (const guchar val, glong size);	GValue gda_value_new_binary (const guchar val, glong size);
	GValue gda_value_new_blob (const guchar val, gl ong size);	GValue gda_value_new_blob (const guchar val, gl ong size);

	skipping to change at line 176	skipping to change at line 168

	gchar gda_binary_to_string (const GdaBinary bi n, guint maxlen);	gchar gda_binary_to_string (const GdaBinary bi n, guint maxlen);
	GdaBinary gda_string_to_binary (const gchar str);	GdaBinary gda_string_to_binary (const gchar str);

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

	/* Custom data types */	/* Custom data types */

	GType gda_numeric_get_type (void) G_GNUC_CONST;	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) G_GNUC_CONST;	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) G_GNUC_CONS T;	GType gda_timestamp_get_type (void) G_GNUC_CONS T;

	gpointer gda_timestamp_copy (gpointer boxed);	gpointer gda_timestamp_copy (gpointer boxed) G_GNU
	void gda_timestamp_free (gpointer boxed);	C_CONST;
		void gda_timestamp_free (gpointer boxed) G_GNU
		C_CONST;

	GType gda_geometricpoint_get_type (void) G_GNUC _CONST;	GType gda_geometricpoint_get_type (void) G_GNUC _CONST;

	gpointer gda_geometricpoint_copy (gpointer boxed);	gpointer gda_geometricpoint_copy (gpointer boxed)
	void gda_geometricpoint_free (gpointer boxed);	G_GNUC_CONST;
		void gda_geometricpoint_free (gpointer boxed)
		G_GNUC_CONST;

	GType gda_binary_get_type (void) G_GNUC_CONST;	GType gda_binary_get_type (void) G_GNUC_CONST;

	gpointer gda_binary_copy (gpointer boxed);	gpointer gda_binary_copy (gpointer boxed) G_GNUC_C
	void gda_binary_free (gpointer boxed);	ONST;
		void gda_binary_free (gpointer boxed) G_GNUC_C
		ONST;

	GType gda_blob_get_type (void) G_GNUC_CONST;	GType gda_blob_get_type (void) G_GNUC_CONST;

	gpointer gda_blob_copy (gpointer boxed);	gpointer gda_blob_copy (gpointer boxed) G_GNUC_CON
	void gda_blob_free (gpointer boxed);	ST;
		void gda_blob_free (gpointer boxed) G_GNUC_CON
		ST;
	void gda_blob_set_op (GdaBlob blob, GdaBlobOp op);	void gda_blob_set_op (GdaBlob blob, GdaBlobOp op);

	GType gda_value_list_get_type (void) G_GNUC_CON ST;	GType gda_value_list_get_type (void) G_GNUC_CON ST;
	GType gda_short_get_type (void) G_GNUC_CONST;	GType gda_short_get_type (void) G_GNUC_CONST;
	GType gda_ushort_get_type (void) G_GNUC_CONST;	GType gda_ushort_get_type (void) G_GNUC_CONST;

	/* Helper macros */	/* Helper macros */
	#define gda_value_new_null() (g_new0 (GValue, 1))	#define gda_value_new_null() (g_new0 (GValue, 1))

	G_END_DECLS	G_END_DECLS

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

	libgda.h	libgda.h

	skipping to change at line 74	skipping to change at line 74
	#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>
	#include <libgda/gda-meta-store.h>	#include <libgda/gda-meta-store.h>
	#include <libgda/gda-meta-struct.h>	#include <libgda/gda-meta-struct.h>

	#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-tree.h>
		#include <libgda/gda-tree-manager.h>
		#include <libgda/gda-tree-mgr-columns.h>
		#include <libgda/gda-tree-mgr-label.h>
		#include <libgda/gda-tree-mgr-schemas.h>
		#include <libgda/gda-tree-mgr-select.h>
		#include <libgda/gda-tree-mgr-tables.h>
		#include <libgda/gda-tree-node.h>

		#include <libgda/gda-sql-builder.h>

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

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

	G_BEGIN_DECLS	G_BEGIN_DECLS

	void gda_init (void);	void gda_init (void);
	gchar gda_get_application_exec_path (const gchar app_name);	gchar gda_get_application_exec_path (const gchar app_name);

	G_END_DECLS	G_END_DECLS

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

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

	gda-data-access-wrapper.h	gda-data-access-wrapper.h

	skipping to change at line 27	skipping to change at line 27
	* 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_ACCESS_WRAPPER_H__	#ifndef __GDA_DATA_ACCESS_WRAPPER_H__
	#define __GDA_DATA_ACCESS_WRAPPER_H__	#define __GDA_DATA_ACCESS_WRAPPER_H__

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

		#include <libxml/tree.h>

	G_BEGIN_DECLS	G_BEGIN_DECLS

	#define GDA_TYPE_DATA_ACCESS_WRAPPER (gda_data_access_wrapper_ge t_type())	#define GDA_TYPE_DATA_ACCESS_WRAPPER (gda_data_access_wrapper_ge t_type())
	#define GDA_DATA_ACCESS_WRAPPER(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_ACCESS_WRAPPER, GdaDataAccessWrapper))	#define GDA_DATA_ACCESS_WRAPPER(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_ACCESS_WRAPPER, GdaDataAccessWrapper))
	#define GDA_DATA_ACCESS_WRAPPER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (k lass, GDA_TYPE_DATA_ACCESS_WRAPPER, GdaDataAccessWrapperClass))	#define GDA_DATA_ACCESS_WRAPPER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (k lass, GDA_TYPE_DATA_ACCESS_WRAPPER, GdaDataAccessWrapperClass))
	#define GDA_IS_DATA_ACCESS_WRAPPER(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_DATA_ACCESS_WRAPPER))	#define GDA_IS_DATA_ACCESS_WRAPPER(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_DATA_ACCESS_WRAPPER))
	#define GDA_IS_DATA_ACCESS_WRAPPER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((k lass), GDA_TYPE_DATA_ACCESS_WRAPPER))	#define GDA_IS_DATA_ACCESS_WRAPPER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((k lass), GDA_TYPE_DATA_ACCESS_WRAPPER))

	typedef struct _GdaDataAccessWrapper GdaDataAccessWrapper;	typedef struct _GdaDataAccessWrapper GdaDataAccessWrapper;

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

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


		/* Generated data (by glib-mkenums) */

	#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-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" */

	skipping to change at line 57	skipping to change at line 59
	/* enumerations from "gda-easy.h" */	/* enumerations from "gda-easy.h" */
	GType gda_easy_error_get_type (void);	GType gda_easy_error_get_type (void);
	#define GDA_TYPE_EASY_ERROR (gda_easy_error_get_type())	#define GDA_TYPE_EASY_ERROR (gda_easy_error_get_type())
	GType gda_easy_create_table_flag_get_type (void);	GType gda_easy_create_table_flag_get_type (void);
	#define GDA_TYPE_EASY_CREATE_TABLE_FLAG (gda_easy_create_table_flag_get_typ e())	#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_sql_identifier_style_get_type (void);
	#define GDA_TYPE_SQL_IDENTIFIER_STYLE (gda_sql_identifier_style_get_type())
	/* enumerations from "gda-holder.h" */	/* enumerations from "gda-holder.h" */
	GType gda_holder_error_get_type (void);	GType gda_holder_error_get_type (void);
	#define GDA_TYPE_HOLDER_ERROR (gda_holder_error_get_type())	#define GDA_TYPE_HOLDER_ERROR (gda_holder_error_get_type())
	/* enumerations from "gda-meta-store.h" */	/* enumerations from "gda-meta-store.h" */
	GType gda_meta_store_error_get_type (void);	GType gda_meta_store_error_get_type (void);
	#define GDA_TYPE_META_STORE_ERROR (gda_meta_store_error_get_type())	#define GDA_TYPE_META_STORE_ERROR (gda_meta_store_error_get_type())
	GType gda_meta_store_change_type_get_type (void);	GType gda_meta_store_change_type_get_type (void);
	#define GDA_TYPE_META_STORE_CHANGE_TYPE (gda_meta_store_change_type_get_typ e())	#define GDA_TYPE_META_STORE_CHANGE_TYPE (gda_meta_store_change_type_get_typ e())
	/* enumerations from "gda-meta-struct.h" */	/* enumerations from "gda-meta-struct.h" */
	GType gda_meta_struct_error_get_type (void);	GType gda_meta_struct_error_get_type (void);

	skipping to change at line 98	skipping to change at line 98
	/* enumerations from "gda-server-provider.h" */	/* enumerations from "gda-server-provider.h" */
	GType gda_server_provider_error_get_type (void);	GType gda_server_provider_error_get_type (void);
	#define GDA_TYPE_SERVER_PROVIDER_ERROR (gda_server_provider_error_get_type( ))	#define GDA_TYPE_SERVER_PROVIDER_ERROR (gda_server_provider_error_get_type( ))
	/* enumerations from "gda-statement.h" */	/* enumerations from "gda-statement.h" */
	GType gda_statement_error_get_type (void);	GType gda_statement_error_get_type (void);
	#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-sql-builder.h" */
		GType gda_sql_builder_error_get_type (void);
		#define GDA_TYPE_SQL_BUILDER_ERROR (gda_sql_builder_error_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-tree.h" */
		GType gda_tree_error_get_type (void);
		#define GDA_TYPE_TREE_ERROR (gda_tree_error_get_type())
		/* enumerations from "gda-tree-node.h" */
		GType gda_tree_node_error_get_type (void);
		#define GDA_TYPE_TREE_NODE_ERROR (gda_tree_node_error_get_type())
		/* enumerations from "gda-tree-manager.h" */
		GType gda_tree_manager_error_get_type (void);
		#define GDA_TYPE_TREE_MANAGER_ERROR (gda_tree_manager_error_get_type())
	/* enumerations from "gda-xa-transaction.h" */	/* enumerations from "gda-xa-transaction.h" */
	GType gda_xa_transaction_error_get_type (void);	GType gda_xa_transaction_error_get_type (void);
	#define GDA_TYPE_XA_TRANSACTION_ERROR (gda_xa_transaction_error_get_type())	#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__ */


		/* Generated data ends here */

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

	gda-enums.h	gda-enums.h
	/* gda-enums.h	/* gda-enums.h
	*	*

	* Copyright (C) 2003 - 2009 Vivien Malerba	* Copyright (C) 2003 - 2006 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 48	skipping to change at line 48
	GDA_VALUE_ATTR_IS_DEFAULT = 1 << 2,	GDA_VALUE_ATTR_IS_DEFAULT = 1 << 2,
	GDA_VALUE_ATTR_CAN_BE_DEFAULT = 1 << 3,	GDA_VALUE_ATTR_CAN_BE_DEFAULT = 1 << 3,
	GDA_VALUE_ATTR_IS_UNCHANGED = 1 << 4,	GDA_VALUE_ATTR_IS_UNCHANGED = 1 << 4,
	GDA_VALUE_ATTR_ACTIONS_SHOWN = 1 << 5,	GDA_VALUE_ATTR_ACTIONS_SHOWN = 1 << 5,
	GDA_VALUE_ATTR_DATA_NON_VALID = 1 << 6,	GDA_VALUE_ATTR_DATA_NON_VALID = 1 << 6,
	GDA_VALUE_ATTR_HAS_VALUE_ORIG = 1 << 7,	GDA_VALUE_ATTR_HAS_VALUE_ORIG = 1 << 7,
	GDA_VALUE_ATTR_NO_MODIF = 1 << 8,	GDA_VALUE_ATTR_NO_MODIF = 1 << 8,
	GDA_VALUE_ATTR_UNUSED = 1 << 9	GDA_VALUE_ATTR_UNUSED = 1 << 9
	} GdaValueAttribute;	} GdaValueAttribute;


	/* how SQL identifiers are represented */
	typedef enum {
	GDA_SQL_IDENTIFIERS_LOWER_CASE = 1 << 0,
	GDA_SQL_IDENTIFIERS_UPPER_CASE = 1 << 1
	} GdaSqlIdentifierStyle;

	/* possible different keywords used when qualifying a table's column's extr a attributes */	/* possible different keywords used when qualifying a table's column's extr a attributes */
	#define GDA_EXTRA_AUTO_INCREMENT "AUTO_INCREMENT"	#define GDA_EXTRA_AUTO_INCREMENT "AUTO_INCREMENT"

	#endif	#endif

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

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

	skipping to change at line 116	skipping to change at line 116
	void (*_gda_reserved4) (void);	void (*_gda_reserved4) (void);
	};	};

	GType gda_server_operation_get_type (vo id) G_GNUC_CONST;	GType gda_server_operation_get_type (vo id) G_GNUC_CONST;
	GdaServerOperation gda_server_operation_new (Gd aServerOperationType op_type, const gchar xml_file);	GdaServerOperation gda_server_operation_new (Gd aServerOperationType op_type, const gchar xml_file);
	GdaServerOperationType gda_server_operation_get_op_type (Gd aServerOperation *op);	GdaServerOperationType gda_server_operation_get_op_type (Gd aServerOperation *op);
	const gchar *gda_server_operation_op_type_to_string (Gd aServerOperationType type);	const gchar *gda_server_operation_op_type_to_string (Gd aServerOperationType type);
	GdaServerOperationNode gda_server_operation_get_node_info (Gd aServerOperation op, const gchar *path_format, ...);	GdaServerOperationNode gda_server_operation_get_node_info (Gd aServerOperation op, const gchar *path_format, ...);

	const GValue gda_server_operation_get_value_at (Gd aServerOperation op, const gchar *path_format, ...);	const GValue gda_server_operation_get_value_at (Gd aServerOperation op, const gchar *path_format, ...);

	gchar *gda_server_operation_get_sql_identifier_at (Gd
	aServerOperation *op,
	Gda
	Connection cnc, GdaServerProvider prov,
	con
	st gchar *path_format, ...);
	gboolean gda_server_operation_set_value_at (Gd aServerOperation op, const gchar value,	gboolean gda_server_operation_set_value_at (Gd aServerOperation op, const gchar value,
	GEr ror *error, const gchar path_format, ...);	GEr ror *error, const gchar path_format, ...);

	xmlNodePtr gda_server_operation_save_data_to_xml (Gd aServerOperation op, GError *error);	xmlNodePtr gda_server_operation_save_data_to_xml (Gd aServerOperation op, GError *error);
	gboolean gda_server_operation_load_data_from_xml (Gd aServerOperation *op,	gboolean gda_server_operation_load_data_from_xml (Gd aServerOperation *op,
	xml NodePtr node, GError **error);	xml NodePtr node, GError **error);

	gchar** gda_server_operation_get_root_nodes (Gd aServerOperation *op);	gchar** gda_server_operation_get_root_nodes (Gd aServerOperation *op);
	GdaServerOperationNodeType gda_server_operation_get_node_type (Gd aServerOperation op, const gchar path,	GdaServerOperationNodeType gda_server_operation_get_node_type (Gd aServerOperation op, const gchar path,
	Gda ServerOperationNodeStatus *status);	Gda ServerOperationNodeStatus *status);

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