<STRUCT>
<NAME>TestSuite</NAME>
typedef struct {
	gchar   *name;
	GdaDict *dict;
	GArray  *unit_files;
	GArray  *unit_tests; /* an array of GArray of SqlTest */
} TestSuite;
</STRUCT>
<FUNCTION>
<NAME>test_suite_load_from_file</NAME>
<RETURNS>GSList *</RETURNS>
const gchar *xml_file
</FUNCTION>
<STRUCT>
<NAME>SqlParam</NAME>
typedef struct {
	gchar    *name;
	gchar    *type;
	gchar    *descr;
	gboolean  nullok;
	gboolean  isparam;
	gchar    *default_string;
	GValue   *default_gvalue;
} SqlParam;
</STRUCT>
<ENUM>
<NAME>SqlRenderingAttr</NAME>
typedef enum {
	/* dictionary presence */
	TEST_RENDERING_WHEN_DICT = 1 << 0,
	TEST_RENDERING_WHEN_NO_DICT = 1 << 1,
	TEST_RENDERING_WHEN_ANY_DICT = TEST_RENDERING_WHEN_DICT | TEST_RENDERING_WHEN_NO_DICT,

	/* parsing status */
	TEST_RENDERING_SQL_DELIMITER = 1 << 2,
	TEST_RENDERING_SQL_PARSER = 1 << 3,
	TEST_RENDERING_SQL_ACTIVE = 1 << 4,
	TEST_RENDERING_SQL_ANY = TEST_RENDERING_SQL_DELIMITER | TEST_RENDERING_SQL_PARSER | TEST_RENDERING_SQL_ACTIVE,

	/* GdaQuery or gda_delimiter context */
	TEST_RENDERING_GDA_QUERY = 1 << 5,
	TEST_RENDERING_GDA_DELIMITER = 1 << 6,
	TEST_RENDERING_GDA_ANY = TEST_RENDERING_GDA_DELIMITER | TEST_RENDERING_GDA_QUERY
} SqlRenderingAttr;
</ENUM>
<STRUCT>
<NAME>SqlRendering</NAME>
typedef struct {
	SqlRenderingAttr attrs;
	gchar           *sql;
} SqlRendering;
</STRUCT>
<STRUCT>
<NAME>SqlTest</NAME>
typedef struct {
	TestSuite *suite;
	gchar     *test_name;
	gchar     *sql_to_test;

	gboolean   delim_parsed; /* TRUE if the delimiter can work on the statement */
	gboolean   sql_parsed;   /* TRUE if the SQL parser (libsql) can work on the statement */
	gboolean   sql_active;   /* TRUE if the parsed query must be active (if there is a dictionary) */

	GArray    *renderings; /* array of SqlRendering* */
	GSList    *params; /* list of @SqlParam structs */
	gint       n_statements;
} SqlTest;
</STRUCT>
<FUNCTION>
<NAME>sql_test_rendering_new</NAME>
<RETURNS>SqlRendering *</RETURNS>
SqlRenderingAttr attrs, const gchar *sql
</FUNCTION>
<FUNCTION>
<NAME>sql_test_rendering_free</NAME>
<RETURNS>void          </RETURNS>
SqlRendering *ren
</FUNCTION>
<FUNCTION>
<NAME>sql_tests_load_from_file</NAME>
<RETURNS>GArray   *</RETURNS>
const gchar *xml_file
</FUNCTION>
<FUNCTION>
<NAME>sql_tests_take_param</NAME>
<RETURNS>SqlParam *</RETURNS>
SqlTest *test, const gchar *pname
</FUNCTION>
<FUNCTION>
<NAME>sql_param_free</NAME>
<RETURNS>void      </RETURNS>
SqlParam *param
</FUNCTION>
<FUNCTION>
<NAME>sql_test_rendering_is_correct</NAME>
<RETURNS>gboolean  </RETURNS>
SqlTest *test, const gchar *sql
</FUNCTION>
<MACRO>
<NAME>fail</NAME>
#define fail(x) g_warning (x)
</MACRO>
<MACRO>
<NAME>fail_if</NAME>
#define fail_if(x,y) if (x) g_warning (y)
</MACRO>
<MACRO>
<NAME>fail_unless</NAME>
#define fail_unless(x,y) if (!(x)) g_warning (y)
</MACRO>
<FUNCTION>
<NAME>prov_test_common_setup</NAME>
<RETURNS>int </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>prov_test_common_create_tables_sql</NAME>
<RETURNS>int </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>prov_test_common_check_schemas</NAME>
<RETURNS>int </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>prov_test_common_clean</NAME>
<RETURNS>int </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>prov_test_setup_connection</NAME>
<RETURNS>GdaConnection *</RETURNS>
GdaProviderInfo *prov_info, gboolean *params_provided, gboolean *db_created
</FUNCTION>
<FUNCTION>
<NAME>prov_test_clean_connection</NAME>
<RETURNS>gboolean       </RETURNS>
GdaConnection *cnc, gboolean destroy_db
</FUNCTION>
<FUNCTION>
<NAME>prov_test_create_tables_sql</NAME>
<RETURNS>gboolean       </RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>prov_test_check_table_schema</NAME>
<RETURNS>gboolean       </RETURNS>
GdaConnection *cnc, const gchar *table
</FUNCTION>
<FUNCTION>
<NAME>prov_test_check_types_schema</NAME>
<RETURNS>gboolean       </RETURNS>
GdaConnection *cnc
</FUNCTION>
<STRUCT>
<NAME>HtmlFile</NAME>
typedef struct {
	gchar      *name;
	xmlDocPtr   doc;
	xmlNodePtr  body;
	xmlNodePtr  toc;
} HtmlFile;
</STRUCT>
<STRUCT>
<NAME>HtmlConfig</NAME>
typedef struct {
	HtmlFile          *index;
	
	GHashTable        *nodes; /* key=node name, value=xmlNodePtr */
	gchar             *dir;
	GSList            *all_files;
} HtmlConfig;
</STRUCT>
<MACRO>
<NAME>HTML_CONFIG</NAME>
#define HTML_CONFIG(x) ((HtmlConfig*)(x))
</MACRO>
<FUNCTION>
<NAME>html_init_config</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config
</FUNCTION>
<FUNCTION>
<NAME>html_file_new</NAME>
<RETURNS>HtmlFile  *</RETURNS>
HtmlConfig *config,const gchar *name, const gchar *title
</FUNCTION>
<FUNCTION>
<NAME>html_file_write</NAME>
<RETURNS>gboolean   </RETURNS>
HtmlFile *file, HtmlConfig *config
</FUNCTION>
<FUNCTION>
<NAME>html_file_free</NAME>
<RETURNS>void       </RETURNS>
HtmlFile *file
</FUNCTION>
<FUNCTION>
<NAME>html_declare_node</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, const gchar *path, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_declare_node_own</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, gchar *path, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_add_link_to_node</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, const gchar *nodepath,const gchar *text, const gchar *link_to
</FUNCTION>
<FUNCTION>
<NAME>html_add_to_toc</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, HtmlFile *file, const gchar *text, const gchar *link_to
</FUNCTION>
<FUNCTION>
<NAME>html_add_header</NAME>
<RETURNS>xmlNodePtr </RETURNS>
HtmlConfig *config, HtmlFile *file, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>html_mark_path_error</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, const gchar *nodepath
</FUNCTION>
<FUNCTION>
<NAME>html_mark_node_error</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_mark_node_warning</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_mark_node_notice</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_render_attribute_str</NAME>
<RETURNS>xmlNodePtr </RETURNS>
xmlNodePtr parent, const gchar *node_type,const gchar *att_name, const gchar *att_val
</FUNCTION>
<FUNCTION>
<NAME>html_render_attribute_bool</NAME>
<RETURNS>xmlNodePtr </RETURNS>
xmlNodePtr parent, const gchar *node_type,const gchar *att_name, gboolean att_val
</FUNCTION>
<FUNCTION>
<NAME>html_render_data_model</NAME>
<RETURNS>xmlNodePtr </RETURNS>
xmlNodePtr parent, GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>html_render_data_model_all</NAME>
<RETURNS>xmlNodePtr </RETURNS>
xmlNodePtr parent, GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>input_from_console</NAME>
<RETURNS>gchar   *</RETURNS>
const gchar *prompt
</FUNCTION>
<FUNCTION>
<NAME>input_from_stream</NAME>
<RETURNS>gchar   *</RETURNS>
FILE *stream
</FUNCTION>
<FUNCTION>
<NAME>init_input</NAME>
<RETURNS>void     </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>input_get_size</NAME>
<RETURNS>void     </RETURNS>
gint *width, gint *height
</FUNCTION>
<FUNCTION>
<NAME>init_history</NAME>
<RETURNS>void     </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>add_to_history</NAME>
<RETURNS>void     </RETURNS>
const gchar *txt
</FUNCTION>
<FUNCTION>
<NAME>save_history</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *file, GError **error
</FUNCTION>
<ENUM>
<NAME>GdaInternalCommandResultType</NAME>
typedef enum {
	GDA_INTERNAL_COMMAND_RESULT_EMPTY,
	GDA_INTERNAL_COMMAND_RESULT_DATA_MODEL,
	GDA_INTERNAL_COMMAND_RESULT_PLIST,
	GDA_INTERNAL_COMMAND_RESULT_TXT,
	GDA_INTERNAL_COMMAND_RESULT_TXT_STDOUT,
	GDA_INTERNAL_COMMAND_RESULT_MULTIPLE,
	GDA_INTERNAL_COMMAND_RESULT_EXIT
} GdaInternalCommandResultType;
</ENUM>
<STRUCT>
<NAME>GdaInternalCommandResult</NAME>
typedef struct {
	GdaInternalCommandResultType type;
	union {
		GdaDataModel     *model;
		GdaParameterList *plist;
		GString          *txt;
		GSList           *multiple_results; /* for GDA_INTERNAL_COMMAND_RESULT_MULTIPLE */
	} u;
} GdaInternalCommandResult;
</STRUCT>
<USER_FUNCTION>
<NAME>GdaInternalCommandFunc</NAME>
<RETURNS>GdaInternalCommandResult *</RETURNS>
GdaConnection *, GdaDict *,
							     const gchar **,
							     GError **, gpointer
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdaInternalCommandArgsFunc</NAME>
<RETURNS>gchar **</RETURNS>
const gchar *
</USER_FUNCTION>
<STRUCT>
<NAME>GdaInternalCommandArgument</NAME>
typedef struct {
	gchar    *name;
	gboolean  optional;
} GdaInternalCommandArgument;
</STRUCT>
<STRUCT>
<NAME>GdaInternalCommand</NAME>
typedef struct {
	gchar                     *group;
	gchar                     *name; /* without the '\' */
	gchar                     *description;
	GSList                    *args; /* list of GdaInternalCommandArgument structures */
	GdaInternalCommandFunc     command_func;
	gpointer                   user_data;
	GdaInternalCommandArgsFunc arguments_delimiter_func;
} GdaInternalCommand;
</STRUCT>
<STRUCT>
<NAME>GdaInternalCommandsList</NAME>
typedef struct {
	GSList    *commands;

	/* internal usage */
	GSList    *name_ordered;
	GSList    *group_ordered;
} GdaInternalCommandsList;
</STRUCT>
<FUNCTION>
<NAME>gda_internal_command_execute</NAME>
<RETURNS>GdaInternalCommandResult *</RETURNS>
GdaInternalCommandsList *commands_list,GdaConnection *cnc, GdaDict *dict,const gchar *command_str, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_internal_command_exec_result_free</NAME>
<RETURNS>void                      </RETURNS>
GdaInternalCommandResult *res
</FUNCTION>
<FUNCTION>
<NAME>gda_internal_command_help</NAME>
<RETURNS>GdaInternalCommandResult *</RETURNS>
GdaConnection *cnc, GdaDict *dict,const gchar **args,GError **error, GdaInternalCommandsList *clist
</FUNCTION>
<FUNCTION>
<NAME>gda_internal_command_history</NAME>
<RETURNS>GdaInternalCommandResult *</RETURNS>
GdaConnection *cnc, GdaDict *dict,const gchar **args,GError **error, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gda_internal_command_dict_sync</NAME>
<RETURNS>GdaInternalCommandResult *</RETURNS>
GdaConnection *cnc, GdaDict *dict,const gchar **args,GError **error, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gda_internal_command_dict_save</NAME>
<RETURNS>GdaInternalCommandResult *</RETURNS>
GdaConnection *cnc, GdaDict *dict,const gchar **args,GError **error, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gda_internal_command_list_tables_views</NAME>
<RETURNS>GdaInternalCommandResult *</RETURNS>
GdaConnection *cnc, GdaDict *dict,const gchar **args,GError **error, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gda_internal_command_list_queries</NAME>
<RETURNS>GdaInternalCommandResult *</RETURNS>
GdaConnection *cnc, GdaDict *dict,const gchar **args,GError **error, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gda_internal_command_detail</NAME>
<RETURNS>GdaInternalCommandResult *</RETURNS>
GdaConnection *cnc, GdaDict *dict,const gchar **args,GError **error, gpointer data
</FUNCTION>
<MACRO>
<NAME>DATABASE</NAME>
#define	DATABASE "access.db"
</MACRO>
<MACRO>
<NAME>COLORSIZE</NAME>
#define COLORSIZE 10
</MACRO>
<MACRO>
<NAME>NAMESIZE</NAME>
#define NAMESIZE 10
</MACRO>
<STRUCT>
<NAME>Key</NAME>
typedef struct {
	char  color[COLORSIZE];
	int   type;
} Key;
</STRUCT>
<STRUCT>
<NAME>Value</NAME>
typedef struct {
	float  size;
	char   name[NAMESIZE];
} Value;
</STRUCT>
<MACRO>
<NAME>TYPE_CUSTOM_DATA_MODEL</NAME>
#define TYPE_CUSTOM_DATA_MODEL            (custom_data_model_get_type())
</MACRO>
<MACRO>
<NAME>CUSTOM_DATA_MODEL</NAME>
#define CUSTOM_DATA_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_VPROVIDER_DATA_MODEL, CustomDataModel))
</MACRO>
<MACRO>
<NAME>CUSTOM_DATA_MODEL_CLASS</NAME>
#define CUSTOM_DATA_MODEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_VPROVIDER_DATA_MODEL, CustomDataModelClass))
</MACRO>
<MACRO>
<NAME>IS_CUSTOM_DATA_MODEL</NAME>
#define IS_CUSTOM_DATA_MODEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_VPROVIDER_DATA_MODEL))
</MACRO>
<MACRO>
<NAME>IS_CUSTOM_DATA_MODEL_CLASS</NAME>
#define IS_CUSTOM_DATA_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_VPROVIDER_DATA_MODEL))
</MACRO>
<STRUCT>
<NAME>CustomDataModel</NAME>
</STRUCT>
<STRUCT>
<NAME>CustomDataModelClass</NAME>
</STRUCT>
<STRUCT>
<NAME>CustomDataModelPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>CustomDataModel</NAME>
struct _CustomDataModel {
	GdaDataModelBdb         base;
	CustomDataModelPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>CustomDataModelClass</NAME>
struct _CustomDataModelClass {
	GdaDataModelBdbClass    parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>custom_data_model_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>custom_data_model_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>open_source_connection</NAME>
<RETURNS>GdaConnection *</RETURNS>
GdaClient *client
</FUNCTION>
<FUNCTION>
<NAME>open_destination_connection</NAME>
<RETURNS>GdaConnection *</RETURNS>
GdaClient *client
</FUNCTION>
<FUNCTION>
<NAME>run_sql_non_select</NAME>
<RETURNS>void           </RETURNS>
GdaConnection *cnc, const gchar *sql
</FUNCTION>
<STRUCT>
<NAME>HtmlFile</NAME>
typedef struct {
	gchar      *name;
	xmlDocPtr   doc;
	xmlNodePtr  body;
	xmlNodePtr  toc;
} HtmlFile;
</STRUCT>
<STRUCT>
<NAME>HtmlConfig</NAME>
typedef struct {
	HtmlFile          *index;
	
	GHashTable        *nodes; /* key=node name, value=xmlNodePtr */
	gchar             *dir;
	GSList            *all_files;
} HtmlConfig;
</STRUCT>
<MACRO>
<NAME>HTML_CONFIG</NAME>
#define HTML_CONFIG(x) ((HtmlConfig*)(x))
</MACRO>
<FUNCTION>
<NAME>html_init_config</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config
</FUNCTION>
<FUNCTION>
<NAME>html_file_new</NAME>
<RETURNS>HtmlFile  *</RETURNS>
HtmlConfig *config,const gchar *name, const gchar *title
</FUNCTION>
<FUNCTION>
<NAME>html_file_write</NAME>
<RETURNS>gboolean   </RETURNS>
HtmlFile *file, HtmlConfig *config
</FUNCTION>
<FUNCTION>
<NAME>html_file_free</NAME>
<RETURNS>void       </RETURNS>
HtmlFile *file
</FUNCTION>
<FUNCTION>
<NAME>html_declare_node</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, const gchar *path, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_declare_node_own</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, gchar *path, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_add_link_to_node</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, const gchar *nodepath,const gchar *text, const gchar *link_to
</FUNCTION>
<FUNCTION>
<NAME>html_add_to_toc</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, HtmlFile *file, const gchar *text, const gchar *link_to
</FUNCTION>
<FUNCTION>
<NAME>html_add_header</NAME>
<RETURNS>xmlNodePtr </RETURNS>
HtmlConfig *config, HtmlFile *file, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>html_mark_path_error</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, const gchar *nodepath
</FUNCTION>
<FUNCTION>
<NAME>html_mark_node_error</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_mark_node_warning</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_mark_node_notice</NAME>
<RETURNS>void       </RETURNS>
HtmlConfig *config, xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>html_render_attribute_str</NAME>
<RETURNS>xmlNodePtr </RETURNS>
xmlNodePtr parent, const gchar *node_type,const gchar *att_name, const gchar *att_val
</FUNCTION>
<FUNCTION>
<NAME>html_render_attribute_bool</NAME>
<RETURNS>xmlNodePtr </RETURNS>
xmlNodePtr parent, const gchar *node_type,const gchar *att_name, gboolean att_val
</FUNCTION>
<FUNCTION>
<NAME>html_render_data_model</NAME>
<RETURNS>xmlNodePtr </RETURNS>
xmlNodePtr parent, GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>html_render_data_model_all</NAME>
<RETURNS>xmlNodePtr </RETURNS>
xmlNodePtr parent, GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_report_document_run_converter_path</NAME>
<RETURNS>gboolean </RETURNS>
GdaReportDocument *doc, const gchar *filename,const gchar *full_converter_path, const gchar *converter_name,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_report_document_run_converter_argv</NAME>
<RETURNS>gboolean </RETURNS>
GdaReportDocument *doc, const gchar *filename,gchar **argv, gint argv_index_fname,const gchar *converter_name, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_REPORT_DOCUMENT</NAME>
#define GDA_TYPE_REPORT_DOCUMENT            (gda_report_document_get_type())
</MACRO>
<MACRO>
<NAME>GDA_REPORT_DOCUMENT</NAME>
#define GDA_REPORT_DOCUMENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_REPORT_DOCUMENT, GdaReportDocument))
</MACRO>
<MACRO>
<NAME>GDA_REPORT_DOCUMENT_CLASS</NAME>
#define GDA_REPORT_DOCUMENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_REPORT_DOCUMENT, GdaReportDocumentClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_REPORT_DOCUMENT</NAME>
#define GDA_IS_REPORT_DOCUMENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_REPORT_DOCUMENT))
</MACRO>
<MACRO>
<NAME>GDA_IS_REPORT_DOCUMENT_CLASS</NAME>
#define GDA_IS_REPORT_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_REPORT_DOCUMENT))
</MACRO>
<STRUCT>
<NAME>GdaReportDocument</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportDocumentClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportDocumentPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportDocument</NAME>
struct _GdaReportDocument {
	GObject                   base;
	GdaReportDocumentPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaReportDocumentClass</NAME>
struct _GdaReportDocumentClass {
	GObjectClass              parent_class;

	/* virtual methods */
	gboolean                (*run_as_html) (GdaReportDocument *doc, const gchar *filename, GError **error);
	gboolean                (*run_as_pdf) (GdaReportDocument *doc, const gchar *filename, GError **error);
};
</STRUCT>
<FUNCTION>
<NAME>gda_report_document_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_report_document_set_template</NAME>
<RETURNS>void                  </RETURNS>
GdaReportDocument *doc, const gchar *file
</FUNCTION>
<FUNCTION>
<NAME>gda_report_document_run_as_html</NAME>
<RETURNS>gboolean              </RETURNS>
GdaReportDocument *doc, const gchar *filename, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_report_document_run_as_pdf</NAME>
<RETURNS>gboolean              </RETURNS>
GdaReportDocument *doc, const gchar *filename, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_REPORT_RML_DOCUMENT</NAME>
#define GDA_TYPE_REPORT_RML_DOCUMENT            (gda_report_rml_document_get_type())
</MACRO>
<MACRO>
<NAME>GDA_REPORT_RML_DOCUMENT</NAME>
#define GDA_REPORT_RML_DOCUMENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_REPORT_RML_DOCUMENT, GdaReportRmlDocument))
</MACRO>
<MACRO>
<NAME>GDA_REPORT_RML_DOCUMENT_CLASS</NAME>
#define GDA_REPORT_RML_DOCUMENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_REPORT_RML_DOCUMENT, GdaReportRmlDocumentClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_REPORT_RML_DOCUMENT</NAME>
#define GDA_IS_REPORT_RML_DOCUMENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_REPORT_RML_DOCUMENT))
</MACRO>
<MACRO>
<NAME>GDA_IS_REPORT_RML_DOCUMENT_CLASS</NAME>
#define GDA_IS_REPORT_RML_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_REPORT_RML_DOCUMENT))
</MACRO>
<STRUCT>
<NAME>GdaReportRmlDocument</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportRmlDocumentClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportRmlDocumentPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportRmlDocument</NAME>
struct _GdaReportRmlDocument {
	GdaReportDocument            base;
	GdaReportRmlDocumentPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaReportRmlDocumentClass</NAME>
struct _GdaReportRmlDocumentClass {
	GdaReportDocumentClass       parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_report_rml_document_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_report_rml_document_new</NAME>
<RETURNS>GdaReportDocument *</RETURNS>
GdaReportEngine *engine
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_REPORT_ENGINE</NAME>
#define GDA_TYPE_REPORT_ENGINE            (gda_report_engine_get_type())
</MACRO>
<MACRO>
<NAME>GDA_REPORT_ENGINE</NAME>
#define GDA_REPORT_ENGINE(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_REPORT_ENGINE, GdaReportEngine))
</MACRO>
<MACRO>
<NAME>GDA_REPORT_ENGINE_CLASS</NAME>
#define GDA_REPORT_ENGINE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_REPORT_ENGINE, GdaReportEngineClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_REPORT_ENGINE</NAME>
#define GDA_IS_REPORT_ENGINE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_REPORT_ENGINE))
</MACRO>
<MACRO>
<NAME>GDA_IS_REPORT_ENGINE_CLASS</NAME>
#define GDA_IS_REPORT_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_REPORT_ENGINE))
</MACRO>
<STRUCT>
<NAME>GdaReportEngine</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportEngineClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportEnginePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportEngine</NAME>
struct _GdaReportEngine {
	GObject                 base;
	GdaReportEnginePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaReportEngineClass</NAME>
struct _GdaReportEngineClass {
	GObjectClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_report_engine_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_report_engine_new</NAME>
<RETURNS>GdaReportEngine *</RETURNS>
xmlNodePtr spec_node
</FUNCTION>
<FUNCTION>
<NAME>gda_report_engine_new_from_string</NAME>
<RETURNS>GdaReportEngine *</RETURNS>
const gchar *spec_string
</FUNCTION>
<FUNCTION>
<NAME>gda_report_engine_new_from_file</NAME>
<RETURNS>GdaReportEngine *</RETURNS>
const gchar *spec_file_name
</FUNCTION>
<FUNCTION>
<NAME>gda_report_engine_declare_object</NAME>
<RETURNS>void             </RETURNS>
GdaReportEngine *engine, GObject *object, const gchar *obj_name
</FUNCTION>
<FUNCTION>
<NAME>gda_report_engine_find_declared_object</NAME>
<RETURNS>GObject         *</RETURNS>
GdaReportEngine *engine, GType obj_type, const gchar *obj_name
</FUNCTION>
<FUNCTION>
<NAME>gda_report_engine_run_as_node</NAME>
<RETURNS>xmlNodePtr       </RETURNS>
GdaReportEngine *engine, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_report_engine_run_as_doc</NAME>
<RETURNS>xmlDocPtr        </RETURNS>
GdaReportEngine *engine, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_REPORT_DOCBOOK_DOCUMENT</NAME>
#define GDA_TYPE_REPORT_DOCBOOK_DOCUMENT            (gda_report_docbook_document_get_type())
</MACRO>
<MACRO>
<NAME>GDA_REPORT_DOCBOOK_DOCUMENT</NAME>
#define GDA_REPORT_DOCBOOK_DOCUMENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_REPORT_DOCBOOK_DOCUMENT, GdaReportDocbookDocument))
</MACRO>
<MACRO>
<NAME>GDA_REPORT_DOCBOOK_DOCUMENT_CLASS</NAME>
#define GDA_REPORT_DOCBOOK_DOCUMENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_REPORT_DOCBOOK_DOCUMENT, GdaReportDocbookDocumentClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_REPORT_DOCBOOK_DOCUMENT</NAME>
#define GDA_IS_REPORT_DOCBOOK_DOCUMENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_REPORT_DOCBOOK_DOCUMENT))
</MACRO>
<MACRO>
<NAME>GDA_IS_REPORT_DOCBOOK_DOCUMENT_CLASS</NAME>
#define GDA_IS_REPORT_DOCBOOK_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_REPORT_DOCBOOK_DOCUMENT))
</MACRO>
<STRUCT>
<NAME>GdaReportDocbookDocument</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportDocbookDocumentClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportDocbookDocumentPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReportDocbookDocument</NAME>
struct _GdaReportDocbookDocument {
	GdaReportDocument            base;
	GdaReportDocbookDocumentPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaReportDocbookDocumentClass</NAME>
struct _GdaReportDocbookDocumentClass {
	GdaReportDocumentClass       parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_report_docbook_document_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_report_docbook_document_new</NAME>
<RETURNS>GdaReportDocument *</RETURNS>
GdaReportEngine *engine
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_TARGET</NAME>
#define GDA_TYPE_QUERY_TARGET          (gda_query_target_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_TARGET</NAME>
#define GDA_QUERY_TARGET(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_target_get_type(), GdaQueryTarget)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_TARGET_CLASS</NAME>
#define GDA_QUERY_TARGET_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_target_get_type (), GdaQueryTargetClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_TARGET</NAME>
#define GDA_IS_QUERY_TARGET(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_target_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_target_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_TARGET_ERROR</NAME>
#define GDA_QUERY_TARGET_ERROR gda_query_target_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryTargetError</NAME>
typedef enum
{
	GDA_QUERY_TARGET_XML_LOAD_ERROR,
	GDA_QUERY_TARGET_XML_SAVE_ERROR,
	GDA_QUERY_TARGET_META_DATA_UPDATE,
	GDA_QUERY_TARGET_FIELDS_ERROR
} GdaQueryTargetError;
</ENUM>
<STRUCT>
<NAME>GdaQueryTarget</NAME>
struct _GdaQueryTarget
{
	GdaQueryObject          object;
	GdaQueryTargetPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryTargetClass</NAME>
struct _GdaQueryTargetClass
{
	GdaQueryObjectClass     parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_target_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_target_new</NAME>
<RETURNS>GdaQueryTarget *</RETURNS>
GdaQuery *query, const gchar *table
</FUNCTION>
<FUNCTION>
<NAME>gda_query_target_new_copy</NAME>
<RETURNS>GdaQueryTarget *</RETURNS>
GdaQueryTarget *orig
</FUNCTION>
<FUNCTION>
<NAME>gda_query_target_get_query</NAME>
<RETURNS>GdaQuery       *</RETURNS>
GdaQueryTarget *target
</FUNCTION>
<FUNCTION>
<NAME>gda_query_target_get_represented_entity</NAME>
<RETURNS>GdaEntity      *</RETURNS>
GdaQueryTarget *target
</FUNCTION>
<FUNCTION>
<NAME>gda_query_target_get_represented_table_name</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaQueryTarget *target
</FUNCTION>
<FUNCTION>
<NAME>gda_query_target_set_alias</NAME>
<RETURNS>void            </RETURNS>
GdaQueryTarget *target, const gchar *alias
</FUNCTION>
<FUNCTION>
<NAME>gda_query_target_get_alias</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaQueryTarget *target
</FUNCTION>
<FUNCTION>
<NAME>gda_query_target_get_complete_name</NAME>
<RETURNS>gchar          *</RETURNS>
GdaQueryTarget *target
</FUNCTION>
<FUNCTION>
<NAME>g_types_get_register</NAME>
<RETURNS>GdaDictRegisterStruct *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>gda_functions_get_register</NAME>
<RETURNS>GdaDictRegisterStruct *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>gda_functions_get_by_name</NAME>
<RETURNS>GSList                *</RETURNS>
GdaDict *dict, const gchar *aggname
</FUNCTION>
<FUNCTION>
<NAME>gda_functions_get_by_name_arg</NAME>
<RETURNS>GdaDictFunction       *</RETURNS>
GdaDict *dict,const gchar *aggname, const GSList *argtypes
</FUNCTION>
<FUNCTION>
<NAME>gda_functions_get_by_name_arg_in_list</NAME>
<RETURNS>GdaDictFunction       *</RETURNS>
GdaDict *dict, GSList *functions,const gchar *aggname, const GSList *argtypes
</FUNCTION>
<FUNCTION>
<NAME>gda_functions_get_by_dbms_id</NAME>
<RETURNS>GdaDictFunction       *</RETURNS>
GdaDict *dict, const gchar *dbms_id
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_TYPE</NAME>
#define GDA_TYPE_DICT_TYPE          (gda_dict_type_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DICT_TYPE</NAME>
#define GDA_DICT_TYPE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_dict_type_get_type(), GdaDictType)
</MACRO>
<MACRO>
<NAME>GDA_DICT_TYPE_CLASS</NAME>
#define GDA_DICT_TYPE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_dict_type_get_type (), GdaDictTypeClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DICT_TYPE</NAME>
#define GDA_IS_DICT_TYPE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_dict_type_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_dict_type_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DICT_TYPE_ERROR</NAME>
#define GDA_DICT_TYPE_ERROR gda_dict_type_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDictTypeError</NAME>
typedef enum
{
	GDA_DICT_TYPE_XML_LOAD_ERROR
} GdaDictTypeError;
</ENUM>
<STRUCT>
<NAME>GdaDictType</NAME>
struct _GdaDictType
{
	GdaObject                 object;
	GdaDictTypePrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDictTypeClass</NAME>
struct _GdaDictTypeClass
{
	GdaObjectClass                    parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_dict_type_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_type_new</NAME>
<RETURNS>GdaDictType        *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_type_set_sqlname</NAME>
<RETURNS>void                </RETURNS>
GdaDictType *dt, const gchar *sqlname
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_type_get_sqlname</NAME>
<RETURNS>const gchar        *</RETURNS>
GdaDictType *dt
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_type_set_g_type</NAME>
<RETURNS>void                </RETURNS>
GdaDictType *dt, GType g_type
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_type_get_g_type</NAME>
<RETURNS>GType               </RETURNS>
GdaDictType *dt
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_type_add_synonym</NAME>
<RETURNS>void                </RETURNS>
GdaDictType *dt, const gchar *synonym
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_type_get_synonyms</NAME>
<RETURNS>const GSList       *</RETURNS>
GdaDictType *dt
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_type_clear_synonyms</NAME>
<RETURNS>void                </RETURNS>
GdaDictType *dt
</FUNCTION>
<STRUCT>
<NAME>ParseData</NAME>
typedef struct {
	GSList     *prev_targets;/* list of targets existing in the query before a new parsing */
	GSList     *prev_fields; /* list of GdaQueryField objects existing in the query before a new parsing */
	GSList     *parsed_targets; /* list of targets in the INVERTED order in which they were parsed */
	GHashTable *new_targets; /* KEY= target's alias or target's represented entity's name, VAL=GdaQueryTarget */
	GHashTable *sql_table_targets; /* KEY=sql_table struct, VAL=GdaQueryTarget */
} ParseData;
</STRUCT>
<FUNCTION>
<NAME>parse_data_new</NAME>
<RETURNS>ParseData   *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>parse_data_destroy</NAME>
<RETURNS>void         </RETURNS>
ParseData *pdata
</FUNCTION>
<FUNCTION>
<NAME>parse_data_compute_targets_hash</NAME>
<RETURNS>void         </RETURNS>
GdaQuery *query, ParseData *pdata
</FUNCTION>
<FUNCTION>
<NAME>parsed_create_select_query</NAME>
<RETURNS>gboolean     </RETURNS>
GdaQuery *query, sql_select_statement *select, GError **error
</FUNCTION>
<FUNCTION>
<NAME>parsed_create_update_query</NAME>
<RETURNS>gboolean     </RETURNS>
GdaQuery *query, sql_update_statement *update, GError **error
</FUNCTION>
<FUNCTION>
<NAME>parsed_create_insert_query</NAME>
<RETURNS>gboolean     </RETURNS>
GdaQuery *query, sql_insert_statement *insert, GError **error
</FUNCTION>
<FUNCTION>
<NAME>parsed_create_delete_query</NAME>
<RETURNS>gboolean     </RETURNS>
GdaQuery *query, sql_delete_statement *del, GError **error
</FUNCTION>
<FUNCTION>
<NAME>parsed_create_global_query_field</NAME>
<RETURNS>GdaEntityField    *</RETURNS>
GdaQuery *query, gboolean add_to_query,ParseData *pdata, sql_field *field,gboolean try_existing_field, gboolean *new_field,GdaQueryTarget **target_return, GError **error
</FUNCTION>
<FUNCTION>
<NAME>parsed_create_complex_condition</NAME>
<RETURNS>GdaQueryCondition *</RETURNS>
GdaQuery *query, ParseData *pdata, sql_where *where,gboolean try_existing_field,GSList **targets_return, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_field_by_sql_naming_fields</NAME>
<RETURNS>GdaQueryField     *</RETURNS>
GdaQuery *query, const gchar *sql_name, GSList *fields_list
</FUNCTION>
<STRUCT>
<NAME>GdaObject</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaObjectClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaObjectPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaConnection</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaConnectionClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaConnectionPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaConnectionEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaConnectionEventClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaConnectionEventPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataHandler</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataHandlerIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaServerProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaServerProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaServerProviderPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaServerProviderInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaServerOperation</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaServerOperationClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaServerOperationPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaClient</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaClientClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaClientPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaEntity</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaEntityIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaEntityField</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaEntityFieldIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataProxy</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataProxyClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataProxyPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaColumn</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaColumnClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaColumnPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelIter</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelIterClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelIterPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDict</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictPrivate</NAME>
</STRUCT>
<VARIABLE>
<NAME>default_dict</NAME>
extern  GdaDict *default_dict;
</VARIABLE>
<MACRO>
<NAME>ASSERT_DICT</NAME>
#define ASSERT_DICT(x) ((x) ? (x) : default_dict)
</MACRO>
<STRUCT>
<NAME>GdaDictType</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictTypeClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictTypePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GDA_FUNC_AGG_TEST_PARAMS_DO_TEST</NAME>
#define GDA_FUNC_AGG_TEST_PARAMS_DO_TEST 0
</MACRO>
<STRUCT>
<NAME>GdaDictFunction</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictFunctionClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictFunctionPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictAggregate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictAggregateClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictAggregatePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictDatabase</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictDatabaseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictDatabasePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictTable</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictTableClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictTablePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictField</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictFieldClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictFieldPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictConstraint</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictConstraintClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDictConstraintPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaParameter</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaParameterClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaParameterPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaParameterList</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaParameterListClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaParameterListNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaParameterListGroup</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaParameterListSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaParameterListPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlStorage</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXmlStorageIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaRenderer</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaRendererIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaReferer</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaRefererIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaObjectRef</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaObjectRefClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaObjectRefPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQuery</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryTarget</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryTargetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryTargetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryJoin</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryJoinClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryJoinPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryCondition</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryConditionClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryConditionPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryField</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldAll</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldAllClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldAllPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldField</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldFieldClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldFieldPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldValue</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldValueClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldValuePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldFunc</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldFuncClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldFuncPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldAgg</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldAggClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldAggPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaBlobOp</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaBlobOpClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraph</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphQuery</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphQueryClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphQueryPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphItemClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphItemPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>strtok_r</NAME>
#define strtok_r(s,d,p) strtok(s,d)
</MACRO>
<MACRO>
<NAME>D_COL_NOR</NAME>
#define D_COL_NOR "\033[0m"
</MACRO>
<MACRO>
<NAME>D_COL_H0</NAME>
#define D_COL_H0 "\033[;34;7m"
</MACRO>
<MACRO>
<NAME>D_COL_H1</NAME>
#define D_COL_H1 "\033[;36;7m"
</MACRO>
<MACRO>
<NAME>D_COL_H2</NAME>
#define D_COL_H2 "\033[;36;4m"
</MACRO>
<MACRO>
<NAME>D_COL_OK</NAME>
#define D_COL_OK "\033[;32m"
</MACRO>
<MACRO>
<NAME>D_COL_ERR</NAME>
#define D_COL_ERR "\033[;31;1m"
</MACRO>
<MACRO>
<NAME>AAA</NAME>
#define AAA(X) (g_print (D_COL_H1 "DEBUG MARK %d\n" D_COL_NOR, X))
</MACRO>
<MACRO>
<NAME>DEBUG_HEADER</NAME>
#define DEBUG_HEADER (g_print (D_COL_H0 "====================== %s %s():%d ======================\n" D_COL_NOR, __FILE__, __FUNCTION__, __LINE__))
</MACRO>
<MACRO>
<NAME>DEBUG_HEADER_STR</NAME>
#define DEBUG_HEADER_STR(str) (g_print (D_COL_H0 "====================== %s %s %s():%d ======================\n" D_COL_NOR, (str), __FILE__, __FUNCTION__, __LINE__))
</MACRO>
<MACRO>
<NAME>TO_IMPLEMENT</NAME>
    #define TO_IMPLEMENT g_print (D_COL_ERR "Implementation missing:" D_COL_NOR " %s() in %s line %d\n", __FUNCTION__, __FILE__,__LINE__)
</MACRO>
<MACRO>
<NAME>TO_IMPLEMENT</NAME>
    #define TO_IMPLEMENT g_print ("Implementation missing: %s() in %s line %d\n", __FUNCTION__, __FILE__,__LINE__)
</MACRO>
<MACRO>
<NAME>GDA_TYPE_DICT</NAME>
#define GDA_TYPE_DICT          (gda_dict_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DICT</NAME>
#define GDA_DICT(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_dict_get_type(), GdaDict)
</MACRO>
<MACRO>
<NAME>GDA_DICT_CLASS</NAME>
#define GDA_DICT_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_dict_get_type (), GdaDictClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DICT</NAME>
#define GDA_IS_DICT(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_dict_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_dict_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DICT_ERROR</NAME>
#define GDA_DICT_ERROR gda_dict_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDictError</NAME>
typedef enum {
	GDA_DICT_META_DATA_UPDATE_ERROR,
	GDA_DICT_META_DATA_UPDATE_USER_STOPPED,
	GDA_DICT_LOAD_FILE_NOT_EXIST_ERROR,
	GDA_DICT_FILE_LOAD_ERROR,
	GDA_DICT_FILE_SAVE_ERROR,
	GDA_DICT_DATATYPE_ERROR,
	GDA_DICT_FUNCTIONS_ERROR,
	GDA_DICT_AGGREGATES_ERROR
} GdaDictError;
</ENUM>
<STRUCT>
<NAME>GdaDict</NAME>
struct _GdaDict
{
	GObject          object;
	GdaDictPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDictClass</NAME>
struct _GdaDictClass
{
	GObjectClass     parent_class;

	/* signals the addition, removal or update of objects */
	void    (*object_added)         (GdaDict *dict, GdaObject *obj);
	void    (*object_removed)       (GdaDict *dict, GdaObject *obj);
	void    (*object_updated)       (GdaDict *dict, GdaObject *obj);
	void    (*object_act_changed)   (GdaDict *dict, GdaObject *obj);

        void    (*data_update_started)  (GdaDict *dict);
        void    (*update_progress)      (GdaDict *dict, gchar *msg, guint now, guint total);
        void    (*data_update_finished) (GdaDict *dict);

	/* signal that a change in the whole dictionary has occurred */
	void    (*changed)              (GdaDict * dict);

	/* class variable */
	GSList   *class_registry_list; /* list of GdaDictRegFunc functions */
	gpointer  reserved1;
	gpointer  reserved2;
};
</STRUCT>
<FUNCTION>
<NAME>gda_dict_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_new</NAME>
<RETURNS>GdaDict          *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_extend_with_functions</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_set_connection</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict, GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_connection</NAME>
<RETURNS>GdaConnection    *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_database</NAME>
<RETURNS>GdaDictDatabase  *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_declare_object_string_id_change</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict, GdaObject *obj, const gchar *oldid
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_object_by_string_id</NAME>
<RETURNS>GdaObject        *</RETURNS>
GdaDict *dict, const gchar *strid
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_update_dbms_meta_data</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDict *dict, GType limit_to_type, const gchar *limit_obj_name,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_stop_update_dbms_meta_data</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_compute_xml_filename</NAME>
<RETURNS>gchar            *</RETURNS>
GdaDict *dict, const gchar *datasource,const gchar *app_id, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_set_xml_filename</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict, const gchar *xmlfile
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_xml_filename</NAME>
<RETURNS>const gchar      *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_load</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDict *dict, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_save</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDict *dict, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_load_xml_file</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDict *dict, const gchar *xmlfile, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_save_xml_file</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDict *dict, const gchar *xmlfile, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_handler</NAME>
<RETURNS>GdaDataHandler   *</RETURNS>
GdaDict *dict, GType for_type
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_default_handler</NAME>
<RETURNS>GdaDataHandler   *</RETURNS>
GdaDict *dict, GType for_type
</FUNCTION>
<MACRO>
<NAME>gda_dict_get_queries</NAME>
#define gda_dict_get_queries(dict) gda_dict_get_objects((dict), GDA_TYPE_QUERY)
</MACRO>
<MACRO>
<NAME>gda_dict_get_query_by_xml_id</NAME>
#define gda_dict_get_query_by_xml_id(dict,xml_id) ((GdaQuery*)gda_dict_get_object_by_xml_id((dict), GDA_TYPE_QUERY, (xml_id)))
</MACRO>
<MACRO>
<NAME>gda_dict_get_dict_types</NAME>
#define gda_dict_get_dict_types(dict) gda_dict_get_objects((dict), GDA_TYPE_DICT_TYPE)
</MACRO>
<MACRO>
<NAME>gda_dict_get_dict_type_by_name</NAME>
#define gda_dict_get_dict_type_by_name(dict,type_name) ((GdaDictType*)gda_dict_get_object_by_name((dict), GDA_TYPE_DICT_TYPE, (type_name)))
</MACRO>
<MACRO>
<NAME>gda_dict_get_dict_type_by_xml_id</NAME>
#define gda_dict_get_dict_type_by_xml_id(dict,xml_id) ((GdaDictType*)gda_dict_get_object_by_xml_id((dict), GDA_TYPE_DICT_TYPE, (xml_id)))
</MACRO>
<MACRO>
<NAME>gda_dict_get_functions</NAME>
#define gda_dict_get_functions(dict) gda_dict_get_objects ((dict), GDA_TYPE_DICT_FUNCTION)
</MACRO>
<MACRO>
<NAME>gda_dict_get_functions_by_name</NAME>
#define gda_dict_get_functions_by_name(dict,funcname) gda_functions_get_by_name ((dict), (funcname))
</MACRO>
<MACRO>
<NAME>gda_dict_get_function_by_name_arg</NAME>
#define gda_dict_get_function_by_name_arg(dict,funcname,argtypes) gda_functions_get_by_name_arg ((dict), (funcname), (argtypes))
</MACRO>
<MACRO>
<NAME>gda_dict_get_function_by_xml_id</NAME>
#define gda_dict_get_function_by_xml_id(dict,xml_id) gda_dict_get_object_by_xml_id ((dict), GDA_TYPE_DICT_FUNCTION, (xml_id))
</MACRO>
<MACRO>
<NAME>gda_dict_get_function_by_dbms_id</NAME>
#define gda_dict_get_function_by_dbms_id(dict,dbms_id) gda_functions_get_by_dbms_id ((dict), (dbms_id))
</MACRO>
<MACRO>
<NAME>gda_dict_get_aggregates</NAME>
#define gda_dict_get_aggregates(dict) gda_dict_get_objects((dict), GDA_TYPE_DICT_AGGREGATE)
</MACRO>
<MACRO>
<NAME>gda_dict_get_aggregates_by_name</NAME>
#define gda_dict_get_aggregates_by_name(dict,aggname) gda_aggregates_get_by_name((dict), (aggname))
</MACRO>
<MACRO>
<NAME>gda_dict_get_aggregate_by_name_arg</NAME>
#define gda_dict_get_aggregate_by_name_arg(dict,argname,argtype) gda_aggregates_get_by_name_arg ((dict), (argname), (argtype))
</MACRO>
<MACRO>
<NAME>gda_dict_get_aggregate_by_xml_id</NAME>
#define gda_dict_get_aggregate_by_xml_id(dict,xml_id) gda_dict_get_object_by_xml_id((dict), GDA_TYPE_DICT_AGGREGATE, (xml_id))
</MACRO>
<MACRO>
<NAME>gda_dict_get_aggregate_by_dbms_id</NAME>
#define gda_dict_get_aggregate_by_dbms_id(dict,dbmsid) gda_aggregates_get_by_dbms_id((dict),(dbmsid))
</MACRO>
<FUNCTION>
<NAME>gda_dict_declare_object</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict, GdaObject *object
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_declare_object_as</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict, GdaObject *object, GType as_type
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_assume_object</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict, GdaObject *object
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_assume_object_as</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict, GdaObject *object, GType as_type
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_unassume_object</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict, GdaObject *object
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_object_is_assumed</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDict *dict, GdaObject *object
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_objects</NAME>
<RETURNS>GSList           *</RETURNS>
GdaDict *dict, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_object_by_name</NAME>
<RETURNS>GdaObject        *</RETURNS>
GdaDict *dict, GType type, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_object_by_xml_id</NAME>
<RETURNS>GdaObject        *</RETURNS>
GdaDict *dict, GType type, const gchar *xml_id
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_dump</NAME>
<RETURNS>void              </RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_declare_param_user</NAME>
<RETURNS>void                   </RETURNS>
GdaParameter *param, GdaObject *user
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_get_param_users</NAME>
<RETURNS>GSList                *</RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_replace_param_users</NAME>
<RETURNS>void                   </RETURNS>
GdaParameter *param, GHashTable *replacements
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_find_param_for_user</NAME>
<RETURNS>GdaParameter          *</RETURNS>
GdaParameterList *paramlist,GdaObject *user
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_get_alphanum_name</NAME>
<RETURNS>gchar                 *</RETURNS>
GdaParameter *param
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_THREADER</NAME>
#define GDA_TYPE_THREADER          (gda_threader_get_type())
</MACRO>
<MACRO>
<NAME>GDA_THREADER</NAME>
#define GDA_THREADER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_threader_get_type(), GdaThreader)
</MACRO>
<MACRO>
<NAME>GDA_THREADER_CLASS</NAME>
#define GDA_THREADER_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_threader_get_type (), GdaThreaderClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_THREADER</NAME>
#define GDA_IS_THREADER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_threader_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaThreader</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaThreaderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaThreaderPrivate</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GdaThreaderFunc</NAME>
<RETURNS>void </RETURNS>
GdaThreader *, guint, gpointer
</USER_FUNCTION>
<STRUCT>
<NAME>GdaThreader</NAME>
struct _GdaThreader
{
	GObject             object;
	GdaThreaderPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaThreaderClass</NAME>
struct _GdaThreaderClass
{
	GObjectClass            parent_class;

	/* signals */
	void        (*finished)       (GdaThreader *thread, guint job_id, gpointer arg_data);
	void        (*cancelled)      (GdaThreader *thread, guint job_id, gpointer arg_data);
};
</STRUCT>
<FUNCTION>
<NAME>gda_threader_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_threader_new</NAME>
<RETURNS>GObject     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_threader_start_thread</NAME>
<RETURNS>guint        </RETURNS>
GdaThreader *thread, GThreadFunc func, gpointer func_arg,GdaThreaderFunc ok_callback, GdaThreaderFunc cancel_callback,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_threader_cancel</NAME>
<RETURNS>void         </RETURNS>
GdaThreader *thread, guint job_id
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_PARAMETER</NAME>
#define GDA_TYPE_PARAMETER          (gda_parameter_get_type())
</MACRO>
<MACRO>
<NAME>GDA_PARAMETER</NAME>
#define GDA_PARAMETER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_parameter_get_type(), GdaParameter)
</MACRO>
<MACRO>
<NAME>GDA_PARAMETER_CLASS</NAME>
#define GDA_PARAMETER_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_parameter_get_type (), GdaParameterClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_PARAMETER</NAME>
#define GDA_IS_PARAMETER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_parameter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_parameter_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_PARAMETER_ERROR</NAME>
#define GDA_PARAMETER_ERROR gda_parameter_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaParameterError</NAME>
typedef enum {
	GDA_PARAMETER_QUERY_LIMIT_ERROR
} GdaParameterError;
</ENUM>
<STRUCT>
<NAME>GdaParameter</NAME>
struct _GdaParameter
{
	GdaObject                  object;
	GdaParameterPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaParameterClass</NAME>
struct _GdaParameterClass
{
	GdaObjectClass             parent_class;
	void                     (*restrict_changed)         (GdaParameter *param);
	void                     (*reserved_0)               (GdaParameter *param);
	void                     (*reserved_1)               (GdaParameter *param);
	void                     (*reserved_2)               (GdaParameter *param);
	void                     (*reserved_3)               (GdaParameter *param);
};
</STRUCT>
<FUNCTION>
<NAME>gda_parameter_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_new</NAME>
<RETURNS>GdaParameter          *</RETURNS>
GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_new_copy</NAME>
<RETURNS>GdaParameter          *</RETURNS>
GdaParameter *orig
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_get_g_type</NAME>
<RETURNS>GType                  </RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_new_string</NAME>
<RETURNS>GdaParameter          *</RETURNS>
const gchar *name, const gchar *str
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_new_boolean</NAME>
<RETURNS>GdaParameter          *</RETURNS>
const gchar *name, gboolean value
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_get_value</NAME>
<RETURNS>const GValue          *</RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_get_value_str</NAME>
<RETURNS>gchar                 *</RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_set_value</NAME>
<RETURNS>void                   </RETURNS>
GdaParameter *param, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_set_value_str</NAME>
<RETURNS>gboolean               </RETURNS>
GdaParameter *param, const gchar *value
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_declare_invalid</NAME>
<RETURNS>void                   </RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_is_valid</NAME>
<RETURNS>gboolean               </RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_get_default_value</NAME>
<RETURNS>const GValue          *</RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_set_default_value</NAME>
<RETURNS>void                   </RETURNS>
GdaParameter *param, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_get_exists_default_value</NAME>
<RETURNS>gboolean               </RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_set_exists_default_value</NAME>
<RETURNS>void                   </RETURNS>
GdaParameter *param, gboolean default_value_exists
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_set_not_null</NAME>
<RETURNS>void                   </RETURNS>
GdaParameter *param, gboolean not_null
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_get_not_null</NAME>
<RETURNS>gboolean               </RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_restrict_values</NAME>
<RETURNS>gboolean               </RETURNS>
GdaParameter *param, GdaDataModel *model,gint col, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_has_restrict_values</NAME>
<RETURNS>gboolean               </RETURNS>
GdaParameter *param, GdaDataModel **model,gint *col
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_bind_to_param</NAME>
<RETURNS>void                   </RETURNS>
GdaParameter *param, GdaParameter *bind_to
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_get_bind_param</NAME>
<RETURNS>GdaParameter          *</RETURNS>
GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_internal_transaction_started</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, const gchar *parent_trans, const gchar *trans_name,GdaTransactionIsolation isol_level
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_internal_transaction_rolledback</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, const gchar *trans_name
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_internal_transaction_committed</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, const gchar *trans_name
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_internal_sql_executed</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, const gchar *sql, GdaConnectionEvent *error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_internal_savepoint_added</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, const gchar *parent_trans, const gchar *svp_name
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_internal_savepoint_rolledback</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, const gchar *svp_name
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_internal_savepoint_removed</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, const gchar *svp_name
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_internal_change_transaction_state</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc,GdaTransactionStatusState newstate
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_internal_treat_sql</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, const gchar *sql, GdaConnectionEvent *error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_force_status</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, gboolean opened
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_init_prepared_statement_hash</NAME>
<RETURNS>void     </RETURNS>
GdaConnection *cnc, GDestroyNotify stmt_destroy_func
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_destroy_prepared_statement_hash</NAME>
<RETURNS>void     </RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_add_prepared_statement</NAME>
<RETURNS>void     </RETURNS>
GdaConnection *cnc, GdaQuery *query, gpointer prepared_stmt
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_del_prepared_statement</NAME>
<RETURNS>void     </RETURNS>
GdaConnection *cnc, GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_prepared_statement</NAME>
<RETURNS>gpointer </RETURNS>
GdaConnection *cnc, GdaQuery *query
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_FIELD</NAME>
#define GDA_TYPE_QUERY_FIELD_FIELD          (gda_query_field_field_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_FIELD</NAME>
#define GDA_QUERY_FIELD_FIELD(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_field_field_get_type(), GdaQueryFieldField)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_FIELD_CLASS</NAME>
#define GDA_QUERY_FIELD_FIELD_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_field_field_get_type (), GdaQueryFieldFieldClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_FIELD_FIELD</NAME>
#define GDA_IS_QUERY_FIELD_FIELD(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_field_field_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_field_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_FIELD_FIELD_ERROR</NAME>
#define GDA_QUERY_FIELD_FIELD_ERROR gda_query_field_field_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryFieldFieldError</NAME>
typedef enum
{
	GDA_QUERY_FIELD_FIELD_XML_LOAD_ERROR,
	GDA_QUERY_FIELD_FIELD_RENDER_ERROR
} GdaQueryFieldFieldError;
</ENUM>
<STRUCT>
<NAME>GdaQueryFieldField</NAME>
struct _GdaQueryFieldField
{
	GdaQueryField              object;
	GdaQueryFieldFieldPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldFieldClass</NAME>
struct _GdaQueryFieldFieldClass
{
	GdaQueryFieldClass                  parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_field_field_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_field_new</NAME>
<RETURNS>GdaQueryField    *</RETURNS>
GdaQuery *query, const gchar *field
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_field_get_ref_field_name</NAME>
<RETURNS>gchar            *</RETURNS>
GdaQueryFieldField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_field_get_ref_field</NAME>
<RETURNS>GdaEntityField   *</RETURNS>
GdaQueryFieldField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_field_get_target</NAME>
<RETURNS>GdaQueryTarget   *</RETURNS>
GdaQueryFieldField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_to_xml_node</NAME>
<RETURNS>xmlNodePtr                    </RETURNS>
GdaDataModel *model, const gint *cols, gint nb_cols,const gint *rows, gint nb_rows, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_add_data_from_xml_node</NAME>
<RETURNS>gboolean                      </RETURNS>
GdaDataModel *model, xmlNodePtr node, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_move_iter_at_row</NAME>
<RETURNS>gboolean                      </RETURNS>
GdaDataModel *model, GdaDataModelIter *iter, gint row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_move_iter_next</NAME>
<RETURNS>gboolean                      </RETURNS>
GdaDataModel *model, GdaDataModelIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_move_iter_prev</NAME>
<RETURNS>gboolean                      </RETURNS>
GdaDataModel *model, GdaDataModelIter *iter
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_IMPORT</NAME>
#define GDA_TYPE_DATA_MODEL_IMPORT            (gda_data_model_import_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_IMPORT</NAME>
#define GDA_DATA_MODEL_IMPORT(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_MODEL_IMPORT, GdaDataModelImport))
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_IMPORT_CLASS</NAME>
#define GDA_DATA_MODEL_IMPORT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_IMPORT, GdaDataModelImportClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_IMPORT</NAME>
#define GDA_IS_DATA_MODEL_IMPORT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_DATA_MODEL_IMPORT))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_IMPORT_CLASS</NAME>
#define GDA_IS_DATA_MODEL_IMPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_DATA_MODEL_IMPORT))
</MACRO>
<STRUCT>
<NAME>GdaDataModelImport</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelImportClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelImportPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelImport</NAME>
struct _GdaDataModelImport {
	GdaObject                  object;
	GdaDataModelImportPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataModelImportClass</NAME>
struct _GdaDataModelImportClass {
	GdaObjectClass             parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_import_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_import_new_file</NAME>
<RETURNS>GdaDataModel *</RETURNS>
const gchar *filename, gboolean random_access,GdaParameterList *options
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_import_new_mem</NAME>
<RETURNS>GdaDataModel *</RETURNS>
const gchar *data, gboolean random_access,GdaParameterList *options
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_import_new_xml_node</NAME>
<RETURNS>GdaDataModel *</RETURNS>
xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_import_get_errors</NAME>
<RETURNS>GSList       *</RETURNS>
GdaDataModelImport *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_import_clean_errors</NAME>
<RETURNS>void          </RETURNS>
GdaDataModelImport *model
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CONNECTION</NAME>
#define GDA_TYPE_CONNECTION            (gda_connection_get_type())
</MACRO>
<MACRO>
<NAME>GDA_CONNECTION</NAME>
#define GDA_CONNECTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_CONNECTION, GdaConnection))
</MACRO>
<MACRO>
<NAME>GDA_CONNECTION_CLASS</NAME>
#define GDA_CONNECTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_CONNECTION, GdaConnectionClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_CONNECTION</NAME>
#define GDA_IS_CONNECTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_CONNECTION))
</MACRO>
<MACRO>
<NAME>GDA_IS_CONNECTION_CLASS</NAME>
#define GDA_IS_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_CONNECTION))
</MACRO>
<FUNCTION>
<NAME>gda_connection_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_CONNECTION_ERROR</NAME>
#define GDA_CONNECTION_ERROR gda_connection_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaConnectionError</NAME>
typedef enum {
        GDA_CONNECTION_CONN_OPEN_ERROR,
        GDA_CONNECTION_DO_QUERY_ERROR,
	GDA_CONNECTION_NONEXIST_DSN_ERROR,
	GDA_CONNECTION_NO_CNC_SPEC_ERROR,
	GDA_CONNECTION_NO_PROVIDER_SPEC_ERROR,
	GDA_CONNECTION_OPEN_ERROR,
	GDA_CONNECTION_EXECUTE_COMMAND_ERROR
} GdaConnectionError;
</ENUM>
<STRUCT>
<NAME>GdaConnection</NAME>
struct _GdaConnection {
	GObject               object;
	GdaConnectionPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaConnectionClass</NAME>
struct _GdaConnectionClass {
	GObjectClass          object_class;

	/* signals */
	void   (*error)                     (GdaConnection *cnc, GdaConnectionEvent *error);
        void   (*conn_opened)               (GdaConnection *obj);
        void   (*conn_to_close)             (GdaConnection *obj);
        void   (*conn_closed)               (GdaConnection *obj);
	void   (*dsn_changed)               (GdaConnection *obj);
	void   (*transaction_status_changed)(GdaConnection *obj);
};
</STRUCT>
<ENUM>
<NAME>GdaConnectionOptions</NAME>
typedef enum {
        GDA_CONNECTION_OPTIONS_NONE = 0,
	GDA_CONNECTION_OPTIONS_READ_ONLY = 1 << 0,
	GDA_CONNECTION_OPTIONS_DONT_SHARE = 2 << 0
} GdaConnectionOptions;
</ENUM>
<ENUM>
<NAME>GdaConnectionFeature</NAME>
typedef enum {
	GDA_CONNECTION_FEATURE_AGGREGATES,
	GDA_CONNECTION_FEATURE_BLOBS,
	GDA_CONNECTION_FEATURE_INDEXES,
	GDA_CONNECTION_FEATURE_INHERITANCE,
	GDA_CONNECTION_FEATURE_NAMESPACES,
	GDA_CONNECTION_FEATURE_PROCEDURES,
	GDA_CONNECTION_FEATURE_SEQUENCES,
	GDA_CONNECTION_FEATURE_SQL,
	GDA_CONNECTION_FEATURE_TRANSACTIONS,
	GDA_CONNECTION_FEATURE_SAVEPOINTS,
	GDA_CONNECTION_FEATURE_SAVEPOINTS_REMOVE,
	GDA_CONNECTION_FEATURE_TRIGGERS,
	GDA_CONNECTION_FEATURE_UPDATABLE_CURSOR,
	GDA_CONNECTION_FEATURE_USERS,
	GDA_CONNECTION_FEATURE_VIEWS,
	GDA_CONNECTION_FEATURE_XML_QUERIES
} GdaConnectionFeature;
</ENUM>
<ENUM>
<NAME>GdaConnectionSchema</NAME>
typedef enum {
	GDA_CONNECTION_SCHEMA_AGGREGATES,
	GDA_CONNECTION_SCHEMA_DATABASES,
	GDA_CONNECTION_SCHEMA_FIELDS,
	GDA_CONNECTION_SCHEMA_INDEXES,
	GDA_CONNECTION_SCHEMA_LANGUAGES,
	GDA_CONNECTION_SCHEMA_NAMESPACES,
	GDA_CONNECTION_SCHEMA_PARENT_TABLES,
	GDA_CONNECTION_SCHEMA_PROCEDURES,
	GDA_CONNECTION_SCHEMA_SEQUENCES,
	GDA_CONNECTION_SCHEMA_TABLES,
	GDA_CONNECTION_SCHEMA_TRIGGERS,
	GDA_CONNECTION_SCHEMA_TYPES,
	GDA_CONNECTION_SCHEMA_USERS,
	GDA_CONNECTION_SCHEMA_VIEWS,
	GDA_CONNECTION_SCHEMA_CONSTRAINTS,
	GDA_CONNECTION_SCHEMA_TABLE_CONTENTS
} GdaConnectionSchema;
</ENUM>
<FUNCTION>
<NAME>gda_connection_get_type</NAME>
<RETURNS>GType                </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_new</NAME>
<RETURNS>GdaConnection       *</RETURNS>
GdaClient *client,GdaServerProvider *provider,const gchar *dsn,const gchar *username,const gchar *password,GdaConnectionOptions options
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_open</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_close</NAME>
<RETURNS>void                 </RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_close_no_warning</NAME>
<RETURNS>void                 </RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_is_opened</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_client</NAME>
<RETURNS>GdaClient           *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_provider</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_provider_obj</NAME>
<RETURNS>GdaServerProvider   *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_infos</NAME>
<RETURNS>GdaServerProviderInfo *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_options</NAME>
<RETURNS>GdaConnectionOptions </RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_server_version</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_database</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_dsn</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_set_dsn</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *datasource
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_cnc_string</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_username</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_set_username</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *username
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_password</NAME>
<RETURNS>const gchar         *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_set_password</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *password
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_add_event</NAME>
<RETURNS>void                 </RETURNS>
GdaConnection *cnc, GdaConnectionEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_add_event_string</NAME>
<RETURNS>GdaConnectionEvent  *</RETURNS>
GdaConnection *cnc, const gchar *str, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_add_events_list</NAME>
<RETURNS>void                 </RETURNS>
GdaConnection *cnc, GList *events_list
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_clear_events_list</NAME>
<RETURNS>void                 </RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_events</NAME>
<RETURNS>const GList         *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_change_database</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_execute_select_command</NAME>
<RETURNS>GdaDataModel        *</RETURNS>
GdaConnection *cnc, GdaCommand *cmd,GdaParameterList *params, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_execute_non_select_command</NAME>
<RETURNS>gint                 </RETURNS>
GdaConnection *cnc, GdaCommand *cmd,GdaParameterList *params, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_execute_command</NAME>
<RETURNS>GList               *</RETURNS>
GdaConnection *cnc, GdaCommand *cmd,GdaParameterList *params, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_last_insert_id</NAME>
<RETURNS>gchar               *</RETURNS>
GdaConnection *cnc, GdaDataModel *recset
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_begin_transaction</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *name,GdaTransactionIsolation level, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_commit_transaction</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_rollback_transaction</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_add_savepoint</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_rollback_savepoint</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_delete_savepoint</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_transaction_status</NAME>
<RETURNS>GdaTransactionStatus *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_value_to_sql_string</NAME>
<RETURNS>gchar               *</RETURNS>
GdaConnection *cnc, GValue *from
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_supports_feature</NAME>
<RETURNS>gboolean             </RETURNS>
GdaConnection *cnc, GdaConnectionFeature feature
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_get_schema</NAME>
<RETURNS>GdaDataModel        *</RETURNS>
GdaConnection *cnc, GdaConnectionSchema schema,GdaParameterList *params, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_PROXY</NAME>
#define GDA_TYPE_DATA_PROXY          (gda_data_proxy_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_PROXY</NAME>
#define GDA_DATA_PROXY(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_data_proxy_get_type(), GdaDataProxy)
</MACRO>
<MACRO>
<NAME>GDA_DATA_PROXY_CLASS</NAME>
#define GDA_DATA_PROXY_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_data_proxy_get_type (), GdaDataProxyClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_PROXY</NAME>
#define GDA_IS_DATA_PROXY(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_data_proxy_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_data_proxy_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DATA_PROXY_ERROR</NAME>
#define GDA_DATA_PROXY_ERROR gda_data_proxy_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDataProxyError</NAME>
typedef enum {
	GDA_DATA_PROXY_COMMIT_ERROR,
	GDA_DATA_PROXY_COMMIT_CANCELLED,
	GDA_DATA_PROXY_READ_ONLY_VALUE,
	GDA_DATA_PROXY_READ_ONLY_ROW,
	GDA_DATA_PROXY_FILTER_ERROR
} GdaDataProxyError;
</ENUM>
<STRUCT>
<NAME>GdaDataProxy</NAME>
struct _GdaDataProxy
{
	GdaObject               object;
	GdaDataProxyPrivate    *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataProxyClass</NAME>
struct _GdaDataProxyClass
{
	GdaObjectClass          parent_class;

	void                 (* row_delete_changed)   (GdaDataProxy *proxy, gint row, gboolean to_be_deleted);

	void                 (* sample_size_changed)  (GdaDataProxy *proxy, gint sample_size);
	void                 (* sample_changed)       (GdaDataProxy *proxy, gint sample_start, gint sample_end);

	gboolean             (* pre_changes_applied)  (GdaDataProxy *proxy, gint row, gint proxied_row);
	void                 (* post_changes_applied) (GdaDataProxy *proxy, gint row, gint proxied_row);
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_proxy_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_new</NAME>
<RETURNS>GObject          *</RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_proxied_model</NAME>
<RETURNS>GdaDataModel     *</RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_proxied_model_n_cols</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_proxied_model_n_rows</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_is_read_only</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_values</NAME>
<RETURNS>GSList           *</RETURNS>
GdaDataProxy *proxy, gint proxy_row,gint *cols_index, gint n_cols
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_value_attributes</NAME>
<RETURNS>GdaValueAttribute </RETURNS>
GdaDataProxy *proxy, gint proxy_row, gint col
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_alter_value_attributes</NAME>
<RETURNS>void              </RETURNS>
GdaDataProxy *proxy, gint proxy_row, gint col, GdaValueAttribute alter_flags
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_proxied_model_row</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy, gint proxy_row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_delete</NAME>
<RETURNS>void              </RETURNS>
GdaDataProxy *proxy, gint proxy_row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_undelete</NAME>
<RETURNS>void              </RETURNS>
GdaDataProxy *proxy, gint proxy_row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_row_is_deleted</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataProxy *proxy, gint proxy_row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_row_is_inserted</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataProxy *proxy, gint proxy_row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_find_row_from_values</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy, GSList *values,gint *cols_index
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_row_has_changed</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataProxy *proxy, gint proxy_row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_has_changed</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_n_new_rows</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_n_modified_rows</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_apply_row_changes</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataProxy *proxy, gint proxy_row, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_cancel_row_changes</NAME>
<RETURNS>void              </RETURNS>
GdaDataProxy *proxy, gint proxy_row, gint col
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_apply_all_changes</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataProxy *proxy, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_cancel_all_changes</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_set_sample_size</NAME>
<RETURNS>void              </RETURNS>
GdaDataProxy *proxy, gint sample_size
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_sample_size</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_set_sample_start</NAME>
<RETURNS>void              </RETURNS>
GdaDataProxy *proxy, gint sample_start
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_sample_start</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_sample_end</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_set_filter_expr</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataProxy *proxy, const gchar *filter_expr, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_filter_expr</NAME>
<RETURNS>const gchar      *</RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<FUNCTION>
<NAME>gda_data_proxy_get_filtered_n_rows</NAME>
<RETURNS>gint              </RETURNS>
GdaDataProxy *proxy
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_OBJECT_REF</NAME>
#define GDA_TYPE_OBJECT_REF          (gda_object_ref_get_type())
</MACRO>
<MACRO>
<NAME>GDA_OBJECT_REF</NAME>
#define GDA_OBJECT_REF(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_object_ref_get_type(), GdaObjectRef)
</MACRO>
<MACRO>
<NAME>GDA_OBJECT_REF_CLASS</NAME>
#define GDA_OBJECT_REF_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_object_ref_get_type (), GdaObjectRefClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_OBJECT_REF</NAME>
#define GDA_IS_OBJECT_REF(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_object_ref_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_object_ref_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_OBJECT_REF_ERROR</NAME>
#define GDA_OBJECT_REF_ERROR gda_object_ref_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaObjectRefType</NAME>
typedef enum
{
	REFERENCE_BY_XML_ID,
	REFERENCE_BY_NAME
} GdaObjectRefType;
</ENUM>
<ENUM>
<NAME>GdaObjectRefError</NAME>
typedef enum
{
	GDA_OBJECT_REF_XML_LOAD_ERROR
} GdaObjectRefError;
</ENUM>
<STRUCT>
<NAME>GdaObjectRef</NAME>
struct _GdaObjectRef
{
	GdaObject                  object;
	GdaObjectRefPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaObjectRefClass</NAME>
struct _GdaObjectRefClass
{
	GdaObjectClass                    parent_class;

	/* signals */
	void   (*ref_found)           (GdaObjectRef *obj);
	void   (*ref_lost)            (GdaObjectRef *obj);
};
</STRUCT>
<FUNCTION>
<NAME>gda_object_ref_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_new</NAME>
<RETURNS>GObject        *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_new_no_ref_count</NAME>
<RETURNS>GObject        *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_new_copy</NAME>
<RETURNS>GObject        *</RETURNS>
GdaObjectRef *orig
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_set_ref_name</NAME>
<RETURNS>void            </RETURNS>
GdaObjectRef *ref, GType ref_type,GdaObjectRefType type, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_get_ref_name</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaObjectRef *ref, GType *ref_type, GdaObjectRefType *type
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_get_ref_object_name</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaObjectRef *ref
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_get_ref_type</NAME>
<RETURNS>GType           </RETURNS>
GdaObjectRef *ref
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_set_ref_object</NAME>
<RETURNS>void            </RETURNS>
GdaObjectRef *ref, GdaObject *object
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_set_ref_object_type</NAME>
<RETURNS>void            </RETURNS>
GdaObjectRef *ref, GdaObject *object, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_replace_ref_object</NAME>
<RETURNS>void            </RETURNS>
GdaObjectRef *ref, GHashTable *replacements
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_get_ref_object</NAME>
<RETURNS>GdaObject      *</RETURNS>
GdaObjectRef *ref
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_activate</NAME>
<RETURNS>gboolean        </RETURNS>
GdaObjectRef *ref
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_deactivate</NAME>
<RETURNS>void            </RETURNS>
GdaObjectRef *ref
</FUNCTION>
<FUNCTION>
<NAME>gda_object_ref_is_active</NAME>
<RETURNS>gboolean        </RETURNS>
GdaObjectRef *ref
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_COLUMN</NAME>
#define GDA_TYPE_COLUMN            (gda_column_get_type())
</MACRO>
<MACRO>
<NAME>GDA_COLUMN</NAME>
#define GDA_COLUMN(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_COLUMN, GdaColumn))
</MACRO>
<MACRO>
<NAME>GDA_COLUMN_CLASS</NAME>
#define GDA_COLUMN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_COLUMN, GdaColumnClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_COLUMN</NAME>
#define GDA_IS_COLUMN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_COLUMN))
</MACRO>
<MACRO>
<NAME>GDA_IS_COLUMN_CLASS</NAME>
#define GDA_IS_COLUMN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_COLUMN))
</MACRO>
<STRUCT>
<NAME>GdaColumn</NAME>
struct _GdaColumn {
	GObject           object;
	GdaColumnPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaColumnClass</NAME>
struct _GdaColumnClass {
	GObjectClass parent_class;
	
	/* signals */
	void (* name_changed)     (GdaColumn *column, const gchar *old_name);
	void (* g_type_changed) (GdaColumn *column, GType old_type, GType new_type);
};
</STRUCT>
<FUNCTION>
<NAME>gda_column_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_column_new</NAME>
<RETURNS>GdaColumn      *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_column_copy</NAME>
<RETURNS>GdaColumn      *</RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_title</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_title</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, const gchar *title
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_defined_size</NAME>
<RETURNS>glong           </RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_defined_size</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, glong size
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_name</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_name</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_table</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_table</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, const gchar *table
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_caption</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_caption</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, const gchar *caption
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_scale</NAME>
<RETURNS>glong           </RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_scale</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, glong scale
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_dbms_type</NAME>
<RETURNS>const gchar*</RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_dbms_type</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, const gchar *dbms_type
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_g_type</NAME>
<RETURNS>GType           </RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_g_type</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_allow_null</NAME>
<RETURNS>gboolean        </RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_allow_null</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, gboolean allow
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_primary_key</NAME>
<RETURNS>gboolean        </RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_primary_key</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, gboolean pk
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_unique_key</NAME>
<RETURNS>gboolean        </RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_unique_key</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, gboolean uk
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_references</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_references</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, const gchar *ref
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_auto_increment</NAME>
<RETURNS>gboolean        </RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_auto_increment</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, gboolean is_auto
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_position</NAME>
<RETURNS>gint            </RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_position</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, gint position
</FUNCTION>
<FUNCTION>
<NAME>gda_column_get_default_value</NAME>
<RETURNS>const GValue   *</RETURNS>
GdaColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gda_column_set_default_value</NAME>
<RETURNS>void            </RETURNS>
GdaColumn *column, const GValue *default_value
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_string</NAME>
<RETURNS>gchar   *</RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_int</NAME>
<RETURNS>gint     </RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_float</NAME>
<RETURNS>gdouble  </RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_boolean</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_set_string</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *path, const gchar *new_value
</FUNCTION>
<FUNCTION>
<NAME>gda_config_set_int</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *path, gint new_value
</FUNCTION>
<FUNCTION>
<NAME>gda_config_set_float</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *path, gdouble new_value
</FUNCTION>
<FUNCTION>
<NAME>gda_config_set_boolean</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *path, gboolean new_value
</FUNCTION>
<FUNCTION>
<NAME>gda_config_remove_section</NAME>
<RETURNS>void     </RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_remove_key</NAME>
<RETURNS>void     </RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_has_section</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_has_key</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_list_sections</NAME>
<RETURNS>GList   *</RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_list_keys</NAME>
<RETURNS>GList   *</RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_type</NAME>
<RETURNS>gchar   *</RETURNS>
const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_config_free_list</NAME>
<RETURNS>void     </RETURNS>
GList *list
</FUNCTION>
<USER_FUNCTION>
<NAME>GdaConfigListenerFunc</NAME>
<RETURNS>void </RETURNS>
const gchar *path, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gda_config_add_listener</NAME>
<RETURNS>guint    </RETURNS>
const gchar *path, GdaConfigListenerFunc func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gda_config_remove_listener</NAME>
<RETURNS>void     </RETURNS>
guint id
</FUNCTION>
<STRUCT>
<NAME>GdaProviderInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaProviderInfo</NAME>
struct _GdaProviderInfo {
	gchar            *id;
	gchar            *location;
	gchar            *description;
	GdaParameterList *gda_params; /* Contains a list of GdaParameter to create a DSN */
	gchar            *dsn_spec; /* XML string with all the parameters required to create a DSN */
};
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_PROVIDER_INFO</NAME>
#define GDA_TYPE_PROVIDER_INFO (gda_provider_info_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_provider_info_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_provider_info_copy</NAME>
<RETURNS>GdaProviderInfo*</RETURNS>
GdaProviderInfo *src
</FUNCTION>
<FUNCTION>
<NAME>gda_provider_info_free</NAME>
<RETURNS>void             </RETURNS>
GdaProviderInfo *provider_info
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_provider_list</NAME>
<RETURNS>GList           *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_config_free_provider_list</NAME>
<RETURNS>void             </RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_provider_by_name</NAME>
<RETURNS>GdaProviderInfo *</RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_provider_model</NAME>
<RETURNS>GdaDataModel    *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdaDataSourceInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataSourceInfo</NAME>
struct _GdaDataSourceInfo {
	gchar    *name;
	gchar    *provider;
	gchar    *cnc_string;
	gchar    *description;
	gchar    *username;
	gchar    *password;
	gboolean  is_global;
};
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_DATA_SOURCE_INFO</NAME>
#define GDA_TYPE_DATA_SOURCE_INFO (gda_data_source_info_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_data_source_info_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_source_info_copy</NAME>
<RETURNS>GdaDataSourceInfo *</RETURNS>
GdaDataSourceInfo *src
</FUNCTION>
<FUNCTION>
<NAME>gda_data_source_info_equal</NAME>
<RETURNS>gboolean           </RETURNS>
GdaDataSourceInfo *info1, GdaDataSourceInfo *info2
</FUNCTION>
<FUNCTION>
<NAME>gda_config_find_data_source</NAME>
<RETURNS>GdaDataSourceInfo *</RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_data_source_info_free</NAME>
<RETURNS>void               </RETURNS>
GdaDataSourceInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_data_source_list</NAME>
<RETURNS>GList             *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_config_free_data_source_list</NAME>
<RETURNS>void               </RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>gda_config_get_data_source_model</NAME>
<RETURNS>GdaDataModel      *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_config_can_modify_global_config</NAME>
<RETURNS>gboolean           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_config_save_data_source</NAME>
<RETURNS>gboolean           </RETURNS>
const gchar *name,const gchar *provider,const gchar *cnc_string,const gchar *description,const gchar *username,const gchar *password,gboolean is_global
</FUNCTION>
<FUNCTION>
<NAME>gda_config_save_data_source_info</NAME>
<RETURNS>gboolean           </RETURNS>
GdaDataSourceInfo *dsn_info
</FUNCTION>
<FUNCTION>
<NAME>gda_config_remove_data_source</NAME>
<RETURNS>void               </RETURNS>
const gchar *name
</FUNCTION>
<MACRO>
<NAME>CSV_MAJOR</NAME>
#define CSV_MAJOR 2
</MACRO>
<MACRO>
<NAME>CSV_MINOR</NAME>
#define CSV_MINOR 0
</MACRO>
<MACRO>
<NAME>CSV_RELEASE</NAME>
#define CSV_RELEASE 1
</MACRO>
<MACRO>
<NAME>CSV_SUCCESS</NAME>
#define CSV_SUCCESS 0
</MACRO>
<MACRO>
<NAME>CSV_EPARSE</NAME>
#define CSV_EPARSE 1   /* Parse error in strict mode */
</MACRO>
<MACRO>
<NAME>CSV_ENOMEM</NAME>
#define CSV_ENOMEM 2   /* Out of memory while increasing buffer size */
</MACRO>
<MACRO>
<NAME>CSV_ETOOBIG</NAME>
#define CSV_ETOOBIG 3  /* Buffer larger than SIZE_MAX needed */
</MACRO>
<MACRO>
<NAME>CSV_EINVALID</NAME>
#define CSV_EINVALID 4 /* Invalid code,should never be received from csv_error*/
</MACRO>
<MACRO>
<NAME>CSV_STRICT</NAME>
#define CSV_STRICT 1    /* enable strict mode */
</MACRO>
<MACRO>
<NAME>CSV_REPALL_NL</NAME>
#define CSV_REPALL_NL 2 /* report all unquoted carriage returns and linefeeds */
</MACRO>
<MACRO>
<NAME>CSV_STRICT_FINI</NAME>
#define CSV_STRICT_FINI 4 /* causes csv_fini to return CSV_EPARSE if last
</MACRO>
<MACRO>
<NAME>CSV_TAB</NAME>
#define CSV_TAB    0x09
</MACRO>
<MACRO>
<NAME>CSV_SPACE</NAME>
#define CSV_SPACE  0x20
</MACRO>
<MACRO>
<NAME>CSV_CR</NAME>
#define CSV_CR     0x0d
</MACRO>
<MACRO>
<NAME>CSV_LF</NAME>
#define CSV_LF     0x0a
</MACRO>
<MACRO>
<NAME>CSV_COMMA</NAME>
#define CSV_COMMA  0x2c
</MACRO>
<MACRO>
<NAME>CSV_QUOTE</NAME>
#define CSV_QUOTE  0x22
</MACRO>
<STRUCT>
<NAME>csv_parser</NAME>
struct csv_parser {
  int pstate;         /* Parser state */
  int quoted;         /* Is the current field a quoted field? */
  size_t spaces;      /* Number of continious spaces after quote or in a non-quoted field */
  char * entry_buf;   /* Entry buffer */
  size_t entry_pos;   /* Current position in entry_buf (and current size of entry) */
  size_t entry_size;  /* Size of buffer */
  int status;         /* Operation status */
  unsigned char options;
  char quote_char;
  char delim_char;
  int (*is_space)(char);
  int (*is_term)(char);
};
</STRUCT>
<FUNCTION>
<NAME>csv_init</NAME>
<RETURNS>int </RETURNS>
struct csv_parser **p, unsigned char options
</FUNCTION>
<FUNCTION>
<NAME>csv_fini</NAME>
<RETURNS>int </RETURNS>
struct csv_parser *p, void (*cb1)(char *, size_t, void *), void (*cb2)(char, void *), void *data
</FUNCTION>
<FUNCTION>
<NAME>csv_free</NAME>
<RETURNS>void </RETURNS>
struct csv_parser *p
</FUNCTION>
<FUNCTION>
<NAME>csv_error</NAME>
<RETURNS>int </RETURNS>
struct csv_parser *p
</FUNCTION>
<FUNCTION>
<NAME>csv_strerror</NAME>
<RETURNS>char *</RETURNS>
int error
</FUNCTION>
<FUNCTION>
<NAME>csv_parse</NAME>
<RETURNS>size_t </RETURNS>
struct csv_parser *p, const char *s, size_t len, void (*cb1)(char *, size_t, void *), void (*cb2)(char, void *), void *data
</FUNCTION>
<FUNCTION>
<NAME>csv_write</NAME>
<RETURNS>size_t </RETURNS>
char *dest, size_t dest_size, const char *src, size_t src_size
</FUNCTION>
<FUNCTION>
<NAME>csv_fwrite</NAME>
<RETURNS>int </RETURNS>
FILE *fp, const char *src, size_t src_size
</FUNCTION>
<FUNCTION>
<NAME>csv_write2</NAME>
<RETURNS>size_t </RETURNS>
char *dest, size_t dest_size, const char *src, size_t src_size, char quote
</FUNCTION>
<FUNCTION>
<NAME>csv_fwrite2</NAME>
<RETURNS>int </RETURNS>
FILE *fp, const char *src, size_t src_size, char quote
</FUNCTION>
<FUNCTION>
<NAME>csv_opts</NAME>
<RETURNS>int </RETURNS>
struct csv_parser *p, unsigned char options
</FUNCTION>
<FUNCTION>
<NAME>csv_set_delim</NAME>
<RETURNS>void </RETURNS>
struct csv_parser *p, char c
</FUNCTION>
<FUNCTION>
<NAME>csv_set_quote</NAME>
<RETURNS>void </RETURNS>
struct csv_parser *p, char c
</FUNCTION>
<FUNCTION>
<NAME>csv_get_delim</NAME>
<RETURNS>char </RETURNS>
struct csv_parser *p
</FUNCTION>
<FUNCTION>
<NAME>csv_get_quote</NAME>
<RETURNS>char </RETURNS>
struct csv_parser *p
</FUNCTION>
<FUNCTION>
<NAME>csv_set_space_func</NAME>
<RETURNS>void </RETURNS>
struct csv_parser *p, int (*f)(char)
</FUNCTION>
<FUNCTION>
<NAME>csv_set_term_func</NAME>
<RETURNS>void </RETURNS>
struct csv_parser *p, int (*f)(char)
</FUNCTION>
<STRUCT>
<NAME>GdaQuarkList</NAME>
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_QUARK_LIST</NAME>
#define GDA_TYPE_QUARK_LIST (gda_quark_list_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_quark_list_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_new</NAME>
<RETURNS>GdaQuarkList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_new_from_string</NAME>
<RETURNS>GdaQuarkList *</RETURNS>
const gchar *string
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_copy</NAME>
<RETURNS>GdaQuarkList *</RETURNS>
GdaQuarkList *qlist
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_free</NAME>
<RETURNS>void          </RETURNS>
GdaQuarkList *qlist
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_add_from_string</NAME>
<RETURNS>void          </RETURNS>
GdaQuarkList *qlist,const gchar *string,gboolean cleanup
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_find</NAME>
<RETURNS>const gchar  *</RETURNS>
GdaQuarkList *qlist, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_remove</NAME>
<RETURNS>void          </RETURNS>
GdaQuarkList *qlist, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_clear</NAME>
<RETURNS>void          </RETURNS>
GdaQuarkList *qlist
</FUNCTION>
<FUNCTION>
<NAME>gda_quark_list_foreach</NAME>
<RETURNS>void          </RETURNS>
GdaQuarkList *qlist, GHFunc func, gpointer user_data
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_CONSTRAINT</NAME>
#define GDA_TYPE_DICT_CONSTRAINT          (gda_dict_constraint_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DICT_CONSTRAINT</NAME>
#define GDA_DICT_CONSTRAINT(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_dict_constraint_get_type(), GdaDictConstraint)
</MACRO>
<MACRO>
<NAME>GDA_DICT_CONSTRAINT_CLASS</NAME>
#define GDA_DICT_CONSTRAINT_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_dict_constraint_get_type (), GdaDictConstraintClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DICT_CONSTRAINT</NAME>
#define GDA_IS_DICT_CONSTRAINT(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_dict_constraint_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_dict_constraint_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DICT_CONSTRAINT_ERROR</NAME>
#define GDA_DICT_CONSTRAINT_ERROR gda_dict_constraint_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDictConstraintError</NAME>
typedef enum
{
	GDA_DICT_CONSTRAINT_XML_SAVE_ERROR,
	GDA_DICT_CONSTRAINT_XML_LOAD_ERROR
} GdaDictConstraintError;
</ENUM>
<ENUM>
<NAME>GdaDictConstraintType</NAME>
typedef enum
{
	CONSTRAINT_PRIMARY_KEY,
	CONSTRAINT_FOREIGN_KEY,
	CONSTRAINT_UNIQUE,
	CONSTRAINT_NOT_NULL,
	CONSTRAINT_CHECK_EXPR,
	CONSTRAINT_CHECK_IN_LIST,
	CONSTRAINT_CHECK_SETOF_LIST,
	CONSTRAINT_UNKNOWN
} GdaDictConstraintType;
</ENUM>
<ENUM>
<NAME>GdaDictConstraintFkAction</NAME>
typedef enum
{
	CONSTRAINT_FK_ACTION_CASCADE,
	CONSTRAINT_FK_ACTION_SET_NULL,
	CONSTRAINT_FK_ACTION_SET_DEFAULT,
	CONSTRAINT_FK_ACTION_SET_VALUE,
	CONSTRAINT_FK_ACTION_NO_ACTION
} GdaDictConstraintFkAction;
</ENUM>
<MACRO>
<NAME>GDA_DICT_CONSTRAINT_FK_PAIR</NAME>
#define GDA_DICT_CONSTRAINT_FK_PAIR(x) ((GdaDictConstraintFkeyPair*) (x))
</MACRO>
<STRUCT>
<NAME>GdaDictConstraint</NAME>
struct _GdaDictConstraint
{
	GdaObject                  object;
	GdaDictConstraintPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDictConstraintClass</NAME>
struct _GdaDictConstraintClass
{
	GdaObjectClass                    parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_dict_constraint_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_new</NAME>
<RETURNS>GdaDictConstraint     *</RETURNS>
GdaDictTable *table, GdaDictConstraintType type
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_new_with_db</NAME>
<RETURNS>GdaDictConstraint     *</RETURNS>
GdaDictDatabase *db
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_get_constraint_type</NAME>
<RETURNS>GdaDictConstraintType  </RETURNS>
GdaDictConstraint *cstr
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_equal</NAME>
<RETURNS>gboolean               </RETURNS>
GdaDictConstraint *cstr1, GdaDictConstraint *cstr2
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_get_table</NAME>
<RETURNS>GdaDictTable          *</RETURNS>
GdaDictConstraint *cstr
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_uses_field</NAME>
<RETURNS>gboolean               </RETURNS>
GdaDictConstraint *cstr, GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_pkey_set_fields</NAME>
<RETURNS>void                   </RETURNS>
GdaDictConstraint *cstr, const GSList *fields
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_pkey_get_fields</NAME>
<RETURNS>GSList                *</RETURNS>
GdaDictConstraint *cstr
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_fkey_set_fields</NAME>
<RETURNS>void                   </RETURNS>
GdaDictConstraint *cstr, const GSList *pairs
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_fkey_get_ref_table</NAME>
<RETURNS>GdaDictTable          *</RETURNS>
GdaDictConstraint *cstr
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_fkey_get_fields</NAME>
<RETURNS>GSList                *</RETURNS>
GdaDictConstraint *cstr
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_fkey_set_actions</NAME>
<RETURNS>void                   </RETURNS>
GdaDictConstraint *cstr,GdaDictConstraintFkAction on_update,GdaDictConstraintFkAction on_delete
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_fkey_get_actions</NAME>
<RETURNS>void                   </RETURNS>
GdaDictConstraint *cstr,GdaDictConstraintFkAction *on_update,GdaDictConstraintFkAction *on_delete
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_unique_set_fields</NAME>
<RETURNS>void                   </RETURNS>
GdaDictConstraint *cstr, const GSList *fields
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_unique_get_fields</NAME>
<RETURNS>GSList                *</RETURNS>
GdaDictConstraint *cstr
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_not_null_set_field</NAME>
<RETURNS>void                   </RETURNS>
GdaDictConstraint *cstr, GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_constraint_not_null_get_field</NAME>
<RETURNS>GdaDictField          *</RETURNS>
GdaDictConstraint *cstr
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_ARRAY</NAME>
#define GDA_TYPE_DATA_MODEL_ARRAY            (gda_data_model_array_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_ARRAY</NAME>
#define GDA_DATA_MODEL_ARRAY(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_MODEL_ARRAY, GdaDataModelArray))
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_ARRAY_CLASS</NAME>
#define GDA_DATA_MODEL_ARRAY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_ARRAY, GdaDataModelArrayClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_ARRAY</NAME>
#define GDA_IS_DATA_MODEL_ARRAY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_DATA_MODEL_ARRAY))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_ARRAY_CLASS</NAME>
#define GDA_IS_DATA_MODEL_ARRAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_DATA_MODEL_ARRAY))
</MACRO>
<STRUCT>
<NAME>GdaDataModelArray</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelArrayClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelArrayPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelArray</NAME>
struct _GdaDataModelArray {
	GdaDataModelRow model;
	GdaDataModelArrayPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataModelArrayClass</NAME>
struct _GdaDataModelArrayClass {
	GdaDataModelRowClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_array_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_array_new_with_g_types</NAME>
<RETURNS>GdaDataModel *</RETURNS>
gint cols, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_array_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
gint cols
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_array_copy_model</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaDataModel *src, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_array_set_n_columns</NAME>
<RETURNS>void          </RETURNS>
GdaDataModelArray *model, gint cols
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_array_clear</NAME>
<RETURNS>void          </RETURNS>
GdaDataModelArray *model
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DIR_BLOB_OP</NAME>
#define GDA_TYPE_DIR_BLOB_OP            (gda_dir_blob_op_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DIR_BLOB_OP</NAME>
#define GDA_DIR_BLOB_OP(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DIR_BLOB_OP, GdaDirBlobOp))
</MACRO>
<MACRO>
<NAME>GDA_DIR_BLOB_OP_CLASS</NAME>
#define GDA_DIR_BLOB_OP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DIR_BLOB_OP, GdaDirBlobOpClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DIR_BLOB_OP</NAME>
#define GDA_IS_DIR_BLOB_OP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_DIR_BLOB_OP))
</MACRO>
<MACRO>
<NAME>GDA_IS_DIR_BLOB_OP_CLASS</NAME>
#define GDA_IS_DIR_BLOB_OP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_DIR_BLOB_OP))
</MACRO>
<STRUCT>
<NAME>GdaDirBlobOp</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDirBlobOpClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDirBlobOpPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDirBlobOp</NAME>
struct _GdaDirBlobOp {
	GdaBlobOp                 parent;
	GdaDirBlobOpPrivate      *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDirBlobOpClass</NAME>
struct _GdaDirBlobOpClass {
	GdaBlobOpClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_dir_blob_op_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dir_blob_op_new</NAME>
<RETURNS>GdaBlobOp    *</RETURNS>
const gchar *complete_filename
</FUNCTION>
<FUNCTION>
<NAME>gda_dir_blob_set_filename</NAME>
<RETURNS>void          </RETURNS>
GdaDirBlobOp *blob, const gchar *complete_filename
</FUNCTION>
<FUNCTION>
<NAME>gda_dir_blob_get_filename</NAME>
<RETURNS>const gchar  *</RETURNS>
GdaDirBlobOp *blob
</FUNCTION>
<STRUCT>
<NAME>GdaDictPrivate</NAME>
struct _GdaDictPrivate
{
	GdaDictDatabase   *database;
	GdaConnection     *cnc;
	gchar             *xml_filename;

	gboolean           with_functions;

	gchar             *dsn;
	gchar             *user;

	/* DBMS update related information */
	gboolean           update_in_progress;
	gboolean           stop_update; /* TRUE if a DBMS data update must be stopped */

	/* DBMS objects */
	GSList            *users;

	/* Hash tables for fast retreival of any object */
	GHashTable        *object_ids; /* key = string ID, value = GdaObject for that ID */


	/* Generic interface for handled objects */
	GSList            *registry_list; /* list of GdaDictRegisterStruct */
	GHashTable        *registry; /* key = GType, value = GdaDictRegisterStruct ("referenced" here) */
	GHashTable        *registry_xml_groups; /* key = XML group tag, value = GdaDictRegisterStruct (not "referenced" here) */
	GHashTable        *objects_as_hash; /* key = object, value = GType as which it has been assumed */
};
</STRUCT>
<STRUCT>
<NAME>GdaDictRegisterStruct</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GdaDictRegFreeFunc</NAME>
<RETURNS>void </RETURNS>
GdaDict *, GdaDictRegisterStruct *
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdaDictRegSyncFunc</NAME>
<RETURNS>gboolean </RETURNS>
GdaDict *, const gchar *limit_object_name, GError **
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdaDictRegGetListFunc</NAME>
<RETURNS>GSList *</RETURNS>
GdaDict *
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdaDictRegSaveFunc</NAME>
<RETURNS>gboolean </RETURNS>
GdaDict *, xmlNodePtr, GError **
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdaDictRegLoadFunc</NAME>
<RETURNS>gboolean </RETURNS>
GdaDict *, xmlNodePtr, GError **
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdaDictGetObjFunc</NAME>
<RETURNS>GdaObject *</RETURNS>
GdaDict *, const gchar *
</USER_FUNCTION>
<STRUCT>
<NAME>GdaDictRegisterStruct</NAME>
struct _GdaDictRegisterStruct {
	/* general information */
	GType                  type; /* type of object, always valid */
	gboolean               sort; /* TRUE if lists of objects are sorted by object name */
	GdaDictRegFreeFunc     free; /* to free @GdaDictRegisterStruct or NULL if just g_free() */

	/* lists of objects */
	GSList                *all_objects;
	GSList                *assumed_objects;

	/* operations on lists */
	gchar                 *dbms_sync_key;
	gchar                 *dbms_sync_descr;
	GdaDictRegSyncFunc     dbms_sync; /* DBMS sync, or NULL if no sync possible */
	GdaDictRegGetListFunc  get_objects; /* get the list of objects, or NULL if generic method */
	GdaDictGetObjFunc      get_by_name; /* get a specific object, or NULL if generic method */

	/* XML related */
	const gchar           *xml_group_tag; /* tag for the group of objects in XML file, or NULL if no storage */
	GdaDictRegSaveFunc     load_xml_tree; /* loading from XML file, or NULL if no loading */
	GdaDictRegLoadFunc     save_xml_tree; /* saving to XML file, or NULL if no saving*/
};
</STRUCT>
<USER_FUNCTION>
<NAME>GdaDictRegFunc</NAME>
<RETURNS>GdaDictRegisterStruct *</RETURNS>
void
</USER_FUNCTION>
<FUNCTION>
<NAME>gda_dict_class_always_register</NAME>
<RETURNS>void                   </RETURNS>
GdaDictRegFunc func
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_register_object_type</NAME>
<RETURNS>void                   </RETURNS>
GdaDict *dict, GdaDictRegisterStruct *reg
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_get_object_type_registration</NAME>
<RETURNS>GdaDictRegisterStruct *</RETURNS>
GdaDict *dict, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_queries_get_register</NAME>
<RETURNS>GdaDictRegisterStruct *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>gda_queries_get_serial</NAME>
<RETURNS>guint                  </RETURNS>
GdaDictRegisterStruct *reg
</FUNCTION>
<FUNCTION>
<NAME>gda_queries_declare_serial</NAME>
<RETURNS>void                   </RETURNS>
GdaDictRegisterStruct *reg, guint id
</FUNCTION>
<ENUM>
<NAME>GdaCommandOptions</NAME>
typedef enum {
	GDA_COMMAND_OPTION_IGNORE_ERRORS  = 1,
	GDA_COMMAND_OPTION_STOP_ON_ERRORS = 1 << 1,
	GDA_COMMAND_OPTION_BAD_OPTION     = 1 << 2
} GdaCommandOptions;
</ENUM>
<MACRO>
<NAME>GDA_COMMAND_DEFAULT_OPTION</NAME>
#define GDA_COMMAND_DEFAULT_OPTION GDA_COMMAND_OPTION_IGNORE_ERRORS
</MACRO>
<ENUM>
<NAME>GdaCommandType</NAME>
typedef enum {
	GDA_COMMAND_TYPE_SQL,
	GDA_COMMAND_TYPE_XML,
	GDA_COMMAND_TYPE_PROCEDURE,
	GDA_COMMAND_TYPE_TABLE,
	GDA_COMMAND_TYPE_SCHEMA,
	GDA_COMMAND_TYPE_INVALID
} GdaCommandType;
</ENUM>
<STRUCT>
<NAME>GdaCommand</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaCommand</NAME>
struct _GdaCommand {
	gchar             *text;
	GdaCommandType     type;
	GdaCommandOptions  options;
};
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_COMMAND</NAME>
#define GDA_TYPE_COMMAND (gda_command_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_command_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_command_new</NAME>
<RETURNS>GdaCommand       *</RETURNS>
const gchar *text, GdaCommandType type,GdaCommandOptions options
</FUNCTION>
<FUNCTION>
<NAME>gda_command_free</NAME>
<RETURNS>void              </RETURNS>
GdaCommand *cmd
</FUNCTION>
<FUNCTION>
<NAME>gda_command_copy</NAME>
<RETURNS>GdaCommand       *</RETURNS>
GdaCommand *cmd
</FUNCTION>
<FUNCTION>
<NAME>gda_command_get_text</NAME>
<RETURNS>const gchar      *</RETURNS>
GdaCommand *cmd
</FUNCTION>
<FUNCTION>
<NAME>gda_command_set_text</NAME>
<RETURNS>void              </RETURNS>
GdaCommand *cmd, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gda_command_get_command_type</NAME>
<RETURNS>GdaCommandType    </RETURNS>
GdaCommand *cmd
</FUNCTION>
<FUNCTION>
<NAME>gda_command_set_command_type</NAME>
<RETURNS>void              </RETURNS>
GdaCommand *cmd, GdaCommandType type
</FUNCTION>
<FUNCTION>
<NAME>gda_command_get_options</NAME>
<RETURNS>GdaCommandOptions </RETURNS>
GdaCommand *cmd
</FUNCTION>
<FUNCTION>
<NAME>gda_command_set_options</NAME>
<RETURNS>void              </RETURNS>
GdaCommand *cmd, GdaCommandOptions options
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_ENTITY</NAME>
#define GDA_TYPE_ENTITY          (gda_entity_get_type())
</MACRO>
<MACRO>
<NAME>GDA_ENTITY</NAME>
#define GDA_ENTITY(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ENTITY, GdaEntity)
</MACRO>
<MACRO>
<NAME>GDA_IS_ENTITY</NAME>
#define GDA_IS_ENTITY(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ENTITY)
</MACRO>
<MACRO>
<NAME>GDA_ENTITY_GET_IFACE</NAME>
#define GDA_ENTITY_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GDA_TYPE_ENTITY, GdaEntityIface))
</MACRO>
<STRUCT>
<NAME>GdaEntityIface</NAME>
struct _GdaEntityIface
{
	GTypeInterface           g_iface;

	/* virtual table */
	gboolean         (*has_field)            (GdaEntity *iface, GdaEntityField *field);
	GSList          *(*get_fields)           (GdaEntity *iface);
	GdaEntityField  *(*get_field_by_name)    (GdaEntity *iface, const gchar *name);
	GdaEntityField  *(*get_field_by_xml_id)  (GdaEntity *iface, const gchar *xml_id);
	GdaEntityField  *(*get_field_by_index)   (GdaEntity *iface, gint index);
	gint             (*get_field_index)      (GdaEntity *iface, GdaEntityField *field);
	void             (*add_field)            (GdaEntity *iface, GdaEntityField *field);
	void             (*add_field_before)     (GdaEntity *iface, GdaEntityField *field, GdaEntityField *field_before);
	void             (*swap_fields)          (GdaEntity *iface, GdaEntityField *field1, GdaEntityField *field2);
	void             (*remove_field)         (GdaEntity *iface, GdaEntityField *field);
	gboolean         (*is_writable)          (GdaEntity *iface);

	/* signals */
	void             (*field_added)          (GdaEntity *iface, GdaEntityField *field);
	void             (*field_removed)        (GdaEntity *iface, GdaEntityField *field);
	void             (*field_updated)        (GdaEntity *iface, GdaEntityField *field);
	void             (*fields_order_changed) (GdaEntity *iface);
};
</STRUCT>
<FUNCTION>
<NAME>gda_entity_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_has_field</NAME>
<RETURNS>gboolean          </RETURNS>
GdaEntity *iface, GdaEntityField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_get_fields</NAME>
<RETURNS>GSList           *</RETURNS>
GdaEntity *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_get_n_fields</NAME>
<RETURNS>gint              </RETURNS>
GdaEntity *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_get_field_by_name</NAME>
<RETURNS>GdaEntityField   *</RETURNS>
GdaEntity *iface, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_get_field_by_xml_id</NAME>
<RETURNS>GdaEntityField   *</RETURNS>
GdaEntity *iface, const gchar *xml_id
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_get_field_by_index</NAME>
<RETURNS>GdaEntityField   *</RETURNS>
GdaEntity *iface, gint index
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_get_field_index</NAME>
<RETURNS>gint              </RETURNS>
GdaEntity *iface, GdaEntityField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_add_field</NAME>
<RETURNS>void              </RETURNS>
GdaEntity *iface, GdaEntityField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_add_field_before</NAME>
<RETURNS>void              </RETURNS>
GdaEntity *iface, GdaEntityField *field, GdaEntityField *field_before
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_swap_fields</NAME>
<RETURNS>void              </RETURNS>
GdaEntity *iface, GdaEntityField *field1, GdaEntityField *field2
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_remove_field</NAME>
<RETURNS>void              </RETURNS>
GdaEntity *iface, GdaEntityField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_is_writable</NAME>
<RETURNS>gboolean          </RETURNS>
GdaEntity *iface
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_RENDERER</NAME>
#define GDA_TYPE_RENDERER          (gda_renderer_get_type())
</MACRO>
<MACRO>
<NAME>GDA_RENDERER</NAME>
#define GDA_RENDERER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_RENDERER, GdaRenderer)
</MACRO>
<MACRO>
<NAME>GDA_IS_RENDERER</NAME>
#define GDA_IS_RENDERER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_RENDERER)
</MACRO>
<MACRO>
<NAME>GDA_RENDERER_GET_IFACE</NAME>
#define GDA_RENDERER_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GDA_TYPE_RENDERER, GdaRendererIface))
</MACRO>
<ENUM>
<NAME>GdaRendererOptions</NAME>
typedef enum {
	GDA_RENDERER_EXTRA_PRETTY_SQL       = 1 << 0,
	GDA_RENDERER_PARAMS_AS_DETAILED     = 1 << 1,
	GDA_RENDERER_ERROR_IF_DEFAULT       = 1 << 2,
	GDA_RENDERER_FIELDS_NO_TARGET_ALIAS = 1 << 3,
	GDA_RENDERER_PARAMS_AS_COLON        = 1 << 4,/* params as :param_name, replacing any char not in [0-9A-Za-z] by '_' */
	GDA_RENDERER_PARAMS_AS_DOLLAR       = 1 << 5,/* params as $1, $2, etc (starts at $1) */
	GDA_RENDERER_PARAMS_AS_QMARK        = 1 << 6 /* params as ?1, ?2, etc (starts at ?1) */
} GdaRendererOptions;
</ENUM>
<STRUCT>
<NAME>GdaRendererIface</NAME>
struct _GdaRendererIface
{
	GTypeInterface           g_iface;

	/* virtual table */
	gchar      *(* render_as_sql)   (GdaRenderer *iface, GdaParameterList *context, GSList **out_params_used, 
					 GdaRendererOptions options, GError **error); 
	gchar      *(* render_as_str)   (GdaRenderer *iface, GdaParameterList *context);
	gboolean    (* is_valid)        (GdaRenderer *iface, GdaParameterList *context, GError **error);
};
</STRUCT>
<FUNCTION>
<NAME>gda_renderer_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_renderer_render_as_sql</NAME>
<RETURNS>gchar          *</RETURNS>
GdaRenderer *iface, GdaParameterList *context, GSList **out_params_used,GdaRendererOptions options, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_renderer_render_as_str</NAME>
<RETURNS>gchar          *</RETURNS>
GdaRenderer *iface, GdaParameterList *context
</FUNCTION>
<FUNCTION>
<NAME>gda_renderer_is_valid</NAME>
<RETURNS>gboolean        </RETURNS>
GdaRenderer *iface, GdaParameterList *context, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_g_type_to_string</NAME>
<RETURNS>const gchar *</RETURNS>
GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_g_type_from_string</NAME>
<RETURNS>GType        </RETURNS>
const gchar *str
</FUNCTION>
<FUNCTION>
<NAME>gda_string_hash_to_list</NAME>
<RETURNS>GList       *</RETURNS>
GHashTable *hash_table
</FUNCTION>
<FUNCTION>
<NAME>gda_default_escape_string</NAME>
<RETURNS>gchar       *</RETURNS>
const gchar *string
</FUNCTION>
<FUNCTION>
<NAME>gda_default_unescape_string</NAME>
<RETURNS>gchar       *</RETURNS>
const gchar *string
</FUNCTION>
<FUNCTION>
<NAME>gda_file_load</NAME>
<RETURNS>gchar    *</RETURNS>
const gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gda_file_save</NAME>
<RETURNS>gboolean  </RETURNS>
const gchar *filename, const gchar *buffer, gint len
</FUNCTION>
<FUNCTION>
<NAME>gda_utility_table_field_attrs_stringify</NAME>
<RETURNS>gchar *</RETURNS>
GdaValueAttribute attributes
</FUNCTION>
<FUNCTION>
<NAME>gda_utility_table_field_attrs_parse</NAME>
<RETURNS>guint  </RETURNS>
const gchar *str
</FUNCTION>
<FUNCTION>
<NAME>gda_utility_build_encoded_id</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *prefix, const gchar *id
</FUNCTION>
<FUNCTION>
<NAME>gda_utility_build_decoded_id</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *prefix, const gchar *id
</FUNCTION>
<FUNCTION>
<NAME>gda_utility_check_data_model</NAME>
<RETURNS>gboolean </RETURNS>
GdaDataModel *model, gint nbcols, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_utility_data_model_dump_data_to_xml</NAME>
<RETURNS>void     </RETURNS>
GdaDataModel *model, xmlNodePtr parent,const gint *cols, gint nb_cols, const gint *rows, gint nb_rows,gboolean use_col_ids
</FUNCTION>
<FUNCTION>
<NAME>gda_utility_parameter_load_attributes</NAME>
<RETURNS>void     </RETURNS>
GdaParameter *param, xmlNodePtr node, GSList *sources
</FUNCTION>
<FUNCTION>
<NAME>gda_utility_find_or_create_data_type</NAME>
<RETURNS>GdaDictType *</RETURNS>
GdaDict *dict, GdaServerProvider *prov, GdaConnection *cnc,const gchar *dbms_type, const gchar *g_type, gboolean *created
</FUNCTION>
<FUNCTION>
<NAME>gda_text_to_alphanum</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gda_alphanum_to_text</NAME>
<RETURNS>gchar *</RETURNS>
gchar *text
</FUNCTION>
<STRUCT>
<NAME>GdaDataModelIndex</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelIndex</NAME>
struct _GdaDataModelIndex {
	gchar *name;
	gchar *table_name;
	gboolean primary_key;
	gboolean unique_key;
	gchar *references;
	GList *col_idx_list;
};
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_INDEX</NAME>
#define GDA_TYPE_DATA_MODEL_INDEX (gda_data_model_index_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_data_model_index_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_new</NAME>
<RETURNS>GdaDataModelIndex  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_copy</NAME>
<RETURNS>GdaDataModelIndex  *</RETURNS>
GdaDataModelIndex *dmi
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_free</NAME>
<RETURNS>void                </RETURNS>
GdaDataModelIndex *dmi
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_equal</NAME>
<RETURNS>gboolean            </RETURNS>
const GdaDataModelIndex *lhs, const GdaDataModelIndex *rhs
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_get_name</NAME>
<RETURNS>const gchar        *</RETURNS>
GdaDataModelIndex *dmi
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_set_name</NAME>
<RETURNS>void                </RETURNS>
GdaDataModelIndex *dmi, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_get_table_name</NAME>
<RETURNS>const gchar        *</RETURNS>
GdaDataModelIndex *dmi
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_set_table_name</NAME>
<RETURNS>void                </RETURNS>
GdaDataModelIndex *dmi, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_get_primary_key</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModelIndex *dmi
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_set_primary_key</NAME>
<RETURNS>void                </RETURNS>
GdaDataModelIndex *dmi, gboolean pk
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_get_unique_key</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModelIndex *dmi
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_set_unique_key</NAME>
<RETURNS>void                </RETURNS>
GdaDataModelIndex *dmi, gboolean uk
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_get_references</NAME>
<RETURNS>const gchar        *</RETURNS>
GdaDataModelIndex *dmi
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_set_references</NAME>
<RETURNS>void                </RETURNS>
GdaDataModelIndex *dmi, const gchar *ref
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_get_column_index_list</NAME>
<RETURNS>GList              *</RETURNS>
GdaDataModelIndex *dmi
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_index_set_column_index_list</NAME>
<RETURNS>void                </RETURNS>
GdaDataModelIndex *dmi, GList *col_idx_list
</FUNCTION>
<FUNCTION>
<NAME>gda_log_enable</NAME>
<RETURNS>void     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_log_disable</NAME>
<RETURNS>void     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_log_is_enabled</NAME>
<RETURNS>gboolean </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_log_message</NAME>
<RETURNS>void     </RETURNS>
const gchar * format, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_log_error</NAME>
<RETURNS>void     </RETURNS>
const gchar * format, ...
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_VALUE</NAME>
#define GDA_TYPE_QUERY_FIELD_VALUE          (gda_query_field_value_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_VALUE</NAME>
#define GDA_QUERY_FIELD_VALUE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_field_value_get_type(), GdaQueryFieldValue)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_VALUE_CLASS</NAME>
#define GDA_QUERY_FIELD_VALUE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_field_value_get_type (), GdaQueryFieldValueClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_FIELD_VALUE</NAME>
#define GDA_IS_QUERY_FIELD_VALUE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_field_value_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_value_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_FIELD_VALUE_ERROR</NAME>
#define GDA_QUERY_FIELD_VALUE_ERROR gda_query_field_value_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryFieldValueError</NAME>
typedef enum
{
	GDA_QUERY_FIELD_VALUE_XML_LOAD_ERROR,
	GDA_QUERY_FIELD_VALUE_RENDER_ERROR,
	GDA_QUERY_FIELD_VALUE_PARAM_ERROR,
	GDA_QUERY_FIELD_VALUE_DEFAULT_PARAM_ERROR
} GdaQueryFieldValueError;
</ENUM>
<STRUCT>
<NAME>GdaQueryFieldValue</NAME>
struct _GdaQueryFieldValue
{
	GdaQueryField              object;
	GdaQueryFieldValuePrivate     *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldValueClass</NAME>
struct _GdaQueryFieldValueClass
{
	GdaQueryFieldClass                  parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_field_value_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_new</NAME>
<RETURNS>GdaQueryField    *</RETURNS>
GdaQuery *query, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_set_value</NAME>
<RETURNS>void              </RETURNS>
GdaQueryFieldValue *field, const GValue *val
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_get_value</NAME>
<RETURNS>const GValue     *</RETURNS>
GdaQueryFieldValue *field
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_set_default_value</NAME>
<RETURNS>void              </RETURNS>
GdaQueryFieldValue *field, const GValue *default_val
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_get_default_value</NAME>
<RETURNS>const GValue     *</RETURNS>
GdaQueryFieldValue *field
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_set_is_parameter</NAME>
<RETURNS>void              </RETURNS>
GdaQueryFieldValue *field, gboolean is_param
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_get_is_parameter</NAME>
<RETURNS>gboolean          </RETURNS>
GdaQueryFieldValue *field
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_get_parameter_index</NAME>
<RETURNS>gint              </RETURNS>
GdaQueryFieldValue *field
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_set_not_null</NAME>
<RETURNS>void              </RETURNS>
GdaQueryFieldValue *field, gboolean not_null
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_get_not_null</NAME>
<RETURNS>gboolean          </RETURNS>
GdaQueryFieldValue *field
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_is_value_null</NAME>
<RETURNS>gboolean          </RETURNS>
GdaQueryFieldValue *field, GdaParameterList *context
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_value_restrict</NAME>
<RETURNS>gboolean          </RETURNS>
GdaQueryFieldValue *field,GdaDataModel *model, gint col, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_ROW</NAME>
#define GDA_TYPE_ROW            (gda_row_get_type())
</MACRO>
<MACRO>
<NAME>GDA_ROW</NAME>
#define GDA_ROW(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ROW, GdaRow))
</MACRO>
<MACRO>
<NAME>GDA_ROW_CLASS</NAME>
#define GDA_ROW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_ROW, GdaRowClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_ROW</NAME>
#define GDA_IS_ROW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ROW))
</MACRO>
<MACRO>
<NAME>GDA_IS_ROW_CLASS</NAME>
#define GDA_IS_ROW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_ROW))
</MACRO>
<STRUCT>
<NAME>GdaRow</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaRowClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaRowPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaRow</NAME>
struct _GdaRow {
	GObject        object;
	GdaRowPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaRowClass</NAME>
struct _GdaRowClass {
	GObjectClass   parent_class;
	
	/* signals */
	gboolean (* value_to_change) (GdaRow *row, gint num, const GValue *current, const GValue *proposed);
	void     (* value_changed)   (GdaRow *row, gint num, const GValue *old_value, const GValue *new_value);
};
</STRUCT>
<FUNCTION>
<NAME>gda_row_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_row_new</NAME>
<RETURNS>GdaRow       *</RETURNS>
GdaDataModel *model, gint count
</FUNCTION>
<FUNCTION>
<NAME>gda_row_new_from_list</NAME>
<RETURNS>GdaRow       *</RETURNS>
GdaDataModel *model, const GList *values
</FUNCTION>
<FUNCTION>
<NAME>gda_row_copy</NAME>
<RETURNS>GdaRow       *</RETURNS>
GdaRow *row
</FUNCTION>
<FUNCTION>
<NAME>gda_row_set_model</NAME>
<RETURNS>void          </RETURNS>
GdaRow *row, GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_row_get_model</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaRow *row
</FUNCTION>
<FUNCTION>
<NAME>gda_row_get_length</NAME>
<RETURNS>gint          </RETURNS>
GdaRow *row
</FUNCTION>
<FUNCTION>
<NAME>gda_row_get_number</NAME>
<RETURNS>gint          </RETURNS>
GdaRow *row
</FUNCTION>
<FUNCTION>
<NAME>gda_row_set_number</NAME>
<RETURNS>void          </RETURNS>
GdaRow *row, gint number
</FUNCTION>
<FUNCTION>
<NAME>gda_row_get_id</NAME>
<RETURNS>const gchar  *</RETURNS>
GdaRow *row
</FUNCTION>
<FUNCTION>
<NAME>gda_row_set_id</NAME>
<RETURNS>void          </RETURNS>
GdaRow *row, const gchar *id
</FUNCTION>
<FUNCTION>
<NAME>gda_row_get_value</NAME>
<RETURNS>GValue     *</RETURNS>
GdaRow *row, gint num
</FUNCTION>
<FUNCTION>
<NAME>gda_row_set_value</NAME>
<RETURNS>gboolean      </RETURNS>
GdaRow *row, gint num, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_row_set_is_default</NAME>
<RETURNS>void          </RETURNS>
GdaRow *row, gint num, gboolean is_default
</FUNCTION>
<FUNCTION>
<NAME>gda_row_get_is_default</NAME>
<RETURNS>gboolean      </RETURNS>
GdaRow *row, gint num
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_HANDLER</NAME>
#define GDA_TYPE_DATA_HANDLER          (gda_data_handler_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_HANDLER</NAME>
#define GDA_DATA_HANDLER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_HANDLER, GdaDataHandler)
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_HANDLER</NAME>
#define GDA_IS_DATA_HANDLER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_DATA_HANDLER)
</MACRO>
<MACRO>
<NAME>GDA_DATA_HANDLER_GET_IFACE</NAME>
#define GDA_DATA_HANDLER_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GDA_TYPE_DATA_HANDLER, GdaDataHandlerIface))
</MACRO>
<STRUCT>
<NAME>GdaDataHandlerIface</NAME>
struct _GdaDataHandlerIface
{
	GTypeInterface           g_iface;

	/* virtual table */
	gchar         *(* get_sql_from_value)   (GdaDataHandler *dh, const GValue *value);
	gchar         *(* get_str_from_value)   (GdaDataHandler *dh, const GValue *value);
	GValue        *(* get_value_from_sql)   (GdaDataHandler *dh, const gchar *sql, GType type);
	GValue        *(* get_value_from_str)   (GdaDataHandler *dh, const gchar *str, GType type);
	GValue        *(* get_sane_init_value)  (GdaDataHandler *dh, GType type);

	guint          (* get_nb_g_types)       (GdaDataHandler *dh);
	GType          (* get_g_type_index)     (GdaDataHandler *dh, guint index);
	gboolean       (* accepts_g_type)       (GdaDataHandler *dh, GType type);
	const gchar   *(* get_descr)            (GdaDataHandler *dh);
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_handler_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_handler_get_sql_from_value</NAME>
<RETURNS>gchar         *</RETURNS>
GdaDataHandler *dh, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_data_handler_get_str_from_value</NAME>
<RETURNS>gchar         *</RETURNS>
GdaDataHandler *dh, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_data_handler_get_value_from_sql</NAME>
<RETURNS>GValue        *</RETURNS>
GdaDataHandler *dh, const gchar *sql, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_data_handler_get_value_from_str</NAME>
<RETURNS>GValue        *</RETURNS>
GdaDataHandler *dh, const gchar *str, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_data_handler_get_sane_init_value</NAME>
<RETURNS>GValue        *</RETURNS>
GdaDataHandler *dh, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_data_handler_get_nb_g_types</NAME>
<RETURNS>guint          </RETURNS>
GdaDataHandler *dh
</FUNCTION>
<FUNCTION>
<NAME>gda_data_handler_get_g_type_index</NAME>
<RETURNS>GType          </RETURNS>
GdaDataHandler *dh, guint index
</FUNCTION>
<FUNCTION>
<NAME>gda_data_handler_accepts_g_type</NAME>
<RETURNS>gboolean       </RETURNS>
GdaDataHandler *dh, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_data_handler_get_descr</NAME>
<RETURNS>const gchar   *</RETURNS>
GdaDataHandler *dh
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_OBJECT</NAME>
#define GDA_TYPE_OBJECT          (gda_object_get_type())
</MACRO>
<MACRO>
<NAME>GDA_OBJECT</NAME>
#define GDA_OBJECT(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_object_get_type(), GdaObject)
</MACRO>
<MACRO>
<NAME>GDA_OBJECT_CLASS</NAME>
#define GDA_OBJECT_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_object_get_type (), GdaObjectClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_OBJECT</NAME>
#define GDA_IS_OBJECT(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_object_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaObject</NAME>
struct _GdaObject
{
	GObject            object;
	GdaObjectPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaObjectClass</NAME>
struct _GdaObjectClass
{
	GObjectClass            parent_class;

	/* signals */
	void        (*changed)           (GdaObject *object);
	void        (*id_changed)        (GdaObject *object);
	void        (*name_changed)      (GdaObject *object);
	void        (*descr_changed)     (GdaObject *object);
	void        (*owner_changed)     (GdaObject *object);

	void        (*to_be_destroyed)   (GdaObject *object);
	void        (*destroyed)         (GdaObject *object);

	/* pure virtual functions */
	void        (*signal_changed) (GdaObject *object, gboolean block_changed_signal);
#ifdef GDA_DEBUG
	void        (*dump)           (GdaObject *object, guint offset);
#endif

	/* class attributes */
	gboolean      id_unique_enforced; /* TRUE if a unique string ID must be enforced for that class */
	gboolean      name_as_initial_id; /* TRUE if the name of the object must be copied as the ID if ID is NULL */
};
</STRUCT>
<FUNCTION>
<NAME>gda_object_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_object_get_dict</NAME>
<RETURNS>GdaDict     *</RETURNS>
GdaObject *gdaobj
</FUNCTION>
<FUNCTION>
<NAME>gda_object_set_id</NAME>
<RETURNS>void         </RETURNS>
GdaObject *gdaobj, const gchar *strid
</FUNCTION>
<FUNCTION>
<NAME>gda_object_set_name</NAME>
<RETURNS>void         </RETURNS>
GdaObject *gdaobj, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_object_set_description</NAME>
<RETURNS>void         </RETURNS>
GdaObject *gdaobj, const gchar *descr
</FUNCTION>
<FUNCTION>
<NAME>gda_object_set_owner</NAME>
<RETURNS>void         </RETURNS>
GdaObject *gdaobj, const gchar *owner
</FUNCTION>
<FUNCTION>
<NAME>gda_object_get_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdaObject *gdaobj
</FUNCTION>
<FUNCTION>
<NAME>gda_object_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GdaObject *gdaobj
</FUNCTION>
<FUNCTION>
<NAME>gda_object_get_description</NAME>
<RETURNS>const gchar *</RETURNS>
GdaObject *gdaobj
</FUNCTION>
<FUNCTION>
<NAME>gda_object_get_owner</NAME>
<RETURNS>const gchar *</RETURNS>
GdaObject *gdaobj
</FUNCTION>
<FUNCTION>
<NAME>gda_object_destroy</NAME>
<RETURNS>void         </RETURNS>
GdaObject *gdaobj
</FUNCTION>
<FUNCTION>
<NAME>gda_object_destroy_check</NAME>
<RETURNS>void         </RETURNS>
GdaObject *gdaobj
</FUNCTION>
<FUNCTION>
<NAME>gda_object_connect_destroy</NAME>
<RETURNS>gulong       </RETURNS>
gpointer gdaobj, GCallback callback, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gda_object_signal_emit_changed</NAME>
<RETURNS>void         </RETURNS>
GdaObject *object
</FUNCTION>
<FUNCTION>
<NAME>gda_object_block_changed</NAME>
<RETURNS>void         </RETURNS>
GdaObject *gdaobj
</FUNCTION>
<FUNCTION>
<NAME>gda_object_unblock_changed</NAME>
<RETURNS>void         </RETURNS>
GdaObject *gdaobj
</FUNCTION>
<FUNCTION>
<NAME>gda_object_dump</NAME>
<RETURNS>void         </RETURNS>
GdaObject *gdaobj, guint offset
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_AGG</NAME>
#define GDA_TYPE_QUERY_FIELD_AGG          (gda_query_field_agg_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_AGG</NAME>
#define GDA_QUERY_FIELD_AGG(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_field_agg_get_type(), GdaQueryFieldAgg)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_AGG_CLASS</NAME>
#define GDA_QUERY_FIELD_AGG_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_field_agg_get_type (), GdaQueryFieldAggClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_FIELD_AGG</NAME>
#define GDA_IS_QUERY_FIELD_AGG(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_field_agg_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_agg_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_FIELD_AGG_ERROR</NAME>
#define GDA_QUERY_FIELD_AGG_ERROR gda_query_field_agg_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryFieldAggError</NAME>
typedef enum
{
	GDA_QUERY_FIELD_AGG_XML_LOAD_ERROR,
	GDA_QUERY_FIELD_AGG_RENDER_ERROR
} GdaQueryFieldAggError;
</ENUM>
<STRUCT>
<NAME>GdaQueryFieldAgg</NAME>
struct _GdaQueryFieldAgg
{
	GdaQueryField                  object;
	GdaQueryFieldAggPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldAggClass</NAME>
struct _GdaQueryFieldAggClass
{
	GdaQueryFieldClass             parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_field_agg_get_type</NAME>
<RETURNS>GType                   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_agg_new</NAME>
<RETURNS>GdaQueryField          *</RETURNS>
GdaQuery *query, const gchar *agg_name
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_agg_get_ref_agg</NAME>
<RETURNS>GdaDictAggregate       *</RETURNS>
GdaQueryFieldAgg *agg
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_agg_set_arg</NAME>
<RETURNS>gboolean                </RETURNS>
GdaQueryFieldAgg *agg, GdaQueryField *arg
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_agg_get_arg</NAME>
<RETURNS>GdaQueryField          *</RETURNS>
GdaQueryFieldAgg *agg
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_ALL</NAME>
#define GDA_TYPE_QUERY_FIELD_ALL          (gda_query_field_all_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_ALL</NAME>
#define GDA_QUERY_FIELD_ALL(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_field_all_get_type(), GdaQueryFieldAll)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_ALL_CLASS</NAME>
#define GDA_QUERY_FIELD_ALL_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_field_all_get_type (), GdaQueryFieldAllClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_FIELD_ALL</NAME>
#define GDA_IS_QUERY_FIELD_ALL(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_field_all_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_all_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_FIELD_ALL_ERROR</NAME>
#define GDA_QUERY_FIELD_ALL_ERROR gda_query_field_all_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryFieldAllError</NAME>
typedef enum
{
	GDA_QUERY_FIELD_ALL_XML_LOAD_ERROR,
	GDA_QUERY_FIELD_ALL_RENDER_ERROR
} GdaQueryFieldAllError;
</ENUM>
<STRUCT>
<NAME>GdaQueryFieldAll</NAME>
struct _GdaQueryFieldAll
{
	GdaQueryField              object;
	GdaQueryFieldAllPrivate   *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldAllClass</NAME>
struct _GdaQueryFieldAllClass
{
	GdaQueryFieldClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_field_all_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_all_new</NAME>
<RETURNS>GdaQueryField  *</RETURNS>
GdaQuery *query, const gchar *target
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_all_get_target</NAME>
<RETURNS>GdaQueryTarget *</RETURNS>
GdaQueryFieldAll *field
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_AGGREGATE</NAME>
#define GDA_TYPE_DICT_AGGREGATE          (gda_dict_aggregate_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DICT_AGGREGATE</NAME>
#define GDA_DICT_AGGREGATE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_dict_aggregate_get_type(), GdaDictAggregate)
</MACRO>
<MACRO>
<NAME>GDA_DICT_AGGREGATE_CLASS</NAME>
#define GDA_DICT_AGGREGATE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_dict_aggregate_get_type (), GdaDictAggregateClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DICT_AGGREGATE</NAME>
#define GDA_IS_DICT_AGGREGATE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_dict_aggregate_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_dict_aggregate_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DICT_AGGREGATE_ERROR</NAME>
#define GDA_DICT_AGGREGATE_ERROR gda_dict_aggregate_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDictAggregateError</NAME>
typedef enum
{
	GDA_DICT_AGGREGATE_XML_LOAD_ERROR
} GdaDictAggregateError;
</ENUM>
<STRUCT>
<NAME>GdaDictAggregate</NAME>
struct _GdaDictAggregate
{
	GdaObject                         object;
	GdaDictAggregatePrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDictAggregateClass</NAME>
struct _GdaDictAggregateClass
{
	GdaObjectClass                    parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_dict_aggregate_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_aggregate_new</NAME>
<RETURNS>GObject          *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_aggregate_set_dbms_id</NAME>
<RETURNS>void              </RETURNS>
GdaDictAggregate *agg, const gchar *id
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_aggregate_get_dbms_id</NAME>
<RETURNS>gchar            *</RETURNS>
GdaDictAggregate *agg
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_aggregate_set_sqlname</NAME>
<RETURNS>void              </RETURNS>
GdaDictAggregate *agg, const gchar *sqlname
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_aggregate_get_sqlname</NAME>
<RETURNS>const gchar      *</RETURNS>
GdaDictAggregate *agg
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_aggregate_set_arg_dict_type</NAME>
<RETURNS>void              </RETURNS>
GdaDictAggregate *agg, GdaDictType *dt
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_aggregate_get_arg_dict_type</NAME>
<RETURNS>GdaDictType      *</RETURNS>
GdaDictAggregate *agg
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_aggregate_set_ret_dict_type</NAME>
<RETURNS>void              </RETURNS>
GdaDictAggregate *agg, GdaDictType *dt
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_aggregate_get_ret_dict_type</NAME>
<RETURNS>GdaDictType      *</RETURNS>
GdaDictAggregate *agg
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY</NAME>
#define GDA_TYPE_QUERY          (gda_query_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY</NAME>
#define GDA_QUERY(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_get_type(), GdaQuery)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_CLASS</NAME>
#define GDA_QUERY_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_get_type (), GdaQueryClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY</NAME>
#define GDA_IS_QUERY(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_ERROR</NAME>
#define GDA_QUERY_ERROR gda_query_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryType</NAME>
typedef enum {
        GDA_QUERY_TYPE_SELECT,
	GDA_QUERY_TYPE_INSERT,
	GDA_QUERY_TYPE_UPDATE,
	GDA_QUERY_TYPE_DELETE,
        GDA_QUERY_TYPE_UNION,
        GDA_QUERY_TYPE_INTERSECT,
	GDA_QUERY_TYPE_EXCEPT,
        GDA_QUERY_TYPE_NON_PARSED_SQL
} GdaQueryType;
</ENUM>
<ENUM>
<NAME>GdaQueryError</NAME>
typedef enum
{
	GDA_QUERY_XML_LOAD_ERROR,
	GDA_QUERY_META_DATA_UPDATE,
	GDA_QUERY_FIELDS_ERROR,
	GDA_QUERY_TARGETS_ERROR,
	GDA_QUERY_RENDER_ERROR,
	GDA_QUERY_PARSE_ERROR,
	GDA_QUERY_SYNTAX_ERROR,
	GDA_QUERY_STRUCTURE_ERROR,
	GDA_QUERY_SQL_ANALYSE_ERROR,
	GDA_QUERY_NO_CNC_ERROR,
	GDA_QUERY_CNC_CLOSED_ERROR,
	GDA_QUERY_EXEC_ERROR,
	GDA_QUERY_PARAM_TYPE_ERROR,
	GDA_QUERY_MULTIPLE_STATEMENTS_ERROR
} GdaQueryError;
</ENUM>
<STRUCT>
<NAME>GdaQuery</NAME>
struct _GdaQuery
{
	GdaQueryObject         object;
	GdaQueryPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryClass</NAME>
struct _GdaQueryClass
{
	GdaQueryObjectClass    parent_class;

	/* signals */
	void   (*type_changed)         (GdaQuery *query);
	void   (*condition_changed)    (GdaQuery *query);

	void   (*target_added)         (GdaQuery *query, GdaQueryTarget *target);
	void   (*target_removed)       (GdaQuery *query, GdaQueryTarget *target);
	void   (*target_updated)       (GdaQuery *query, GdaQueryTarget *target);

	void   (*join_added)           (GdaQuery *query, GdaQueryJoin *join);
	void   (*join_removed)         (GdaQuery *query, GdaQueryJoin *join);
	void   (*join_updated)         (GdaQuery *query, GdaQueryJoin *join);
	
	void   (*sub_query_added)      (GdaQuery *query, GdaQuery *sub_query);
	void   (*sub_query_removed)    (GdaQuery *query, GdaQuery *sub_query);
	void   (*sub_query_updated)    (GdaQuery *query, GdaQuery *sub_query);
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_new</NAME>
<RETURNS>GdaQuery          *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_query_new_copy</NAME>
<RETURNS>GdaQuery          *</RETURNS>
GdaQuery *orig, GHashTable *replacements
</FUNCTION>
<FUNCTION>
<NAME>gda_query_new_from_sql</NAME>
<RETURNS>GdaQuery          *</RETURNS>
GdaDict *dict, const gchar *sql, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_set_query_type</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQueryType type
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_query_type</NAME>
<RETURNS>GdaQueryType       </RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_query_type_string</NAME>
<RETURNS>const gchar       *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_is_select_query</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_is_insert_query</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_is_update_query</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_is_delete_query</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_is_modify_query</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_is_well_formed</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQuery *query, GdaParameterList *context, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_parent_query</NAME>
<RETURNS>GdaQuery          *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_parameters</NAME>
<RETURNS>GSList            *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_parameter_list</NAME>
<RETURNS>GdaParameterList  *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_execute</NAME>
<RETURNS>GdaObject         *</RETURNS>
GdaQuery *query, GdaParameterList *params,gboolean iter_model_only_requested, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_set_sql_text</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, const gchar *sql, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_sql_text</NAME>
<RETURNS>gchar             *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_sub_queries</NAME>
<RETURNS>GSList            *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_add_sub_query</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQuery *sub_query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_del_sub_query</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQuery *sub_query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_add_param_source</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaDataModel *param_source
</FUNCTION>
<FUNCTION>
<NAME>gda_query_del_param_source</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaDataModel *param_source
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_param_sources</NAME>
<RETURNS>const GSList      *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_add_target</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQuery *query, GdaQueryTarget *target, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_del_target</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQueryTarget *target
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_targets</NAME>
<RETURNS>GSList            *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_target_by_xml_id</NAME>
<RETURNS>GdaQueryTarget    *</RETURNS>
GdaQuery *query, const gchar *xml_id
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_target_by_alias</NAME>
<RETURNS>GdaQueryTarget    *</RETURNS>
GdaQuery *query, const gchar *alias_or_name
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_target_pkfields</NAME>
<RETURNS>GSList            *</RETURNS>
GdaQuery *query, GdaQueryTarget *target
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_joins</NAME>
<RETURNS>GSList            *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_join_by_targets</NAME>
<RETURNS>GdaQueryJoin      *</RETURNS>
GdaQuery *query, GdaQueryTarget *target1, GdaQueryTarget *target2
</FUNCTION>
<FUNCTION>
<NAME>gda_query_add_join</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQuery *query, GdaQueryJoin *join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_del_join</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQueryJoin *join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_set_condition</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQueryCondition *cond
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_condition</NAME>
<RETURNS>GdaQueryCondition *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_main_conditions</NAME>
<RETURNS>GSList            *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_append_condition</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQueryCondition *cond, gboolean append_as_and
</FUNCTION>
<FUNCTION>
<NAME>gda_query_set_order_by_field</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQueryField *field, gint order, gboolean ascendant
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_order_by_field</NAME>
<RETURNS>gint               </RETURNS>
GdaQuery *query, GdaQueryField *field, gboolean *ascendant
</FUNCTION>
<FUNCTION>
<NAME>gda_query_set_results_limit</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, gboolean has_limit, guint limit, guint offset
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_results_limit</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQuery *query, guint *limit, guint *offset
</FUNCTION>
<FUNCTION>
<NAME>gda_query_add_field_from_sql</NAME>
<RETURNS>GdaQueryField     *</RETURNS>
GdaQuery *query, const gchar *field, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_all_fields</NAME>
<RETURNS>GSList            *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_field_by_sql_naming</NAME>
<RETURNS>GdaQueryField     *</RETURNS>
GdaQuery *query, const gchar *sql_name
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_field_by_param_name</NAME>
<RETURNS>GdaQueryField     *</RETURNS>
GdaQuery *query, const gchar *param_name
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_field_by_ref_field</NAME>
<RETURNS>GdaQueryField     *</RETURNS>
GdaQuery *query, GdaQueryTarget *target,GdaEntityField *ref_field,GdaQueryFieldState field_state
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_first_field_for_target</NAME>
<RETURNS>GdaQueryField     *</RETURNS>
GdaQuery *query, GdaQueryTarget *target
</FUNCTION>
<FUNCTION>
<NAME>gda_query_expand_all_field</NAME>
<RETURNS>GSList            *</RETURNS>
GdaQuery *query, GdaQueryTarget *target
</FUNCTION>
<FUNCTION>
<NAME>gda_query_order_fields_using_join_conds</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_query_get_fields_by_target</NAME>
<RETURNS>GSList            *</RETURNS>
GdaQuery *query, GdaQueryTarget *target, gboolean visible_fields_only
</FUNCTION>
<FUNCTION>
<NAME>gda_query_declare_condition</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQueryCondition *cond
</FUNCTION>
<FUNCTION>
<NAME>gda_query_undeclare_condition</NAME>
<RETURNS>void               </RETURNS>
GdaQuery *query, GdaQueryCondition *cond
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_BDB</NAME>
#define GDA_TYPE_DATA_MODEL_BDB            (gda_data_model_bdb_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_BDB</NAME>
#define GDA_DATA_MODEL_BDB(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_MODEL_BDB, GdaDataModelBdb))
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_BDB_CLASS</NAME>
#define GDA_DATA_MODEL_BDB_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_BDB, GdaDataModelBdbClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_BDB</NAME>
#define GDA_IS_DATA_MODEL_BDB(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_DATA_MODEL_BDB))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_BDB_CLASS</NAME>
#define GDA_IS_DATA_MODEL_BDB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_DATA_MODEL_BDB))
</MACRO>
<STRUCT>
<NAME>GdaDataModelBdb</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelBdbClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelBdbPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelBdb</NAME>
struct _GdaDataModelBdb {
	GdaObject               object;
	GdaDataModelBdbPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataModelBdbClass</NAME>
struct _GdaDataModelBdbClass {
	GdaObjectClass          parent_class;

	/* virtual methods */
	GSList                *(*create_key_columns)  (GdaDataModelBdb *model);
	GSList                *(*create_data_columns) (GdaDataModelBdb *model);
	GValue                *(*get_key_part)        (GdaDataModelBdb *model, 
						       gpointer data, gint length, gint part);
	GValue                *(*get_data_part)       (GdaDataModelBdb *model,
						       gpointer data, gint length, gint part);
	gboolean               (*update_key_part)     (GdaDataModelBdb *model,
						       gpointer data, gint length, gint part, 
						       const GValue *value, GError **error);
	gboolean               (*update_data_part)    (GdaDataModelBdb *model,
						       gpointer data, gint length, gint part, 
						       const GValue *value, GError **error);
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_bdb_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_bdb_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
const gchar *filename, const gchar *db_name
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_bdb_get_errors</NAME>
<RETURNS>GSList       *</RETURNS>
GdaDataModelBdb *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_bdb_clean_errors</NAME>
<RETURNS>void          </RETURNS>
GdaDataModelBdb *model
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_DIR</NAME>
#define GDA_TYPE_DATA_MODEL_DIR            (gda_data_model_dir_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_DIR</NAME>
#define GDA_DATA_MODEL_DIR(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_MODEL_DIR, GdaDataModelDir))
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_DIR_CLASS</NAME>
#define GDA_DATA_MODEL_DIR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_DIR, GdaDataModelDirClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_DIR</NAME>
#define GDA_IS_DATA_MODEL_DIR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_DATA_MODEL_DIR))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_DIR_CLASS</NAME>
#define GDA_IS_DATA_MODEL_DIR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_DATA_MODEL_DIR))
</MACRO>
<STRUCT>
<NAME>GdaDataModelDir</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelDirClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelDirPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelDir</NAME>
struct _GdaDataModelDir {
	GdaObject               object;
	GdaDataModelDirPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataModelDirClass</NAME>
struct _GdaDataModelDirClass {
	GdaObjectClass          parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_dir_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_dir_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
const gchar *basedir
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_dir_get_errors</NAME>
<RETURNS>GSList       *</RETURNS>
GdaDataModelDir *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_dir_clean_errors</NAME>
<RETURNS>void          </RETURNS>
GdaDataModelDir *model
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_ROW</NAME>
#define GDA_TYPE_DATA_MODEL_ROW            (gda_data_model_row_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_ROW</NAME>
#define GDA_DATA_MODEL_ROW(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_MODEL_ROW, GdaDataModelRow))
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_ROW_CLASS</NAME>
#define GDA_DATA_MODEL_ROW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_ROW, GdaDataModelRowClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_ROW</NAME>
#define GDA_IS_DATA_MODEL_ROW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_DATA_MODEL_ROW))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_ROW_CLASS</NAME>
#define GDA_IS_DATA_MODEL_ROW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_DATA_MODEL_ROW))
</MACRO>
<STRUCT>
<NAME>GdaDataModelRow</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelRowClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelRowPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelRow</NAME>
struct _GdaDataModelRow {
	GdaObject               object;
	GdaDataModelRowPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataModelRowClass</NAME>
struct _GdaDataModelRowClass {
	GdaObjectClass parent_class;

	/* virtual methods */
	gint                (* get_n_rows)      (GdaDataModelRow *model);
	gint                (* get_n_columns)   (GdaDataModelRow *model);
	GdaRow             *(* get_row)         (GdaDataModelRow *model, gint row, GError **error);
	const GValue       *(* get_value_at)    (GdaDataModelRow *model, gint col, gint row);
	
	gboolean            (* is_updatable)    (GdaDataModelRow *model);

	GdaRow             *(* append_values)   (GdaDataModelRow *model, const GList *values, GError **error);
	gboolean            (* append_row)      (GdaDataModelRow *model, GdaRow *row, GError **error);
	gboolean            (* update_row)      (GdaDataModelRow *model, GdaRow *row, GError **error);
	gboolean            (* remove_row)      (GdaDataModelRow *model, GdaRow *row, GError **error);
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_row_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_row_get_row</NAME>
<RETURNS>GdaRow      *</RETURNS>
GdaDataModelRow *model, gint row, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_HASH</NAME>
#define GDA_TYPE_DATA_MODEL_HASH            (gda_data_model_hash_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_HASH</NAME>
#define GDA_DATA_MODEL_HASH(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_MODEL_HASH, GdaDataModelHash))
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_HASH_CLASS</NAME>
#define GDA_DATA_MODEL_HASH_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_HASH, GdaDataModelHashClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_HASH</NAME>
#define GDA_IS_DATA_MODEL_HASH(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_DATA_MODEL_HASH))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_HASH_CLASS</NAME>
#define GDA_IS_DATA_MODEL_HASH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_DATA_MODEL_HASH))
</MACRO>
<STRUCT>
<NAME>GdaDataModelHash</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelHashClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelHashPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelHash</NAME>
struct _GdaDataModelHash {
	GdaDataModelRow model;
	GdaDataModelHashPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataModelHashClass</NAME>
struct _GdaDataModelHashClass {
	GdaDataModelRowClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_hash_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_hash_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
gint cols
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_hash_clear</NAME>
<RETURNS>void	      </RETURNS>
GdaDataModelHash *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_hash_set_n_columns</NAME>
<RETURNS>void	      </RETURNS>
GdaDataModelHash *model,gint cols
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_hash_insert_row</NAME>
<RETURNS>void 	      </RETURNS>
GdaDataModelHash *model,gint rownum,GdaRow *row
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_ENTITY_FIELD</NAME>
#define GDA_TYPE_ENTITY_FIELD          (gda_entity_field_get_type())
</MACRO>
<MACRO>
<NAME>GDA_ENTITY_FIELD</NAME>
#define GDA_ENTITY_FIELD(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ENTITY_FIELD, GdaEntityField)
</MACRO>
<MACRO>
<NAME>GDA_IS_ENTITY_FIELD</NAME>
#define GDA_IS_ENTITY_FIELD(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ENTITY_FIELD)
</MACRO>
<MACRO>
<NAME>GDA_ENTITY_FIELD_GET_IFACE</NAME>
#define GDA_ENTITY_FIELD_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GDA_TYPE_ENTITY_FIELD, GdaEntityFieldIface))
</MACRO>
<STRUCT>
<NAME>GdaEntityFieldIface</NAME>
struct _GdaEntityFieldIface
{
	GTypeInterface           g_iface;

	/* virtual table */
	GdaEntity         *(* get_entity)      (GdaEntityField *iface);
	GType              (* get_g_type)      (GdaEntityField *iface);
    void               (* set_dict_type)   (GdaEntityField *iface, GdaDictType *type);
	GdaDictType       *(* get_dict_type)   (GdaEntityField *iface);
	const gchar       *(* get_alias)       (GdaEntityField *iface);
};
</STRUCT>
<FUNCTION>
<NAME>gda_entity_field_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_field_get_entity</NAME>
<RETURNS>GdaEntity       *</RETURNS>
GdaEntityField *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_field_get_g_type</NAME>
<RETURNS>GType            </RETURNS>
GdaEntityField *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_field_set_dict_type</NAME>
<RETURNS>void             </RETURNS>
GdaEntityField *iface, GdaDictType *type
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_field_get_dict_type</NAME>
<RETURNS>GdaDictType     *</RETURNS>
GdaEntityField *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_field_get_name</NAME>
<RETURNS>const gchar     *</RETURNS>
GdaEntityField *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_entity_field_get_description</NAME>
<RETURNS>const gchar     *</RETURNS>
GdaEntityField *iface
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CONNECTION_EVENT</NAME>
#define GDA_TYPE_CONNECTION_EVENT            (gda_connection_event_get_type())
</MACRO>
<MACRO>
<NAME>GDA_CONNECTION_EVENT</NAME>
#define GDA_CONNECTION_EVENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_CONNECTION_EVENT, GdaConnectionEvent))
</MACRO>
<MACRO>
<NAME>GDA_CONNECTION_EVENT_CLASS</NAME>
#define GDA_CONNECTION_EVENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_CONNECTION_EVENT, GdaConnectionEventClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_CONNECTION_EVENT</NAME>
#define GDA_IS_CONNECTION_EVENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_CONNECTION_EVENT))
</MACRO>
<MACRO>
<NAME>GDA_IS_CONNECTION_EVENT_CLASS</NAME>
#define GDA_IS_CONNECTION_EVENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_CONNECTION_EVENT))
</MACRO>
<STRUCT>
<NAME>GdaConnectionEvent</NAME>
struct _GdaConnectionEvent {
	GObject object;
	GdaConnectionEventPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaConnectionEventClass</NAME>
struct _GdaConnectionEventClass {
	GObjectClass parent_class;
};
</STRUCT>
<ENUM>
<NAME>GdaConnectionEventType</NAME>
typedef enum {
	GDA_CONNECTION_EVENT_NOTICE,
	GDA_CONNECTION_EVENT_WARNING,
	GDA_CONNECTION_EVENT_ERROR,
	GDA_CONNECTION_EVENT_COMMAND
	
} GdaConnectionEventType;
</ENUM>
<ENUM>
<NAME>GdaConnectionEventCode</NAME>
typedef enum
{
       GDA_CONNECTION_EVENT_CODE_CONSTRAINT_VIOLATION,
       GDA_CONNECTION_EVENT_CODE_RESTRICT_VIOLATION,
       GDA_CONNECTION_EVENT_CODE_NOT_NULL_VIOLATION,
       GDA_CONNECTION_EVENT_CODE_FOREIGN_KEY_VIOLATION,
       GDA_CONNECTION_EVENT_CODE_UNIQUE_VIOLATION,
       GDA_CONNECTION_EVENT_CODE_CHECK_VIOLATION,
       GDA_CONNECTION_EVENT_CODE_INSUFFICIENT_PRIVILEGES,
       GDA_CONNECTION_EVENT_CODE_UNDEFINED_COLUMN,
       GDA_CONNECTION_EVENT_CODE_UNDEFINED_FUNCTION,
       GDA_CONNECTION_EVENT_CODE_UNDEFINED_TABLE,
       GDA_CONNECTION_EVENT_CODE_DUPLICATE_COLUMN,
       GDA_CONNECTION_EVENT_CODE_DUPLICATE_DATABASE,
       GDA_CONNECTION_EVENT_CODE_DUPLICATE_FUNCTION,
       GDA_CONNECTION_EVENT_CODE_DUPLICATE_SCHEMA,
       GDA_CONNECTION_EVENT_CODE_DUPLICATE_TABLE,
       GDA_CONNECTION_EVENT_CODE_DUPLICATE_ALIAS,
       GDA_CONNECTION_EVENT_CODE_DUPLICATE_OBJECT,
       GDA_CONNECTION_EVENT_CODE_SYNTAX_ERROR,
       GDA_CONNECTION_EVENT_CODE_UNKNOWN
} GdaConnectionEventCode;
</ENUM>
<MACRO>
<NAME>GDA_SQLSTATE_NO_ERROR</NAME>
#define GDA_SQLSTATE_NO_ERROR "00000"
</MACRO>
<MACRO>
<NAME>GDA_SQLSTATE_GENERAL_ERROR</NAME>
#define GDA_SQLSTATE_GENERAL_ERROR "HY000"
</MACRO>
<FUNCTION>
<NAME>gda_connection_event_get_type</NAME>
<RETURNS>GType                   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_new</NAME>
<RETURNS>GdaConnectionEvent     *</RETURNS>
GdaConnectionEventType type
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_free</NAME>
<RETURNS>void                    </RETURNS>
GdaConnectionEvent * event
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_list_copy</NAME>
<RETURNS>GList                  *</RETURNS>
const GList * events
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_list_free</NAME>
<RETURNS>void                    </RETURNS>
GList * events
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_set_event_type</NAME>
<RETURNS>void                    </RETURNS>
GdaConnectionEvent *event, GdaConnectionEventType type
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_get_event_type</NAME>
<RETURNS>GdaConnectionEventType  </RETURNS>
GdaConnectionEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_get_description</NAME>
<RETURNS>const gchar            *</RETURNS>
GdaConnectionEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_set_description</NAME>
<RETURNS>void                    </RETURNS>
GdaConnectionEvent *event, const gchar *description
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_get_code</NAME>
<RETURNS>glong                   </RETURNS>
GdaConnectionEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_set_code</NAME>
<RETURNS>void                    </RETURNS>
GdaConnectionEvent *event, glong code
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_get_gda_code</NAME>
<RETURNS>GdaConnectionEventCode  </RETURNS>
GdaConnectionEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_set_gda_code</NAME>
<RETURNS>void                    </RETURNS>
GdaConnectionEvent *event, GdaConnectionEventCode code
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_get_source</NAME>
<RETURNS>const gchar            *</RETURNS>
GdaConnectionEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_set_source</NAME>
<RETURNS>void                    </RETURNS>
GdaConnectionEvent *event, const gchar *source
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_get_sqlstate</NAME>
<RETURNS>const gchar            *</RETURNS>
GdaConnectionEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gda_connection_event_set_sqlstate</NAME>
<RETURNS>void                    </RETURNS>
GdaConnectionEvent *event, const gchar *sqlstate
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_ITER</NAME>
#define GDA_TYPE_DATA_MODEL_ITER          (gda_data_model_iter_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_ITER</NAME>
#define GDA_DATA_MODEL_ITER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_data_model_iter_get_type(), GdaDataModelIter)
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_ITER_CLASS</NAME>
#define GDA_DATA_MODEL_ITER_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_data_model_iter_get_type (), GdaDataModelIterClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_ITER</NAME>
#define GDA_IS_DATA_MODEL_ITER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_data_model_iter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_data_model_iter_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DATA_MODEL_ITER_ERROR</NAME>
#define GDA_DATA_MODEL_ITER_ERROR gda_data_model_iter_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDataModelIterError</NAME>
typedef enum
{
	GDA_DATA_MODEL_ITER_WHAT_ERROR
} GdaDataModelIterError;
</ENUM>
<STRUCT>
<NAME>GdaDataModelIter</NAME>
struct _GdaDataModelIter
{
	GdaParameterList           object;
	GdaDataModelIterPrivate   *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataModelIterClass</NAME>
struct _GdaDataModelIterClass
{
	GdaParameterListClass      parent_class;

	gboolean                (* row_to_change)    (GdaDataModelIter *iter, gint row);
	void                    (* row_changed)      (GdaDataModelIter *iter, gint row);
	void                    (* end_of_data)      (GdaDataModelIter *iter);
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_iter_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_new</NAME>
<RETURNS>GdaDataModelIter *</RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_get_value_at</NAME>
<RETURNS>const GValue     *</RETURNS>
GdaDataModelIter *iter, gint col
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_get_value_for_field</NAME>
<RETURNS>const GValue     *</RETURNS>
GdaDataModelIter *iter, const gchar *field_name
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_set_at_row</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataModelIter *iter, gint row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_move_next</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataModelIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_move_prev</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataModelIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_get_row</NAME>
<RETURNS>gint              </RETURNS>
GdaDataModelIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_can_be_moved</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataModelIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_invalidate_contents</NAME>
<RETURNS>void              </RETURNS>
GdaDataModelIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_is_valid</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataModelIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_get_column_for_param</NAME>
<RETURNS>gint              </RETURNS>
GdaDataModelIter *iter, GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_iter_get_param_for_column</NAME>
<RETURNS>GdaParameter     *</RETURNS>
GdaDataModelIter *iter, gint col
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_XML_STORAGE</NAME>
#define GDA_TYPE_XML_STORAGE          (gda_xml_storage_get_type())
</MACRO>
<MACRO>
<NAME>GDA_XML_STORAGE</NAME>
#define GDA_XML_STORAGE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_XML_STORAGE, GdaXmlStorage)
</MACRO>
<MACRO>
<NAME>GDA_IS_XML_STORAGE</NAME>
#define GDA_IS_XML_STORAGE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_XML_STORAGE)
</MACRO>
<MACRO>
<NAME>GDA_XML_STORAGE_GET_IFACE</NAME>
#define GDA_XML_STORAGE_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GDA_TYPE_XML_STORAGE, GdaXmlStorageIface))
</MACRO>
<STRUCT>
<NAME>GdaXmlStorageIface</NAME>
struct _GdaXmlStorageIface
{
	GTypeInterface           g_iface;

	/* virtual table */
	gchar      *(* get_xml_id)      (GdaXmlStorage *iface);
	xmlNodePtr  (* save_to_xml)     (GdaXmlStorage *iface, GError **error);
	gboolean    (* load_from_xml)   (GdaXmlStorage *iface, xmlNodePtr node, GError **error);
};
</STRUCT>
<FUNCTION>
<NAME>gda_xml_storage_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_storage_get_xml_id</NAME>
<RETURNS>gchar          *</RETURNS>
GdaXmlStorage *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_storage_save_to_xml</NAME>
<RETURNS>xmlNodePtr      </RETURNS>
GdaXmlStorage *iface, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_xml_storage_load_from_xml</NAME>
<RETURNS>gboolean        </RETURNS>
GdaXmlStorage *iface, xmlNodePtr node, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_QUERY</NAME>
#define GDA_TYPE_DATA_MODEL_QUERY            (gda_data_model_query_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_QUERY</NAME>
#define GDA_DATA_MODEL_QUERY(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_MODEL_QUERY, GdaDataModelQuery))
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_QUERY_CLASS</NAME>
#define GDA_DATA_MODEL_QUERY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_QUERY, GdaDataModelQueryClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_QUERY</NAME>
#define GDA_IS_DATA_MODEL_QUERY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_DATA_MODEL_QUERY))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_QUERY_CLASS</NAME>
#define GDA_IS_DATA_MODEL_QUERY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_DATA_MODEL_QUERY))
</MACRO>
<STRUCT>
<NAME>GdaDataModelQuery</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelQueryClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelQueryPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_query_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DATA_MODEL_QUERY_ERROR</NAME>
#define GDA_DATA_MODEL_QUERY_ERROR gda_data_model_query_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDataModelQueryError</NAME>
typedef enum {
        GDA_DATA_MODEL_QUERY_XML_LOAD_ERROR,
	GDA_DATA_MODEL_QUERY_COMPUTE_MODIF_QUERIES_ERROR
} GdaDataModelQueryError;
</ENUM>
<ENUM>
<NAME>GdaDataModelQueryOptions</NAME>
typedef enum {
	GDA_DATA_MODEL_QUERY_OPTION_USE_ALL_FIELDS_IF_NO_PK = 1 << 0
} GdaDataModelQueryOptions;
</ENUM>
<STRUCT>
<NAME>GdaDataModelQuery</NAME>
struct _GdaDataModelQuery {
	GdaObject                  object;
	GdaDataModelQueryPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataModelQueryClass</NAME>
struct _GdaDataModelQueryClass {
	GdaObjectClass             parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_query_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_query_new</NAME>
<RETURNS>GdaDataModel     *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_query_get_parameter_list</NAME>
<RETURNS>GdaParameterList *</RETURNS>
GdaDataModelQuery *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_query_refresh</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataModelQuery *model, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_query_set_modification_query</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataModelQuery *model,const gchar *query, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_query_compute_modification_queries</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDataModelQuery *model, const gchar *target,GdaDataModelQueryOptions options, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_SERVER_PROVIDER</NAME>
#define GDA_TYPE_SERVER_PROVIDER            (gda_server_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_SERVER_PROVIDER</NAME>
#define GDA_SERVER_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_SERVER_PROVIDER, GdaServerProvider))
</MACRO>
<MACRO>
<NAME>GDA_SERVER_PROVIDER_CLASS</NAME>
#define GDA_SERVER_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_SERVER_PROVIDER, GdaServerProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_SERVER_PROVIDER</NAME>
#define GDA_IS_SERVER_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_SERVER_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_SERVER_PROVIDER_CLASS</NAME>
#define GDA_IS_SERVER_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_SERVER_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GdaServerProviderInfo</NAME>
struct _GdaServerProviderInfo {
        gchar         *provider_name; /* equal to the return of gda_connection_get_provider() */

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

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

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

	/* TRUE is tables can be aliased in SELECT queries*/
	gboolean       supports_alias;

	/* TRUE if it is possible to write "SELECT table.field ..." or if it is only possible
	 * to write "SELECT field..."
	 */
	gboolean       supports_prefixed_fields;

	/* TRUE if non lower case identifiers must be surrounded by double quotes to distinguish them
	 * with their lower case equivalent, that is TRUE if by default the non lower case identifiers
	 * are converted into lower case.
	 */
	gboolean       quote_non_lc_identifiers;

	/* reserved for extensions */
	gboolean       reserved[20];
};
</STRUCT>
<STRUCT>
<NAME>GdaServerProvider</NAME>
struct _GdaServerProvider {
	GObject                   object;
	GdaServerProviderPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaServerProviderClass</NAME>
struct _GdaServerProviderClass {
	GObjectClass parent_class;

	/* signals */
	void                   (* last_connection_gone) (GdaServerProvider *provider);
	gpointer                  sig_reserved1;
	gpointer                  sig_reserved2;
	gpointer                  sig_reserved3;
	gpointer                  sig_reserved4;

	/* virtual methods */

	/* provider information */
	const gchar           *(* get_version) (GdaServerProvider *provider);
	const gchar           *(* get_server_version) (GdaServerProvider *provider,
						       GdaConnection *cnc);
	GdaServerProviderInfo *(* get_info) (GdaServerProvider *provider,
					     GdaConnection *cnc);
	gboolean               (* supports_feature) (GdaServerProvider *provider,
					             GdaConnection *cnc,
					             GdaConnectionFeature feature);
	
	GdaDataModel          *(* get_schema) (GdaServerProvider *provider,
					       GdaConnection *cnc,
					       GdaConnectionSchema schema,
					       GdaParameterList *params);

	/* types and values manipulation */
	GdaDataHandler        *(* get_data_handler) (GdaServerProvider *provider,
						     GdaConnection *cnc,
						     GType g_type,
						     const gchar *dbms_type);
	GValue                *(* string_to_value) (GdaServerProvider *provider,
						    GdaConnection *cnc,
						    const gchar *string, 
						    GType prefered_type,
						    gchar **dbms_type);
	const gchar           *(*get_def_dbms_type) (GdaServerProvider *provider,
						     GdaConnection *cnc,
						     GType g_type);
	gchar                 *(*escape_string)     (GdaServerProvider *provider,
						     GdaConnection *cnc, const gchar *str);
	gchar                 *(*unescape_string)   (GdaServerProvider *provider,
						     GdaConnection *cnc, const gchar *str);

	/* connections management */
	gboolean               (* open_connection) (GdaServerProvider *provider,
						    GdaConnection *cnc,
						    GdaQuarkList *params,
						    const gchar *username,
						    const gchar *password);
	gboolean               (* close_connection) (GdaServerProvider *provider,
						     GdaConnection *cnc);
	
	const gchar           *(* get_database) (GdaServerProvider *provider,
						 GdaConnection *cnc);
	gboolean               (* change_database) (GdaServerProvider *provider,
						    GdaConnection *cnc,
						    const gchar *name);
	/* operations */
	gboolean               (* supports_operation) (GdaServerProvider *provider, GdaConnection *cnc, 
						       GdaServerOperationType type, GdaParameterList *options);
	GdaServerOperation    *(* create_operation)   (GdaServerProvider *provider, GdaConnection *cnc, 
						       GdaServerOperationType type, 
						       GdaParameterList *options, GError **error);
	gchar                 *(* render_operation)   (GdaServerProvider *provider, GdaConnection *cnc, 
						       GdaServerOperation *op, GError **error);
	gboolean               (* perform_operation)  (GdaServerProvider *provider, GdaConnection *cnc, 
						       GdaServerOperation *op, GError **error);	

	/* commands */
	GList                  *(* execute_command) (GdaServerProvider *provider,
						     GdaConnection *cnc,
						     GdaCommand *cmd,
						     GdaParameterList *params);
	GdaObject              *(* execute_query) (GdaServerProvider *provider,
						   GdaConnection *cnc,
						   GdaQuery *query,
						   GdaParameterList *params);
	char                   *(* get_last_insert_id) (GdaServerProvider *provider,
							GdaConnection *cnc,
							GdaDataModel *recset);
	
	/* transactions */
	gboolean                (* begin_transaction) (GdaServerProvider *provider,
						       GdaConnection *cnc,
						       const gchar *name, GdaTransactionIsolation level,
						       GError **error);
	gboolean                (* commit_transaction) (GdaServerProvider *provider,
							GdaConnection *cnc,
							const gchar *name, GError **error);
	gboolean                (* rollback_transaction) (GdaServerProvider *provider,
							  GdaConnection *cnc,
							  const gchar *name, GError **error);
	gboolean                (* add_savepoint)      (GdaServerProvider *provider,
							GdaConnection *cnc,
							const gchar *name, GError **error);
	gboolean                (* rollback_savepoint) (GdaServerProvider *provider,
							GdaConnection *cnc,
							const gchar *name, GError **error);
	gboolean                (* delete_savepoint)   (GdaServerProvider *provider,
							GdaConnection *cnc,
							const gchar *name, GError **error);

	/* future extensions */
	gpointer                   reserved1; /* is_reserved_word() ? */
	gpointer                   reserved2; /* ping_or_reconnect() ? */
	gpointer                   reserved3; /* execute () ? */
	gpointer                   reserved4;
	/* extended from 3.0 */

	GdaConnection          *(* create_connection)  (GdaServerProvider *provider);
};
</STRUCT>
<FUNCTION>
<NAME>gda_server_provider_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_version</NAME>
<RETURNS>const gchar           *</RETURNS>
GdaServerProvider *provider
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_server_version</NAME>
<RETURNS>const gchar           *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_info</NAME>
<RETURNS>GdaServerProviderInfo *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_supports_feature</NAME>
<RETURNS>gboolean               </RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GdaConnectionFeature feature
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_schema</NAME>
<RETURNS>GdaDataModel          *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GdaConnectionSchema schema,GdaParameterList *params, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_data_handler_gtype</NAME>
<RETURNS>GdaDataHandler        *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GType for_type
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_data_handler_dbms</NAME>
<RETURNS>GdaDataHandler        *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,const gchar *for_type
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_string_to_value</NAME>
<RETURNS>GValue                *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,const gchar *string,GType prefered_type,gchar **dbms_type
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_value_to_sql_string</NAME>
<RETURNS>gchar                 *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GValue *from
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_default_dbms_type</NAME>
<RETURNS>const gchar           *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_escape_string</NAME>
<RETURNS>gchar                 *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc, const gchar *str
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_unescape_string</NAME>
<RETURNS>gchar                 *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc, const gchar *str
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_create_connection</NAME>
<RETURNS>GdaConnection         *</RETURNS>
GdaClient *client, GdaServerProvider *provider,const gchar *dsn,const gchar *username,const gchar *password,GdaConnectionOptions options
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_create_connection_from_string</NAME>
<RETURNS>GdaConnection         *</RETURNS>
GdaClient *client, GdaServerProvider *provider,const gchar *cnc_string,const gchar *username,const gchar *password,GdaConnectionOptions options
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_open_connection</NAME>
<RETURNS>gboolean               </RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GdaQuarkList *params,const gchar *username,const gchar *password
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_close_connection</NAME>
<RETURNS>gboolean               </RETURNS>
GdaServerProvider *provider,GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_database</NAME>
<RETURNS>const gchar           *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_change_database</NAME>
<RETURNS>gboolean               </RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_supports_operation</NAME>
<RETURNS>gboolean               </RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperationType type, GdaParameterList *options
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_create_operation</NAME>
<RETURNS>GdaServerOperation    *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperationType type,GdaParameterList *options, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_render_operation</NAME>
<RETURNS>gchar                 *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_perform_operation</NAME>
<RETURNS>gboolean               </RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_execute_command</NAME>
<RETURNS>GList        *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GdaCommand *cmd,GdaParameterList *params
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_execute_query</NAME>
<RETURNS>GdaObject    *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GdaQuery *query,GdaParameterList *params
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_last_insert_id</NAME>
<RETURNS>gchar        *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GdaDataModel *recset
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_begin_transaction</NAME>
<RETURNS>gboolean      </RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,const gchar *name, GdaTransactionIsolation level,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_commit_transaction</NAME>
<RETURNS>gboolean      </RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_rollback_transaction</NAME>
<RETURNS>gboolean      </RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_add_savepoint</NAME>
<RETURNS>gboolean      </RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_rollback_savepoint</NAME>
<RETURNS>gboolean      </RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_delete_savepoint</NAME>
<RETURNS>gboolean      </RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_get_schema_nb_columns</NAME>
<RETURNS>gint      </RETURNS>
GdaConnectionSchema schema
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_init_schema_model</NAME>
<RETURNS>gboolean  </RETURNS>
GdaDataModel *model, GdaConnectionSchema schema
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_test_schema_model</NAME>
<RETURNS>gboolean  </RETURNS>
GdaDataModel *model, GdaConnectionSchema schema, GError **error
</FUNCTION>
<STRUCT>
<NAME>GdaServerProviderHandlerInfo</NAME>
typedef struct {
	GdaConnection *cnc;
	GType          g_type;
	gchar         *dbms_type;
} GdaServerProviderHandlerInfo;
</STRUCT>
<FUNCTION>
<NAME>gda_server_provider_handler_info_hash_func</NAME>
<RETURNS>guint           </RETURNS>
GdaServerProviderHandlerInfo *key
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_handler_info_equal_func</NAME>
<RETURNS>gboolean        </RETURNS>
GdaServerProviderHandlerInfo *a,GdaServerProviderHandlerInfo *b
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_handler_info_free</NAME>
<RETURNS>void            </RETURNS>
GdaServerProviderHandlerInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_handler_find</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
GdaServerProvider *prov, GdaConnection *cnc,GType g_type, const gchar *dbms_type
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_handler_declare</NAME>
<RETURNS>void            </RETURNS>
GdaServerProvider *prov, GdaDataHandler *dh,GdaConnection *cnc,GType g_type, const gchar *dbms_type
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_blob_list_for_update</NAME>
<RETURNS>gboolean       </RETURNS>
GdaConnection *cnc, GdaQuery *query,GdaQuery **out_select, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_blob_list_for_delete</NAME>
<RETURNS>gboolean       </RETURNS>
GdaConnection *cnc, GdaQuery *query,GdaQuery **out_select, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_split_update_query</NAME>
<RETURNS>gboolean       </RETURNS>
GdaConnection *cnc, GdaQuery *query,GdaQuery **out_query, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_select_query_has_blobs</NAME>
<RETURNS>gboolean       </RETURNS>
GdaConnection *cnc, GdaQuery *query, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_find_file</NAME>
<RETURNS>gchar         *</RETURNS>
GdaServerProvider *prov, const gchar *inst_dir, const gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gda_server_provider_load_file_contents</NAME>
<RETURNS>gchar         *</RETURNS>
const gchar *inst_dir, const gchar *data_dir, const gchar *filename
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_JOIN</NAME>
#define GDA_TYPE_QUERY_JOIN          (gda_query_join_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_JOIN</NAME>
#define GDA_QUERY_JOIN(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_join_get_type(), GdaQueryJoin)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_JOIN_CLASS</NAME>
#define GDA_QUERY_JOIN_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_join_get_type (), GdaQueryJoinClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_JOIN</NAME>
#define GDA_IS_QUERY_JOIN(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_join_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_join_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_JOIN_ERROR</NAME>
#define GDA_QUERY_JOIN_ERROR gda_query_join_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryJoinType</NAME>
typedef enum {
        GDA_QUERY_JOIN_TYPE_INNER,
	GDA_QUERY_JOIN_TYPE_LEFT_OUTER,
	GDA_QUERY_JOIN_TYPE_RIGHT_OUTER,
	GDA_QUERY_JOIN_TYPE_FULL_OUTER,
        GDA_QUERY_JOIN_TYPE_CROSS,
        GDA_QUERY_JOIN_TYPE_LAST
} GdaQueryJoinType;
</ENUM>
<ENUM>
<NAME>GdaQueryJoinError</NAME>
typedef enum
{
	GDA_QUERY_JOIN_XML_LOAD_ERROR,
	GDA_QUERY_JOIN_META_DATA_UPDATE,
	GDA_QUERY_JOIN_FIELDS_ERROR,
	GDA_QUERY_JOIN_SQL_ANALYSE_ERROR,
	GDA_QUERY_JOIN_PARSE_ERROR
} GdaQueryJoinError;
</ENUM>
<STRUCT>
<NAME>GdaQueryJoin</NAME>
struct _GdaQueryJoin
{
	GdaQueryObject             object;
	GdaQueryJoinPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryJoinClass</NAME>
struct _GdaQueryJoinClass
{
	GdaQueryObjectClass        parent_class;

	/* signals */
	void   (*type_changed)         (GdaQueryJoin *join);
	void   (*condition_changed)    (GdaQueryJoin *join);
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_join_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_new_with_targets</NAME>
<RETURNS>GdaQueryJoin      *</RETURNS>
GdaQuery *query, GdaQueryTarget *target_1, GdaQueryTarget *target_2
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_new_with_xml_ids</NAME>
<RETURNS>GdaQueryJoin      *</RETURNS>
GdaQuery *query, const gchar *target_1_xml_id, const gchar *target_2_xml_id
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_new_copy</NAME>
<RETURNS>GdaQueryJoin      *</RETURNS>
GdaQueryJoin *orig, GHashTable *replacements
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_set_join_type</NAME>
<RETURNS>void               </RETURNS>
GdaQueryJoin *join, GdaQueryJoinType type
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_get_join_type</NAME>
<RETURNS>GdaQueryJoinType   </RETURNS>
GdaQueryJoin *join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_get_query</NAME>
<RETURNS>GdaQuery          *</RETURNS>
GdaQueryJoin *join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_get_target_1</NAME>
<RETURNS>GdaQueryTarget    *</RETURNS>
GdaQueryJoin *join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_get_target_2</NAME>
<RETURNS>GdaQueryTarget    *</RETURNS>
GdaQueryJoin *join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_swap_targets</NAME>
<RETURNS>void               </RETURNS>
GdaQueryJoin *join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_set_condition</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQueryJoin *join, GdaQueryCondition *cond
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_get_condition</NAME>
<RETURNS>GdaQueryCondition *</RETURNS>
GdaQueryJoin *join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_set_condition_from_fkcons</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQueryJoin *join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_set_condition_from_sql</NAME>
<RETURNS>gboolean           </RETURNS>
GdaQueryJoin *join, const gchar *cond, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_join_render_type</NAME>
<RETURNS>const gchar       *</RETURNS>
GdaQueryJoin *join
</FUNCTION>
<ENUM>
<NAME>GdaTransactionIsolation</NAME>
typedef enum {
	GDA_TRANSACTION_ISOLATION_UNKNOWN,
	GDA_TRANSACTION_ISOLATION_READ_COMMITTED,
	GDA_TRANSACTION_ISOLATION_READ_UNCOMMITTED,
	GDA_TRANSACTION_ISOLATION_REPEATABLE_READ,
	GDA_TRANSACTION_ISOLATION_SERIALIZABLE
} GdaTransactionIsolation;
</ENUM>
<ENUM>
<NAME>GdaValueAttribute</NAME>
typedef enum  {
	GDA_VALUE_ATTR_NONE           = 0,
        GDA_VALUE_ATTR_IS_NULL        = 1 << 0,
        GDA_VALUE_ATTR_CAN_BE_NULL    = 1 << 1,
        GDA_VALUE_ATTR_IS_DEFAULT     = 1 << 2,
        GDA_VALUE_ATTR_CAN_BE_DEFAULT = 1 << 3,
        GDA_VALUE_ATTR_IS_UNCHANGED   = 1 << 4,
        GDA_VALUE_ATTR_ACTIONS_SHOWN  = 1 << 5,
        GDA_VALUE_ATTR_DATA_NON_VALID = 1 << 6,
        GDA_VALUE_ATTR_HAS_VALUE_ORIG = 1 << 7,
	GDA_VALUE_ATTR_NO_MODIF       = 1 << 8,
	GDA_VALUE_ATTR_UNUSED         = 1 << 9
} GdaValueAttribute;
</ENUM>
<ENUM>
<NAME>GdaGraphType</NAME>
typedef enum {
        GDA_GRAPH_DB_RELATIONS,
	GDA_GRAPH_QUERY_JOINS,
        GDA_GRAPH_MODELLING /* for future extensions */
} GdaGraphType;
</ENUM>
<ENUM>
<NAME>GdaQueryFieldState</NAME>
typedef enum {
	GDA_ENTITY_FIELD_VISIBLE   = 1 << 0,
	GDA_ENTITY_FIELD_INVISIBLE = 1 << 1,
	GDA_ENTITY_FIELD_ANY       = GDA_ENTITY_FIELD_VISIBLE | GDA_ENTITY_FIELD_INVISIBLE
} GdaQueryFieldState;
</ENUM>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD</NAME>
#define GDA_TYPE_QUERY_FIELD          (gda_query_field_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD</NAME>
#define GDA_QUERY_FIELD(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_field_get_type(), GdaQueryField)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_CLASS</NAME>
#define GDA_QUERY_FIELD_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_field_get_type (), GdaQueryFieldClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_FIELD</NAME>
#define GDA_IS_QUERY_FIELD(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_field_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_FIELD_ERROR</NAME>
#define GDA_QUERY_FIELD_ERROR gda_query_field_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryFieldError</NAME>
typedef enum
{
	GDA_QUERY_FIELD_XML_LOAD_ERROR
} GdaQueryFieldError;
</ENUM>
<STRUCT>
<NAME>GdaQueryField</NAME>
struct _GdaQueryField
{
	GdaQueryObject              object;
	GdaQueryFieldPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldClass</NAME>
struct _GdaQueryFieldClass
{
	GdaQueryObjectClass         parent_class;

	/* pure virtual functions */
	GObject          *(*copy)           (GdaQueryField *orig);
	GSList           *(*get_params)     (GdaQueryField *qfield);
	gboolean          (*is_equal)       (GdaQueryField *qfield1, GdaQueryField *qfield2);
	gboolean          (*is_list)        (GdaQueryField *qfield);
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_field_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_new_from_xml</NAME>
<RETURNS>GdaQueryField    *</RETURNS>
GdaQuery *query, xmlNodePtr node, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_new_copy</NAME>
<RETURNS>GdaQueryField    *</RETURNS>
GdaQueryField *orig
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_new_from_sql</NAME>
<RETURNS>GdaQueryField    *</RETURNS>
GdaQuery *query, const gchar *sqlfield, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_get_dict_type</NAME>
<RETURNS>GdaDictType      *</RETURNS>
GdaQueryField *qfield
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_get_parameters</NAME>
<RETURNS>GSList           *</RETURNS>
GdaQueryField *qfield
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_set_alias</NAME>
<RETURNS>void              </RETURNS>
GdaQueryField *qfield, const gchar *alias
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_get_alias</NAME>
<RETURNS>const gchar      *</RETURNS>
GdaQueryField *qfield
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_set_visible</NAME>
<RETURNS>void              </RETURNS>
GdaQueryField *qfield, gboolean visible
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_is_visible</NAME>
<RETURNS>gboolean          </RETURNS>
GdaQueryField *qfield
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_set_internal</NAME>
<RETURNS>void              </RETURNS>
GdaQueryField *qfield, gboolean internal
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_is_internal</NAME>
<RETURNS>gboolean          </RETURNS>
GdaQueryField *qfield
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_is_equal</NAME>
<RETURNS>gboolean          </RETURNS>
GdaQueryField *qfield1, GdaQueryField *qfield2
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_is_list</NAME>
<RETURNS>gboolean          </RETURNS>
GdaQueryField *qfield
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL</NAME>
#define GDA_TYPE_DATA_MODEL            (gda_data_model_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL</NAME>
#define GDA_DATA_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_MODEL, GdaDataModel))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL</NAME>
#define GDA_IS_DATA_MODEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_DATA_MODEL))
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_GET_CLASS</NAME>
#define GDA_DATA_MODEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GDA_TYPE_DATA_MODEL, GdaDataModelClass))
</MACRO>
<ENUM>
<NAME>GdaDataModelAccessFlags</NAME>
typedef enum {
	GDA_DATA_MODEL_ACCESS_RANDOM = 1 << 0,
	GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD = 1 << 1,
	GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD = 1 << 2,
	GDA_DATA_MODEL_ACCESS_INSERT  = 1 << 3,
	GDA_DATA_MODEL_ACCESS_UPDATE  = 1 << 4,
	GDA_DATA_MODEL_ACCESS_DELETE  = 1 << 5,
	GDA_DATA_MODEL_ACCESS_WRITE = GDA_DATA_MODEL_ACCESS_INSERT | GDA_DATA_MODEL_ACCESS_UPDATE |
	GDA_DATA_MODEL_ACCESS_DELETE
} GdaDataModelAccessFlags;
</ENUM>
<ENUM>
<NAME>GdaDataModelHint</NAME>
typedef enum {
	GDA_DATA_MODEL_HINT_START_BATCH_UPDATE,
	GDA_DATA_MODEL_HINT_END_BATCH_UPDATE,
	GDA_DATA_MODEL_HINT_REFRESH
} GdaDataModelHint;
</ENUM>
<ENUM>
<NAME>GdaDataModelIOFormat</NAME>
typedef enum {
	GDA_DATA_MODEL_IO_DATA_ARRAY_XML,
	GDA_DATA_MODEL_IO_TEXT_SEPARATED
} GdaDataModelIOFormat;
</ENUM>
<STRUCT>
<NAME>GdaDataModelClass</NAME>
struct _GdaDataModelClass {
	GTypeInterface           g_iface;

	/* virtual table */
	gint                 (* i_get_n_rows)       (GdaDataModel *model);
	gint                 (* i_get_n_columns)    (GdaDataModel *model);

	GdaColumn           *(* i_describe_column)  (GdaDataModel *model, gint col);
	GdaDataModelAccessFlags (* i_get_access_flags) (GdaDataModel *model);

	const GValue        *(* i_get_value_at)     (GdaDataModel *model, gint col, gint row);
	GdaValueAttribute    (* i_get_attributes_at)(GdaDataModel *model, gint col, gint row);
	GdaDataModelIter    *(* i_create_iter)      (GdaDataModel *model);
	gboolean             (* i_iter_at_row)      (GdaDataModel *model, GdaDataModelIter *iter, gint row);
	gboolean             (* i_iter_next)        (GdaDataModel *model, GdaDataModelIter *iter); 
	gboolean             (* i_iter_prev)        (GdaDataModel *model, GdaDataModelIter *iter);

	gboolean             (* i_set_value_at)     (GdaDataModel *model, gint col, gint row, 
						     const GValue *value, GError **error);
	gboolean             (* i_set_values)       (GdaDataModel *model, gint row, GList *values,
						     GError **error);
	gint                 (* i_append_values)    (GdaDataModel *model, const GList *values, GError **error);
	gint                 (* i_append_row)       (GdaDataModel *model, GError **error);
	gboolean             (* i_remove_row)       (GdaDataModel *model, gint row, GError **error);
	gint                 (* i_find_row)         (GdaDataModel *model, GSList *values, gint *cols_index);

	void                 (* i_set_notify)       (GdaDataModel *model, gboolean do_notify_changes);
	gboolean             (* i_get_notify)       (GdaDataModel *model);
	void                 (* i_send_hint)        (GdaDataModel *model, GdaDataModelHint hint, const GValue *hint_value);
	gpointer                reserved1;
	gpointer                reserved2;
	gpointer                reserved3;
	gpointer                reserved4;

	/* signals */
	void                 (* row_inserted)       (GdaDataModel *model, gint row);
	void                 (* row_updated)        (GdaDataModel *model, gint row);
	void                 (* row_removed)        (GdaDataModel *model, gint row);
	void                 (* reset)              (GdaDataModel *model);
	gpointer                sig_reserved1;
	gpointer                sig_reserved2;
	gpointer                sig_reserved3;
	gpointer                sig_reserved4;
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_is_updatable</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_access_flags</NAME>
<RETURNS>GdaDataModelAccessFlags </RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_n_rows</NAME>
<RETURNS>gint                </RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_n_columns</NAME>
<RETURNS>gint                </RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_describe_column</NAME>
<RETURNS>GdaColumn          *</RETURNS>
GdaDataModel *model, gint col
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_column_index_by_name</NAME>
<RETURNS>gint                </RETURNS>
GdaDataModel *model, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_column_name</NAME>
<RETURNS>const gchar        *</RETURNS>
GdaDataModel *model, gint col
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_set_column_name</NAME>
<RETURNS>void                </RETURNS>
GdaDataModel *model, gint col, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_column_title</NAME>
<RETURNS>const gchar        *</RETURNS>
GdaDataModel *model, gint col
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_set_column_title</NAME>
<RETURNS>void                </RETURNS>
GdaDataModel *model, gint col, const gchar *title
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_value_at</NAME>
<RETURNS>const GValue       *</RETURNS>
GdaDataModel *model, gint col, gint row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_value_at_col_name</NAME>
<RETURNS>const GValue       *</RETURNS>
GdaDataModel *model,const gchar *column_name, gint row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_attributes_at</NAME>
<RETURNS>GdaValueAttribute   </RETURNS>
GdaDataModel *model, gint col, gint row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_create_iter</NAME>
<RETURNS>GdaDataModelIter   *</RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_freeze</NAME>
<RETURNS>void                </RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_thaw</NAME>
<RETURNS>void                </RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_set_value_at</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModel *model, gint col, gint row,const GValue *value, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_set_values</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModel *model, gint row,GList *values, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_append_row</NAME>
<RETURNS>gint                </RETURNS>
GdaDataModel *model, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_append_values</NAME>
<RETURNS>gint                </RETURNS>
GdaDataModel *model, const GList *values, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_remove_row</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModel *model, gint row, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_get_row_from_values</NAME>
<RETURNS>gint                </RETURNS>
GdaDataModel *model, GSList *values, gint *cols_index
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_send_hint</NAME>
<RETURNS>void                </RETURNS>
GdaDataModel *model, GdaDataModelHint hint, const GValue *hint_value
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_export_to_string</NAME>
<RETURNS>gchar              *</RETURNS>
GdaDataModel *model, GdaDataModelIOFormat format,const gint *cols, gint nb_cols,const gint *rows, gint nb_rows, GdaParameterList *options
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_export_to_file</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModel *model, GdaDataModelIOFormat format,const gchar *file,const gint *cols, gint nb_cols,const gint *rows, gint nb_rows,GdaParameterList *options, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_import_from_model</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModel *to, GdaDataModel *from, gboolean overwrite,GHashTable *cols_trans, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_import_from_string</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModel *model,const gchar *string, GHashTable *cols_trans,GdaParameterList *options, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_import_from_file</NAME>
<RETURNS>gboolean            </RETURNS>
GdaDataModel *model,const gchar *file, GHashTable *cols_trans,GdaParameterList *options, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_dump</NAME>
<RETURNS>void                </RETURNS>
GdaDataModel *model, FILE *to_stream
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_dump_as_string</NAME>
<RETURNS>gchar              *</RETURNS>
GdaDataModel *model
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_TRANSACTION_STATUS</NAME>
#define GDA_TYPE_TRANSACTION_STATUS            (gda_transaction_status_get_type())
</MACRO>
<MACRO>
<NAME>GDA_TRANSACTION_STATUS</NAME>
#define GDA_TRANSACTION_STATUS(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_TRANSACTION_STATUS, GdaTransactionStatus))
</MACRO>
<MACRO>
<NAME>GDA_TRANSACTION_STATUS_CLASS</NAME>
#define GDA_TRANSACTION_STATUS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_TRANSACTION_STATUS, GdaTransactionStatusClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_TRANSACTION_STATUS</NAME>
#define GDA_IS_TRANSACTION_STATUS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_TRANSACTION_STATUS))
</MACRO>
<MACRO>
<NAME>GDA_IS_TRANSACTION_STATUS_CLASS</NAME>
#define GDA_IS_TRANSACTION_STATUS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_TRANSACTION_STATUS))
</MACRO>
<STRUCT>
<NAME>GdaTransactionStatus</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaTransactionStatusClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaTransactionStatusEvent</NAME>
</STRUCT>
<ENUM>
<NAME>GdaTransactionStatusEventType</NAME>
typedef enum {
	GDA_TRANSACTION_STATUS_EVENT_SAVEPOINT,
	GDA_TRANSACTION_STATUS_EVENT_SQL,
	GDA_TRANSACTION_STATUS_EVENT_SUB_TRANSACTION
} GdaTransactionStatusEventType;
</ENUM>
<ENUM>
<NAME>GdaTransactionStatusState</NAME>
typedef enum {
	GDA_TRANSACTION_STATUS_STATE_OK,
	GDA_TRANSACTION_STATUS_STATE_FAILED
} GdaTransactionStatusState;
</ENUM>
<STRUCT>
<NAME>GdaTransactionStatusEvent</NAME>
struct _GdaTransactionStatusEvent {
	GdaTransactionStatus         *trans;
	GdaTransactionStatusEventType type;
	union {
		gchar                *svp_name; /* save point name if this event corresponds to a new save point */
		gchar                *sql;      /* SQL to store SQL queries in transactions */
		GdaTransactionStatus *sub_trans;/* sub transaction event */
	} pl;
	GdaConnectionEvent           *conn_event;

	gpointer  reserved1;
	gpointer  reserved2;
};
</STRUCT>
<STRUCT>
<NAME>GdaTransactionStatus</NAME>
struct _GdaTransactionStatus {
	GObject                    object;
	
	gchar                     *name;
	GdaTransactionIsolation    isolation_level;
	GdaTransactionStatusState  state;
	GList                     *events;
};
</STRUCT>
<STRUCT>
<NAME>GdaTransactionStatusClass</NAME>
struct _GdaTransactionStatusClass {
	GObjectClass             parent_class;
	gpointer                 reserved[10];
};
</STRUCT>
<FUNCTION>
<NAME>gda_transaction_status_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_transaction_status_new</NAME>
<RETURNS>GdaTransactionStatus *</RETURNS>
const gchar *name
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CLIENT</NAME>
#define GDA_TYPE_CLIENT            (gda_client_get_type())
</MACRO>
<MACRO>
<NAME>GDA_CLIENT</NAME>
#define GDA_CLIENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_CLIENT, GdaClient))
</MACRO>
<MACRO>
<NAME>GDA_CLIENT_CLASS</NAME>
#define GDA_CLIENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_CLIENT, GdaClientClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_CLIENT</NAME>
#define GDA_IS_CLIENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_CLIENT))
</MACRO>
<MACRO>
<NAME>GDA_IS_CLIENT_CLASS</NAME>
#define GDA_IS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_CLIENT))
</MACRO>
<ENUM>
<NAME>GdaClientEvent</NAME>
typedef enum {
	GDA_CLIENT_EVENT_INVALID,

	/* events usually notified by the library itself, and which the providers
	   should notify on very special cases (like a transaction being started
	   or committed via a BEGIN/COMMIT command directly sent to the
	   execute_command method on the provider */
	GDA_CLIENT_EVENT_ERROR,                 /* params: "error" */
	GDA_CLIENT_EVENT_CONNECTION_OPENED,     /* params: */
	GDA_CLIENT_EVENT_CONNECTION_CLOSED,     /* params: */
	GDA_CLIENT_EVENT_TRANSACTION_STARTED,   /* params: "transaction" */
	GDA_CLIENT_EVENT_TRANSACTION_COMMITTED, /* params: "transaction" */
	GDA_CLIENT_EVENT_TRANSACTION_CANCELLED  /* params: "transaction" */
} GdaClientEvent;
</ENUM>
<STRUCT>
<NAME>GdaClient</NAME>
struct _GdaClient {
	GObject           object;
	GdaClientPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaClientClass</NAME>
struct _GdaClientClass {
	GObjectClass      parent_class;

	/* signals */
	void (* event_notification) (GdaClient *client,
				     GdaConnection *cnc,
				     GdaClientEvent event,
				     GdaParameterList *params);
};
</STRUCT>
<FUNCTION>
<NAME>gda_client_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_CLIENT_ERROR</NAME>
#define GDA_CLIENT_ERROR gda_client_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaClientError</NAME>
typedef enum
{
  GDA_CLIENT_GENERAL_ERROR
} GdaClientError;
</ENUM>
<FUNCTION>
<NAME>gda_client_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_client_new</NAME>
<RETURNS>GdaClient     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_client_open_connection</NAME>
<RETURNS>GdaConnection *</RETURNS>
GdaClient *client,const gchar *dsn,const gchar *username,const gchar *password,GdaConnectionOptions options,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_client_declare_connection</NAME>
<RETURNS>void           </RETURNS>
GdaClient *client, GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_client_open_connection_from_string</NAME>
<RETURNS>GdaConnection *</RETURNS>
GdaClient *client,const gchar *provider_id,const gchar *cnc_string,const gchar *username,const gchar *password,GdaConnectionOptions options,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_client_get_connections</NAME>
<RETURNS>const GList   *</RETURNS>
GdaClient *client
</FUNCTION>
<FUNCTION>
<NAME>gda_client_find_connection</NAME>
<RETURNS>GdaConnection *</RETURNS>
GdaClient *client,const gchar *dsn,const gchar *username,const gchar *password
</FUNCTION>
<FUNCTION>
<NAME>gda_client_close_all_connections</NAME>
<RETURNS>void           </RETURNS>
GdaClient *client
</FUNCTION>
<FUNCTION>
<NAME>gda_client_notify_event</NAME>
<RETURNS>void           </RETURNS>
GdaClient *client, GdaConnection *cnc,GdaClientEvent event, GdaParameterList *params
</FUNCTION>
<FUNCTION>
<NAME>gda_client_notify_error_event</NAME>
<RETURNS>void           </RETURNS>
GdaClient *client, GdaConnection *cnc, GdaConnectionEvent *error
</FUNCTION>
<FUNCTION>
<NAME>gda_client_notify_connection_opened_event</NAME>
<RETURNS>void           </RETURNS>
GdaClient *client, GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_client_notify_connection_closed_event</NAME>
<RETURNS>void           </RETURNS>
GdaClient *client, GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_client_get_dsn_specs</NAME>
<RETURNS>gchar         *</RETURNS>
GdaClient *client, const gchar *provider
</FUNCTION>
<FUNCTION>
<NAME>gda_client_prepare_create_database</NAME>
<RETURNS>GdaServerOperation *</RETURNS>
GdaClient *client, const gchar *db_name,const gchar *provider
</FUNCTION>
<FUNCTION>
<NAME>gda_client_perform_create_database</NAME>
<RETURNS>gboolean       </RETURNS>
GdaClient *client, GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_client_prepare_drop_database</NAME>
<RETURNS>GdaServerOperation *</RETURNS>
GdaClient *client, const gchar *db_name,const gchar *provider
</FUNCTION>
<FUNCTION>
<NAME>gda_client_perform_drop_database</NAME>
<RETURNS>gboolean       </RETURNS>
GdaClient *client, GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_client_begin_transaction</NAME>
<RETURNS>gboolean       </RETURNS>
GdaClient *client, const gchar *name, GdaTransactionIsolation level,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_client_commit_transaction</NAME>
<RETURNS>gboolean       </RETURNS>
GdaClient *client, const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_client_rollback_transaction</NAME>
<RETURNS>gboolean       </RETURNS>
GdaClient *client, const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_transaction_status_add_event_svp</NAME>
<RETURNS>GdaTransactionStatusEvent *</RETURNS>
GdaTransactionStatus *tstatus, const gchar *svp_name
</FUNCTION>
<FUNCTION>
<NAME>gda_transaction_status_add_event_sql</NAME>
<RETURNS>GdaTransactionStatusEvent *</RETURNS>
GdaTransactionStatus *tstatus, const gchar *sql,GdaConnectionEvent *conn_event
</FUNCTION>
<FUNCTION>
<NAME>gda_transaction_status_add_event_sub</NAME>
<RETURNS>GdaTransactionStatusEvent *</RETURNS>
GdaTransactionStatus *tstatus, GdaTransactionStatus *sub_trans
</FUNCTION>
<FUNCTION>
<NAME>gda_transaction_status_free_events</NAME>
<RETURNS>void                       </RETURNS>
GdaTransactionStatus *tstatus, GdaTransactionStatusEvent *event,gboolean free_after
</FUNCTION>
<FUNCTION>
<NAME>gda_transaction_status_find</NAME>
<RETURNS>GdaTransactionStatus      *</RETURNS>
GdaTransactionStatus *tstatus, const gchar *str,GdaTransactionStatusEvent **destev
</FUNCTION>
<FUNCTION>
<NAME>gda_transaction_status_find_current</NAME>
<RETURNS>GdaTransactionStatus      *</RETURNS>
GdaTransactionStatus *tstatus, GdaTransactionStatusEvent **destev,gboolean unnamed_only
</FUNCTION>
<FUNCTION>
<NAME>gda_transaction_status_dump</NAME>
<RETURNS>void                       </RETURNS>
GdaTransactionStatus *tstatus, guint offset
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_CONDITION</NAME>
#define GDA_TYPE_QUERY_CONDITION          (gda_query_condition_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_CONDITION</NAME>
#define GDA_QUERY_CONDITION(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_condition_get_type(), GdaQueryCondition)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_CONDITION_CLASS</NAME>
#define GDA_QUERY_CONDITION_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_condition_get_type (), GdaQueryConditionClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_CONDITION</NAME>
#define GDA_IS_QUERY_CONDITION(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_condition_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_condition_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_CONDITION_ERROR</NAME>
#define GDA_QUERY_CONDITION_ERROR gda_query_condition_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryConditionType</NAME>
typedef enum {
        GDA_QUERY_CONDITION_NODE_AND,
        GDA_QUERY_CONDITION_NODE_OR,
        GDA_QUERY_CONDITION_NODE_NOT,
	GDA_QUERY_CONDITION_LEAF_EQUAL,
        GDA_QUERY_CONDITION_LEAF_DIFF,
        GDA_QUERY_CONDITION_LEAF_SUP,
        GDA_QUERY_CONDITION_LEAF_SUPEQUAL,
        GDA_QUERY_CONDITION_LEAF_INF,
        GDA_QUERY_CONDITION_LEAF_INFEQUAL,
        GDA_QUERY_CONDITION_LEAF_LIKE,
	GDA_QUERY_CONDITION_LEAF_SIMILAR,
        GDA_QUERY_CONDITION_LEAF_REGEX,
        GDA_QUERY_CONDITION_LEAF_REGEX_NOCASE,
        GDA_QUERY_CONDITION_LEAF_NOT_REGEX,
        GDA_QUERY_CONDITION_LEAF_NOT_REGEX_NOCASE,
        GDA_QUERY_CONDITION_LEAF_IN,
        GDA_QUERY_CONDITION_LEAF_BETWEEN,
        GDA_QUERY_CONDITION_TYPE_UNKNOWN
} GdaQueryConditionType;
</ENUM>
<ENUM>
<NAME>GdaQueryConditionOperator</NAME>
typedef enum {
	GDA_QUERY_CONDITION_OP_LEFT   = 0,
	GDA_QUERY_CONDITION_OP_RIGHT  = 1,
	GDA_QUERY_CONDITION_OP_RIGHT2 = 2
} GdaQueryConditionOperator;
</ENUM>
<ENUM>
<NAME>GdaQueryConditionError</NAME>
typedef enum
{
	GDA_QUERY_CONDITION_XML_LOAD_ERROR,
	GDA_QUERY_CONDITION_RENDERER_ERROR,
	GDA_QUERY_CONDITION_PARENT_ERROR
} GdaQueryConditionError;
</ENUM>
<STRUCT>
<NAME>GdaQueryCondition</NAME>
struct _GdaQueryCondition
{
	GdaQueryObject             object;
	GdaQueryConditionPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryConditionClass</NAME>
struct _GdaQueryConditionClass
{
	GdaQueryObjectClass        parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_condition_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_new</NAME>
<RETURNS>GdaQueryCondition    *</RETURNS>
GdaQuery *query, GdaQueryConditionType type
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_new_copy</NAME>
<RETURNS>GdaQueryCondition    *</RETURNS>
GdaQueryCondition *orig, GHashTable *replacements
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_new_from_sql</NAME>
<RETURNS>GdaQueryCondition    *</RETURNS>
GdaQuery *query, const gchar *sql_cond,GSList **targets, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_set_cond_type</NAME>
<RETURNS>void                  </RETURNS>
GdaQueryCondition *condition, GdaQueryConditionType type
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_get_cond_type</NAME>
<RETURNS>GdaQueryConditionType </RETURNS>
GdaQueryCondition *condition
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_get_children</NAME>
<RETURNS>GSList               *</RETURNS>
GdaQueryCondition *condition
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_get_parent</NAME>
<RETURNS>GdaQueryCondition    *</RETURNS>
GdaQueryCondition *condition
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_get_child_by_xml_id</NAME>
<RETURNS>GdaQueryCondition    *</RETURNS>
GdaQueryCondition *condition, const gchar *xml_id
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_is_ancestor</NAME>
<RETURNS>gboolean              </RETURNS>
GdaQueryCondition *condition, GdaQueryCondition *ancestor
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_is_leaf</NAME>
<RETURNS>gboolean              </RETURNS>
GdaQueryCondition *condition
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_node_add_child</NAME>
<RETURNS>gboolean              </RETURNS>
GdaQueryCondition *condition,GdaQueryCondition *child, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_node_del_child</NAME>
<RETURNS>void                  </RETURNS>
GdaQueryCondition *condition, GdaQueryCondition *child
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_leaf_set_operator</NAME>
<RETURNS>void                  </RETURNS>
GdaQueryCondition *condition,GdaQueryConditionOperator op, GdaQueryField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_leaf_get_operator</NAME>
<RETURNS>GdaQueryField        *</RETURNS>
GdaQueryCondition *condition, GdaQueryConditionOperator op
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_get_ref_objects_all</NAME>
<RETURNS>GSList               *</RETURNS>
GdaQueryCondition *cond
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_represents_join</NAME>
<RETURNS>gboolean              </RETURNS>
GdaQueryCondition *condition,GdaQueryTarget **target1, GdaQueryTarget **target2,gboolean *is_equi_join
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_represents_join_strict</NAME>
<RETURNS>gboolean              </RETURNS>
GdaQueryCondition *condition,GdaQueryTarget **target1, GdaQueryTarget **target2
</FUNCTION>
<FUNCTION>
<NAME>gda_query_condition_get_main_conditions</NAME>
<RETURNS>GSList               *</RETURNS>
GdaQueryCondition *condition
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_ACCESS_WRAPPER</NAME>
#define GDA_TYPE_DATA_ACCESS_WRAPPER            (gda_data_access_wrapper_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_ACCESS_WRAPPER</NAME>
#define GDA_DATA_ACCESS_WRAPPER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_ACCESS_WRAPPER, GdaDataAccessWrapper))
</MACRO>
<MACRO>
<NAME>GDA_DATA_ACCESS_WRAPPER_CLASS</NAME>
#define GDA_DATA_ACCESS_WRAPPER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_ACCESS_WRAPPER, GdaDataAccessWrapperClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_ACCESS_WRAPPER</NAME>
#define GDA_IS_DATA_ACCESS_WRAPPER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_DATA_ACCESS_WRAPPER))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_ACCESS_WRAPPER_CLASS</NAME>
#define GDA_IS_DATA_ACCESS_WRAPPER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_DATA_ACCESS_WRAPPER))
</MACRO>
<STRUCT>
<NAME>GdaDataAccessWrapper</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataAccessWrapperClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataAccessWrapperPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataAccessWrapper</NAME>
struct _GdaDataAccessWrapper {
	GdaObject                      object;
	GdaDataAccessWrapperPrivate   *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataAccessWrapperClass</NAME>
struct _GdaDataAccessWrapperClass {
	GdaObjectClass                 parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_access_wrapper_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_access_wrapper_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_access_wrapper_row_exists</NAME>
<RETURNS>gboolean      </RETURNS>
GdaDataAccessWrapper *wrapper, gint row
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_FILTER_SQL</NAME>
#define GDA_TYPE_DATA_MODEL_FILTER_SQL            (gda_data_model_filter_sql_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_FILTER_SQL</NAME>
#define GDA_DATA_MODEL_FILTER_SQL(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_DATA_MODEL_FILTER_SQL, GdaDataModelFilterSQL))
</MACRO>
<MACRO>
<NAME>GDA_DATA_MODEL_FILTER_SQL_CLASS</NAME>
#define GDA_DATA_MODEL_FILTER_SQL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_DATA_MODEL_FILTER_SQL, GdaDataModelFilterSQLClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_FILTER_SQL</NAME>
#define GDA_IS_DATA_MODEL_FILTER_SQL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_DATA_MODEL_FILTER_SQL))
</MACRO>
<MACRO>
<NAME>GDA_IS_DATA_MODEL_FILTER_SQL_CLASS</NAME>
#define GDA_IS_DATA_MODEL_FILTER_SQL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_DATA_MODEL_FILTER_SQL))
</MACRO>
<STRUCT>
<NAME>GdaDataModelFilterSQL</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelFilterSQLClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelFilterSQLPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDataModelFilterSQL</NAME>
struct _GdaDataModelFilterSQL {
	GdaDataModelArray             model;
	GdaDataModelFilterSQLPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDataModelFilterSQLClass</NAME>
struct _GdaDataModelFilterSQLClass {
	GdaDataModelArrayClass        parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_data_model_filter_sql_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_filter_sql_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_filter_sql_add_source</NAME>
<RETURNS>void          </RETURNS>
GdaDataModelFilterSQL *sel, const gchar *name, GdaDataModel *source
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_filter_sql_set_sql</NAME>
<RETURNS>void          </RETURNS>
GdaDataModelFilterSQL *sel, const gchar *sql
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_filter_sql_run</NAME>
<RETURNS>gboolean      </RETURNS>
GdaDataModelFilterSQL *sel
</FUNCTION>
<FUNCTION>
<NAME>gda_aggregates_get_register</NAME>
<RETURNS>GdaDictRegisterStruct *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>gda_aggregates_get_by_name</NAME>
<RETURNS>GSList                *</RETURNS>
GdaDict *dict, const gchar *aggname
</FUNCTION>
<FUNCTION>
<NAME>gda_aggregates_get_by_name_arg</NAME>
<RETURNS>GdaDictAggregate      *</RETURNS>
GdaDict *dict,const gchar *aggname, GdaDictType *argtype
</FUNCTION>
<FUNCTION>
<NAME>gda_aggregates_get_by_name_arg_in_list</NAME>
<RETURNS>GdaDictAggregate      *</RETURNS>
GdaDict *dict, GSList *aggregates,const gchar *aggname, GdaDictType *argtype
</FUNCTION>
<FUNCTION>
<NAME>gda_aggregates_get_by_dbms_id</NAME>
<RETURNS>GdaDictAggregate      *</RETURNS>
GdaDict *dict, const gchar *dbms_id
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_FUNCTION</NAME>
#define GDA_TYPE_DICT_FUNCTION          (gda_dict_function_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DICT_FUNCTION</NAME>
#define GDA_DICT_FUNCTION(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_dict_function_get_type(), GdaDictFunction)
</MACRO>
<MACRO>
<NAME>GDA_DICT_FUNCTION_CLASS</NAME>
#define GDA_DICT_FUNCTION_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_dict_function_get_type (), GdaDictFunctionClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DICT_FUNCTION</NAME>
#define GDA_IS_DICT_FUNCTION(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_dict_function_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_dict_function_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DICT_FUNCTION_ERROR</NAME>
#define GDA_DICT_FUNCTION_ERROR gda_dict_function_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDictFunctionError</NAME>
typedef enum
{
	GDA_DICT_FUNCTION_XML_LOAD_ERROR
} GdaDictFunctionError;
</ENUM>
<STRUCT>
<NAME>GdaDictFunction</NAME>
struct _GdaDictFunction
{
	GdaObject                         object;
	GdaDictFunctionPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDictFunctionClass</NAME>
struct _GdaDictFunctionClass
{
	GdaObjectClass                    parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_dict_function_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_new</NAME>
<RETURNS>GObject          *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_set_dbms_id</NAME>
<RETURNS>void              </RETURNS>
GdaDictFunction *func, const gchar *id
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_get_dbms_id</NAME>
<RETURNS>gchar            *</RETURNS>
GdaDictFunction *func
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_set_sqlname</NAME>
<RETURNS>void              </RETURNS>
GdaDictFunction *func, const gchar *sqlname
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_get_sqlname</NAME>
<RETURNS>const gchar      *</RETURNS>
GdaDictFunction *func
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_set_arg_dict_types</NAME>
<RETURNS>void              </RETURNS>
GdaDictFunction *func, const GSList *arg_types
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_get_arg_dict_types</NAME>
<RETURNS>const GSList     *</RETURNS>
GdaDictFunction *func
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_set_ret_dict_type</NAME>
<RETURNS>void              </RETURNS>
GdaDictFunction *func, GdaDictType *dt
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_get_ret_dict_type</NAME>
<RETURNS>GdaDictType      *</RETURNS>
GdaDictFunction *func
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_function_accepts_arg_dict_types</NAME>
<RETURNS>gboolean          </RETURNS>
GdaDictFunction *func, const GSList *arg_types
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_REFERER</NAME>
#define GDA_TYPE_REFERER          (gda_referer_get_type())
</MACRO>
<MACRO>
<NAME>GDA_REFERER</NAME>
#define GDA_REFERER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_REFERER, GdaReferer)
</MACRO>
<MACRO>
<NAME>GDA_IS_REFERER</NAME>
#define GDA_IS_REFERER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_REFERER)
</MACRO>
<MACRO>
<NAME>GDA_REFERER_GET_IFACE</NAME>
#define GDA_REFERER_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GDA_TYPE_REFERER, GdaRefererIface))
</MACRO>
<STRUCT>
<NAME>GdaRefererContext</NAME>
struct _GdaRefererContext
{
	gpointer fill_later;
};
</STRUCT>
<STRUCT>
<NAME>GdaRefererIface</NAME>
struct _GdaRefererIface
{
	GTypeInterface           g_iface;

	/* virtual table */
	gboolean    (* activate)        (GdaReferer *iface);
	void        (* deactivate)      (GdaReferer *iface);
	gboolean    (* is_active)       (GdaReferer *iface);
	GSList     *(* get_ref_objects) (GdaReferer *iface);
	void        (* replace_refs)    (GdaReferer *iface, GHashTable *replacements);

	/* signals */
	void        (* activated)       (GdaReferer *iface);
	void        (* deactivated)     (GdaReferer *iface);
};
</STRUCT>
<FUNCTION>
<NAME>gda_referer_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_referer_activate</NAME>
<RETURNS>gboolean    </RETURNS>
GdaReferer *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_referer_deactivate</NAME>
<RETURNS>void        </RETURNS>
GdaReferer *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_referer_is_active</NAME>
<RETURNS>gboolean    </RETURNS>
GdaReferer *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_referer_get_ref_objects</NAME>
<RETURNS>GSList     *</RETURNS>
GdaReferer *iface
</FUNCTION>
<FUNCTION>
<NAME>gda_referer_replace_refs</NAME>
<RETURNS>void        </RETURNS>
GdaReferer *iface, GHashTable *replacements
</FUNCTION>
<FUNCTION>
<NAME>gda_general_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_GENERAL_ERROR</NAME>
#define GDA_GENERAL_ERROR gda_general_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaGeneralError</NAME>
typedef enum  {
    GDA_GENERAL_OBJECT_NAME_ERROR,
    GDA_GENERAL_INCORRECT_VALUE_ERROR,
    GDA_GENERAL_OPERATION_ERROR
} GdaGeneralError;
</ENUM>
<FUNCTION>
<NAME>gda_init</NAME>
<RETURNS>void     </RETURNS>
const gchar *app_id, const gchar *version, gint nargs, gchar *args[]
</FUNCTION>
<FUNCTION>
<NAME>gda_get_default_dict</NAME>
<RETURNS>GdaDict *</RETURNS>
void
</FUNCTION>
<USER_FUNCTION>
<NAME>GdaInitFunc</NAME>
<RETURNS>void </RETURNS>
gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gda_main_run</NAME>
<RETURNS>void     </RETURNS>
GdaInitFunc init_func, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gda_main_quit</NAME>
<RETURNS>void     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_open_connection</NAME>
<RETURNS>GdaConnection*</RETURNS>
const gchar *dsn,const gchar *username,const gchar *password,GdaConnectionOptions options,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_insert_row_into_table</NAME>
<RETURNS>gboolean            </RETURNS>
GdaConnection *cnn,const gchar *table_name,GError **error, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_insert_row_into_table_from_string</NAME>
<RETURNS>gboolean            </RETURNS>
GdaConnection *cnn,const gchar *table_name,GError **error, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_update_value_in_table</NAME>
<RETURNS>gboolean            </RETURNS>
GdaConnection *cnn,const gchar *table_name,const gchar *search_for_column,const GValue *condition,const gchar *column_name,const GValue *new_value, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_update_values_in_table</NAME>
<RETURNS>gboolean            </RETURNS>
GdaConnection *cnn,const gchar *table_name,const gchar *condition_column_name,const GValue *condition,GError **error, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_delete_row_from_table</NAME>
<RETURNS>gboolean            </RETURNS>
GdaConnection *cnn, const gchar *table_name,const gchar *condition_column_name, const GValue *condition,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_execute_select_command</NAME>
<RETURNS>GdaDataModel*</RETURNS>
GdaConnection *cnn, const gchar *sql,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_execute_sql_command</NAME>
<RETURNS>gint                </RETURNS>
GdaConnection *cnn, const gchar *sql,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_create_table</NAME>
<RETURNS>gboolean            </RETURNS>
GdaConnection *cnn,const gchar *table_name, GError **error, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_drop_table</NAME>
<RETURNS>gboolean            </RETURNS>
GdaConnection *cnn,const gchar *table_name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_signal_emit_changed</NAME>
<RETURNS>void     </RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_row_inserted</NAME>
<RETURNS>void     </RETURNS>
GdaDataModel *model, gint row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_row_updated</NAME>
<RETURNS>void     </RETURNS>
GdaDataModel *model, gint row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_row_removed</NAME>
<RETURNS>void     </RETURNS>
GdaDataModel *model, gint row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_reset</NAME>
<RETURNS>void     </RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_move_iter_at_row_default</NAME>
<RETURNS>gboolean </RETURNS>
GdaDataModel *model, GdaDataModelIter *iter, gint row
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_move_iter_next_default</NAME>
<RETURNS>gboolean </RETURNS>
GdaDataModel *model, GdaDataModelIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gda_data_model_move_iter_prev_default</NAME>
<RETURNS>gboolean </RETURNS>
GdaDataModel *model, GdaDataModelIter *iter
</FUNCTION>
<MACRO>
<NAME>GDA_TIMEZONE_INVALID</NAME>
#define GDA_TIMEZONE_INVALID (2*12*60*60)
</MACRO>
<MACRO>
<NAME>GDA_TYPE_NULL</NAME>
#define GDA_TYPE_NULL 0
</MACRO>
<MACRO>
<NAME>GDA_TYPE_BINARY</NAME>
#define	GDA_TYPE_BINARY (gda_binary_get_type())
</MACRO>
<MACRO>
<NAME>GDA_TYPE_BLOB</NAME>
#define GDA_TYPE_BLOB (gda_blob_get_type())
</MACRO>
<MACRO>
<NAME>GDA_TYPE_GEOMETRIC_POINT</NAME>
#define	GDA_TYPE_GEOMETRIC_POINT (gda_geometricpoint_get_type())
</MACRO>
<MACRO>
<NAME>GDA_TYPE_LIST</NAME>
#define	GDA_TYPE_LIST (gda_value_list_get_type())
</MACRO>
<MACRO>
<NAME>GDA_TYPE_NUMERIC</NAME>
#define	GDA_TYPE_NUMERIC (gda_numeric_get_type())
</MACRO>
<MACRO>
<NAME>GDA_TYPE_SHORT</NAME>
#define	GDA_TYPE_SHORT (gda_short_get_type()) 
</MACRO>
<MACRO>
<NAME>GDA_TYPE_USHORT</NAME>
#define	GDA_TYPE_USHORT (gda_ushort_get_type())
</MACRO>
<MACRO>
<NAME>GDA_TYPE_TIME</NAME>
#define GDA_TYPE_TIME (gda_time_get_type())
</MACRO>
<MACRO>
<NAME>GDA_TYPE_TIMESTAMP</NAME>
#define GDA_TYPE_TIMESTAMP (gda_timestamp_get_type())
</MACRO>
<MACRO>
<NAME>GDA_VALUE_HOLDS_BINARY</NAME>
#define GDA_VALUE_HOLDS_BINARY(value)          G_VALUE_HOLDS(value, GDA_TYPE_BINARY)
</MACRO>
<MACRO>
<NAME>GDA_VALUE_HOLDS_BLOB</NAME>
#define GDA_VALUE_HOLDS_BLOB(value)            G_VALUE_HOLDS(value, GDA_TYPE_BLOB)
</MACRO>
<MACRO>
<NAME>GDA_VALUE_HOLDS_GEOMETRIC_POINT</NAME>
#define GDA_VALUE_HOLDS_GEOMETRIC_POINT(value) G_VALUE_HOLDS(value, GDA_TYPE_GEOMETRIC_POINT)
</MACRO>
<MACRO>
<NAME>GDA_VALUE_HOLDS_LIST</NAME>
#define GDA_VALUE_HOLDS_LIST(value)            G_VALUE_HOLDS(value, GDA_TYPE_LIST)
</MACRO>
<MACRO>
<NAME>GDA_VALUE_HOLDS_NUMERIC</NAME>
#define GDA_VALUE_HOLDS_NUMERIC(value)         G_VALUE_HOLDS(value, GDA_TYPE_NUMERIC)
</MACRO>
<MACRO>
<NAME>GDA_VALUE_HOLDS_SHORT</NAME>
#define GDA_VALUE_HOLDS_SHORT(value)           G_VALUE_HOLDS(value, GDA_TYPE_SHORT)
</MACRO>
<MACRO>
<NAME>GDA_VALUE_HOLDS_USHORT</NAME>
#define GDA_VALUE_HOLDS_USHORT(value)          G_VALUE_HOLDS(value, GDA_TYPE_USHORT)
</MACRO>
<MACRO>
<NAME>GDA_VALUE_HOLDS_TIME</NAME>
#define GDA_VALUE_HOLDS_TIME(value)            G_VALUE_HOLDS(value, GDA_TYPE_TIME)
</MACRO>
<MACRO>
<NAME>GDA_VALUE_HOLDS_TIMESTAMP</NAME>
#define GDA_VALUE_HOLDS_TIMESTAMP(value)       G_VALUE_HOLDS(value, GDA_TYPE_TIMESTAMP)
</MACRO>
<STRUCT>
<NAME>GdaGeometricPoint</NAME>
typedef struct {
	gdouble x;
	gdouble y;
} GdaGeometricPoint;
</STRUCT>
<STRUCT>
<NAME>GdaNumeric</NAME>
typedef struct {
	gchar *number;
	glong precision;
	glong width;
} GdaNumeric;
</STRUCT>
<STRUCT>
<NAME>GdaTime</NAME>
typedef struct {
	gushort hour;
	gushort minute;
	gushort second;
	gulong fraction;
	glong timezone;	/* # of seconds to the east UTC */
} GdaTime;
</STRUCT>
<STRUCT>
<NAME>GdaTimestamp</NAME>
typedef struct {
	gshort year;
	gushort month;
	gushort day;
	gushort hour;
	gushort minute;
	gushort second;
	gulong fraction;
	glong timezone;	/* # of seconds to the east UTC */
} GdaTimestamp;
</STRUCT>
<STRUCT>
<NAME>GdaBinary</NAME>
typedef struct {
	guchar *data;
	glong   binary_length;
} GdaBinary;
</STRUCT>
<STRUCT>
<NAME>GdaBlob</NAME>
typedef struct {
	GdaBinary  data;
	GdaBlobOp *op; /* set up by providers if the GdaBlob is linked to something actually existing in the database, 
			  useable by anyone */
} GdaBlob;
</STRUCT>
<TYPEDEF>
<NAME>GdaValueList</NAME>
typedef GList GdaValueList;
</TYPEDEF>
<MACRO>
<NAME>gda_value_isa</NAME>
#define gda_value_isa(value, type) (G_VALUE_HOLDS(value, type))
</MACRO>
<FUNCTION>
<NAME>gda_value_new</NAME>
<RETURNS>GValue                           *</RETURNS>
GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_value_new_binary</NAME>
<RETURNS>GValue                           *</RETURNS>
const guchar *val, glong size
</FUNCTION>
<FUNCTION>
<NAME>gda_value_new_blob</NAME>
<RETURNS>GValue                           *</RETURNS>
const guchar *val, glong size
</FUNCTION>
<FUNCTION>
<NAME>gda_value_new_timestamp_from_timet</NAME>
<RETURNS>GValue                           *</RETURNS>
time_t val
</FUNCTION>
<FUNCTION>
<NAME>gda_value_new_from_string</NAME>
<RETURNS>GValue                           *</RETURNS>
const gchar *as_string, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_value_new_from_xml</NAME>
<RETURNS>GValue                           *</RETURNS>
const xmlNodePtr node
</FUNCTION>
<FUNCTION>
<NAME>gda_value_free</NAME>
<RETURNS>void                              </RETURNS>
GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_reset_with_type</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_value_is_null</NAME>
<RETURNS>gboolean                          </RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_is_number</NAME>
<RETURNS>gboolean                          </RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_copy</NAME>
<RETURNS>GValue                           *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_get_binary</NAME>
<RETURNS>G_CONST_RETURN GdaBinary         *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_binary</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const GdaBinary *binary
</FUNCTION>
<FUNCTION>
<NAME>gda_value_take_binary</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const GdaBinary *binary
</FUNCTION>
<FUNCTION>
<NAME>gda_value_get_blob</NAME>
<RETURNS>G_CONST_RETURN GdaBlob           *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_blob</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const GdaBlob *blob
</FUNCTION>
<FUNCTION>
<NAME>gda_value_take_blob</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const GdaBlob *blob
</FUNCTION>
<FUNCTION>
<NAME>gda_value_get_geometric_point</NAME>
<RETURNS>G_CONST_RETURN GdaGeometricPoint *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_geometric_point</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const GdaGeometricPoint *val
</FUNCTION>
<FUNCTION>
<NAME>gda_value_get_list</NAME>
<RETURNS>G_CONST_RETURN GdaValueList      *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_list</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const GdaValueList *val
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_null</NAME>
<RETURNS>void                              </RETURNS>
GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_get_numeric</NAME>
<RETURNS>G_CONST_RETURN GdaNumeric        *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_numeric</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const GdaNumeric *val
</FUNCTION>
<FUNCTION>
<NAME>gda_value_get_short</NAME>
<RETURNS>gshort                            </RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_short</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const gshort val
</FUNCTION>
<FUNCTION>
<NAME>gda_value_get_ushort</NAME>
<RETURNS>gushort                           </RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_ushort</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const gushort val
</FUNCTION>
<FUNCTION>
<NAME>gda_value_get_time</NAME>
<RETURNS>G_CONST_RETURN GdaTime           *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_time</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const GdaTime *val
</FUNCTION>
<FUNCTION>
<NAME>gda_value_get_timestamp</NAME>
<RETURNS>G_CONST_RETURN GdaTimestamp      *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_timestamp</NAME>
<RETURNS>void                              </RETURNS>
GValue *value, const GdaTimestamp *val
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_from_string</NAME>
<RETURNS>gboolean                          </RETURNS>
GValue *value,const gchar *as_string,GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_value_set_from_value</NAME>
<RETURNS>gboolean                          </RETURNS>
GValue *value, const GValue *from
</FUNCTION>
<FUNCTION>
<NAME>gda_value_compare</NAME>
<RETURNS>gint                              </RETURNS>
const GValue *value1, const GValue *value2
</FUNCTION>
<FUNCTION>
<NAME>gda_value_compare_ext</NAME>
<RETURNS>gint                              </RETURNS>
const GValue *value1, const GValue *value2
</FUNCTION>
<FUNCTION>
<NAME>gda_value_stringify</NAME>
<RETURNS>gchar                            *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_value_to_xml</NAME>
<RETURNS>xmlNodePtr                        </RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_binary_to_string</NAME>
<RETURNS>gchar                            *</RETURNS>
const GdaBinary *bin, guint maxlen
</FUNCTION>
<FUNCTION>
<NAME>gda_string_to_binary</NAME>
<RETURNS>gboolean                          </RETURNS>
const gchar *str, GdaBinary *bin
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_to_string</NAME>
<RETURNS>gchar                            *</RETURNS>
GdaBlob *blob, guint maxlen
</FUNCTION>
<FUNCTION>
<NAME>gda_string_to_blob</NAME>
<RETURNS>gboolean                          </RETURNS>
const gchar *str, GdaBlob *blob
</FUNCTION>
<FUNCTION>
<NAME>gda_numeric_get_type</NAME>
<RETURNS>GType                             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_numeric_copy</NAME>
<RETURNS>gpointer                          </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_numeric_free</NAME>
<RETURNS>void                              </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_time_get_type</NAME>
<RETURNS>GType                             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_time_copy</NAME>
<RETURNS>gpointer                          </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_time_free</NAME>
<RETURNS>void                              </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_timestamp_get_type</NAME>
<RETURNS>GType                             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_timestamp_copy</NAME>
<RETURNS>gpointer                          </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_timestamp_free</NAME>
<RETURNS>void                              </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_geometricpoint_get_type</NAME>
<RETURNS>GType                             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_geometricpoint_copy</NAME>
<RETURNS>gpointer                          </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_geometricpoint_free</NAME>
<RETURNS>void                              </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_binary_get_type</NAME>
<RETURNS>GType                             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_binary_copy</NAME>
<RETURNS>gpointer                          </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_binary_free</NAME>
<RETURNS>void                              </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_get_type</NAME>
<RETURNS>GType                             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_copy</NAME>
<RETURNS>gpointer                          </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_free</NAME>
<RETURNS>void                              </RETURNS>
gpointer boxed
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_set_op</NAME>
<RETURNS>void                              </RETURNS>
GdaBlob *blob, GdaBlobOp *op
</FUNCTION>
<FUNCTION>
<NAME>gda_value_list_get_type</NAME>
<RETURNS>GType                             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_short_get_type</NAME>
<RETURNS>GType                             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_ushort_get_type</NAME>
<RETURNS>GType                             </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>gda_value_new_null</NAME>
#define                           gda_value_new_null() (g_new0 (GValue, 1))
</MACRO>
<MACRO>
<NAME>GDA_TYPE_SERVER_OPERATION</NAME>
#define GDA_TYPE_SERVER_OPERATION            (gda_server_operation_get_type())
</MACRO>
<MACRO>
<NAME>GDA_SERVER_OPERATION</NAME>
#define GDA_SERVER_OPERATION(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_SERVER_OPERATION, GdaServerOperation))
</MACRO>
<MACRO>
<NAME>GDA_SERVER_OPERATION_CLASS</NAME>
#define GDA_SERVER_OPERATION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_SERVER_OPERATION, GdaServerOperationClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_SERVER_OPERATION</NAME>
#define GDA_IS_SERVER_OPERATION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_SERVER_OPERATION))
</MACRO>
<MACRO>
<NAME>GDA_IS_SERVER_OPERATION_CLASS</NAME>
#define GDA_IS_SERVER_OPERATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_SERVER_OPERATION))
</MACRO>
<ENUM>
<NAME>GdaServerOperationType</NAME>
typedef enum {
	GDA_SERVER_OPERATION_CREATE_DB,
	GDA_SERVER_OPERATION_DROP_DB,
		
	GDA_SERVER_OPERATION_CREATE_TABLE,
	GDA_SERVER_OPERATION_DROP_TABLE,
	GDA_SERVER_OPERATION_RENAME_TABLE,

	GDA_SERVER_OPERATION_ADD_COLUMN,
	GDA_SERVER_OPERATION_DROP_COLUMN,

	GDA_SERVER_OPERATION_CREATE_INDEX,
	GDA_SERVER_OPERATION_DROP_INDEX,

	GDA_SERVER_OPERATION_NB
} GdaServerOperationType;
</ENUM>
<ENUM>
<NAME>GdaServerOperationNodeType</NAME>
typedef enum {
	GDA_SERVER_OPERATION_NODE_PARAMLIST,
	GDA_SERVER_OPERATION_NODE_DATA_MODEL,
	GDA_SERVER_OPERATION_NODE_PARAM,
	GDA_SERVER_OPERATION_NODE_SEQUENCE,
	GDA_SERVER_OPERATION_NODE_SEQUENCE_ITEM,

	GDA_SERVER_OPERATION_NODE_DATA_MODEL_COLUMN,
	GDA_SERVER_OPERATION_NODE_UNKNOWN
} GdaServerOperationNodeType;
</ENUM>
<ENUM>
<NAME>GdaServerOperationNodeStatus</NAME>
typedef enum {
	GDA_SERVER_OPERATION_STATUS_OPTIONAL,
	GDA_SERVER_OPERATION_STATUS_REQUIRED,
	GDA_SERVER_OPERATION_STATUS_UNKNOWN
} GdaServerOperationNodeStatus;
</ENUM>
<STRUCT>
<NAME>GdaServerOperationNode</NAME>
typedef struct _GdaServerOperationNode {
	GdaServerOperationNodeType    type;
	GdaServerOperationNodeStatus  status;
	
	GdaParameterList             *plist;
	GdaDataModel                 *model;
	GdaColumn                    *column;
	GdaParameter                 *param; 
	gpointer                      priv;
} GdaServerOperationNode;
</STRUCT>
<STRUCT>
<NAME>GdaServerOperation</NAME>
struct _GdaServerOperation {
	GObject                    object;
	GdaServerOperationPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaServerOperationClass</NAME>
struct _GdaServerOperationClass {
	GObjectClass               parent_class;

	/* signals */
	void                     (*seq_item_added) (GdaServerOperation *op, const gchar *seq_path, gint item_index);
	void                     (*seq_item_remove) (GdaServerOperation *op, const gchar *seq_path, gint item_index);

};
</STRUCT>
<FUNCTION>
<NAME>gda_server_operation_get_type</NAME>
<RETURNS>GType                      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_new</NAME>
<RETURNS>GdaServerOperation        *</RETURNS>
GdaServerOperationType op_type, const gchar *xml_file
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_op_type</NAME>
<RETURNS>GdaServerOperationType     </RETURNS>
GdaServerOperation *op
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_op_type_to_string</NAME>
<RETURNS>const gchar               *</RETURNS>
GdaServerOperationType type
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_node_info</NAME>
<RETURNS>GdaServerOperationNode    *</RETURNS>
GdaServerOperation *op, const gchar *path_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_value_at</NAME>
<RETURNS>const GValue              *</RETURNS>
GdaServerOperation *op, const gchar *path_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_set_value_at</NAME>
<RETURNS>gboolean                   </RETURNS>
GdaServerOperation *op, const gchar *value,GError **error, const gchar *path_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_save_data_to_xml</NAME>
<RETURNS>xmlNodePtr                 </RETURNS>
GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_load_data_from_xml</NAME>
<RETURNS>gboolean                   </RETURNS>
GdaServerOperation *op,xmlNodePtr node, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_root_nodes</NAME>
<RETURNS>gchar**</RETURNS>
GdaServerOperation *op
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_node_type</NAME>
<RETURNS>GdaServerOperationNodeType </RETURNS>
GdaServerOperation *op, const gchar *path,GdaServerOperationNodeStatus *status
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_node_parent</NAME>
<RETURNS>gchar                     *</RETURNS>
GdaServerOperation *op, const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_node_path_portion</NAME>
<RETURNS>gchar                     *</RETURNS>
GdaServerOperation *op, const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_sequence_name</NAME>
<RETURNS>const gchar               *</RETURNS>
GdaServerOperation *op, const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_sequence_size</NAME>
<RETURNS>guint                      </RETURNS>
GdaServerOperation *op, const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_sequence_max_size</NAME>
<RETURNS>guint                      </RETURNS>
GdaServerOperation *op, const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_sequence_min_size</NAME>
<RETURNS>guint                      </RETURNS>
GdaServerOperation *op, const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_get_sequence_item_names</NAME>
<RETURNS>gchar                    **</RETURNS>
GdaServerOperation *op, const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_add_item_to_sequence</NAME>
<RETURNS>guint                      </RETURNS>
GdaServerOperation *op, const gchar *path
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_del_item_from_sequence</NAME>
<RETURNS>gboolean                   </RETURNS>
GdaServerOperation *op, const gchar *item_path
</FUNCTION>
<FUNCTION>
<NAME>gda_server_operation_is_valid</NAME>
<RETURNS>gboolean                   </RETURNS>
GdaServerOperation *op, const gchar *xml_file, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_PARAMETER_LIST</NAME>
#define GDA_TYPE_PARAMETER_LIST          (gda_parameter_list_get_type())
</MACRO>
<MACRO>
<NAME>GDA_PARAMETER_LIST</NAME>
#define GDA_PARAMETER_LIST(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_parameter_list_get_type(), GdaParameterList)
</MACRO>
<MACRO>
<NAME>GDA_PARAMETER_LIST_CLASS</NAME>
#define GDA_PARAMETER_LIST_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_parameter_list_get_type (), GdaParameterListClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_PARAMETER_LIST</NAME>
#define GDA_IS_PARAMETER_LIST(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_parameter_list_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_parameter_list_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_PARAMETER_LIST_ERROR</NAME>
#define GDA_PARAMETER_LIST_ERROR gda_parameter_list_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaParameterListError</NAME>
typedef enum
{
	GDA_PARAMETER_LIST_NO_NODE_ERROR,
	GDA_PARAMETER_LIST_NODE_OUTDATED_ERROR,
	GDA_PARAMETER_LIST_VALUE_PROV_OBJ_TYPE_ERROR,
	GDA_PARAMETER_LIST_VALUE_PROV_DATA_TYPE_ERROR,
	GDA_PARAMETER_LIST_VALUE_PROV_INVISIBLE_ERROR,
	GDA_PARAMETER_LIST_VALUE_PROV_QUERY_TYPE_ERROR,
	GDA_PARAMETER_LIST_DEPENDENCY_NOT_IN_PARAMLIST_ERROR,
	GDA_PARAMETER_LIST_DEPENDENCY_POSITION_ERROR,
	GDA_PARAMETER_LIST_XML_SPEC_ERROR
} GdaParameterListError;
</ENUM>
<ENUM>
<NAME>GdaParameterListParamHint</NAME>
typedef enum {
	GDA_PARAMETER_LIST_PARAM_READ_ONLY = 1 << 0, /* param should not be affected by user modifications */
	GDA_PARAMETER_LIST_PARAM_HIDE      = 1 << 1  /* param should not be shown to the user */
} GdaParameterListParamHint;
</ENUM>
<STRUCT>
<NAME>GdaParameterListNode</NAME>
struct _GdaParameterListNode {
	GdaParameter   *param;         /* Can't be NULL */
	GdaDataModel   *source_model;  /* may be NULL if @param is free-fill */
	gint            source_column; /* unused is @source_model is NULL */
	guint           hint;
};
</STRUCT>
<STRUCT>
<NAME>GdaParameterListGroup</NAME>
struct _GdaParameterListGroup {
	GSList                 *nodes;        /* list of GdaParameterListNode, at least one entry */
	GdaParameterListSource *nodes_source; /* if NULL, then @nodes contains exactly one entry */
};
</STRUCT>
<STRUCT>
<NAME>GdaParameterListSource</NAME>
struct _GdaParameterListSource {
	GdaDataModel   *data_model;   /* Can't be NULL */
	GSList         *nodes;        /* list of #GdaParameterListNode for which source_model == @data_model */

	/* displayed columns in 'data_model' */
        gint            shown_n_cols;
        gint           *shown_cols_index;

        /* columns used as a reference (corresponding to PK values) in 'data_model' */
        gint            ref_n_cols;
        gint           *ref_cols_index;
};
</STRUCT>
<MACRO>
<NAME>GDA_PARAMETER_LIST_NODE</NAME>
#define GDA_PARAMETER_LIST_NODE(x) ((GdaParameterListNode *)x)
</MACRO>
<MACRO>
<NAME>GDA_PARAMETER_LIST_SOURCE</NAME>
#define GDA_PARAMETER_LIST_SOURCE(x) ((GdaParameterListSource *)x)
</MACRO>
<MACRO>
<NAME>GDA_PARAMETER_LIST_GROUP</NAME>
#define GDA_PARAMETER_LIST_GROUP(x) ((GdaParameterListGroup *)x)
</MACRO>
<STRUCT>
<NAME>GdaParameterList</NAME>
struct _GdaParameterList
{
	GdaObject                 object;
	GSList                   *parameters;   /* list of GdaParameter objects */

	GSList                   *nodes_list;   /* list of GdaParameterListNode */
        GSList                   *sources_list; /* list of GdaParameterListSource */
	GSList                   *groups_list;  /* list of GdaParameterListGroup */

	GdaParameterListPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaParameterListClass</NAME>
struct _GdaParameterListClass
{
	GdaObjectClass          parent_class;

	void                  (*param_changed)        (GdaParameterList *paramlist, GdaParameter *param);
	void                  (*param_plugin_changed) (GdaParameterList *paramlist, GdaParameter *param);
	void                  (*param_attr_changed)   (GdaParameterList *paramlist, GdaParameter *param);
	void                  (*public_data_changed)  (GdaParameterList *paramlist);
};
</STRUCT>
<FUNCTION>
<NAME>gda_parameter_list_get_type</NAME>
<RETURNS>GType                   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_new</NAME>
<RETURNS>GdaParameterList       *</RETURNS>
GSList *params
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_new_inline</NAME>
<RETURNS>GdaParameterList       *</RETURNS>
GdaDict *dict, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_new_from_spec_string</NAME>
<RETURNS>GdaParameterList       *</RETURNS>
GdaDict *dict, const gchar *xml_spec, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_new_from_spec_node</NAME>
<RETURNS>GdaParameterList       *</RETURNS>
GdaDict *dict, xmlNodePtr xml_spec, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_get_spec</NAME>
<RETURNS>gchar                  *</RETURNS>
GdaParameterList *paramlist
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_get_length</NAME>
<RETURNS>guint                   </RETURNS>
GdaParameterList *paramlist
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_add_param</NAME>
<RETURNS>void                    </RETURNS>
GdaParameterList *paramlist, GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_add_param_from_string</NAME>
<RETURNS>GdaParameter           *</RETURNS>
GdaParameterList *paramlist, const gchar *name,GType type, const gchar *str
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_add_param_from_value</NAME>
<RETURNS>GdaParameter           *</RETURNS>
GdaParameterList *paramlist, const gchar *name,GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_merge</NAME>
<RETURNS>void                    </RETURNS>
GdaParameterList *paramlist,GdaParameterList *paramlist_to_merge
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_is_coherent</NAME>
<RETURNS>gboolean                </RETURNS>
GdaParameterList *paramlist, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_is_valid</NAME>
<RETURNS>gboolean                </RETURNS>
GdaParameterList *paramlist
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_find_param</NAME>
<RETURNS>GdaParameter           *</RETURNS>
GdaParameterList *paramlist,const gchar *param_name
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_find_node_for_param</NAME>
<RETURNS>GdaParameterListNode   *</RETURNS>
GdaParameterList *paramlist,GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_find_source</NAME>
<RETURNS>GdaParameterListSource *</RETURNS>
GdaParameterList *paramlist,GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_find_source_for_param</NAME>
<RETURNS>GdaParameterListSource *</RETURNS>
GdaParameterList *paramlist,GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_find_group_for_param</NAME>
<RETURNS>GdaParameterListGroup  *</RETURNS>
GdaParameterList *paramlist,GdaParameter *param
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_set_param_default_value</NAME>
<RETURNS>void                    </RETURNS>
GdaParameterList *paramlist,GdaParameter *param, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_set_param_default_alias</NAME>
<RETURNS>void                    </RETURNS>
GdaParameterList *paramlist,GdaParameter *param, GdaParameter *alias
</FUNCTION>
<FUNCTION>
<NAME>gda_parameter_list_get_param_default_value</NAME>
<RETURNS>const GValue           *</RETURNS>
GdaParameterList *paramlist, GdaParameter *param
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_COLUMN_INDEX</NAME>
#define GDA_TYPE_COLUMN_INDEX            (gda_column_index_get_type())
</MACRO>
<MACRO>
<NAME>GDA_COLUMN_INDEX</NAME>
#define GDA_COLUMN_INDEX(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_COLUMN_INDEX, GdaColumnIndex))
</MACRO>
<MACRO>
<NAME>GDA_COLUMN_INDEX_CLASS</NAME>
#define GDA_COLUMN_INDEX_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_COLUMN_INDEX, GdaColumnIndexClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_COLUMN_INDEX</NAME>
#define GDA_IS_COLUMN_INDEX(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_COLUMN_INDEX))
</MACRO>
<MACRO>
<NAME>GDA_IS_COLUMN_INDEX_CLASS</NAME>
#define GDA_IS_COLUMN_INDEX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_COLUMN_INDEX))
</MACRO>
<ENUM>
<NAME>GdaSorting</NAME>
typedef enum {
	GDA_SORTING_ASCENDING,
	GDA_SORTING_DESCENDING
} GdaSorting;
</ENUM>
<STRUCT>
<NAME>GdaColumnIndex</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaColumnIndexClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaColumnIndexPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaColumnIndex</NAME>
struct _GdaColumnIndex {
	GObject object;
	GdaColumnIndexPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaColumnIndexClass</NAME>
struct _GdaColumnIndexClass {
	GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_column_index_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_new</NAME>
<RETURNS>GdaColumnIndex *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_copy</NAME>
<RETURNS>GdaColumnIndex *</RETURNS>
GdaColumnIndex *dmcia
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_equal</NAME>
<RETURNS>gboolean        </RETURNS>
const GdaColumnIndex *lhs, const GdaColumnIndex *rhs
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_get_column_name</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaColumnIndex *dmcia
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_set_column_name</NAME>
<RETURNS>void            </RETURNS>
GdaColumnIndex *dmcia, const gchar *column_name
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_get_defined_size</NAME>
<RETURNS>glong           </RETURNS>
GdaColumnIndex *dmcia
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_set_defined_size</NAME>
<RETURNS>void            </RETURNS>
GdaColumnIndex *dmcia, glong size
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_get_sorting</NAME>
<RETURNS>GdaSorting      </RETURNS>
GdaColumnIndex *dmcia
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_set_sorting</NAME>
<RETURNS>void            </RETURNS>
GdaColumnIndex *dmcia, GdaSorting sorting
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_get_references</NAME>
<RETURNS>const gchar    *</RETURNS>
GdaColumnIndex *dmcia
</FUNCTION>
<FUNCTION>
<NAME>gda_column_index_set_references</NAME>
<RETURNS>void            </RETURNS>
GdaColumnIndex *dmcia, const gchar *ref
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_TABLE</NAME>
#define GDA_TYPE_DICT_TABLE          (gda_dict_table_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DICT_TABLE</NAME>
#define GDA_DICT_TABLE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_dict_table_get_type(), GdaDictTable)
</MACRO>
<MACRO>
<NAME>GDA_DICT_TABLE_CLASS</NAME>
#define GDA_DICT_TABLE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_dict_table_get_type (), GdaDictTableClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DICT_TABLE</NAME>
#define GDA_IS_DICT_TABLE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_dict_table_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_dict_table_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DICT_TABLE_ERROR</NAME>
#define GDA_DICT_TABLE_ERROR gda_dict_table_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDictTableError</NAME>
typedef enum
{
	GDA_DICT_TABLE_XML_LOAD_ERROR,
	GDA_DICT_TABLE_META_DATA_UPDATE,
	GDA_DICT_FIELDS_ERROR
} GdaDictTableError;
</ENUM>
<STRUCT>
<NAME>GdaDictTable</NAME>
struct _GdaDictTable
{
	GdaObject                  object;
	GdaDictTablePrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDictTableClass</NAME>
struct _GdaDictTableClass
{
	GdaObjectClass             parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_dict_table_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_table_new</NAME>
<RETURNS>GObject           *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_table_get_database</NAME>
<RETURNS>GdaDictDatabase   *</RETURNS>
GdaDictTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_table_is_view</NAME>
<RETURNS>gboolean           </RETURNS>
GdaDictTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_table_get_parents</NAME>
<RETURNS>const GSList      *</RETURNS>
GdaDictTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_table_get_constraints</NAME>
<RETURNS>GSList            *</RETURNS>
GdaDictTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_table_get_pk_constraint</NAME>
<RETURNS>GdaDictConstraint *</RETURNS>
GdaDictTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_table_update_dbms_data</NAME>
<RETURNS>gboolean           </RETURNS>
GdaDictTable *table, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_FUNC</NAME>
#define GDA_TYPE_QUERY_FIELD_FUNC          (gda_query_field_func_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_FUNC</NAME>
#define GDA_QUERY_FIELD_FUNC(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_field_func_get_type(), GdaQueryFieldFunc)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_FIELD_FUNC_CLASS</NAME>
#define GDA_QUERY_FIELD_FUNC_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_field_func_get_type (), GdaQueryFieldFuncClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_FIELD_FUNC</NAME>
#define GDA_IS_QUERY_FIELD_FUNC(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_field_func_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_func_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_QUERY_FIELD_FUNC_ERROR</NAME>
#define GDA_QUERY_FIELD_FUNC_ERROR gda_query_field_func_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaQueryFieldFuncError</NAME>
typedef enum
{
	GDA_QUERY_FIELD_FUNC_XML_LOAD_ERROR,
	GDA_QUERY_FIELD_FUNC_RENDER_ERROR
} GdaQueryFieldFuncError;
</ENUM>
<STRUCT>
<NAME>GdaQueryFieldFunc</NAME>
struct _GdaQueryFieldFunc
{
	GdaQueryField               object;
	GdaQueryFieldFuncPrivate   *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryFieldFuncClass</NAME>
struct _GdaQueryFieldFuncClass
{
	GdaQueryFieldClass          parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_field_func_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_func_new</NAME>
<RETURNS>GdaQueryField         *</RETURNS>
GdaQuery *query, const gchar *func_name
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_func_get_ref_func</NAME>
<RETURNS>GdaDictFunction       *</RETURNS>
GdaQueryFieldFunc *func
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_func_get_ref_func_name</NAME>
<RETURNS>const gchar           *</RETURNS>
GdaQueryFieldFunc *func
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_func_set_args</NAME>
<RETURNS>gboolean               </RETURNS>
GdaQueryFieldFunc *func, GSList *args
</FUNCTION>
<FUNCTION>
<NAME>gda_query_field_func_get_args</NAME>
<RETURNS>GSList                *</RETURNS>
GdaQueryFieldFunc *func
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_OBJECT</NAME>
#define GDA_TYPE_QUERY_OBJECT          (gda_query_object_get_type())
</MACRO>
<MACRO>
<NAME>GDA_QUERY_OBJECT</NAME>
#define GDA_QUERY_OBJECT(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_query_object_get_type(), GdaQueryObject)
</MACRO>
<MACRO>
<NAME>GDA_QUERY_OBJECT_CLASS</NAME>
#define GDA_QUERY_OBJECT_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_query_object_get_type (), GdaQueryObjectClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_QUERY_OBJECT</NAME>
#define GDA_IS_QUERY_OBJECT(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_query_object_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaQueryObject</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryObjectClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryObjectPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaQueryObject</NAME>
struct _GdaQueryObject
{
	GdaObject               object;
	GdaQueryObjectPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaQueryObjectClass</NAME>
struct _GdaQueryObjectClass
{
	GdaObjectClass          parent_class;

	/* signals */
	void                  (*numid_changed)(GdaQueryObject *object);

	/* pure virtual functions */
	void                  (*set_int_id)  (GdaQueryObject *object, guint id);
};
</STRUCT>
<FUNCTION>
<NAME>gda_query_object_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_query_object_set_int_id</NAME>
<RETURNS>void         </RETURNS>
GdaQueryObject *qobj, guint id
</FUNCTION>
<FUNCTION>
<NAME>gda_query_object_get_int_id</NAME>
<RETURNS>guint        </RETURNS>
GdaQueryObject *qobj
</FUNCTION>
<STRUCT>
<NAME>GdaGraphviz</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphvizClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaGraphvizPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_GRAPHVIZ</NAME>
#define GDA_TYPE_GRAPHVIZ          (gda_graphviz_get_type())
</MACRO>
<MACRO>
<NAME>GDA_GRAPHVIZ</NAME>
#define GDA_GRAPHVIZ(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_graphviz_get_type(), GdaGraphviz)
</MACRO>
<MACRO>
<NAME>GDA_GRAPHVIZ_CLASS</NAME>
#define GDA_GRAPHVIZ_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_graphviz_get_type (), GdaGraphvizClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_GRAPHVIZ</NAME>
#define GDA_IS_GRAPHVIZ(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_graphviz_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaGraphviz</NAME>
struct _GdaGraphviz
{
	GdaObject                 object;
	GdaGraphvizPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaGraphvizClass</NAME>
struct _GdaGraphvizClass
{
	GdaObjectClass              parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_graphviz_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_graphviz_new</NAME>
<RETURNS>GObject        *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_graphviz_add_to_graph</NAME>
<RETURNS>void            </RETURNS>
GdaGraphviz *graph, GObject *obj
</FUNCTION>
<FUNCTION>
<NAME>gda_graphviz_save_file</NAME>
<RETURNS>gboolean        </RETURNS>
GdaGraphviz *graph, const gchar *filename, GError **error
</FUNCTION>
<STRUCT>
<NAME>GdaServerProviderPrivate</NAME>
struct _GdaServerProviderPrivate {
	GHashTable *data_handlers; /* key = a GdaServerProviderHandlerInfo pointer, value = a GdaDataHandler */
};
</STRUCT>
<MACRO>
<NAME>GDA_TYPE_BLOB_OP</NAME>
#define GDA_TYPE_BLOB_OP            (gda_blob_op_get_type())
</MACRO>
<MACRO>
<NAME>GDA_BLOB_OP</NAME>
#define GDA_BLOB_OP(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_BLOB_OP, GdaBlobOp))
</MACRO>
<MACRO>
<NAME>GDA_BLOB_OP_CLASS</NAME>
#define GDA_BLOB_OP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_BLOB_OP, GdaBlobOpClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_BLOB_OP</NAME>
#define GDA_IS_BLOB_OP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_BLOB_OP))
</MACRO>
<MACRO>
<NAME>GDA_IS_BLOB_OP_CLASS</NAME>
#define GDA_IS_BLOB_OP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_BLOB_OP))
</MACRO>
<STRUCT>
<NAME>GdaBlobOp</NAME>
struct _GdaBlobOp {
	GObject object;
};
</STRUCT>
<STRUCT>
<NAME>GdaBlobOpClass</NAME>
struct _GdaBlobOpClass {
	GObjectClass parent_class;

	/* Virtual methods */
	glong    (* get_length) (GdaBlobOp *op);
	glong    (* read)       (GdaBlobOp *op, GdaBlob *blob, glong offset, glong size);
	glong    (* write)      (GdaBlobOp *op, GdaBlob *blob, glong offset);
	gboolean (* write_all)  (GdaBlobOp *op, GdaBlob *blob);
};
</STRUCT>
<FUNCTION>
<NAME>gda_blob_op_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_op_get_length</NAME>
<RETURNS>glong    </RETURNS>
GdaBlobOp *op
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_op_read</NAME>
<RETURNS>glong    </RETURNS>
GdaBlobOp *op, GdaBlob *blob, glong offset, glong size
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_op_read_all</NAME>
<RETURNS>gboolean </RETURNS>
GdaBlobOp *op, GdaBlob *blob
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_op_write</NAME>
<RETURNS>glong    </RETURNS>
GdaBlobOp *op, GdaBlob *blob, glong offset
</FUNCTION>
<FUNCTION>
<NAME>gda_blob_op_write_all</NAME>
<RETURNS>gboolean </RETURNS>
GdaBlobOp *op, GdaBlob *blob
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_DATABASE</NAME>
#define GDA_TYPE_DICT_DATABASE          (gda_dict_database_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DICT_DATABASE</NAME>
#define GDA_DICT_DATABASE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_dict_database_get_type(), GdaDictDatabase)
</MACRO>
<MACRO>
<NAME>GDA_DICT_DATABASE_CLASS</NAME>
#define GDA_DICT_DATABASE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_dict_database_get_type (), GdaDictDatabaseClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DICT_DATABASE</NAME>
#define GDA_IS_DICT_DATABASE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_dict_database_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_dict_database_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DICT_DATABASE_ERROR</NAME>
#define GDA_DICT_DATABASE_ERROR gda_dict_database_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDictDatabaseError</NAME>
typedef enum
{
	GDA_DICT_DATABASE_XML_SAVE_ERROR,
	GDA_DICT_DATABASE_XML_LOAD_ERROR,
	GDA_DICT_DATABASE_META_DATA_UPDATE,
	GDA_DICT_DATABASE_META_DATA_UPDATE_USER_STOPPED,
	GDA_DICT_DATABASE_TABLES_ERROR,
	GDA_DICT_DATABASE_SEQUENCES_ERROR
} GdaDictDatabaseError;
</ENUM>
<STRUCT>
<NAME>GdaDictDatabase</NAME>
struct _GdaDictDatabase
{
	GdaObject                   object;
	GdaDictDatabasePrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDictDatabaseClass</NAME>
struct _GdaDictDatabaseClass
{
	GdaObjectClass parent_class;

	/* signals */
	void   (*table_added)               (GdaDictDatabase *obj, GdaDictTable *table);
	void   (*table_removed)             (GdaDictDatabase *obj, GdaDictTable *table);
	void   (*table_updated)             (GdaDictDatabase *obj, GdaDictTable *table);

	void   (*field_added)               (GdaDictDatabase *obj, GdaDictField *field);
	void   (*field_removed)             (GdaDictDatabase *obj, GdaDictField *field);
	void   (*field_updated)             (GdaDictDatabase *obj, GdaDictField *field);

	void   (*constraint_added)          (GdaDictDatabase *obj, GdaDictConstraint *cstr);
	void   (*constraint_removed)        (GdaDictDatabase *obj, GdaDictConstraint *cstr);
	void   (*constraint_updated)        (GdaDictDatabase *obj, GdaDictConstraint *cstr);
	
	void   (*data_update_started)       (GdaDictDatabase *obj);
	void   (*update_progress)           (GdaDictDatabase *obj, const gchar * msg, guint now, guint total);
	void   (*data_update_finished)      (GdaDictDatabase *obj);

	gpointer reserved1;
	gpointer reserved2;
};
</STRUCT>
<FUNCTION>
<NAME>gda_dict_database_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_new</NAME>
<RETURNS>GObject           *</RETURNS>
GdaDict *dict
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_dict</NAME>
<RETURNS>GdaDict            *</RETURNS>
GdaDictDatabase *db
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_update_dbms_data</NAME>
<RETURNS>gboolean           </RETURNS>
GdaDictDatabase *db,GType limit_to_type, const gchar *limit_obj_name,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_stop_update_dbms_data</NAME>
<RETURNS>void               </RETURNS>
GdaDictDatabase *db
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_tables</NAME>
<RETURNS>GSList            *</RETURNS>
GdaDictDatabase *db
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_table_by_name</NAME>
<RETURNS>GdaDictTable      *</RETURNS>
GdaDictDatabase *db, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_table_by_xml_id</NAME>
<RETURNS>GdaDictTable      *</RETURNS>
GdaDictDatabase *db, const gchar *xml_id
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_field_by_name</NAME>
<RETURNS>GdaDictField      *</RETURNS>
GdaDictDatabase *db, const gchar *fullname
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_field_by_xml_id</NAME>
<RETURNS>GdaDictField      *</RETURNS>
GdaDictDatabase *db, const gchar *xml_id
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_add_constraint</NAME>
<RETURNS>void               </RETURNS>
GdaDictDatabase *db, GdaDictConstraint *cstr
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_all_constraints</NAME>
<RETURNS>GSList            *</RETURNS>
GdaDictDatabase *db
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_all_fk_constraints</NAME>
<RETURNS>GSList            *</RETURNS>
GdaDictDatabase *db
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_table_constraints</NAME>
<RETURNS>GSList            *</RETURNS>
GdaDictDatabase *db, GdaDictTable *table
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_database_get_tables_fk_constraints</NAME>
<RETURNS>GSList            *</RETURNS>
GdaDictDatabase *db, GdaDictTable *table1,GdaDictTable *table2, gboolean table1_has_fk
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_FIELD</NAME>
#define GDA_TYPE_DICT_FIELD          (gda_dict_field_get_type())
</MACRO>
<MACRO>
<NAME>GDA_DICT_FIELD</NAME>
#define GDA_DICT_FIELD(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_dict_field_get_type(), GdaDictField)
</MACRO>
<MACRO>
<NAME>GDA_DICT_FIELD_CLASS</NAME>
#define GDA_DICT_FIELD_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_dict_field_get_type (), GdaDictFieldClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_DICT_FIELD</NAME>
#define GDA_IS_DICT_FIELD(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_dict_field_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_dict_field_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_DICT_FIELD_ERROR</NAME>
#define GDA_DICT_FIELD_ERROR gda_dict_field_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaDictFieldError</NAME>
typedef enum
{
	GDA_DICT_FIELD_XML_LOAD_ERROR
} GdaDictFieldError;
</ENUM>
<STRUCT>
<NAME>GdaDictField</NAME>
struct _GdaDictField
{
	GdaObject               object;
	GdaDictFieldPrivate    *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaDictFieldClass</NAME>
struct _GdaDictFieldClass
{
	GdaObjectClass          parent_class;
};
</STRUCT>
<ENUM>
<NAME>GdaDictFieldAttribute</NAME>
typedef enum {
	FIELD_AUTO_INCREMENT = 1 << 0
} GdaDictFieldAttribute;
</ENUM>
<FUNCTION>
<NAME>gda_dict_field_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_new</NAME>
<RETURNS>GObject        *</RETURNS>
GdaDict *dict, GdaDictType *type
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_set_length</NAME>
<RETURNS>void            </RETURNS>
GdaDictField *field, gint length
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_get_length</NAME>
<RETURNS>gint            </RETURNS>
GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_set_scale</NAME>
<RETURNS>void            </RETURNS>
GdaDictField *field, gint length
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_get_scale</NAME>
<RETURNS>gint            </RETURNS>
GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_get_constraints</NAME>
<RETURNS>GSList         *</RETURNS>
GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_set_default_value</NAME>
<RETURNS>void            </RETURNS>
GdaDictField *field, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_get_default_value</NAME>
<RETURNS>const GValue   *</RETURNS>
GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_is_null_allowed</NAME>
<RETURNS>gboolean        </RETURNS>
GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_is_pkey_part</NAME>
<RETURNS>gboolean        </RETURNS>
GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_is_pkey_alone</NAME>
<RETURNS>gboolean        </RETURNS>
GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_is_fkey_part</NAME>
<RETURNS>gboolean        </RETURNS>
GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_is_fkey_alone</NAME>
<RETURNS>gboolean        </RETURNS>
GdaDictField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_set_attributes</NAME>
<RETURNS>void            </RETURNS>
GdaDictField *field, GdaDictFieldAttribute attributes
</FUNCTION>
<FUNCTION>
<NAME>gda_dict_field_get_attributes</NAME>
<RETURNS>GdaDictFieldAttribute </RETURNS>
GdaDictField *field
</FUNCTION>
<STRUCT>
<NAME>GdaQueryPrivate</NAME>
struct _GdaQueryPrivate
{
	GdaQueryType         query_type;
	gboolean             global_distinct;
	GSList              *targets;
	GSList              *joins_flat;
	GSList              *joins_pack;
	GSList              *fields;
	GSList              *sub_queries;

	GSList              *param_sources; /* list of GdaDataModel objects, owned here */

	GdaQueryCondition   *cond;
	GdaQuery            *parent_query;

	gchar                 *sql;     /* non NULL when the query is defined from SQL */
	GdaDelimiterStatement *sql_exprs; /* non NULL when the query is defined from SQL 
					     parsed with libgnomedb's simple parser */
	
	GSList              *fields_order_by;

	guint                serial_target;
	guint                serial_field;
	guint                serial_cond;

	gint                 internal_transaction; /* > 0 to revent emission of the "changed" signal, when
					       * several changes must occur before the query has a stable 
					       * structure again */

	GSList              *all_conds;
	gboolean             auto_clean;

	gboolean             has_limit; /* LIMIT for SELECT queries */
	guint                limit;
	guint                offset;
};
</STRUCT>
<FUNCTION>
<NAME>gda_client_event_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CLIENT_EVENT</NAME>
#define GDA_TYPE_CLIENT_EVENT (gda_client_event_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_client_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CLIENT_ERROR</NAME>
#define GDA_TYPE_CLIENT_ERROR (gda_client_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_sorting_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_SORTING</NAME>
#define GDA_TYPE_SORTING (gda_sorting_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_command_options_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_COMMAND_OPTIONS</NAME>
#define GDA_TYPE_COMMAND_OPTIONS (gda_command_options_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_command_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_COMMAND_TYPE</NAME>
#define GDA_TYPE_COMMAND_TYPE (gda_command_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_connection_event_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CONNECTION_EVENT_TYPE</NAME>
#define GDA_TYPE_CONNECTION_EVENT_TYPE (gda_connection_event_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_connection_event_code_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CONNECTION_EVENT_CODE</NAME>
#define GDA_TYPE_CONNECTION_EVENT_CODE (gda_connection_event_code_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_connection_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CONNECTION_ERROR</NAME>
#define GDA_TYPE_CONNECTION_ERROR (gda_connection_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_connection_options_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CONNECTION_OPTIONS</NAME>
#define GDA_TYPE_CONNECTION_OPTIONS (gda_connection_options_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_connection_feature_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CONNECTION_FEATURE</NAME>
#define GDA_TYPE_CONNECTION_FEATURE (gda_connection_feature_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_connection_schema_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_CONNECTION_SCHEMA</NAME>
#define GDA_TYPE_CONNECTION_SCHEMA (gda_connection_schema_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_data_model_access_flags_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_ACCESS_FLAGS</NAME>
#define GDA_TYPE_DATA_MODEL_ACCESS_FLAGS (gda_data_model_access_flags_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_data_model_hint_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_HINT</NAME>
#define GDA_TYPE_DATA_MODEL_HINT (gda_data_model_hint_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_data_model_io_format_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_IO_FORMAT</NAME>
#define GDA_TYPE_DATA_MODEL_IO_FORMAT (gda_data_model_io_format_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_data_model_iter_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_ITER_ERROR</NAME>
#define GDA_TYPE_DATA_MODEL_ITER_ERROR (gda_data_model_iter_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_data_model_query_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_QUERY_ERROR</NAME>
#define GDA_TYPE_DATA_MODEL_QUERY_ERROR (gda_data_model_query_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_data_model_query_options_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_MODEL_QUERY_OPTIONS</NAME>
#define GDA_TYPE_DATA_MODEL_QUERY_OPTIONS (gda_data_model_query_options_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_data_proxy_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DATA_PROXY_ERROR</NAME>
#define GDA_TYPE_DATA_PROXY_ERROR (gda_data_proxy_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_aggregate_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_AGGREGATE_ERROR</NAME>
#define GDA_TYPE_DICT_AGGREGATE_ERROR (gda_dict_aggregate_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_constraint_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_CONSTRAINT_ERROR</NAME>
#define GDA_TYPE_DICT_CONSTRAINT_ERROR (gda_dict_constraint_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_constraint_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_CONSTRAINT_TYPE</NAME>
#define GDA_TYPE_DICT_CONSTRAINT_TYPE (gda_dict_constraint_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_constraint_fk_action_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_CONSTRAINT_FK_ACTION</NAME>
#define GDA_TYPE_DICT_CONSTRAINT_FK_ACTION (gda_dict_constraint_fk_action_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_database_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_DATABASE_ERROR</NAME>
#define GDA_TYPE_DICT_DATABASE_ERROR (gda_dict_database_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_field_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_FIELD_ERROR</NAME>
#define GDA_TYPE_DICT_FIELD_ERROR (gda_dict_field_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_field_attribute_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_FIELD_ATTRIBUTE</NAME>
#define GDA_TYPE_DICT_FIELD_ATTRIBUTE (gda_dict_field_attribute_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_function_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_FUNCTION_ERROR</NAME>
#define GDA_TYPE_DICT_FUNCTION_ERROR (gda_dict_function_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_ERROR</NAME>
#define GDA_TYPE_DICT_ERROR (gda_dict_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_table_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_TABLE_ERROR</NAME>
#define GDA_TYPE_DICT_TABLE_ERROR (gda_dict_table_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_dict_type_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_DICT_TYPE_ERROR</NAME>
#define GDA_TYPE_DICT_TYPE_ERROR (gda_dict_type_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_transaction_isolation_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_TRANSACTION_ISOLATION</NAME>
#define GDA_TYPE_TRANSACTION_ISOLATION (gda_transaction_isolation_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_value_attribute_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_VALUE_ATTRIBUTE</NAME>
#define GDA_TYPE_VALUE_ATTRIBUTE (gda_value_attribute_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_graph_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_GRAPH_TYPE</NAME>
#define GDA_TYPE_GRAPH_TYPE (gda_graph_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_state_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_STATE</NAME>
#define GDA_TYPE_QUERY_FIELD_STATE (gda_query_field_state_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_object_ref_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_OBJECT_REF_TYPE</NAME>
#define GDA_TYPE_OBJECT_REF_TYPE (gda_object_ref_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_object_ref_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_OBJECT_REF_ERROR</NAME>
#define GDA_TYPE_OBJECT_REF_ERROR (gda_object_ref_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_parameter_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_PARAMETER_ERROR</NAME>
#define GDA_TYPE_PARAMETER_ERROR (gda_parameter_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_parameter_list_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_PARAMETER_LIST_ERROR</NAME>
#define GDA_TYPE_PARAMETER_LIST_ERROR (gda_parameter_list_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_parameter_list_param_hint_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_PARAMETER_LIST_PARAM_HINT</NAME>
#define GDA_TYPE_PARAMETER_LIST_PARAM_HINT (gda_parameter_list_param_hint_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_condition_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_CONDITION_TYPE</NAME>
#define GDA_TYPE_QUERY_CONDITION_TYPE (gda_query_condition_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_condition_operator_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_CONDITION_OPERATOR</NAME>
#define GDA_TYPE_QUERY_CONDITION_OPERATOR (gda_query_condition_operator_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_condition_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_CONDITION_ERROR</NAME>
#define GDA_TYPE_QUERY_CONDITION_ERROR (gda_query_condition_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_agg_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_AGG_ERROR</NAME>
#define GDA_TYPE_QUERY_FIELD_AGG_ERROR (gda_query_field_agg_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_all_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_ALL_ERROR</NAME>
#define GDA_TYPE_QUERY_FIELD_ALL_ERROR (gda_query_field_all_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_field_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_FIELD_ERROR</NAME>
#define GDA_TYPE_QUERY_FIELD_FIELD_ERROR (gda_query_field_field_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_func_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_FUNC_ERROR</NAME>
#define GDA_TYPE_QUERY_FIELD_FUNC_ERROR (gda_query_field_func_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_ERROR</NAME>
#define GDA_TYPE_QUERY_FIELD_ERROR (gda_query_field_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_field_value_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_FIELD_VALUE_ERROR</NAME>
#define GDA_TYPE_QUERY_FIELD_VALUE_ERROR (gda_query_field_value_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_TYPE</NAME>
#define GDA_TYPE_QUERY_TYPE (gda_query_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_ERROR</NAME>
#define GDA_TYPE_QUERY_ERROR (gda_query_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_join_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_JOIN_TYPE</NAME>
#define GDA_TYPE_QUERY_JOIN_TYPE (gda_query_join_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_join_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_JOIN_ERROR</NAME>
#define GDA_TYPE_QUERY_JOIN_ERROR (gda_query_join_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_query_target_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_QUERY_TARGET_ERROR</NAME>
#define GDA_TYPE_QUERY_TARGET_ERROR (gda_query_target_error_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_renderer_options_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_RENDERER_OPTIONS</NAME>
#define GDA_TYPE_RENDERER_OPTIONS (gda_renderer_options_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_server_operation_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_SERVER_OPERATION_TYPE</NAME>
#define GDA_TYPE_SERVER_OPERATION_TYPE (gda_server_operation_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_server_operation_node_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_SERVER_OPERATION_NODE_TYPE</NAME>
#define GDA_TYPE_SERVER_OPERATION_NODE_TYPE (gda_server_operation_node_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_server_operation_node_status_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_SERVER_OPERATION_NODE_STATUS</NAME>
#define GDA_TYPE_SERVER_OPERATION_NODE_STATUS (gda_server_operation_node_status_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_transaction_status_event_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_TRANSACTION_STATUS_EVENT_TYPE</NAME>
#define GDA_TYPE_TRANSACTION_STATUS_EVENT_TYPE (gda_transaction_status_event_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_transaction_status_state_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_TRANSACTION_STATUS_STATE</NAME>
#define GDA_TYPE_TRANSACTION_STATUS_STATE (gda_transaction_status_state_get_type())
</MACRO>
<FUNCTION>
<NAME>gda_general_error_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_GENERAL_ERROR</NAME>
#define GDA_TYPE_GENERAL_ERROR (gda_general_error_get_type())
</MACRO>
<ENUM>
<NAME>GbrInitError</NAME>
typedef enum {
	/** Cannot allocate memory. */
	_GDA_GBR_INIT_ERROR_NOMEM,
	/** Unable to open /proc/self/maps; see errno for details. */
	_GDA_GBR_INIT_ERROR_OPEN_MAPS,
	/** Unable to read from /proc/self/maps; see errno for details. */
	_GDA_GBR_INIT_ERROR_READ_MAPS,
	/** The file format of /proc/self/maps is invalid; kernel bug? */
	_GDA_GBR_INIT_ERROR_INVALID_MAPS,
	/** BinReloc is disabled (the ENABLE_BINRELOC macro is not defined). */
	_GDA_GBR_INIT_ERROR_DISABLED
} GbrInitError;
</ENUM>
<ENUM>
<NAME>GdaPrefixDir</NAME>
typedef enum {
	GDA_NO_DIR,
	GDA_BIN_DIR,
	GDA_SBIN_DIR,
	GDA_DATA_DIR,
	GDA_LOCALE_DIR,
	GDA_LIB_DIR,
	GDA_LIBEXEC_DIR,
	GDA_ETC_DIR
} GdaPrefixDir;
</ENUM>
<FUNCTION>
<NAME>gda_gbr_init</NAME>
<RETURNS>void     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_gbr_get_file_path</NAME>
<RETURNS>gchar   *</RETURNS>
GdaPrefixDir where, ...
</FUNCTION>
<FUNCTION>
<NAME>gda_graphs_get_register</NAME>
<RETURNS>GdaDictRegisterStruct *</RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>gda_graphs_get_serial</NAME>
<RETURNS>guint                  </RETURNS>
GdaDictRegisterStruct *reg
</FUNCTION>
<FUNCTION>
<NAME>gda_graphs_declare_serial</NAME>
<RETURNS>void                   </RETURNS>
GdaDictRegisterStruct *reg, guint id
</FUNCTION>
<FUNCTION>
<NAME>gda_graphs_get_with_type</NAME>
<RETURNS>GSList                *</RETURNS>
GdaDict *dict, GdaGraphType type_of_graphs
</FUNCTION>
<FUNCTION>
<NAME>gda_graphs_get_graph_for_object</NAME>
<RETURNS>GdaGraph              *</RETURNS>
GdaDict *dict, GObject *obj
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_GRAPH_ITEM</NAME>
#define GDA_TYPE_GRAPH_ITEM          (gda_graph_item_get_type())
</MACRO>
<MACRO>
<NAME>GDA_GRAPH_ITEM</NAME>
#define GDA_GRAPH_ITEM(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_graph_item_get_type(), GdaGraphItem)
</MACRO>
<MACRO>
<NAME>GDA_GRAPH_ITEM_CLASS</NAME>
#define GDA_GRAPH_ITEM_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_graph_item_get_type (), GdaGraphItemClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_GRAPH_ITEM</NAME>
#define GDA_IS_GRAPH_ITEM(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_graph_item_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_graph_item_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_GRAPH_ITEM_ERROR</NAME>
#define GDA_GRAPH_ITEM_ERROR gda_graph_item_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaGraphItemError</NAME>
typedef enum
{
	GDA_GRAPH_ITEM_XML_LOAD_ERROR
} GdaGraphItemError;
</ENUM>
<STRUCT>
<NAME>GdaGraphItem</NAME>
struct _GdaGraphItem
{
	GdaObject               object;
	GdaGraphItemPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaGraphItemClass</NAME>
struct _GdaGraphItemClass
{
	GdaObjectClass   parent_class;
	
	/* signals */
	void        (*moved) (GdaGraphItem *item);
};
</STRUCT>
<FUNCTION>
<NAME>gda_graph_item_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_item_new</NAME>
<RETURNS>GObject         *</RETURNS>
GdaDict *dict, GdaObject *ref_obj
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_item_get_ref_object</NAME>
<RETURNS>GdaObject       *</RETURNS>
GdaGraphItem *item
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_item_set_position</NAME>
<RETURNS>void             </RETURNS>
GdaGraphItem *item, gdouble x, gdouble y
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_item_get_position</NAME>
<RETURNS>void             </RETURNS>
GdaGraphItem *item, gdouble *x, gdouble *y
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_GRAPH_QUERY</NAME>
#define GDA_TYPE_GRAPH_QUERY          (gda_graph_query_get_type())
</MACRO>
<MACRO>
<NAME>GDA_GRAPH_QUERY</NAME>
#define GDA_GRAPH_QUERY(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_graph_query_get_type(), GdaGraphQuery)
</MACRO>
<MACRO>
<NAME>GDA_GRAPH_QUERY_CLASS</NAME>
#define GDA_GRAPH_QUERY_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_graph_query_get_type (), GdaGraphQueryClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_GRAPH_QUERY</NAME>
#define GDA_IS_GRAPH_QUERY(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_graph_query_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaGraphQuery</NAME>
struct _GdaGraphQuery
{
	GdaGraph               object;
	GdaGraphQueryPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaGraphQueryClass</NAME>
struct _GdaGraphQueryClass
{
	GdaGraphClass   parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_graph_query_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_query_new</NAME>
<RETURNS>GObject         *</RETURNS>
GdaQuery *query
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_query_sync_targets</NAME>
<RETURNS>void             </RETURNS>
GdaGraphQuery *graph
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_GRAPH</NAME>
#define GDA_TYPE_GRAPH          (gda_graph_get_type())
</MACRO>
<MACRO>
<NAME>GDA_GRAPH</NAME>
#define GDA_GRAPH(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_graph_get_type(), GdaGraph)
</MACRO>
<MACRO>
<NAME>GDA_GRAPH_CLASS</NAME>
#define GDA_GRAPH_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_graph_get_type (), GdaGraphClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_GRAPH</NAME>
#define GDA_IS_GRAPH(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_graph_get_type ())
</MACRO>
<FUNCTION>
<NAME>gda_graph_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_GRAPH_ERROR</NAME>
#define GDA_GRAPH_ERROR gda_graph_error_quark ()
</MACRO>
<ENUM>
<NAME>GdaGraphError</NAME>
typedef enum
{
	GDA_GRAPH_XML_LOAD_ERROR
} GdaGraphError;
</ENUM>
<STRUCT>
<NAME>GdaGraph</NAME>
struct _GdaGraph
{
	GdaObject         object;
	GdaGraphPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaGraphClass</NAME>
struct _GdaGraphClass
{
	GdaObjectClass   parent_class;
	
	/* signals */
	void        (*item_added)   (GdaGraph *graph, GdaGraphItem *item);
	void        (*item_dropped) (GdaGraph *graph, GdaGraphItem *item);
	void        (*item_moved)   (GdaGraph *graph, GdaGraphItem *item);
};
</STRUCT>
<FUNCTION>
<NAME>gda_graph_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_new</NAME>
<RETURNS>GObject         *</RETURNS>
GdaDict *dict, GdaGraphType type
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_get_graph_type</NAME>
<RETURNS>GdaGraphType     </RETURNS>
GdaGraph *graph
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_add_item</NAME>
<RETURNS>void             </RETURNS>
GdaGraph *graph, GdaGraphItem *item
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_del_item</NAME>
<RETURNS>void             </RETURNS>
GdaGraph *graph, GdaGraphItem *item
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_get_item_from_obj</NAME>
<RETURNS>GdaGraphItem    *</RETURNS>
GdaGraph *graph, GdaObject *ref_obj, gboolean create_if_needed
</FUNCTION>
<FUNCTION>
<NAME>gda_graph_get_items</NAME>
<RETURNS>GSList          *</RETURNS>
GdaGraph *graph
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_HANDLER_NUMERICAL</NAME>
#define GDA_TYPE_HANDLER_NUMERICAL          (gda_handler_numerical_get_type())
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_NUMERICAL</NAME>
#define GDA_HANDLER_NUMERICAL(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_handler_numerical_get_type(), GdaHandlerNumerical)
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_NUMERICAL_CLASS</NAME>
#define GDA_HANDLER_NUMERICAL_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_handler_numerical_get_type (), GdaHandlerNumericalClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_HANDLER_NUMERICAL</NAME>
#define GDA_IS_HANDLER_NUMERICAL(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_handler_numerical_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaHandlerNumerical</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerNumericalClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerNumericalPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerNumerical</NAME>
struct _GdaHandlerNumerical
{
	GdaObject                object;

	GdaHandlerNumericalPriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaHandlerNumericalClass</NAME>
struct _GdaHandlerNumericalClass
{
	GdaObjectClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_handler_numerical_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_numerical_new</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_HANDLER_BIN</NAME>
#define GDA_TYPE_HANDLER_BIN          (gda_handler_bin_get_type())
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_BIN</NAME>
#define GDA_HANDLER_BIN(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_handler_bin_get_type(), GdaHandlerBin)
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_BIN_CLASS</NAME>
#define GDA_HANDLER_BIN_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_handler_bin_get_type (), GdaHandlerBinClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_HANDLER_BIN</NAME>
#define GDA_IS_HANDLER_BIN(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_handler_bin_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaHandlerBin</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerBinClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerBinPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerBin</NAME>
struct _GdaHandlerBin
{
	GdaObject           object;

	GdaHandlerBinPriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaHandlerBinClass</NAME>
struct _GdaHandlerBinClass
{
	GdaObjectClass      parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_handler_bin_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_bin_new</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_HANDLER_BOOLEAN</NAME>
#define GDA_TYPE_HANDLER_BOOLEAN          (gda_handler_boolean_get_type())
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_BOOLEAN</NAME>
#define GDA_HANDLER_BOOLEAN(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_handler_boolean_get_type(), GdaHandlerBoolean)
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_BOOLEAN_CLASS</NAME>
#define GDA_HANDLER_BOOLEAN_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_handler_boolean_get_type (), GdaHandlerBooleanClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_HANDLER_BOOLEAN</NAME>
#define GDA_IS_HANDLER_BOOLEAN(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_handler_boolean_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaHandlerBoolean</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerBooleanClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerBooleanPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerBoolean</NAME>
struct _GdaHandlerBoolean
{
	GdaObject                object;

	GdaHandlerBooleanPriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaHandlerBooleanClass</NAME>
struct _GdaHandlerBooleanClass
{
	GdaObjectClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_handler_boolean_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_boolean_new</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_HANDLER_TIME</NAME>
#define GDA_TYPE_HANDLER_TIME          (gda_handler_time_get_type())
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_TIME</NAME>
#define GDA_HANDLER_TIME(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_handler_time_get_type(), GdaHandlerTime)
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_TIME_CLASS</NAME>
#define GDA_HANDLER_TIME_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_handler_time_get_type (), GdaHandlerTimeClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_HANDLER_TIME</NAME>
#define GDA_IS_HANDLER_TIME(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_handler_time_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaHandlerTime</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerTimeClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerTimePriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerTime</NAME>
struct _GdaHandlerTime
{
	GdaObject            object;

	GdaHandlerTimePriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaHandlerTimeClass</NAME>
struct _GdaHandlerTimeClass
{
	GdaObjectClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_handler_time_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_time_new</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_time_new_no_locale</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_time_set_sql_spec</NAME>
<RETURNS>void            </RETURNS>
GdaHandlerTime *dh, GDateDMY first, GDateDMY sec,GDateDMY third, gchar separator, gboolean twodigits_years
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_time_get_no_locale_str_from_value</NAME>
<RETURNS>gchar          *</RETURNS>
GdaHandlerTime *dh, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_time_get_format</NAME>
<RETURNS>gchar          *</RETURNS>
GdaHandlerTime *dh, GType type
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_HANDLER_TYPE</NAME>
#define GDA_TYPE_HANDLER_TYPE          (gda_handler_type_get_type())
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_TYPE</NAME>
#define GDA_HANDLER_TYPE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_handler_type_get_type(), GdaHandlerType)
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_TYPE_CLASS</NAME>
#define GDA_HANDLER_TYPE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_handler_type_get_type (), GdaHandlerTypeClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_HANDLER_TYPE</NAME>
#define GDA_IS_HANDLER_TYPE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_handler_type_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaHandlerType</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerTypeClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerTypePriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerType</NAME>
struct _GdaHandlerType
{
	GdaObject           object;

	GdaHandlerTypePriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaHandlerTypeClass</NAME>
struct _GdaHandlerTypeClass
{
	GdaObjectClass      parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_handler_type_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_type_new</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_HANDLER_STRING</NAME>
#define GDA_TYPE_HANDLER_STRING          (gda_handler_string_get_type())
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_STRING</NAME>
#define GDA_HANDLER_STRING(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_handler_string_get_type(), GdaHandlerString)
</MACRO>
<MACRO>
<NAME>GDA_HANDLER_STRING_CLASS</NAME>
#define GDA_HANDLER_STRING_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_handler_string_get_type (), GdaHandlerStringClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_HANDLER_STRING</NAME>
#define GDA_IS_HANDLER_STRING(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_handler_string_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaHandlerString</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerStringClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerStringPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaHandlerString</NAME>
struct _GdaHandlerString
{
	GdaObject                object;

	GdaHandlerStringPriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaHandlerStringClass</NAME>
struct _GdaHandlerStringClass
{
	GdaObjectClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_handler_string_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_string_new</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_handler_string_new_with_provider</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
GdaServerProvider *prov, GdaConnection *cnc
</FUNCTION>
<MACRO>
<NAME>YY_NO_UNISTD_H</NAME>
#define YY_NO_UNISTD_H
</MACRO>
<STRUCT>
<NAME>GdaDelimiterStatement</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDelimiterExpr</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaDelimiterParamSpec</NAME>
</STRUCT>
<ENUM>
<NAME>GdaDelimiterStatementType</NAME>
typedef enum
{
	GDA_DELIMITER_SQL_SELECT,
	GDA_DELIMITER_SQL_INSERT,
	GDA_DELIMITER_SQL_DELETE,
	GDA_DELIMITER_SQL_UPDATE,
	GDA_DELIMITER_SQL_BEGIN,
	GDA_DELIMITER_SQL_COMMIT,
	GDA_DELIMITER_MULTIPLE,
	GDA_DELIMITER_UNKNOWN
}
GdaDelimiterStatementType;
</ENUM>
<STRUCT>
<NAME>GdaDelimiterStatement</NAME>
struct _GdaDelimiterStatement
{
	GdaDelimiterStatementType  type;
	GList                     *expr_list;   /* list of GdaDelimiterExpr structures */
	GList                     *params_specs;/* list of GList of GdaDelimiterParamSpec structures */
};
</STRUCT>
<STRUCT>
<NAME>GdaDelimiterExpr</NAME>
struct _GdaDelimiterExpr
{
	GList         *pspec_list; /* list of GdaDelimiterParamSpec structures */
	gchar         *sql_text;
};
</STRUCT>
<MACRO>
<NAME>GDA_DELIMITER_SQL_EXPR</NAME>
#define GDA_DELIMITER_SQL_EXPR(x) ((GdaDelimiterExpr*)(x))
</MACRO>
<ENUM>
<NAME>GdaDelimiterParamSpecType</NAME>
typedef enum
{
	GDA_DELIMITER_PARAM_NAME,
	GDA_DELIMITER_PARAM_DESCR,
	GDA_DELIMITER_PARAM_TYPE,
	GDA_DELIMITER_PARAM_ISPARAM,
	GDA_DELIMITER_PARAM_NULLOK,
	GDA_DELIMITER_PARAM_DEFAULT
} GdaDelimiterParamSpecType;
</ENUM>
<STRUCT>
<NAME>GdaDelimiterParamSpec</NAME>
struct _GdaDelimiterParamSpec
{
	GdaDelimiterParamSpecType  type;
	char                      *content;
};
</STRUCT>
<MACRO>
<NAME>GDA_DELIMITER_PARAM_SPEC</NAME>
#define GDA_DELIMITER_PARAM_SPEC(x) ((GdaDelimiterParamSpec *)(x))
</MACRO>
<FUNCTION>
<NAME>gda_delimiter_display</NAME>
<RETURNS>void                   </RETURNS>
GdaDelimiterStatement *statement
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_to_string</NAME>
<RETURNS>gchar                 *</RETURNS>
GdaDelimiterStatement *statement
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_destroy</NAME>
<RETURNS>int                    </RETURNS>
GdaDelimiterStatement *statement
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_parse</NAME>
<RETURNS>GList                 *</RETURNS>
const char *sql_text
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_parse_with_error</NAME>
<RETURNS>GList                 *</RETURNS>
const char *sql_text, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_split_sql</NAME>
<RETURNS>gchar                **</RETURNS>
const char *sql_text
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_free_list</NAME>
<RETURNS>void                   </RETURNS>
GList *statements
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_concat_list</NAME>
<RETURNS>GdaDelimiterStatement *</RETURNS>
GList *statements
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_parse_copy_statement</NAME>
<RETURNS>GdaDelimiterStatement *</RETURNS>
GdaDelimiterStatement *statement, GHashTable *repl
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_statement_build</NAME>
<RETURNS>GdaDelimiterStatement   *</RETURNS>
GdaDelimiterStatementType type, GList *expr_list
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_expr_build</NAME>
<RETURNS>GdaDelimiterExpr        *</RETURNS>
gchar *str, GList *pspec_list
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_param_spec_build_simple</NAME>
<RETURNS>GList                   *</RETURNS>
gchar *content
</FUNCTION>
<FUNCTION>
<NAME>gda_delimiter_param_spec_build</NAME>
<RETURNS>GdaDelimiterParamSpec   *</RETURNS>
GdaDelimiterParamSpecType type, char *content
</FUNCTION>
<MACRO>
<NAME>L_WORD</NAME>
#define L_WORD 258
</MACRO>
<MACRO>
<NAME>L_CHAR</NAME>
#define L_CHAR 259
</MACRO>
<MACRO>
<NAME>L_SPC</NAME>
#define L_SPC 260
</MACRO>
<MACRO>
<NAME>L_STRING</NAME>
#define L_STRING 261
</MACRO>
<MACRO>
<NAME>L_TEXTUAL</NAME>
#define L_TEXTUAL 262
</MACRO>
<MACRO>
<NAME>L_LSBRACKET</NAME>
#define L_LSBRACKET 263
</MACRO>
<MACRO>
<NAME>L_RSBRACKET</NAME>
#define L_RSBRACKET 264
</MACRO>
<MACRO>
<NAME>L_PNAME</NAME>
#define L_PNAME 265
</MACRO>
<MACRO>
<NAME>L_PTYPE</NAME>
#define L_PTYPE 266
</MACRO>
<MACRO>
<NAME>L_PISPARAM</NAME>
#define L_PISPARAM 267
</MACRO>
<MACRO>
<NAME>L_PDESCR</NAME>
#define L_PDESCR 268
</MACRO>
<MACRO>
<NAME>L_PNULLOK</NAME>
#define L_PNULLOK 269
</MACRO>
<MACRO>
<NAME>L_UNSPECVAL</NAME>
#define L_UNSPECVAL 270
</MACRO>
<MACRO>
<NAME>L_SIMPLE_PARAM</NAME>
#define L_SIMPLE_PARAM 271
</MACRO>
<MACRO>
<NAME>L_SC</NAME>
#define L_SC 272
</MACRO>
<MACRO>
<NAME>yystype</NAME>
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
</MACRO>
<MACRO>
<NAME>YYSTYPE_IS_DECLARED</NAME>
# define YYSTYPE_IS_DECLARED 1
</MACRO>
<MACRO>
<NAME>YYSTYPE_IS_TRIVIAL</NAME>
# define YYSTYPE_IS_TRIVIAL 1
</MACRO>
<VARIABLE>
<NAME>gda_delimiterlval</NAME>
extern YYSTYPE gda_delimiterlval;
</VARIABLE>
<MACRO>
<NAME>GDA_SQLITE_PROVIDER_ID</NAME>
#define GDA_SQLITE_PROVIDER_ID    "GDA SQLite provider"
</MACRO>
<MACRO>
<NAME>OBJECT_DATA_SQLITE_HANDLE</NAME>
#define OBJECT_DATA_SQLITE_HANDLE "GDA_Sqlite_SqliteHandle"
</MACRO>
<STRUCT>
<NAME>SQLITEresult</NAME>
typedef struct {
	sqlite3_stmt *stmt;
	gchar        *sql; /* SQL corresponding to @stmt */

	gint          ncols;
	gint          nrows;
	GType        *types; /* array of ncols types */
	int          *cols_size; /* array of ncols types */
} SQLITEresult;
</STRUCT>
<STRUCT>
<NAME>SQLITEcnc</NAME>
typedef struct {
	sqlite3      *connection;
	gchar        *file;
	GHashTable   *types; /* key = type name, value = GType */
	GdaDataModel *functions_model;
	GdaDataModel *aggregates_model;
} SQLITEcnc;
</STRUCT>
<FUNCTION>
<NAME>gda_sqlite_update_types_hash</NAME>
<RETURNS>void </RETURNS>
SQLITEcnc *scnc
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_result_take_sql</NAME>
<RETURNS>void </RETURNS>
SQLITEresult *sres, gchar *sql
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_free_result</NAME>
<RETURNS>void </RETURNS>
SQLITEresult *sres
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_SQLITE_RECORDSET</NAME>
#define GDA_TYPE_SQLITE_RECORDSET            (gda_sqlite_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_SQLITE_RECORDSET</NAME>
#define GDA_SQLITE_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_SQLITE_RECORDSET, GdaSqliteRecordset))
</MACRO>
<MACRO>
<NAME>GDA_SQLITE_RECORDSET_CLASS</NAME>
#define GDA_SQLITE_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_SQLITE_RECORDSET, GdaSqliteRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_SQLITE_RECORDSET</NAME>
#define GDA_IS_SQLITE_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_SQLITE_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_SQLITE_RECORDSET_CLASS</NAME>
#define GDA_IS_SQLITE_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_SQLITE_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaSqliteRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSqliteRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSqliteRecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSqliteRecordset</NAME>
struct _GdaSqliteRecordset {
	GdaDataModelHash           model;
	GdaSqliteRecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaSqliteRecordsetClass</NAME>
struct _GdaSqliteRecordsetClass {
	GdaDataModelHashClass      parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_sqlite_recordset_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_recordset_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaConnection *cnc, SQLITEresult *sres
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_recordset_new_with_types</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaConnection *cnc, SQLITEresult *sres, gint nbcols, ...
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_SQLITE_PROVIDER</NAME>
#define GDA_TYPE_SQLITE_PROVIDER            (gda_sqlite_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_SQLITE_PROVIDER</NAME>
#define GDA_SQLITE_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_SQLITE_PROVIDER, GdaSqliteProvider))
</MACRO>
<MACRO>
<NAME>GDA_SQLITE_PROVIDER_CLASS</NAME>
#define GDA_SQLITE_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_SQLITE_PROVIDER, GdaSqliteProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_SQLITE_PROVIDER</NAME>
#define GDA_IS_SQLITE_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_SQLITE_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_SQLITE_PROVIDER_CLASS</NAME>
#define GDA_IS_SQLITE_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_SQLITE_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GdaSqliteProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSqliteProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSqliteProvider</NAME>
struct _GdaSqliteProvider {
	GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaSqliteProviderClass</NAME>
struct _GdaSqliteProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_sqlite_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_render_CREATE_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_render_DROP_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_render_RENAME_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_render_ADD_COLUMN</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_render_CREATE_INDEX</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_render_DROP_INDEX</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_HANDLER_BIN</NAME>
#define GDA_TYPE_HANDLER_BIN          (gda_sqlite_handler_bin_get_type())
</MACRO>
<MACRO>
<NAME>GDA_SQLITE_HANDLER_BIN</NAME>
#define GDA_SQLITE_HANDLER_BIN(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_sqlite_handler_bin_get_type(), GdaSqliteHandlerBin)
</MACRO>
<MACRO>
<NAME>GDA_SQLITE_HANDLER_BIN_CLASS</NAME>
#define GDA_SQLITE_HANDLER_BIN_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_sqlite_handler_bin_get_type (), GdaSqliteHandlerBinClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_HANDLER_BIN</NAME>
#define GDA_IS_HANDLER_BIN(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_sqlite_handler_bin_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaSqliteHandlerBin</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSqliteHandlerBinClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSqliteHandlerBinPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSqliteHandlerBin</NAME>
struct _GdaSqliteHandlerBin
{
	GdaObject           object;

	GdaSqliteHandlerBinPriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaSqliteHandlerBinClass</NAME>
struct _GdaSqliteHandlerBinClass
{
	GdaObjectClass      parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_sqlite_handler_bin_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_sqlite_handler_bin_new</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SQLITE_EXTERN</NAME>
# define SQLITE_EXTERN extern
</MACRO>
<MACRO>
<NAME>SQLITE_VERSION</NAME>
#define SQLITE_VERSION         "3.5.1"
</MACRO>
<MACRO>
<NAME>SQLITE_VERSION_NUMBER</NAME>
#define SQLITE_VERSION_NUMBER 3005001
</MACRO>
<FUNCTION>
<NAME>sqlite3_libversion</NAME>
<RETURNS>const char *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_libversion_number</NAME>
<RETURNS>int </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_threadsafe</NAME>
<RETURNS>int </RETURNS>
void
</FUNCTION>
<TYPEDEF>
<NAME>sqlite3</NAME>
typedef struct sqlite3 sqlite3;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite_int64</NAME>
  typedef SQLITE_INT64_TYPE sqlite_int64;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite_uint64</NAME>
  typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite_int64</NAME>
  typedef __int64 sqlite_int64;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite_uint64</NAME>
  typedef unsigned __int64 sqlite_uint64;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite_int64</NAME>
  typedef long long int sqlite_int64;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite_uint64</NAME>
  typedef unsigned long long int sqlite_uint64;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite3_int64</NAME>
typedef sqlite_int64 sqlite3_int64;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite3_uint64</NAME>
typedef sqlite_uint64 sqlite3_uint64;
</TYPEDEF>
<MACRO>
<NAME>double</NAME>
# define double sqlite3_int64
</MACRO>
<FUNCTION>
<NAME>sqlite3_close</NAME>
<RETURNS>int </RETURNS>
sqlite3 *
</FUNCTION>
<USER_FUNCTION>
<NAME>sqlite3_callback</NAME>
<RETURNS>int </RETURNS>
void*,int,char**, char**
</USER_FUNCTION>
<FUNCTION>
<NAME>sqlite3_exec</NAME>
<RETURNS>int </RETURNS>
sqlite3*,const char *sql,int (*callback)(void*,int,char**,char**),void *,char **errmsg
</FUNCTION>
<MACRO>
<NAME>SQLITE_OK</NAME>
#define SQLITE_OK           0   /* Successful result */
</MACRO>
<MACRO>
<NAME>SQLITE_ERROR</NAME>
#define SQLITE_ERROR        1   /* SQL error or missing database */
</MACRO>
<MACRO>
<NAME>SQLITE_INTERNAL</NAME>
#define SQLITE_INTERNAL     2   /* NOT USED. Internal logic error in SQLite */
</MACRO>
<MACRO>
<NAME>SQLITE_PERM</NAME>
#define SQLITE_PERM         3   /* Access permission denied */
</MACRO>
<MACRO>
<NAME>SQLITE_ABORT</NAME>
#define SQLITE_ABORT        4   /* Callback routine requested an abort */
</MACRO>
<MACRO>
<NAME>SQLITE_BUSY</NAME>
#define SQLITE_BUSY         5   /* The database file is locked */
</MACRO>
<MACRO>
<NAME>SQLITE_LOCKED</NAME>
#define SQLITE_LOCKED       6   /* A table in the database is locked */
</MACRO>
<MACRO>
<NAME>SQLITE_NOMEM</NAME>
#define SQLITE_NOMEM        7   /* A malloc() failed */
</MACRO>
<MACRO>
<NAME>SQLITE_READONLY</NAME>
#define SQLITE_READONLY     8   /* Attempt to write a readonly database */
</MACRO>
<MACRO>
<NAME>SQLITE_INTERRUPT</NAME>
#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR</NAME>
#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
</MACRO>
<MACRO>
<NAME>SQLITE_CORRUPT</NAME>
#define SQLITE_CORRUPT     11   /* The database disk image is malformed */
</MACRO>
<MACRO>
<NAME>SQLITE_NOTFOUND</NAME>
#define SQLITE_NOTFOUND    12   /* NOT USED. Table or record not found */
</MACRO>
<MACRO>
<NAME>SQLITE_FULL</NAME>
#define SQLITE_FULL        13   /* Insertion failed because database is full */
</MACRO>
<MACRO>
<NAME>SQLITE_CANTOPEN</NAME>
#define SQLITE_CANTOPEN    14   /* Unable to open the database file */
</MACRO>
<MACRO>
<NAME>SQLITE_PROTOCOL</NAME>
#define SQLITE_PROTOCOL    15   /* NOT USED. Database lock protocol error */
</MACRO>
<MACRO>
<NAME>SQLITE_EMPTY</NAME>
#define SQLITE_EMPTY       16   /* Database is empty */
</MACRO>
<MACRO>
<NAME>SQLITE_SCHEMA</NAME>
#define SQLITE_SCHEMA      17   /* The database schema changed */
</MACRO>
<MACRO>
<NAME>SQLITE_TOOBIG</NAME>
#define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */
</MACRO>
<MACRO>
<NAME>SQLITE_CONSTRAINT</NAME>
#define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
</MACRO>
<MACRO>
<NAME>SQLITE_MISMATCH</NAME>
#define SQLITE_MISMATCH    20   /* Data type mismatch */
</MACRO>
<MACRO>
<NAME>SQLITE_MISUSE</NAME>
#define SQLITE_MISUSE      21   /* Library used incorrectly */
</MACRO>
<MACRO>
<NAME>SQLITE_NOLFS</NAME>
#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
</MACRO>
<MACRO>
<NAME>SQLITE_AUTH</NAME>
#define SQLITE_AUTH        23   /* Authorization denied */
</MACRO>
<MACRO>
<NAME>SQLITE_FORMAT</NAME>
#define SQLITE_FORMAT      24   /* Auxiliary database format error */
</MACRO>
<MACRO>
<NAME>SQLITE_RANGE</NAME>
#define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
</MACRO>
<MACRO>
<NAME>SQLITE_NOTADB</NAME>
#define SQLITE_NOTADB      26   /* File opened that is not a database file */
</MACRO>
<MACRO>
<NAME>SQLITE_ROW</NAME>
#define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
</MACRO>
<MACRO>
<NAME>SQLITE_DONE</NAME>
#define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_READ</NAME>
#define SQLITE_IOERR_READ          (SQLITE_IOERR | (1<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_SHORT_READ</NAME>
#define SQLITE_IOERR_SHORT_READ    (SQLITE_IOERR | (2<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_WRITE</NAME>
#define SQLITE_IOERR_WRITE         (SQLITE_IOERR | (3<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_FSYNC</NAME>
#define SQLITE_IOERR_FSYNC         (SQLITE_IOERR | (4<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_DIR_FSYNC</NAME>
#define SQLITE_IOERR_DIR_FSYNC     (SQLITE_IOERR | (5<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_TRUNCATE</NAME>
#define SQLITE_IOERR_TRUNCATE      (SQLITE_IOERR | (6<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_FSTAT</NAME>
#define SQLITE_IOERR_FSTAT         (SQLITE_IOERR | (7<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_UNLOCK</NAME>
#define SQLITE_IOERR_UNLOCK        (SQLITE_IOERR | (8<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_RDLOCK</NAME>
#define SQLITE_IOERR_RDLOCK        (SQLITE_IOERR | (9<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_DELETE</NAME>
#define SQLITE_IOERR_DELETE        (SQLITE_IOERR | (10<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_BLOCKED</NAME>
#define SQLITE_IOERR_BLOCKED       (SQLITE_IOERR | (11<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_IOERR_NOMEM</NAME>
#define SQLITE_IOERR_NOMEM         (SQLITE_IOERR | (12<<8))
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_READONLY</NAME>
#define SQLITE_OPEN_READONLY         0x00000001
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_READWRITE</NAME>
#define SQLITE_OPEN_READWRITE        0x00000002
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_CREATE</NAME>
#define SQLITE_OPEN_CREATE           0x00000004
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_DELETEONCLOSE</NAME>
#define SQLITE_OPEN_DELETEONCLOSE    0x00000008
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_EXCLUSIVE</NAME>
#define SQLITE_OPEN_EXCLUSIVE        0x00000010
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_MAIN_DB</NAME>
#define SQLITE_OPEN_MAIN_DB          0x00000100
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_TEMP_DB</NAME>
#define SQLITE_OPEN_TEMP_DB          0x00000200
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_TRANSIENT_DB</NAME>
#define SQLITE_OPEN_TRANSIENT_DB     0x00000400
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_MAIN_JOURNAL</NAME>
#define SQLITE_OPEN_MAIN_JOURNAL     0x00000800
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_TEMP_JOURNAL</NAME>
#define SQLITE_OPEN_TEMP_JOURNAL     0x00001000
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_SUBJOURNAL</NAME>
#define SQLITE_OPEN_SUBJOURNAL       0x00002000
</MACRO>
<MACRO>
<NAME>SQLITE_OPEN_MASTER_JOURNAL</NAME>
#define SQLITE_OPEN_MASTER_JOURNAL   0x00004000
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_ATOMIC</NAME>
#define SQLITE_IOCAP_ATOMIC          0x00000001
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_ATOMIC512</NAME>
#define SQLITE_IOCAP_ATOMIC512       0x00000002
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_ATOMIC1K</NAME>
#define SQLITE_IOCAP_ATOMIC1K        0x00000004
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_ATOMIC2K</NAME>
#define SQLITE_IOCAP_ATOMIC2K        0x00000008
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_ATOMIC4K</NAME>
#define SQLITE_IOCAP_ATOMIC4K        0x00000010
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_ATOMIC8K</NAME>
#define SQLITE_IOCAP_ATOMIC8K        0x00000020
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_ATOMIC16K</NAME>
#define SQLITE_IOCAP_ATOMIC16K       0x00000040
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_ATOMIC32K</NAME>
#define SQLITE_IOCAP_ATOMIC32K       0x00000080
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_ATOMIC64K</NAME>
#define SQLITE_IOCAP_ATOMIC64K       0x00000100
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_SAFE_APPEND</NAME>
#define SQLITE_IOCAP_SAFE_APPEND     0x00000200
</MACRO>
<MACRO>
<NAME>SQLITE_IOCAP_SEQUENTIAL</NAME>
#define SQLITE_IOCAP_SEQUENTIAL      0x00000400
</MACRO>
<MACRO>
<NAME>SQLITE_LOCK_NONE</NAME>
#define SQLITE_LOCK_NONE          0
</MACRO>
<MACRO>
<NAME>SQLITE_LOCK_SHARED</NAME>
#define SQLITE_LOCK_SHARED        1
</MACRO>
<MACRO>
<NAME>SQLITE_LOCK_RESERVED</NAME>
#define SQLITE_LOCK_RESERVED      2
</MACRO>
<MACRO>
<NAME>SQLITE_LOCK_PENDING</NAME>
#define SQLITE_LOCK_PENDING       3
</MACRO>
<MACRO>
<NAME>SQLITE_LOCK_EXCLUSIVE</NAME>
#define SQLITE_LOCK_EXCLUSIVE     4
</MACRO>
<MACRO>
<NAME>SQLITE_SYNC_NORMAL</NAME>
#define SQLITE_SYNC_NORMAL        0x00002
</MACRO>
<MACRO>
<NAME>SQLITE_SYNC_FULL</NAME>
#define SQLITE_SYNC_FULL          0x00003
</MACRO>
<MACRO>
<NAME>SQLITE_SYNC_DATAONLY</NAME>
#define SQLITE_SYNC_DATAONLY      0x00010
</MACRO>
<TYPEDEF>
<NAME>sqlite3_file</NAME>
typedef struct sqlite3_file sqlite3_file;
</TYPEDEF>
<STRUCT>
<NAME>sqlite3_file</NAME>
struct sqlite3_file {
  const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */
};
</STRUCT>
<TYPEDEF>
<NAME>sqlite3_io_methods</NAME>
typedef struct sqlite3_io_methods sqlite3_io_methods;
</TYPEDEF>
<STRUCT>
<NAME>sqlite3_io_methods</NAME>
struct sqlite3_io_methods {
  int iVersion;
  int (*xClose)(sqlite3_file*);
  int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
  int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
  int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
  int (*xSync)(sqlite3_file*, int flags);
  int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
  int (*xLock)(sqlite3_file*, int);
  int (*xUnlock)(sqlite3_file*, int);
  int (*xCheckReservedLock)(sqlite3_file*);
  int (*xFileControl)(sqlite3_file*, int op, void *pArg);
  int (*xSectorSize)(sqlite3_file*);
  int (*xDeviceCharacteristics)(sqlite3_file*);
  /* Additional methods may be added in future releases */
};
</STRUCT>
<MACRO>
<NAME>SQLITE_FCNTL_LOCKSTATE</NAME>
#define SQLITE_FCNTL_LOCKSTATE        1
</MACRO>
<TYPEDEF>
<NAME>sqlite3_mutex</NAME>
typedef struct sqlite3_mutex sqlite3_mutex;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite3_vfs</NAME>
typedef struct sqlite3_vfs sqlite3_vfs;
</TYPEDEF>
<STRUCT>
<NAME>sqlite3_vfs</NAME>
struct sqlite3_vfs {
  int iVersion;            /* Structure version number */
  int szOsFile;            /* Size of subclassed sqlite3_file */
  int mxPathname;          /* Maximum file pathname length */
  sqlite3_vfs *pNext;      /* Next registered VFS */
  const char *zName;       /* Name of this virtual file system */
  void *pAppData;          /* Pointer to application-specific data */
  int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
               int flags, int *pOutFlags);
  int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
  int (*xAccess)(sqlite3_vfs*, const char *zName, int flags);
  int (*xGetTempname)(sqlite3_vfs*, int nOut, char *zOut);
  int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
  void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
  void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
  void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol);
  void (*xDlClose)(sqlite3_vfs*, void*);
  int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
  int (*xSleep)(sqlite3_vfs*, int microseconds);
  int (*xCurrentTime)(sqlite3_vfs*, double*);
  /* New fields may be appended in figure versions.  The iVersion
  ** value will increment whenever this happens. */
};
</STRUCT>
<MACRO>
<NAME>SQLITE_ACCESS_EXISTS</NAME>
#define SQLITE_ACCESS_EXISTS    0
</MACRO>
<MACRO>
<NAME>SQLITE_ACCESS_READWRITE</NAME>
#define SQLITE_ACCESS_READWRITE 1
</MACRO>
<MACRO>
<NAME>SQLITE_ACCESS_READ</NAME>
#define SQLITE_ACCESS_READ      2
</MACRO>
<FUNCTION>
<NAME>sqlite3_extended_result_codes</NAME>
<RETURNS>int </RETURNS>
sqlite3*, int onoff
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_last_insert_rowid</NAME>
<RETURNS>sqlite3_int64 </RETURNS>
sqlite3*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_changes</NAME>
<RETURNS>int </RETURNS>
sqlite3*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_total_changes</NAME>
<RETURNS>int </RETURNS>
sqlite3*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_interrupt</NAME>
<RETURNS>void </RETURNS>
sqlite3*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_complete</NAME>
<RETURNS>int </RETURNS>
const char *sql
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_complete16</NAME>
<RETURNS>int </RETURNS>
const void *sql
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_busy_handler</NAME>
<RETURNS>int </RETURNS>
sqlite3*, int(*)(void*,int), void*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_busy_timeout</NAME>
<RETURNS>int </RETURNS>
sqlite3*, int ms
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_get_table</NAME>
<RETURNS>int </RETURNS>
sqlite3*,const char *sql,char ***resultp,int *nrow,int *ncolumn,char **errmsg
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_free_table</NAME>
<RETURNS>void </RETURNS>
char **result
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_mprintf</NAME>
<RETURNS>char *</RETURNS>
const char*,...
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_vmprintf</NAME>
<RETURNS>char *</RETURNS>
const char*, va_list
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_snprintf</NAME>
<RETURNS>char *</RETURNS>
int,char*,const char*, ...
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_malloc</NAME>
<RETURNS>void *</RETURNS>
int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_realloc</NAME>
<RETURNS>void *</RETURNS>
void*, int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_free</NAME>
<RETURNS>void </RETURNS>
void*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_memory_used</NAME>
<RETURNS>sqlite3_int64 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_memory_highwater</NAME>
<RETURNS>sqlite3_int64 </RETURNS>
int resetFlag
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_memory_alarm</NAME>
<RETURNS>int </RETURNS>
void(*xCallback)(void *pArg, sqlite3_int64 used, int N),void *pArg,sqlite3_int64 iThreshold
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_set_authorizer</NAME>
<RETURNS>int </RETURNS>
sqlite3*,int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),void *pUserData
</FUNCTION>
<MACRO>
<NAME>SQLITE_DENY</NAME>
#define SQLITE_DENY   1   /* Abort the SQL statement with an error */
</MACRO>
<MACRO>
<NAME>SQLITE_IGNORE</NAME>
#define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */
</MACRO>
<MACRO>
<NAME>SQLITE_CREATE_INDEX</NAME>
#define SQLITE_CREATE_INDEX          1   /* Index Name      Table Name      */
</MACRO>
<MACRO>
<NAME>SQLITE_CREATE_TABLE</NAME>
#define SQLITE_CREATE_TABLE          2   /* Table Name      NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_CREATE_TEMP_INDEX</NAME>
#define SQLITE_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */
</MACRO>
<MACRO>
<NAME>SQLITE_CREATE_TEMP_TABLE</NAME>
#define SQLITE_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_CREATE_TEMP_TRIGGER</NAME>
#define SQLITE_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */
</MACRO>
<MACRO>
<NAME>SQLITE_CREATE_TEMP_VIEW</NAME>
#define SQLITE_CREATE_TEMP_VIEW      6   /* View Name       NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_CREATE_TRIGGER</NAME>
#define SQLITE_CREATE_TRIGGER        7   /* Trigger Name    Table Name      */
</MACRO>
<MACRO>
<NAME>SQLITE_CREATE_VIEW</NAME>
#define SQLITE_CREATE_VIEW           8   /* View Name       NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_DELETE</NAME>
#define SQLITE_DELETE                9   /* Table Name      NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_DROP_INDEX</NAME>
#define SQLITE_DROP_INDEX           10   /* Index Name      Table Name      */
</MACRO>
<MACRO>
<NAME>SQLITE_DROP_TABLE</NAME>
#define SQLITE_DROP_TABLE           11   /* Table Name      NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_DROP_TEMP_INDEX</NAME>
#define SQLITE_DROP_TEMP_INDEX      12   /* Index Name      Table Name      */
</MACRO>
<MACRO>
<NAME>SQLITE_DROP_TEMP_TABLE</NAME>
#define SQLITE_DROP_TEMP_TABLE      13   /* Table Name      NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_DROP_TEMP_TRIGGER</NAME>
#define SQLITE_DROP_TEMP_TRIGGER    14   /* Trigger Name    Table Name      */
</MACRO>
<MACRO>
<NAME>SQLITE_DROP_TEMP_VIEW</NAME>
#define SQLITE_DROP_TEMP_VIEW       15   /* View Name       NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_DROP_TRIGGER</NAME>
#define SQLITE_DROP_TRIGGER         16   /* Trigger Name    Table Name      */
</MACRO>
<MACRO>
<NAME>SQLITE_DROP_VIEW</NAME>
#define SQLITE_DROP_VIEW            17   /* View Name       NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_INSERT</NAME>
#define SQLITE_INSERT               18   /* Table Name      NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_PRAGMA</NAME>
#define SQLITE_PRAGMA               19   /* Pragma Name     1st arg or NULL */
</MACRO>
<MACRO>
<NAME>SQLITE_READ</NAME>
#define SQLITE_READ                 20   /* Table Name      Column Name     */
</MACRO>
<MACRO>
<NAME>SQLITE_SELECT</NAME>
#define SQLITE_SELECT               21   /* NULL            NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_TRANSACTION</NAME>
#define SQLITE_TRANSACTION          22   /* NULL            NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_UPDATE</NAME>
#define SQLITE_UPDATE               23   /* Table Name      Column Name     */
</MACRO>
<MACRO>
<NAME>SQLITE_ATTACH</NAME>
#define SQLITE_ATTACH               24   /* Filename        NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_DETACH</NAME>
#define SQLITE_DETACH               25   /* Database Name   NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_ALTER_TABLE</NAME>
#define SQLITE_ALTER_TABLE          26   /* Database Name   Table Name      */
</MACRO>
<MACRO>
<NAME>SQLITE_REINDEX</NAME>
#define SQLITE_REINDEX              27   /* Index Name      NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_ANALYZE</NAME>
#define SQLITE_ANALYZE              28   /* Table Name      NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_CREATE_VTABLE</NAME>
#define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */
</MACRO>
<MACRO>
<NAME>SQLITE_DROP_VTABLE</NAME>
#define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */
</MACRO>
<MACRO>
<NAME>SQLITE_FUNCTION</NAME>
#define SQLITE_FUNCTION             31   /* Function Name   NULL            */
</MACRO>
<MACRO>
<NAME>SQLITE_COPY</NAME>
#define SQLITE_COPY                  0   /* No longer used */
</MACRO>
<FUNCTION>
<NAME>sqlite3_trace</NAME>
<RETURNS>void *</RETURNS>
sqlite3*, void(*xTrace)(void*,const char*), void*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_profile</NAME>
<RETURNS>void *</RETURNS>
sqlite3*,void(*xProfile)(void*,const char*,sqlite3_uint64), void*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_progress_handler</NAME>
<RETURNS>void </RETURNS>
sqlite3*, int, int(*)(void*), void*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_open</NAME>
<RETURNS>int </RETURNS>
const char *filename,sqlite3 **ppDb
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_open16</NAME>
<RETURNS>int </RETURNS>
const void *filename,sqlite3 **ppDb
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_open_v2</NAME>
<RETURNS>int </RETURNS>
const char *filename,sqlite3 **ppDb,int flags,const char *zVfs
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_errcode</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_errmsg</NAME>
<RETURNS>const char *</RETURNS>
sqlite3*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_errmsg16</NAME>
<RETURNS>const void *</RETURNS>
sqlite3*
</FUNCTION>
<TYPEDEF>
<NAME>sqlite3_stmt</NAME>
typedef struct sqlite3_stmt sqlite3_stmt;
</TYPEDEF>
<FUNCTION>
<NAME>sqlite3_prepare</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const char *zSql,int nByte,sqlite3_stmt **ppStmt,const char **pzTail
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_prepare_v2</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const char *zSql,int nByte,sqlite3_stmt **ppStmt,const char **pzTail
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_prepare16</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const void *zSql,int nByte,sqlite3_stmt **ppStmt,const void **pzTail
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_prepare16_v2</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const void *zSql,int nByte,sqlite3_stmt **ppStmt,const void **pzTail
</FUNCTION>
<TYPEDEF>
<NAME>sqlite3_value</NAME>
typedef struct Mem sqlite3_value;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite3_context</NAME>
typedef struct sqlite3_context sqlite3_context;
</TYPEDEF>
<FUNCTION>
<NAME>sqlite3_bind_blob</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int, const void*, int n, void(*)(void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_double</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int, double
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_int</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int, int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_int64</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int, sqlite3_int64
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_null</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_text</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int, const char*, int n, void(*)(void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_text16</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int, const void*, int, void(*)(void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_value</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int, const sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_zeroblob</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int, int n
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_parameter_count</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_parameter_name</NAME>
<RETURNS>const char *</RETURNS>
sqlite3_stmt*, int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_bind_parameter_index</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, const char *zName
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_clear_bindings</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_count</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt *pStmt
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_name</NAME>
<RETURNS>const char *</RETURNS>
sqlite3_stmt*, int N
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_name16</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_stmt*, int N
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_database_name</NAME>
<RETURNS>const char *</RETURNS>
sqlite3_stmt*,int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_database_name16</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_stmt*,int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_table_name</NAME>
<RETURNS>const char *</RETURNS>
sqlite3_stmt*,int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_table_name16</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_stmt*,int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_origin_name</NAME>
<RETURNS>const char *</RETURNS>
sqlite3_stmt*,int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_origin_name16</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_stmt*,int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_decltype</NAME>
<RETURNS>const char *</RETURNS>
sqlite3_stmt *, int i
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_decltype16</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_stmt*,int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_step</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_data_count</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt *pStmt
</FUNCTION>
<MACRO>
<NAME>SQLITE_INTEGER</NAME>
#define SQLITE_INTEGER  1
</MACRO>
<MACRO>
<NAME>SQLITE_FLOAT</NAME>
#define SQLITE_FLOAT    2
</MACRO>
<MACRO>
<NAME>SQLITE_BLOB</NAME>
#define SQLITE_BLOB     4
</MACRO>
<MACRO>
<NAME>SQLITE_NULL</NAME>
#define SQLITE_NULL     5
</MACRO>
<MACRO>
<NAME>SQLITE_TEXT</NAME>
# define SQLITE_TEXT     3
</MACRO>
<MACRO>
<NAME>SQLITE3_TEXT</NAME>
#define SQLITE3_TEXT     3
</MACRO>
<FUNCTION>
<NAME>sqlite3_column_blob</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_bytes</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_bytes16</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_double</NAME>
<RETURNS>double </RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_int</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_int64</NAME>
<RETURNS>sqlite3_int64 </RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_text</NAME>
<RETURNS>const unsigned char *</RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_text16</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_type</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_column_value</NAME>
<RETURNS>sqlite3_value *</RETURNS>
sqlite3_stmt*, int iCol
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_finalize</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt *pStmt
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_reset</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt *pStmt
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_create_function</NAME>
<RETURNS>int </RETURNS>
sqlite3 *,const char *zFunctionName,int nArg,int eTextRep,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_create_function16</NAME>
<RETURNS>int </RETURNS>
sqlite3*,const void *zFunctionName,int nArg,int eTextRep,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*)
</FUNCTION>
<MACRO>
<NAME>SQLITE_UTF8</NAME>
#define SQLITE_UTF8           1
</MACRO>
<MACRO>
<NAME>SQLITE_UTF16LE</NAME>
#define SQLITE_UTF16LE        2
</MACRO>
<MACRO>
<NAME>SQLITE_UTF16BE</NAME>
#define SQLITE_UTF16BE        3
</MACRO>
<MACRO>
<NAME>SQLITE_UTF16</NAME>
#define SQLITE_UTF16          4    /* Use native byte order */
</MACRO>
<MACRO>
<NAME>SQLITE_ANY</NAME>
#define SQLITE_ANY            5    /* sqlite3_create_function only */
</MACRO>
<MACRO>
<NAME>SQLITE_UTF16_ALIGNED</NAME>
#define SQLITE_UTF16_ALIGNED  8    /* sqlite3_create_collation only */
</MACRO>
<FUNCTION>
<NAME>sqlite3_aggregate_count</NAME>
<RETURNS>int </RETURNS>
sqlite3_context*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_expired</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_transfer_bindings</NAME>
<RETURNS>int </RETURNS>
sqlite3_stmt*, sqlite3_stmt*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_global_recover</NAME>
<RETURNS>int </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_thread_cleanup</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_blob</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_bytes</NAME>
<RETURNS>int </RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_bytes16</NAME>
<RETURNS>int </RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_double</NAME>
<RETURNS>double </RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_int</NAME>
<RETURNS>int </RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_int64</NAME>
<RETURNS>sqlite3_int64 </RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_text</NAME>
<RETURNS>const unsigned char *</RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_text16</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_text16le</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_text16be</NAME>
<RETURNS>const void *</RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_type</NAME>
<RETURNS>int </RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_value_numeric_type</NAME>
<RETURNS>int </RETURNS>
sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_aggregate_context</NAME>
<RETURNS>void *</RETURNS>
sqlite3_context*, int nBytes
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_user_data</NAME>
<RETURNS>void *</RETURNS>
sqlite3_context*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_get_auxdata</NAME>
<RETURNS>void *</RETURNS>
sqlite3_context*, int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_set_auxdata</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, int, void*, void (*)(void*)
</FUNCTION>
<USER_FUNCTION>
<NAME>sqlite3_destructor_type</NAME>
<RETURNS>void </RETURNS>
void*
</USER_FUNCTION>
<MACRO>
<NAME>SQLITE_STATIC</NAME>
#define SQLITE_STATIC      ((sqlite3_destructor_type)0)
</MACRO>
<MACRO>
<NAME>SQLITE_TRANSIENT</NAME>
#define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)
</MACRO>
<FUNCTION>
<NAME>sqlite3_result_blob</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, const void*, int, void(*)(void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_double</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, double
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_error</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, const char*, int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_error16</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, const void*, int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_error_toobig</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_error_nomem</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_int</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_int64</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, sqlite3_int64
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_null</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_text</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, const char*, int, void(*)(void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_text16</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, const void*, int, void(*)(void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_text16le</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, const void*, int,void(*)(void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_text16be</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, const void*, int,void(*)(void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_value</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, sqlite3_value*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_result_zeroblob</NAME>
<RETURNS>void </RETURNS>
sqlite3_context*, int n
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_create_collation</NAME>
<RETURNS>int </RETURNS>
sqlite3*,const char *zName,int eTextRep,void*,int(*xCompare)(void*,int,const void*,int,const void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_create_collation_v2</NAME>
<RETURNS>int </RETURNS>
sqlite3*,const char *zName,int eTextRep,void*,int(*xCompare)(void*,int,const void*,int,const void*),void(*xDestroy)(void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_create_collation16</NAME>
<RETURNS>int </RETURNS>
sqlite3*,const char *zName,int eTextRep,void*,int(*xCompare)(void*,int,const void*,int,const void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_collation_needed</NAME>
<RETURNS>int </RETURNS>
sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const char*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_collation_needed16</NAME>
<RETURNS>int </RETURNS>
sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const void*)
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_key</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const void *pKey, int nKey
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_rekey</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const void *pKey, int nKey
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_sleep</NAME>
<RETURNS>int </RETURNS>
int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_get_autocommit</NAME>
<RETURNS>int </RETURNS>
sqlite3*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_db_handle</NAME>
<RETURNS>sqlite3 *</RETURNS>
sqlite3_stmt*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_commit_hook</NAME>
<RETURNS>void *</RETURNS>
sqlite3*, int(*)(void*), void*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_rollback_hook</NAME>
<RETURNS>void *</RETURNS>
sqlite3*, void(*)(void *), void*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_update_hook</NAME>
<RETURNS>void *</RETURNS>
sqlite3*,void(*)(void *,int ,char const *,char const *,sqlite3_int64),void*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_enable_shared_cache</NAME>
<RETURNS>int </RETURNS>
int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_release_memory</NAME>
<RETURNS>int </RETURNS>
int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_soft_heap_limit</NAME>
<RETURNS>void </RETURNS>
int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_table_column_metadata</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const char *zDbName,const char *zTableName,const char *zColumnName,char const **pzDataType,char const **pzCollSeq,int *pNotNull,int *pPrimaryKey,int *pAutoinc
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_load_extension</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const char *zFile,const char *zProc,char **pzErrMsg
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_enable_load_extension</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db, int onoff
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_auto_extension</NAME>
<RETURNS>int </RETURNS>
void *xEntryPoint
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_reset_auto_extension</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<TYPEDEF>
<NAME>sqlite3_vtab</NAME>
typedef struct sqlite3_vtab sqlite3_vtab;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite3_index_info</NAME>
typedef struct sqlite3_index_info sqlite3_index_info;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite3_vtab_cursor</NAME>
typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor;
</TYPEDEF>
<TYPEDEF>
<NAME>sqlite3_module</NAME>
typedef struct sqlite3_module sqlite3_module;
</TYPEDEF>
<STRUCT>
<NAME>sqlite3_module</NAME>
struct sqlite3_module {
  int iVersion;
  int (*xCreate)(sqlite3*, void *pAux,
               int argc, const char *const*argv,
               sqlite3_vtab **ppVTab, char**);
  int (*xConnect)(sqlite3*, void *pAux,
               int argc, const char *const*argv,
               sqlite3_vtab **ppVTab, char**);
  int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*);
  int (*xDisconnect)(sqlite3_vtab *pVTab);
  int (*xDestroy)(sqlite3_vtab *pVTab);
  int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
  int (*xClose)(sqlite3_vtab_cursor*);
  int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr,
                int argc, sqlite3_value **argv);
  int (*xNext)(sqlite3_vtab_cursor*);
  int (*xEof)(sqlite3_vtab_cursor*);
  int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int);
  int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid);
  int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *);
  int (*xBegin)(sqlite3_vtab *pVTab);
  int (*xSync)(sqlite3_vtab *pVTab);
  int (*xCommit)(sqlite3_vtab *pVTab);
  int (*xRollback)(sqlite3_vtab *pVTab);
  int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
                       void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
                       void **ppArg);

  int (*xRename)(sqlite3_vtab *pVtab, const char *zNew);
};
</STRUCT>
<STRUCT>
<NAME>sqlite3_index_info</NAME>
struct sqlite3_index_info {
  /* Inputs */
  int nConstraint;           /* Number of entries in aConstraint */
  struct sqlite3_index_constraint {
     int iColumn;              /* Column on left-hand side of constraint */
     unsigned char op;         /* Constraint operator */
     unsigned char usable;     /* True if this constraint is usable */
     int iTermOffset;          /* Used internally - xBestIndex should ignore */
  } *aConstraint;            /* Table of WHERE clause constraints */
  int nOrderBy;              /* Number of terms in the ORDER BY clause */
  struct sqlite3_index_orderby {
     int iColumn;              /* Column number */
     unsigned char desc;       /* True for DESC.  False for ASC. */
  } *aOrderBy;               /* The ORDER BY clause */

  /* Outputs */
  struct sqlite3_index_constraint_usage {
    int argvIndex;           /* if >0, constraint is part of argv to xFilter */
    unsigned char omit;      /* Do not code a test for this constraint */
  } *aConstraintUsage;
  int idxNum;                /* Number used to identify the index */
  char *idxStr;              /* String, possibly obtained from sqlite3_malloc */
  int needToFreeIdxStr;      /* Free idxStr using sqlite3_free() if true */
  int orderByConsumed;       /* True if output is already ordered */
  double estimatedCost;      /* Estimated cost of using this index */
};
</STRUCT>
<MACRO>
<NAME>SQLITE_INDEX_CONSTRAINT_EQ</NAME>
#define SQLITE_INDEX_CONSTRAINT_EQ    2
</MACRO>
<MACRO>
<NAME>SQLITE_INDEX_CONSTRAINT_GT</NAME>
#define SQLITE_INDEX_CONSTRAINT_GT    4
</MACRO>
<MACRO>
<NAME>SQLITE_INDEX_CONSTRAINT_LE</NAME>
#define SQLITE_INDEX_CONSTRAINT_LE    8
</MACRO>
<MACRO>
<NAME>SQLITE_INDEX_CONSTRAINT_LT</NAME>
#define SQLITE_INDEX_CONSTRAINT_LT    16
</MACRO>
<MACRO>
<NAME>SQLITE_INDEX_CONSTRAINT_GE</NAME>
#define SQLITE_INDEX_CONSTRAINT_GE    32
</MACRO>
<MACRO>
<NAME>SQLITE_INDEX_CONSTRAINT_MATCH</NAME>
#define SQLITE_INDEX_CONSTRAINT_MATCH 64
</MACRO>
<FUNCTION>
<NAME>sqlite3_create_module</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const char *zName,const sqlite3_module *,void *
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_create_module_v2</NAME>
<RETURNS>int </RETURNS>
sqlite3 *db,const char *zName,const sqlite3_module *,void *,void(*xDestroy)(void*)
</FUNCTION>
<STRUCT>
<NAME>sqlite3_vtab</NAME>
struct sqlite3_vtab {
  const sqlite3_module *pModule;  /* The module for this virtual table */
  int nRef;                       /* Used internally */
  char *zErrMsg;                  /* Error message from sqlite3_mprintf() */
  /* Virtual table implementations will typically add additional fields */
};
</STRUCT>
<STRUCT>
<NAME>sqlite3_vtab_cursor</NAME>
struct sqlite3_vtab_cursor {
  sqlite3_vtab *pVtab;      /* Virtual table of this cursor */
  /* Virtual table implementations will typically add additional fields */
};
</STRUCT>
<FUNCTION>
<NAME>sqlite3_declare_vtab</NAME>
<RETURNS>int </RETURNS>
sqlite3*, const char *zCreateTable
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_overload_function</NAME>
<RETURNS>int </RETURNS>
sqlite3*, const char *zFuncName, int nArg
</FUNCTION>
<TYPEDEF>
<NAME>sqlite3_blob</NAME>
typedef struct sqlite3_blob sqlite3_blob;
</TYPEDEF>
<FUNCTION>
<NAME>sqlite3_blob_open</NAME>
<RETURNS>int </RETURNS>
sqlite3*,const char *zDb,const char *zTable,const char *zColumn,sqlite3_int64 iRow,int flags,sqlite3_blob **ppBlob
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_blob_close</NAME>
<RETURNS>int </RETURNS>
sqlite3_blob *
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_blob_bytes</NAME>
<RETURNS>int </RETURNS>
sqlite3_blob *
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_blob_read</NAME>
<RETURNS>int </RETURNS>
sqlite3_blob *, void *z, int n, int iOffset
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_blob_write</NAME>
<RETURNS>int </RETURNS>
sqlite3_blob *, const void *z, int n, int iOffset
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_vfs_find</NAME>
<RETURNS>sqlite3_vfs *</RETURNS>
const char *zVfsName
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_vfs_register</NAME>
<RETURNS>int </RETURNS>
sqlite3_vfs*, int makeDflt
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_vfs_unregister</NAME>
<RETURNS>int </RETURNS>
sqlite3_vfs*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_mutex_alloc</NAME>
<RETURNS>sqlite3_mutex *</RETURNS>
int
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_mutex_free</NAME>
<RETURNS>void </RETURNS>
sqlite3_mutex*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_mutex_enter</NAME>
<RETURNS>void </RETURNS>
sqlite3_mutex*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_mutex_try</NAME>
<RETURNS>int </RETURNS>
sqlite3_mutex*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_mutex_leave</NAME>
<RETURNS>void </RETURNS>
sqlite3_mutex*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_mutex_held</NAME>
<RETURNS>int </RETURNS>
sqlite3_mutex*
</FUNCTION>
<FUNCTION>
<NAME>sqlite3_mutex_notheld</NAME>
<RETURNS>int </RETURNS>
sqlite3_mutex*
</FUNCTION>
<MACRO>
<NAME>SQLITE_MUTEX_FAST</NAME>
#define SQLITE_MUTEX_FAST             0
</MACRO>
<MACRO>
<NAME>SQLITE_MUTEX_RECURSIVE</NAME>
#define SQLITE_MUTEX_RECURSIVE        1
</MACRO>
<MACRO>
<NAME>SQLITE_MUTEX_STATIC_MASTER</NAME>
#define SQLITE_MUTEX_STATIC_MASTER    2
</MACRO>
<MACRO>
<NAME>SQLITE_MUTEX_STATIC_MEM</NAME>
#define SQLITE_MUTEX_STATIC_MEM       3  /* sqlite3_malloc() */
</MACRO>
<MACRO>
<NAME>SQLITE_MUTEX_STATIC_MEM2</NAME>
#define SQLITE_MUTEX_STATIC_MEM2      4  /* sqlite3_release_memory() */
</MACRO>
<MACRO>
<NAME>SQLITE_MUTEX_STATIC_PRNG</NAME>
#define SQLITE_MUTEX_STATIC_PRNG      5  /* sqlite3_random() */
</MACRO>
<MACRO>
<NAME>SQLITE_MUTEX_STATIC_LRU</NAME>
#define SQLITE_MUTEX_STATIC_LRU       6  /* lru page list */
</MACRO>
<FUNCTION>
<NAME>sqlite3_file_control</NAME>
<RETURNS>int </RETURNS>
sqlite3*, const char *zDbName, int op, void*
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_VPROVIDER_HUB</NAME>
#define GDA_TYPE_VPROVIDER_HUB            (gda_vprovider_hub_get_type())
</MACRO>
<MACRO>
<NAME>GDA_VPROVIDER_HUB</NAME>
#define GDA_VPROVIDER_HUB(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_VPROVIDER_HUB, GdaVproviderHub))
</MACRO>
<MACRO>
<NAME>GDA_VPROVIDER_HUB_CLASS</NAME>
#define GDA_VPROVIDER_HUB_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_VPROVIDER_HUB, GdaVproviderHubClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_VPROVIDER_HUB</NAME>
#define GDA_IS_VPROVIDER_HUB(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_VPROVIDER_HUB))
</MACRO>
<MACRO>
<NAME>GDA_IS_VPROVIDER_HUB_CLASS</NAME>
#define GDA_IS_VPROVIDER_HUB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_VPROVIDER_HUB))
</MACRO>
<STRUCT>
<NAME>GdaVproviderHub</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVproviderHubClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVproviderHubPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVproviderHub</NAME>
struct _GdaVproviderHub {
	GdaVproviderDataModel      parent;
	GdaVproviderHubPrivate    *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaVproviderHubClass</NAME>
struct _GdaVproviderHubClass {
	GdaVproviderDataModelClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_vprovider_hub_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_vprovider_hub_new</NAME>
<RETURNS>GdaVirtualProvider *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_VIRTUAL_CONNECTION</NAME>
#define GDA_TYPE_VIRTUAL_CONNECTION            (gda_virtual_connection_get_type())
</MACRO>
<MACRO>
<NAME>GDA_VIRTUAL_CONNECTION</NAME>
#define GDA_VIRTUAL_CONNECTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_VIRTUAL_CONNECTION, GdaVirtualConnection))
</MACRO>
<MACRO>
<NAME>GDA_VIRTUAL_CONNECTION_CLASS</NAME>
#define GDA_VIRTUAL_CONNECTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_VIRTUAL_CONNECTION, GdaVirtualConnectionClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_VIRTUAL_CONNECTION</NAME>
#define GDA_IS_VIRTUAL_CONNECTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_VIRTUAL_CONNECTION))
</MACRO>
<MACRO>
<NAME>GDA_IS_VIRTUAL_CONNECTION_CLASS</NAME>
#define GDA_IS_VIRTUAL_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_VIRTUAL_CONNECTION))
</MACRO>
<STRUCT>
<NAME>GdaVirtualConnection</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVirtualConnectionClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVirtualConnectionPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVirtualConnection</NAME>
struct _GdaVirtualConnection {
	GdaConnection                connection;
	GdaVirtualConnectionPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaVirtualConnectionClass</NAME>
struct _GdaVirtualConnectionClass {
	GdaConnectionClass           parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_virtual_connection_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_VCONNECTION_HUB</NAME>
#define GDA_TYPE_VCONNECTION_HUB            (gda_vconnection_hub_get_type())
</MACRO>
<MACRO>
<NAME>GDA_VCONNECTION_HUB</NAME>
#define GDA_VCONNECTION_HUB(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_VCONNECTION_HUB, GdaVconnectionHub))
</MACRO>
<MACRO>
<NAME>GDA_VCONNECTION_HUB_CLASS</NAME>
#define GDA_VCONNECTION_HUB_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_VCONNECTION_HUB, GdaVconnectionHubClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_VCONNECTION_HUB</NAME>
#define GDA_IS_VCONNECTION_HUB(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_VCONNECTION_HUB))
</MACRO>
<MACRO>
<NAME>GDA_IS_VCONNECTION_HUB_CLASS</NAME>
#define GDA_IS_VCONNECTION_HUB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_VCONNECTION_HUB))
</MACRO>
<STRUCT>
<NAME>GdaVconnectionHub</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVconnectionHubClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVconnectionHubPrivate</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GdaVConnectionHubFunc</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc, const gchar *ns, gpointer data
</USER_FUNCTION>
<STRUCT>
<NAME>GdaVconnectionHub</NAME>
struct _GdaVconnectionHub {
	GdaVconnectionDataModel      parent;
	GdaVconnectionHubPrivate    *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaVconnectionHubClass</NAME>
struct _GdaVconnectionHubClass {
	GdaVconnectionDataModelClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_vconnection_hub_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_hub_add</NAME>
<RETURNS>gboolean            </RETURNS>
GdaVconnectionHub *hub,GdaConnection *cnc, const gchar *ns, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_hub_remove</NAME>
<RETURNS>gboolean            </RETURNS>
GdaVconnectionHub *hub, GdaConnection *cnc, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_hub_get_connection</NAME>
<RETURNS>GdaConnection      *</RETURNS>
GdaVconnectionHub *cnc, const gchar *ns
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_hub_foreach</NAME>
<RETURNS>void                </RETURNS>
GdaVconnectionHub *hub,GdaVConnectionHubFunc func, gpointer data
</FUNCTION>
<STRUCT>
<NAME>GdaVConnectionTableData</NAME>
typedef struct {
	GdaVconnectionDataModelSpec *spec;
	GDestroyNotify               spec_free_func;

	GdaDataModel                *real_model; /* data model really being used, a reference count is kept on it */
	gchar                       *table_name;
	gchar                       *unique_name;
} GdaVConnectionTableData;
</STRUCT>
<FUNCTION>
<NAME>gda_vconnection_data_model_table_data_free</NAME>
<RETURNS>void                     </RETURNS>
GdaVConnectionTableData *td
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_get_table_data_by_name</NAME>
<RETURNS>GdaVConnectionTableData *</RETURNS>
GdaVconnectionDataModel *cnc, const gchar *table_name
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_get_table_data_by_model</NAME>
<RETURNS>GdaVConnectionTableData *</RETURNS>
GdaVconnectionDataModel *cnc, GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_get_table_data_by_unique_name</NAME>
<RETURNS>GdaVConnectionTableData *</RETURNS>
GdaVconnectionDataModel *cnc, const gchar *unique_name
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_VCONNECTION_DATA_MODEL</NAME>
#define GDA_TYPE_VCONNECTION_DATA_MODEL            (gda_vconnection_data_model_get_type())
</MACRO>
<MACRO>
<NAME>GDA_VCONNECTION_DATA_MODEL</NAME>
#define GDA_VCONNECTION_DATA_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_VCONNECTION_DATA_MODEL, GdaVconnectionDataModel))
</MACRO>
<MACRO>
<NAME>GDA_VCONNECTION_DATA_MODEL_CLASS</NAME>
#define GDA_VCONNECTION_DATA_MODEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_VCONNECTION_DATA_MODEL, GdaVconnectionDataModelClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_VCONNECTION_DATA_MODEL</NAME>
#define GDA_IS_VCONNECTION_DATA_MODEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_VCONNECTION_DATA_MODEL))
</MACRO>
<MACRO>
<NAME>GDA_IS_VCONNECTION_DATA_MODEL_CLASS</NAME>
#define GDA_IS_VCONNECTION_DATA_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_VCONNECTION_DATA_MODEL))
</MACRO>
<STRUCT>
<NAME>GdaVconnectionDataModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVconnectionDataModelClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVconnectionDataModelPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVconnectionDataModelSpec</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GdaVconnectionDataModelCreateColumnsFunc</NAME>
<RETURNS>GList *</RETURNS>
GdaVconnectionDataModelSpec *
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdaVconnectionDataModelCreateModelFunc</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaVconnectionDataModelSpec *
</USER_FUNCTION>
<STRUCT>
<NAME>GdaVconnectionDataModelSpec</NAME>
struct _GdaVconnectionDataModelSpec {
	GdaDataModel                             *data_model;
	GdaVconnectionDataModelCreateColumnsFunc  create_columns_func;
	GdaVconnectionDataModelCreateModelFunc    create_model_func;
};
</STRUCT>
<MACRO>
<NAME>GDA_VCONNECTION_DATA_MODEL_SPEC</NAME>
#define GDA_VCONNECTION_DATA_MODEL_SPEC(x) ((GdaVconnectionDataModelSpec*)(x))
</MACRO>
<USER_FUNCTION>
<NAME>GdaVConnectionDataModelFunc</NAME>
<RETURNS>void </RETURNS>
GdaDataModel *model, const gchar *table_name, gpointer data
</USER_FUNCTION>
<STRUCT>
<NAME>GdaVconnectionDataModel</NAME>
struct _GdaVconnectionDataModel {
	GdaVirtualConnection            connection;
	GdaVconnectionDataModelPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaVconnectionDataModelClass</NAME>
struct _GdaVconnectionDataModelClass {
	GdaVirtualConnectionClass       parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_vconnection_data_model_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_data_model_add</NAME>
<RETURNS>gboolean            </RETURNS>
GdaVconnectionDataModel *cnc, GdaVconnectionDataModelSpec *spec,GDestroyNotify spec_free_func,const gchar *table_name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_data_model_add_model</NAME>
<RETURNS>gboolean            </RETURNS>
GdaVconnectionDataModel *cnc,GdaDataModel *model, const gchar *table_name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_data_model_remove</NAME>
<RETURNS>gboolean            </RETURNS>
GdaVconnectionDataModel *cnc, const gchar *table_name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_data_model_get_table_name</NAME>
<RETURNS>const gchar        *</RETURNS>
GdaVconnectionDataModel *cnc, GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_data_model_get_model</NAME>
<RETURNS>GdaDataModel       *</RETURNS>
GdaVconnectionDataModel *cnc, const gchar *table_name
</FUNCTION>
<FUNCTION>
<NAME>gda_vconnection_data_model_foreach</NAME>
<RETURNS>void                </RETURNS>
GdaVconnectionDataModel *cnc,GdaVConnectionDataModelFunc func, gpointer data
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_VPROVIDER_DATA_MODEL</NAME>
#define GDA_TYPE_VPROVIDER_DATA_MODEL            (gda_vprovider_data_model_get_type())
</MACRO>
<MACRO>
<NAME>GDA_VPROVIDER_DATA_MODEL</NAME>
#define GDA_VPROVIDER_DATA_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_VPROVIDER_DATA_MODEL, GdaVproviderDataModel))
</MACRO>
<MACRO>
<NAME>GDA_VPROVIDER_DATA_MODEL_CLASS</NAME>
#define GDA_VPROVIDER_DATA_MODEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_VPROVIDER_DATA_MODEL, GdaVproviderDataModelClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_VPROVIDER_DATA_MODEL</NAME>
#define GDA_IS_VPROVIDER_DATA_MODEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_VPROVIDER_DATA_MODEL))
</MACRO>
<MACRO>
<NAME>GDA_IS_VPROVIDER_DATA_MODEL_CLASS</NAME>
#define GDA_IS_VPROVIDER_DATA_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_VPROVIDER_DATA_MODEL))
</MACRO>
<STRUCT>
<NAME>GdaVproviderDataModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVproviderDataModelClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVproviderDataModelPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVproviderDataModel</NAME>
struct _GdaVproviderDataModel {
	GdaVirtualProvider            vprovider;
	GdaVproviderDataModelPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaVproviderDataModelClass</NAME>
struct _GdaVproviderDataModelClass {
	GdaVirtualProviderClass       parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_vprovider_data_model_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_vprovider_data_model_new</NAME>
<RETURNS>GdaVirtualProvider *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_VIRTUAL_PROVIDER</NAME>
#define GDA_TYPE_VIRTUAL_PROVIDER            (gda_virtual_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_VIRTUAL_PROVIDER</NAME>
#define GDA_VIRTUAL_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_VIRTUAL_PROVIDER, GdaVirtualProvider))
</MACRO>
<MACRO>
<NAME>GDA_VIRTUAL_PROVIDER_CLASS</NAME>
#define GDA_VIRTUAL_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_VIRTUAL_PROVIDER, GdaVirtualProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_VIRTUAL_PROVIDER</NAME>
#define GDA_IS_VIRTUAL_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_VIRTUAL_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_VIRTUAL_PROVIDER_CLASS</NAME>
#define GDA_IS_VIRTUAL_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_VIRTUAL_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GdaVirtualProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVirtualProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVirtualProviderPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaVirtualProvider</NAME>
struct _GdaVirtualProvider {
	GdaSqliteProvider          provider;
	GdaVirtualProviderPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaVirtualProviderClass</NAME>
struct _GdaVirtualProviderClass {
	GdaSqliteProviderClass      parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_virtual_provider_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_sql_transaction_build</NAME>
<RETURNS>GdaSqlTransaction  *</RETURNS>
GdaSqlTransactionType type, gchar *trans_name, GdaTransactionIsolation level
</FUNCTION>
<FUNCTION>
<NAME>gda_sql_transaction_destroy</NAME>
<RETURNS>void                </RETURNS>
GdaSqlTransaction *trans
</FUNCTION>
<MACRO>
<NAME>YY_NO_UNISTD_H</NAME>
#define YY_NO_UNISTD_H
</MACRO>
<STRUCT>
<NAME>GdaSqlTransaction</NAME>
</STRUCT>
<ENUM>
<NAME>GdaSqlTransactionType</NAME>
typedef enum {
	GDA_SQL_TRANSACTION_BEGIN,
	GDA_SQL_TRANSACTION_COMMIT,
	GDA_SQL_TRANSACTION_ROLLBACK,
	GDA_SQL_TRANSACTION_SAVEPOINT_ADD,
	GDA_SQL_TRANSACTION_SAVEPOINT_REMOVE,
	GDA_SQL_TRANSACTION_SAVEPOINT_ROLLBACK
} GdaSqlTransactionType;
</ENUM>
<STRUCT>
<NAME>GdaSqlTransaction</NAME>
struct _GdaSqlTransaction
{
	GdaSqlTransactionType    trans_type;
	gchar                   *trans_name;
	gchar                   *full_query;
	GdaTransactionIsolation  isolation_level;
};
</STRUCT>
<FUNCTION>
<NAME>gda_sql_transaction_parse</NAME>
<RETURNS>GdaSqlTransaction *</RETURNS>
const char *sql_statement
</FUNCTION>
<FUNCTION>
<NAME>gda_sql_transaction_parse_with_error</NAME>
<RETURNS>GdaSqlTransaction *</RETURNS>
const char *sql_statement,GError ** error
</FUNCTION>
<MACRO>
<NAME>L_STRING</NAME>
#define L_STRING 258
</MACRO>
<MACRO>
<NAME>L_TEXTUAL</NAME>
#define L_TEXTUAL 259
</MACRO>
<MACRO>
<NAME>L_IDENT</NAME>
#define L_IDENT 260
</MACRO>
<MACRO>
<NAME>L_START</NAME>
#define L_START 261
</MACRO>
<MACRO>
<NAME>L_BEGIN</NAME>
#define L_BEGIN 262
</MACRO>
<MACRO>
<NAME>L_COMMIT</NAME>
#define L_COMMIT 263
</MACRO>
<MACRO>
<NAME>L_ROLLBACK</NAME>
#define L_ROLLBACK 264
</MACRO>
<MACRO>
<NAME>L_SAVEPOINT</NAME>
#define L_SAVEPOINT 265
</MACRO>
<MACRO>
<NAME>L_RELEASE</NAME>
#define L_RELEASE 266
</MACRO>
<MACRO>
<NAME>L_TRANSACTION</NAME>
#define L_TRANSACTION 267
</MACRO>
<MACRO>
<NAME>L_ISOLATION</NAME>
#define L_ISOLATION 268
</MACRO>
<MACRO>
<NAME>L_LEVEL</NAME>
#define L_LEVEL 269
</MACRO>
<MACRO>
<NAME>L_SERIALIZABLE</NAME>
#define L_SERIALIZABLE 270
</MACRO>
<MACRO>
<NAME>L_READ</NAME>
#define L_READ 271
</MACRO>
<MACRO>
<NAME>L_WRITE</NAME>
#define L_WRITE 272
</MACRO>
<MACRO>
<NAME>L_COMMITTED</NAME>
#define L_COMMITTED 273
</MACRO>
<MACRO>
<NAME>L_UNCOMMITTED</NAME>
#define L_UNCOMMITTED 274
</MACRO>
<MACRO>
<NAME>L_REPEATABLE</NAME>
#define L_REPEATABLE 275
</MACRO>
<MACRO>
<NAME>L_END</NAME>
#define L_END 276
</MACRO>
<MACRO>
<NAME>L_ONLY</NAME>
#define L_ONLY 277
</MACRO>
<MACRO>
<NAME>L_W_MARK</NAME>
#define L_W_MARK 278
</MACRO>
<MACRO>
<NAME>L_DEFERRED</NAME>
#define L_DEFERRED 279
</MACRO>
<MACRO>
<NAME>L_IMMEDIATE</NAME>
#define L_IMMEDIATE 280
</MACRO>
<MACRO>
<NAME>L_EXCLUSIVE</NAME>
#define L_EXCLUSIVE 281
</MACRO>
<MACRO>
<NAME>L_COMMENT</NAME>
#define L_COMMENT 282
</MACRO>
<MACRO>
<NAME>L_FORCE</NAME>
#define L_FORCE 283
</MACRO>
<MACRO>
<NAME>L_TO</NAME>
#define L_TO 284
</MACRO>
<MACRO>
<NAME>yystype</NAME>
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
</MACRO>
<MACRO>
<NAME>YYSTYPE_IS_DECLARED</NAME>
# define YYSTYPE_IS_DECLARED 1
</MACRO>
<MACRO>
<NAME>YYSTYPE_IS_TRIVIAL</NAME>
# define YYSTYPE_IS_TRIVIAL 1
</MACRO>
<VARIABLE>
<NAME>tranlval</NAME>
extern YYSTYPE tranlval;
</VARIABLE>
<FUNCTION>
<NAME>memsql_strappend</NAME>
<RETURNS>char *</RETURNS>
const char *string1, const char *string2
</FUNCTION>
<FUNCTION>
<NAME>memsql_strappend_free</NAME>
<RETURNS>char *</RETURNS>
char *string1, char *string2
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_build</NAME>
<RETURNS>sql_statement        *</RETURNS>
sql_statement_type type, void *statement
</FUNCTION>
<FUNCTION>
<NAME>sql_select_statement_build</NAME>
<RETURNS>sql_select_statement *</RETURNS>
int distinct,GList * fields,GList * from,sql_where * where,GList * order,GList * group,sql_limit *limit
</FUNCTION>
<FUNCTION>
<NAME>sql_insert_statement_build</NAME>
<RETURNS>sql_insert_statement *</RETURNS>
sql_table * table,GList * fields,GList * values
</FUNCTION>
<FUNCTION>
<NAME>sql_update_statement_build</NAME>
<RETURNS>sql_update_statement *</RETURNS>
sql_table * table,GList * set,sql_where * where
</FUNCTION>
<FUNCTION>
<NAME>sql_delete_statement_build</NAME>
<RETURNS>sql_delete_statement *</RETURNS>
sql_table * table,sql_where * where
</FUNCTION>
<FUNCTION>
<NAME>sql_limit_build</NAME>
<RETURNS>sql_limit            *</RETURNS>
guint limit, guint offset
</FUNCTION>
<FUNCTION>
<NAME>sql_limit_build_comma_sep</NAME>
<RETURNS>sql_limit            *</RETURNS>
char *lo
</FUNCTION>
<FUNCTION>
<NAME>sql_field_item_build</NAME>
<RETURNS>sql_field_item *</RETURNS>
GList * name
</FUNCTION>
<FUNCTION>
<NAME>sql_field_item_build_equation</NAME>
<RETURNS>sql_field_item *</RETURNS>
sql_field_item * left,sql_field_item * right,sql_field_operator op
</FUNCTION>
<FUNCTION>
<NAME>sql_field_item_build_select</NAME>
<RETURNS>sql_field_item *</RETURNS>
sql_select_statement * select
</FUNCTION>
<FUNCTION>
<NAME>sql_field_build_function</NAME>
<RETURNS>sql_field_item *</RETURNS>
char * funcname,GList * funcarglist
</FUNCTION>
<FUNCTION>
<NAME>sql_field_build</NAME>
<RETURNS>sql_field *</RETURNS>
sql_field_item * item
</FUNCTION>
<FUNCTION>
<NAME>sql_field_set_as</NAME>
<RETURNS>sql_field *</RETURNS>
sql_field * field, char *as
</FUNCTION>
<FUNCTION>
<NAME>sql_field_set_param_spec</NAME>
<RETURNS>sql_field *</RETURNS>
sql_field * field, GList * param_spec
</FUNCTION>
<FUNCTION>
<NAME>sql_table_build</NAME>
<RETURNS>sql_table *</RETURNS>
const char *tablename
</FUNCTION>
<FUNCTION>
<NAME>sql_table_build_function</NAME>
<RETURNS>sql_table *</RETURNS>
char * funcname, GList * funcarglist
</FUNCTION>
<FUNCTION>
<NAME>sql_table_set_join</NAME>
<RETURNS>sql_table *</RETURNS>
sql_table * table, sql_join_type join_type, sql_where * cond
</FUNCTION>
<FUNCTION>
<NAME>sql_table_build_select</NAME>
<RETURNS>sql_table *</RETURNS>
sql_select_statement * select
</FUNCTION>
<FUNCTION>
<NAME>sql_table_set_as</NAME>
<RETURNS>sql_table *</RETURNS>
sql_table * table, char *as
</FUNCTION>
<FUNCTION>
<NAME>sql_where_build_single</NAME>
<RETURNS>sql_where *</RETURNS>
sql_condition * cond
</FUNCTION>
<FUNCTION>
<NAME>sql_where_build_negated</NAME>
<RETURNS>sql_where *</RETURNS>
sql_where * where
</FUNCTION>
<FUNCTION>
<NAME>sql_where_build_pair</NAME>
<RETURNS>sql_where *</RETURNS>
sql_where * left, sql_where * right,sql_logic_operator op
</FUNCTION>
<FUNCTION>
<NAME>sql_build_condition</NAME>
<RETURNS>sql_condition *</RETURNS>
sql_field * left, sql_field * right,sql_condition_operator op
</FUNCTION>
<FUNCTION>
<NAME>sql_build_condition_between</NAME>
<RETURNS>sql_condition *</RETURNS>
sql_field * field,sql_field * lower,sql_field * upper
</FUNCTION>
<FUNCTION>
<NAME>sql_condition_negate</NAME>
<RETURNS>sql_condition *</RETURNS>
sql_condition *cond
</FUNCTION>
<FUNCTION>
<NAME>sql_order_field_build</NAME>
<RETURNS>sql_order_field *</RETURNS>
GList * name, sql_ordertype order_type
</FUNCTION>
<FUNCTION>
<NAME>param_spec_build</NAME>
<RETURNS>param_spec *</RETURNS>
param_spec_type type, char *content
</FUNCTION>
<FUNCTION>
<NAME>param_spec_build_simple</NAME>
<RETURNS>GList *</RETURNS>
char *content
</FUNCTION>
<MACRO>
<NAME>YY_NO_UNISTD_H</NAME>
#define YY_NO_UNISTD_H
</MACRO>
<TYPEDEF>
<NAME>sql_statement</NAME>
typedef struct sql_statement sql_statement;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_select_statement</NAME>
typedef struct sql_select_statement sql_select_statement;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_insert_statement</NAME>
typedef struct sql_insert_statement sql_insert_statement;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_update_statement</NAME>
typedef struct sql_update_statement sql_update_statement;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_delete_statement</NAME>
typedef struct sql_delete_statement sql_delete_statement;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_limit</NAME>
typedef struct sql_limit sql_limit;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_table</NAME>
typedef struct sql_table sql_table;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_where</NAME>
typedef struct sql_where sql_where;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_condition</NAME>
typedef struct sql_condition sql_condition;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_order_field</NAME>
typedef struct sql_order_field sql_order_field;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_field</NAME>
typedef struct sql_field sql_field;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_field_item</NAME>
typedef struct sql_field_item sql_field_item;
</TYPEDEF>
<TYPEDEF>
<NAME>param_spec</NAME>
typedef struct param_spec param_spec;
</TYPEDEF>
<TYPEDEF>
<NAME>sql_wherejoin</NAME>
typedef struct sql_wherejoin sql_wherejoin;
</TYPEDEF>
<ENUM>
<NAME>sql_statement_type</NAME>
typedef enum
{
    SQL_select,
    SQL_insert,
    SQL_delete,
    SQL_update
}
sql_statement_type;
</ENUM>
<STRUCT>
<NAME>sql_statement</NAME>
struct sql_statement
	{
	sql_statement_type type;
	char *full_query;
	void *statement;
	};
</STRUCT>
<STRUCT>
<NAME>sql_limit</NAME>
struct sql_limit
	{
		guint limit;
		guint offset;
	};
</STRUCT>
<STRUCT>
<NAME>sql_select_statement</NAME>
struct sql_select_statement
	{
	int distinct;
	GList *fields;					  /* list of sql_field */
	GList *from;					  /* list of sql_table */
	sql_where *where;
	GList *order;					  /* list of sql_order_field */
	GList *group;
	sql_limit *limit;
	};
</STRUCT>
<STRUCT>
<NAME>sql_insert_statement</NAME>
struct sql_insert_statement
	{
	sql_table *table;
	GList *fields;
	GList *values;
	};
</STRUCT>
<STRUCT>
<NAME>sql_update_statement</NAME>
struct sql_update_statement
	{
	sql_table *table;
	GList *set
	;
	sql_where *where;
	};
</STRUCT>
<STRUCT>
<NAME>sql_delete_statement</NAME>
struct sql_delete_statement
	{
	sql_table *table;
	sql_where *where;
	};
</STRUCT>
<ENUM>
<NAME>sql_field_type</NAME>
typedef enum
{
    SQL_name,
    SQL_equation,
    SQL_inlineselect,
    SQL_function
}
sql_field_type;
</ENUM>
<ENUM>
<NAME>sql_field_operator</NAME>
typedef enum
{
    SQL_plus,
    SQL_minus,
    SQL_times,
    SQL_div
}
sql_field_operator;
</ENUM>
<STRUCT>
<NAME>sql_field_item</NAME>
struct sql_field_item
	{
	sql_field_type type;

	union
		{
		GList *name;
		struct
			{
			sql_field_item *left;
			sql_field_item *right;
			sql_field_operator op;
			}
		equation;
		sql_select_statement *select;
		struct
			{
			gchar *funcname;
			GList *funcarglist;
			}
		function;
		} d;
	};
</STRUCT>
<STRUCT>
<NAME>sql_field</NAME>
struct sql_field
	{
	sql_field_item *item;
	char *as;
	GList *param_spec;
	};
</STRUCT>
<ENUM>
<NAME>param_spec_type</NAME>
typedef enum
{
    PARAM_name,
    PARAM_descr,
    PARAM_type,
    PARAM_isparam,
    PARAM_nullok
} param_spec_type;
</ENUM>
<STRUCT>
<NAME>param_spec</NAME>
struct param_spec
	{
	param_spec_type type;
	char *content;
	};
</STRUCT>
<ENUM>
<NAME>sql_table_type</NAME>
typedef enum
{
    SQL_simple,
    SQL_nestedselect,
    SQL_tablefunction
}
sql_table_type;
</ENUM>
<ENUM>
<NAME>sql_join_type</NAME>
typedef enum
{
    SQL_cross_join, 				  /* default */
    SQL_inner_join,
    SQL_left_join,
    SQL_right_join,
    SQL_full_join
}
sql_join_type;
</ENUM>
<STRUCT>
<NAME>sql_table</NAME>
struct sql_table
	{
	sql_table_type type;
	union
		{
		char *simple;
		sql_select_statement *select;
		struct
			{
			char *funcname; /* Takes ownership: freed in sql_destroy_table(). */
			GList *funcarglist;
			}
		function;
		}
	d;
</STRUCT>
<ENUM>
<NAME>sql_condition_operator</NAME>
typedef enum
{
    SQL_eq,
    SQL_is,
    SQL_in,
    SQL_like,
    SQL_between,
    SQL_gt,
    SQL_lt,
    SQL_geq,
    SQL_leq,
    SQL_diff,
    SQL_regexp,
    SQL_regexp_ci,
    SQL_not_regexp,
    SQL_not_regexp_ci,
    SQL_similar,
    SQL_not
}
sql_condition_operator;
</ENUM>
<STRUCT>
<NAME>sql_condition</NAME>
struct sql_condition
	{
	sql_condition_operator op;
	gboolean negated;

	union
		{
		struct
			{
			sql_field *left;
			sql_field *right;
			}
		pair;
		struct
			{
			sql_field *field;
			sql_field *lower;
			sql_field *upper;
			}
		between;
		}
	d;
</STRUCT>
<ENUM>
<NAME>sql_logic_operator</NAME>
typedef enum
{
    SQL_and,
    SQL_or
}
sql_logic_operator;
</ENUM>
<ENUM>
<NAME>sql_where_type</NAME>
typedef enum
{
    SQL_single,
    SQL_negated,
    SQL_pair
}
sql_where_type;
</ENUM>
<STRUCT>
<NAME>sql_where</NAME>
struct sql_where
	{
	sql_where_type type;

	union
		{
		sql_condition *single;
		sql_where *negated;
		struct
			{
			sql_where *left;
			sql_where *right;
			sql_logic_operator op;
			}
		pair;
		}
	d;
</STRUCT>
<ENUM>
<NAME>sql_ordertype</NAME>
typedef enum
{
    SQL_asc,
    SQL_desc
}
sql_ordertype;
</ENUM>
<STRUCT>
<NAME>sql_order_field</NAME>
struct sql_order_field
	{
	sql_ordertype order_type;
	GList *name;
	};
</STRUCT>
<STRUCT>
<NAME>sql_wherejoin</NAME>
struct sql_wherejoin
	{
	GList *leftfield;				  /* glist contains a string in data tag */
	GList *rightfield;			  /* glist is in table then field order */
	sql_condition_operator condopr;
	/* if left or right side is a constaint mark as true. ie. 'value' or 1234 */
	gboolean rightconstaint;
	gboolean leftconstaint;
	gboolean isajoin;				  /* If it is a join not a where statement */

	sql_where *orginalwhere;
	};
</STRUCT>
<FUNCTION>
<NAME>sql_display</NAME>
<RETURNS>int </RETURNS>
sql_statement * statement
</FUNCTION>
<FUNCTION>
<NAME>sql_destroy</NAME>
<RETURNS>int </RETURNS>
sql_statement * statement
</FUNCTION>
<FUNCTION>
<NAME>sql_stringify</NAME>
<RETURNS>char *</RETURNS>
sql_statement * statement
</FUNCTION>
<FUNCTION>
<NAME>sql_parse</NAME>
<RETURNS>sql_statement *</RETURNS>
const char *sql_statement
</FUNCTION>
<FUNCTION>
<NAME>sql_parse_with_error</NAME>
<RETURNS>sql_statement *</RETURNS>
const char *sql_statement, GError ** error
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_append_field</NAME>
<RETURNS>int </RETURNS>
sql_statement * statement, char *tablename,char *fieldname, char *as
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_append_tablejoin</NAME>
<RETURNS>int </RETURNS>
sql_statement * statement,char *lefttable, char *righttable,char *leftfield, char *rightfield
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_append_where</NAME>
<RETURNS>int </RETURNS>
sql_statement * statement, char *leftfield,char *rightfield, sql_logic_operator logicopr,sql_condition_operator condopr
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_get_fields</NAME>
<RETURNS>GList *</RETURNS>
sql_statement * statement
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_get_tables</NAME>
<RETURNS>GList *</RETURNS>
sql_statement * statement
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_free_tables</NAME>
<RETURNS>void </RETURNS>
GList * tables
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_free_fields</NAME>
<RETURNS>void </RETURNS>
GList * fields
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_get_first_table</NAME>
<RETURNS>char *</RETURNS>
sql_statement * statement
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_get_wherejoin</NAME>
<RETURNS>GList *</RETURNS>
sql_statement * statement
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_free_wherejoin</NAME>
<RETURNS>void </RETURNS>
GList ** wherelist
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_test_wherejoin</NAME>
<RETURNS>gint </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>sql_statement_get_wherejoin_components</NAME>
<RETURNS>void </RETURNS>
sql_wherejoin * wherejoin,char **table, char **field,char leftside
</FUNCTION>
<MACRO>
<NAME>L_SELECT</NAME>
#define L_SELECT 258
</MACRO>
<MACRO>
<NAME>L_FROM</NAME>
#define L_FROM 259
</MACRO>
<MACRO>
<NAME>L_WHERE</NAME>
#define L_WHERE 260
</MACRO>
<MACRO>
<NAME>L_AS</NAME>
#define L_AS 261
</MACRO>
<MACRO>
<NAME>L_ON</NAME>
#define L_ON 262
</MACRO>
<MACRO>
<NAME>L_ORDER</NAME>
#define L_ORDER 263
</MACRO>
<MACRO>
<NAME>L_BY</NAME>
#define L_BY 264
</MACRO>
<MACRO>
<NAME>L_ORDER_ASC</NAME>
#define L_ORDER_ASC 265
</MACRO>
<MACRO>
<NAME>L_ORDER_DSC</NAME>
#define L_ORDER_DSC 266
</MACRO>
<MACRO>
<NAME>L_DISTINCT</NAME>
#define L_DISTINCT 267
</MACRO>
<MACRO>
<NAME>L_BETWEEN</NAME>
#define L_BETWEEN 268
</MACRO>
<MACRO>
<NAME>L_IN</NAME>
#define L_IN 269
</MACRO>
<MACRO>
<NAME>L_GROUP</NAME>
#define L_GROUP 270
</MACRO>
<MACRO>
<NAME>L_INSERT</NAME>
#define L_INSERT 271
</MACRO>
<MACRO>
<NAME>L_INTO</NAME>
#define L_INTO 272
</MACRO>
<MACRO>
<NAME>L_VALUES</NAME>
#define L_VALUES 273
</MACRO>
<MACRO>
<NAME>L_UPDATE</NAME>
#define L_UPDATE 274
</MACRO>
<MACRO>
<NAME>L_SET</NAME>
#define L_SET 275
</MACRO>
<MACRO>
<NAME>L_DOT</NAME>
#define L_DOT 276
</MACRO>
<MACRO>
<NAME>L_COMMA</NAME>
#define L_COMMA 277
</MACRO>
<MACRO>
<NAME>L_NULL</NAME>
#define L_NULL 278
</MACRO>
<MACRO>
<NAME>L_LBRACKET</NAME>
#define L_LBRACKET 279
</MACRO>
<MACRO>
<NAME>L_RBRACKET</NAME>
#define L_RBRACKET 280
</MACRO>
<MACRO>
<NAME>L_IDENT</NAME>
#define L_IDENT 281
</MACRO>
<MACRO>
<NAME>L_NUM</NAME>
#define L_NUM 282
</MACRO>
<MACRO>
<NAME>L_INTEGER</NAME>
#define L_INTEGER 283
</MACRO>
<MACRO>
<NAME>L_EQ</NAME>
#define L_EQ 284
</MACRO>
<MACRO>
<NAME>L_IS</NAME>
#define L_IS 285
</MACRO>
<MACRO>
<NAME>L_LIKE</NAME>
#define L_LIKE 286
</MACRO>
<MACRO>
<NAME>L_GT</NAME>
#define L_GT 287
</MACRO>
<MACRO>
<NAME>L_LT</NAME>
#define L_LT 288
</MACRO>
<MACRO>
<NAME>L_GEQ</NAME>
#define L_GEQ 289
</MACRO>
<MACRO>
<NAME>L_LEQ</NAME>
#define L_LEQ 290
</MACRO>
<MACRO>
<NAME>L_DIFF</NAME>
#define L_DIFF 291
</MACRO>
<MACRO>
<NAME>L_REGEXP</NAME>
#define L_REGEXP 292
</MACRO>
<MACRO>
<NAME>L_REGEXP_CI</NAME>
#define L_REGEXP_CI 293
</MACRO>
<MACRO>
<NAME>L_NOTREGEXP</NAME>
#define L_NOTREGEXP 294
</MACRO>
<MACRO>
<NAME>L_NOTREGEXP_CI</NAME>
#define L_NOTREGEXP_CI 295
</MACRO>
<MACRO>
<NAME>L_SIMILAR</NAME>
#define L_SIMILAR 296
</MACRO>
<MACRO>
<NAME>L_NOT</NAME>
#define L_NOT 297
</MACRO>
<MACRO>
<NAME>L_AND</NAME>
#define L_AND 298
</MACRO>
<MACRO>
<NAME>L_OR</NAME>
#define L_OR 299
</MACRO>
<MACRO>
<NAME>L_MINUS</NAME>
#define L_MINUS 300
</MACRO>
<MACRO>
<NAME>L_PLUS</NAME>
#define L_PLUS 301
</MACRO>
<MACRO>
<NAME>L_TIMES</NAME>
#define L_TIMES 302
</MACRO>
<MACRO>
<NAME>L_DIV</NAME>
#define L_DIV 303
</MACRO>
<MACRO>
<NAME>L_STRING</NAME>
#define L_STRING 304
</MACRO>
<MACRO>
<NAME>L_TEXTUAL</NAME>
#define L_TEXTUAL 305
</MACRO>
<MACRO>
<NAME>L_DELETE</NAME>
#define L_DELETE 306
</MACRO>
<MACRO>
<NAME>L_JOIN</NAME>
#define L_JOIN 307
</MACRO>
<MACRO>
<NAME>L_INNER</NAME>
#define L_INNER 308
</MACRO>
<MACRO>
<NAME>L_LEFT</NAME>
#define L_LEFT 309
</MACRO>
<MACRO>
<NAME>L_RIGHT</NAME>
#define L_RIGHT 310
</MACRO>
<MACRO>
<NAME>L_FULL</NAME>
#define L_FULL 311
</MACRO>
<MACRO>
<NAME>L_OUTER</NAME>
#define L_OUTER 312
</MACRO>
<MACRO>
<NAME>L_LSBRACKET</NAME>
#define L_LSBRACKET 313
</MACRO>
<MACRO>
<NAME>L_RSBRACKET</NAME>
#define L_RSBRACKET 314
</MACRO>
<MACRO>
<NAME>L_PNAME</NAME>
#define L_PNAME 315
</MACRO>
<MACRO>
<NAME>L_PTYPE</NAME>
#define L_PTYPE 316
</MACRO>
<MACRO>
<NAME>L_PISPARAM</NAME>
#define L_PISPARAM 317
</MACRO>
<MACRO>
<NAME>L_PDESCR</NAME>
#define L_PDESCR 318
</MACRO>
<MACRO>
<NAME>L_PNULLOK</NAME>
#define L_PNULLOK 319
</MACRO>
<MACRO>
<NAME>L_UNSPECVAL</NAME>
#define L_UNSPECVAL 320
</MACRO>
<MACRO>
<NAME>L_SIMPLE_PARAM</NAME>
#define L_SIMPLE_PARAM 321
</MACRO>
<MACRO>
<NAME>L_LIMIT</NAME>
#define L_LIMIT 322
</MACRO>
<MACRO>
<NAME>L_OFFSET</NAME>
#define L_OFFSET 323
</MACRO>
<MACRO>
<NAME>L_LIMIT_OFFSET</NAME>
#define L_LIMIT_OFFSET 324
</MACRO>
<MACRO>
<NAME>yystype</NAME>
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
</MACRO>
<MACRO>
<NAME>YYSTYPE_IS_DECLARED</NAME>
# define YYSTYPE_IS_DECLARED 1
</MACRO>
<MACRO>
<NAME>YYSTYPE_IS_TRIVIAL</NAME>
# define YYSTYPE_IS_TRIVIAL 1
</MACRO>
<VARIABLE>
<NAME>sqllval</NAME>
extern YYSTYPE sqllval;
</VARIABLE>
<MACRO>
<NAME>GDA_XSLT_FUNC_GETVALUE</NAME>
#define GDA_XSLT_FUNC_GETVALUE       "getvalue"
</MACRO>
<MACRO>
<NAME>GDA_XSLT_FUNC_GETNODESET</NAME>
#define GDA_XSLT_FUNC_GETNODESET     "getnodeset"
</MACRO>
<MACRO>
<NAME>GDA_XSLT_FUNC_CHECKIF</NAME>
#define GDA_XSLT_FUNC_CHECKIF        "checkif"
</MACRO>
<MACRO>
<NAME>GDA_XSLT_ELEM_SECTION</NAME>
#define GDA_XSLT_ELEM_SECTION        "section"
</MACRO>
<MACRO>
<NAME>GDA_XSLT_ELEM_INTERNAL_QUERY</NAME>
#define GDA_XSLT_ELEM_INTERNAL_QUERY      "query"
</MACRO>
<MACRO>
<NAME>GDA_XSLT_ELEM_INTERNAL_TEMPLATE</NAME>
#define GDA_XSLT_ELEM_INTERNAL_TEMPLATE   "template"
</MACRO>
<STRUCT>
<NAME>GdaXsltIntCont</NAME>
struct _GdaXsltIntCont
{
	int         init;
	GHashTable *result_sets;
};
</STRUCT>
<STRUCT>
<NAME>GdaXsltIntCont</NAME>
</STRUCT>
<FUNCTION>
<NAME>gda_xslt_extension_init</NAME>
<RETURNS>void *</RETURNS>
xsltTransformContextPtr ctxt,const xmlChar * URI
</FUNCTION>
<FUNCTION>
<NAME>gda_xslt_extension_shutdown</NAME>
<RETURNS>void </RETURNS>
xsltTransformContextPtr ctxt,const xmlChar * URI, void *data
</FUNCTION>
<FUNCTION>
<NAME>gda_xslt_bk_section</NAME>
<RETURNS>int </RETURNS>
GdaXsltExCont * exec, GdaXsltIntCont * pdata,xsltTransformContextPtr ctxt, xmlNodePtr node,xmlNodePtr inst, xsltStylePreCompPtr comp
</FUNCTION>
<FUNCTION>
<NAME>gda_xslt_bk_fun_getvalue</NAME>
<RETURNS>xmlXPathObjectPtr </RETURNS>
xmlChar * set, xmlChar * name,GdaXsltExCont * exec,GdaXsltIntCont * pdata
</FUNCTION>
<FUNCTION>
<NAME>gda_xslt_bk_fun_getnodeset</NAME>
<RETURNS>xmlXPathObjectPtr </RETURNS>
xmlChar * set,GdaXsltExCont * exec,GdaXsltIntCont * pdata
</FUNCTION>
<FUNCTION>
<NAME>gda_xslt_bk_fun_checkif</NAME>
<RETURNS>xmlXPathObjectPtr </RETURNS>
xmlChar * setname,xmlChar * sql_condition,GdaXsltExCont * exec,GdaXsltIntCont * pdata
</FUNCTION>
<MACRO>
<NAME>GDA_XSLT_EXTENSION_URI</NAME>
#define GDA_XSLT_EXTENSION_URI "http://www.gnome-db.org/ns/gda-sql-ext"
</MACRO>
<STRUCT>
<NAME>GdaXsltExCont</NAME>
struct _GdaXsltExCont
{
	int init;
	GdaConnection *cnc;
	GdaDict *gda_dict;
	GHashTable *query_hash;
	GError *error;
};
</STRUCT>
<STRUCT>
<NAME>GdaXsltExCont</NAME>
</STRUCT>
<FUNCTION>
<NAME>gda_xslt_register</NAME>
<RETURNS>void           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xslt_set_execution_context</NAME>
<RETURNS>void           </RETURNS>
xsltTransformContextPtr tcxt,GdaXsltExCont * exec
</FUNCTION>
<FUNCTION>
<NAME>gda_xslt_create_context_simple</NAME>
<RETURNS>GdaXsltExCont *</RETURNS>
GdaConnection * cnc,GError ** error
</FUNCTION>
<FUNCTION>
<NAME>gda_xslt_finalize_context</NAME>
<RETURNS>int            </RETURNS>
GdaXsltExCont * ctx
</FUNCTION>
<MACRO>
<NAME>GDA_BDB_PROVIDER_ID</NAME>
#define GDA_BDB_PROVIDER_ID          "GDA Berkeley DB provider"
</MACRO>
<MACRO>
<NAME>BDB_VERSION</NAME>
#define BDB_VERSION  (10000*DB_VERSION_MAJOR+100*DB_VERSION_MINOR+DB_VERSION_PATCH)
</MACRO>
<FUNCTION>
<NAME>gda_bdb_make_error</NAME>
<RETURNS>GdaConnectionEvent *</RETURNS>
int ret
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_BDB_PROVIDER</NAME>
#define GDA_TYPE_BDB_PROVIDER            (gda_bdb_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_BDB_PROVIDER</NAME>
#define GDA_BDB_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_BDB_PROVIDER, GdaBdbProvider))
</MACRO>
<MACRO>
<NAME>GDA_BDB_PROVIDER_CLASS</NAME>
#define GDA_BDB_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_BDB_PROVIDER, GdaBdbProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_BDB_PROVIDER</NAME>
#define GDA_IS_BDB_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_BDB_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_BDB_PROVIDER_CLASS</NAME>
#define GDA_IS_BDB_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_BDB_PROVIDER))
</MACRO>
<MACRO>
<NAME>PARENT_TYPE</NAME>
#define PARENT_TYPE 			GDA_TYPE_VPROVIDER_DATA_MODEL
</MACRO>
<MACRO>
<NAME>OBJECT_DATA_BDB_HANDLE</NAME>
#define OBJECT_DATA_BDB_HANDLE 		"GDA_BDB_BDBHandle"
</MACRO>
<STRUCT>
<NAME>GdaBdbProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaBdbProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaBdbProvider</NAME>
struct _GdaBdbProvider {
	GdaVproviderDataModel provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaBdbProviderClass</NAME>
struct _GdaBdbProviderClass {
	GdaVproviderDataModelClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaBdbConnectionData</NAME>
typedef struct {
	gchar *dbname;
} GdaBdbConnectionData;
</STRUCT>
<FUNCTION>
<NAME>gda_bdb_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_bdb_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdaMdbConnection</NAME>
typedef struct {
	GdaConnection  *cnc;
	MdbHandle      *mdb;
	gchar          *server_version;
} GdaMdbConnection;
</STRUCT>
<MACRO>
<NAME>PARENT_TYPE</NAME>
#define PARENT_TYPE GDA_TYPE_VPROVIDER_DATA_MODEL
</MACRO>
<MACRO>
<NAME>GDA_TYPE_MDB_PROVIDER</NAME>
#define GDA_TYPE_MDB_PROVIDER            (gda_mdb_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_MDB_PROVIDER</NAME>
#define GDA_MDB_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_MDB_PROVIDER, GdaMdbProvider))
</MACRO>
<MACRO>
<NAME>GDA_MDB_PROVIDER_CLASS</NAME>
#define GDA_MDB_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_MDB_PROVIDER, GdaMdbProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_MDB_PROVIDER</NAME>
#define GDA_IS_MDB_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_MDB_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_MDB_PROVIDER_CLASS</NAME>
#define GDA_IS_MDB_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_MDB_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GdaMdbProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMdbProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMdbProvider</NAME>
struct _GdaMdbProvider {
	GdaVproviderDataModel provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaMdbProviderClass</NAME>
struct _GdaMdbProviderClass {
	GdaVproviderDataModelClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_mdb_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_mdb_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>LDAP_DEPRECATED</NAME>
#define LDAP_DEPRECATED 1
</MACRO>
<MACRO>
<NAME>GDA_LDAP_PROVIDER_ID</NAME>
#define GDA_LDAP_PROVIDER_ID          "GDA LDAP provider"
</MACRO>
<FUNCTION>
<NAME>gda_ldap_make_error</NAME>
<RETURNS>GdaConnectionEvent     *</RETURNS>
LDAP *handle
</FUNCTION>
<FUNCTION>
<NAME>gda_ldap_value_to_sql_string</NAME>
<RETURNS>gchar        *</RETURNS>
GValue *value
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_LDAP_PROVIDER</NAME>
#define GDA_TYPE_LDAP_PROVIDER            (gda_ldap_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_LDAP_PROVIDER</NAME>
#define GDA_LDAP_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_LDAP_PROVIDER, GdaLdapProvider))
</MACRO>
<MACRO>
<NAME>GDA_LDAP_PROVIDER_CLASS</NAME>
#define GDA_LDAP_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_LDAP_PROVIDER, GdaLdapProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_LDAP_PROVIDER</NAME>
#define GDA_IS_LDAP_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_LDAP_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_LDAP_PROVIDER_CLASS</NAME>
#define GDA_IS_LDAP_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_LDAP_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GdaLdapProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaLdapProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaLdapProvider</NAME>
struct _GdaLdapProvider {
	GdaServerProvider provider;
	int rc;   /*return code*/
	gchar *t_binddn; 
};
</STRUCT>
<STRUCT>
<NAME>GdaLdapProviderClass</NAME>
struct _GdaLdapProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_ldap_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_ldap_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_LDAP_RECORDSET</NAME>
#define GDA_TYPE_LDAP_RECORDSET            (gda_ldap_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_LDAP_RECORDSET</NAME>
#define GDA_LDAP_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_LDAP_RECORDSET, GdaLdapRecordset))
</MACRO>
<MACRO>
<NAME>GDA_LDAP_RECORDSET_CLASS</NAME>
#define GDA_LDAP_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_LDAP_RECORDSET, GdaLdapRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_LDAP_RECORDSET</NAME>
#define GDA_IS_LDAP_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_LDAP_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_LDAP_RECORDSET_CLASS</NAME>
#define GDA_IS_LDAP_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_LDAP_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaLdapRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaLdapRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaLdapRecordset</NAME>
struct _GdaLdapRecordset {
	GdaDataModelRow model;
	GPtrArray *rows;
	GdaConnection *cnc;
	LDAPMessage *ldap_res;
};
</STRUCT>
<STRUCT>
<NAME>GdaLdapRecordsetClass</NAME>
struct _GdaLdapRecordsetClass {
	GdaDataModelRowClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_ldap_recordset_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_ldap_recordset_new</NAME>
<RETURNS>GdaLdapRecordset *</RETURNS>
GdaConnection *cnc, LDAPMessage *ldap_res
</FUNCTION>
<MACRO>
<NAME>GDA_MSQL_PROVIDER_ID</NAME>
#define GDA_MSQL_PROVIDER_ID "GDA Hughes Technologies mSQL provider"
</MACRO>
<FUNCTION>
<NAME>gda_msql_make_error</NAME>
<RETURNS>GdaConnectionEvent     *</RETURNS>
int sock
</FUNCTION>
<FUNCTION>
<NAME>gda_msql_type_to_gda</NAME>
<RETURNS>GType  </RETURNS>
int msql_type
</FUNCTION>
<FUNCTION>
<NAME>gda_msql_value_to_sql_string</NAME>
<RETURNS>gchar        *</RETURNS>
GValue *val
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_MSQL_RECORDSET</NAME>
#define GDA_TYPE_MSQL_RECORDSET \
  (gda_msql_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_MSQL_RECORDSET</NAME>
#define GDA_MSQL_RECORDSET(o) \
  (G_TYPE_CHECK_INSTANCE_CAST(o,GDA_TYPE_MSQL_RECORDSET,GdaMsqlRecordset))
</MACRO>
<MACRO>
<NAME>GDA_MSQL_RECORDSET_CLASS</NAME>
#define GDA_MSQL_RECORDSET_CLASS(cl) \
  (G_TYPE_CHECK_CLASS_CAST(cl,GDA_TYPE_MSQL_RECORDSET,GdaMsqlRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_MSQL_RECORDSET</NAME>
#define GDA_IS_MSQL_RECORDSET(o) \
  (G_TYPE_CHECK_INSTANCE_TYPE(o,GDA_TYPE_MSQL_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_MSQL_RECORDSET_CLASS</NAME>
#define GDA_IS_MSQL_RECORDSET_CLASS(cl) \
  (G_TYPE_CHECK_CLASS_TYPE((cl),GDA_TYPE_MSQL_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaMsqlRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMsqlRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMsqlRecordset</NAME>
struct _GdaMsqlRecordset {
	GdaDataModelRow model;
	GPtrArray       *rows;
	GdaConnection   *cnc;
	m_result        *res;
	int              sock;
	int              n_rows;
};
</STRUCT>
<STRUCT>
<NAME>GdaMsqlRecordsetClass</NAME>
struct _GdaMsqlRecordsetClass {
	GdaDataModelRowClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_msql_recordset_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_msql_recordset_new</NAME>
<RETURNS>GdaMsqlRecordset *</RETURNS>
GdaConnection *cnc,m_result *res,int sock,int n_rows
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_MSQL_PROVIDER</NAME>
#define GDA_TYPE_MSQL_PROVIDER (gda_msql_provider_get_type()) 
</MACRO>
<MACRO>
<NAME>GDA_MSQL_PROVIDER</NAME>
#define GDA_MSQL_PROVIDER(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST(obj,GDA_TYPE_MSQL_PROVIDER,GdaMsqlProvider))
</MACRO>
<MACRO>
<NAME>GDA_MSQL_PROVIDER_CLASS</NAME>
#define GDA_MSQL_PROVIDER_CLASS(cl) \
  (G_TYPE_CHECK_CLASS_CAST(cl,GDA_TYPE_MSQL_PROVIDER,GdaMsqlProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_MSQL_PROVIDER</NAME>
#define GDA_IS_MSQL_PROVIDER(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE(obj,GDA_TYPE_MSQL_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_MSQL_PROVIDER_CLASS</NAME>
#define GDA_IS_MSQL_PROVIDER_CLASS(cl) \
  (G_TYPE_CHECK_CLASS_TYPE((cl),GDA_TYPE_MSQL_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GdaMsqlProvider</NAME>
struct _GdaMsqlProvider {
  GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaMsqlProviderClass</NAME>
struct _GdaMsqlProviderClass {
  GdaServerProviderClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaMsqlProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMsqlProviderClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gda_msql_provider_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_msql_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>WIN32_LEAN_AND_MEAN</NAME>
#  define WIN32_LEAN_AND_MEAN
</MACRO>
<MACRO>
<NAME>GDA_ODBC_PROVIDER_ID</NAME>
#define GDA_ODBC_PROVIDER_ID "GDA ODBC Provider"
</MACRO>
<FUNCTION>
<NAME>gda_odbc_emit_error</NAME>
<RETURNS>void </RETURNS>
 GdaConnection *cnc, SQLHANDLE env, SQLHANDLE con, SQLHANDLE stmt
</FUNCTION>
<FUNCTION>
<NAME>odbc_to_g_type</NAME>
<RETURNS>GType </RETURNS>
 int odbc_type
</FUNCTION>
<MACRO>
<NAME>WIN32_LEAN_AND_MEAN</NAME>
#  define WIN32_LEAN_AND_MEAN
</MACRO>
<MACRO>
<NAME>GDA_TYPE_ODBC_PROVIDER</NAME>
#define GDA_TYPE_ODBC_PROVIDER            (gda_odbc_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_ODBC_PROVIDER</NAME>
#define GDA_ODBC_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ODBC_PROVIDER, GdaOdbcProvider))
</MACRO>
<MACRO>
<NAME>GDA_ODBC_PROVIDER_CLASS</NAME>
#define GDA_ODBC_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_ODBC_PROVIDER, GdaOdbcProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_ODBC_PROVIDER</NAME>
#define GDA_IS_ODBC_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ODBC_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_ODBC_PROVIDER_CLASS</NAME>
#define GDA_IS_ODBC_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_ODBC_PROVIDER))
</MACRO>
<MACRO>
<NAME>PARENT_TYPE</NAME>
#define PARENT_TYPE GDA_TYPE_SERVER_PROVIDER
</MACRO>
<MACRO>
<NAME>OBJECT_DATA_ODBC_HANDLE</NAME>
#define OBJECT_DATA_ODBC_HANDLE "GDA_ODBC_ODBCHandle"
</MACRO>
<STRUCT>
<NAME>GdaOdbcProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOdbcProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOdbcProvider</NAME>
struct _GdaOdbcProvider {
	GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaOdbcProviderClass</NAME>
struct _GdaOdbcProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaOdbcConnectionData</NAME>
typedef struct {
	SQLHANDLE henv;
        SQLHANDLE hdbc;
	SQLHANDLE hstmt;		/* used for metadata calls only */
	SQLCHAR version[ 128 ];
	SQLCHAR db[ 256 ];
} GdaOdbcConnectionData;
</STRUCT>
<FUNCTION>
<NAME>gda_odbc_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_odbc_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_ODBC_RECORDSET</NAME>
#define GDA_TYPE_ODBC_RECORDSET            (gda_odbc_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_ODBC_RECORDSET</NAME>
#define GDA_ODBC_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ODBC_RECORDSET, GdaOdbcRecordset))
</MACRO>
<MACRO>
<NAME>GDA_ODBC_RECORDSET_CLASS</NAME>
#define GDA_ODBC_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_ODBC_RECORDSET, GdaOdbcRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_ODBC_RECORDSET</NAME>
#define GDA_IS_ODBC_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ODBC_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_ODBC_RECORDSET_CLASS</NAME>
#define GDA_IS_ODBC_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_ODBC_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaOdbcRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOdbcRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOdbcRecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOdbcRecordset</NAME>
struct _GdaOdbcRecordset {
	GdaDataModelHash model;
	GdaOdbcRecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaOdbcRecordsetClass</NAME>
struct _GdaOdbcRecordsetClass {
	GdaDataModelHashClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_odbc_recordset_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_odbc_recordset_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaConnection *cnc, SQLHANDLE stmt
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_render_CREATE_DB</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_render_DROP_DB</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_render_CREATE_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_render_DROP_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_render_RENAME_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_render_ADD_COLUMN</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_render_DROP_COLUMN</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_render_CREATE_INDEX</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_render_DROP_INDEX</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_MYSQL_RECORDSET</NAME>
#define GDA_TYPE_MYSQL_RECORDSET            (gda_mysql_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_MYSQL_RECORDSET</NAME>
#define GDA_MYSQL_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_MYSQL_RECORDSET, GdaMysqlRecordset))
</MACRO>
<MACRO>
<NAME>GDA_MYSQL_RECORDSET_CLASS</NAME>
#define GDA_MYSQL_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_MYSQL_RECORDSET, GdaMysqlRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_MYSQL_RECORDSET</NAME>
#define GDA_IS_MYSQL_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_MYSQL_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_MYSQL_RECORDSET_CLASS</NAME>
#define GDA_IS_MYSQL_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_MYSQL_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaMysqlRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMysqlRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMysqlRecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMysqlRecordset</NAME>
struct _GdaMysqlRecordset {
	GdaDataModelArray         model;
	GdaMysqlRecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaMysqlRecordsetClass</NAME>
struct _GdaMysqlRecordsetClass {
	GdaDataModelArrayClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_mysql_recordset_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_recordset_new</NAME>
<RETURNS>GdaMysqlRecordset *</RETURNS>
GdaConnection *cnc, MYSQL_RES *mysql_res, MYSQL *mysql
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_MYSQL_PROVIDER</NAME>
#define GDA_TYPE_MYSQL_PROVIDER            (gda_mysql_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_MYSQL_PROVIDER</NAME>
#define GDA_MYSQL_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_MYSQL_PROVIDER, GdaMysqlProvider))
</MACRO>
<MACRO>
<NAME>GDA_MYSQL_PROVIDER_CLASS</NAME>
#define GDA_MYSQL_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_MYSQL_PROVIDER, GdaMysqlProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_MYSQL_PROVIDER</NAME>
#define GDA_IS_MYSQL_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_MYSQL_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_MYSQL_PROVIDER_CLASS</NAME>
#define GDA_IS_MYSQL_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_MYSQL_PROVIDER))
</MACRO>
<MACRO>
<NAME>OBJECT_DATA_MYSQL_HANDLE</NAME>
#define OBJECT_DATA_MYSQL_HANDLE "GDA_Mysql_MysqlHandle"
</MACRO>
<STRUCT>
<NAME>GdaMysqlProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMysqlProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaMysqlProvider</NAME>
struct _GdaMysqlProvider {
	GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaMysqlProviderClass</NAME>
struct _GdaMysqlProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_mysql_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_provider_value_to_sql_string</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider,GdaConnection *cnc,GValue *from
</FUNCTION>
<MACRO>
<NAME>GDA_MYSQL_PROVIDER_ID</NAME>
#define GDA_MYSQL_PROVIDER_ID          "GDA MySQL provider"
</MACRO>
<FUNCTION>
<NAME>gda_mysql_make_error</NAME>
<RETURNS>GdaConnectionEvent     *</RETURNS>
MYSQL *handle
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_type_to_gda</NAME>
<RETURNS>GType                   </RETURNS>
enum enum_field_types mysql_type, gboolean is_unsigned
</FUNCTION>
<FUNCTION>
<NAME>gda_mysql_real_query_wrap</NAME>
<RETURNS>int                     </RETURNS>
GdaConnection *cnc, MYSQL *mysql,const char *stmt_str, unsigned long length
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_XBASE_PROVIDER</NAME>
#define GDA_TYPE_XBASE_PROVIDER            (gda_xbase_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_XBASE_PROVIDER</NAME>
#define GDA_XBASE_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_XBASE_PROVIDER, GdaXbaseProvider))
</MACRO>
<MACRO>
<NAME>GDA_XBASE_PROVIDER_CLASS</NAME>
#define GDA_XBASE_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_XBASE_PROVIDER, GdaXbaseProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_XBASE_PROVIDER</NAME>
#define GDA_IS_XBASE_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_XBASE_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_XBASE_PROVIDER_CLASS</NAME>
#define GDA_IS_XBASE_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_XBASE_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GdaXbaseProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXbaseProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaXbaseProvider</NAME>
struct _GdaXbaseProvider {
	GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaXbaseProviderClass</NAME>
struct _GdaXbaseProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_xbase_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xbase_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_xbase_provider_make_error</NAME>
<RETURNS>void               </RETURNS>
GdaConnection *cnc
</FUNCTION>
<STRUCT>
<NAME>GdaXbaseDatabase</NAME>
</STRUCT>
<FUNCTION>
<NAME>gda_xbase_database_open</NAME>
<RETURNS>GdaXbaseDatabase *</RETURNS>
GdaConnection *cnc, const gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gda_xbase_database_create</NAME>
<RETURNS>GdaXbaseDatabase *</RETURNS>
GdaConnection *cnc, const gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gda_xbase_database_close</NAME>
<RETURNS>void              </RETURNS>
GdaXbaseDatabase *xdb
</FUNCTION>
<FUNCTION>
<NAME>gda_xbase_database_delete_all_records</NAME>
<RETURNS>gboolean          </RETURNS>
GdaXbaseDatabase *xdb
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_POSTGRES_HANDLER_BIN</NAME>
#define GDA_TYPE_POSTGRES_HANDLER_BIN          (gda_postgres_handler_bin_get_type())
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_HANDLER_BIN</NAME>
#define GDA_POSTGRES_HANDLER_BIN(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gda_postgres_handler_bin_get_type(), GdaPostgresHandlerBin)
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_HANDLER_BIN_CLASS</NAME>
#define GDA_POSTGRES_HANDLER_BIN_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gda_postgres_handler_bin_get_type (), GdaPostgresHandlerBinClass)
</MACRO>
<MACRO>
<NAME>GDA_IS_POSTGRES_HANDLER_BIN</NAME>
#define GDA_IS_POSTGRES_HANDLER_BIN(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gda_postgres_handler_bin_get_type ())
</MACRO>
<STRUCT>
<NAME>GdaPostgresHandlerBin</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresHandlerBinClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresHandlerBinPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresHandlerBin</NAME>
struct _GdaPostgresHandlerBin
{
	GdaObject           object;

	GdaPostgresHandlerBinPriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaPostgresHandlerBinClass</NAME>
struct _GdaPostgresHandlerBinClass
{
	GdaObjectClass      parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_postgres_handler_bin_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_handler_bin_new</NAME>
<RETURNS>GdaDataHandler *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_render_CREATE_DB</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_render_DROP_DB</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_render_CREATE_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_render_RENAME_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_render_DROP_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_render_ADD_COLUMN</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_render_DROP_COLUMN</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_render_CREATE_INDEX</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_render_DROP_INDEX</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_POSTGRES_RECORDSET</NAME>
#define GDA_TYPE_POSTGRES_RECORDSET            (gda_postgres_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_RECORDSET</NAME>
#define GDA_POSTGRES_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_POSTGRES_RECORDSET, GdaPostgresRecordset))
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_RECORDSET_CLASS</NAME>
#define GDA_POSTGRES_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_POSTGRES_RECORDSET, GdaPostgresRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_POSTGRES_RECORDSET</NAME>
#define GDA_IS_POSTGRES_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_POSTGRES_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_POSTGRES_RECORDSET_CLASS</NAME>
#define GDA_IS_POSTGRES_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_POSTGRES_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaPostgresRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresRecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresRecordset</NAME>
struct _GdaPostgresRecordset {
	GdaDataModelHash model;
	GdaPostgresRecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaPostgresRecordsetClass</NAME>
struct _GdaPostgresRecordsetClass {
	GdaDataModelHashClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_postgres_recordset_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_recordset_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaConnection *cnc, PGresult *pgres
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_recordset_get_pgresult</NAME>
<RETURNS>PGresult     *</RETURNS>
GdaPostgresRecordset *recset
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_POSTGRES_PROVIDER</NAME>
#define GDA_TYPE_POSTGRES_PROVIDER            (gda_postgres_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_PROVIDER</NAME>
#define GDA_POSTGRES_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_POSTGRES_PROVIDER, GdaPostgresProvider))
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_PROVIDER_CLASS</NAME>
#define GDA_POSTGRES_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_POSTGRES_PROVIDER, GdaPostgresProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_POSTGRES_PROVIDER</NAME>
#define GDA_IS_POSTGRES_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_POSTGRES_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_POSTGRES_PROVIDER_CLASS</NAME>
#define GDA_IS_POSTGRES_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_POSTGRES_PROVIDER))
</MACRO>
<MACRO>
<NAME>PARENT_TYPE</NAME>
#define PARENT_TYPE GDA_TYPE_SERVER_PROVIDER
</MACRO>
<MACRO>
<NAME>OBJECT_DATA_POSTGRES_HANDLE</NAME>
#define OBJECT_DATA_POSTGRES_HANDLE "GDA_Postgres_PostgresHandle"
</MACRO>
<STRUCT>
<NAME>GdaPostgresProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresProvider</NAME>
struct _GdaPostgresProvider {
	GdaServerProvider  provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaPostgresProviderClass</NAME>
struct _GdaPostgresProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaPostgresTypeOid</NAME>
typedef struct {
	gchar              *name;
	Oid                 oid;
	GType               type;
	gchar              *comments;
	gchar              *owner;
} GdaPostgresTypeOid;
</STRUCT>
<STRUCT>
<NAME>GdaPostgresConnectionData</NAME>
typedef struct {
	GdaConnection      *cnc;
	PGconn             *pconn;
	gint                ntypes;
	GdaPostgresTypeOid *type_data;
	GHashTable         *h_table;

	/* Version of the backend to which we are connected */
	gchar              *version;
	gfloat              version_float;

	/* Internal data types not returned */
	gchar              *avoid_types;
	gchar              *avoid_types_oids;
	gchar              *any_type_oid; /* oid for the 'any' data type, used to fetch aggregates and functions */

	/* OID of the last inserted tuple */
	Oid                 last_insert_id;

	/* Cursor usage */
	gboolean            use_cursor;
	gint                chunk_size;
} GdaPostgresConnectionData;
</STRUCT>
<FUNCTION>
<NAME>gda_postgres_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_POSTGRES_PROVIDER_ID</NAME>
#define GDA_POSTGRES_PROVIDER_ID "GDA PostgreSQL provider"
</MACRO>
<FUNCTION>
<NAME>gda_postgres_make_error</NAME>
<RETURNS>GdaConnectionEvent *</RETURNS>
GdaConnection *cnc, PGconn *pconn, PGresult *pg_res
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_set_value</NAME>
<RETURNS>void </RETURNS>
GdaConnection *cnc,GValue *value,GType type,const gchar *thevalue,gboolean isNull,gint length
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_type_oid_to_gda</NAME>
<RETURNS>GType </RETURNS>
GdaPostgresTypeOid *type_data,gint ntypes,Oid postgres_type
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_type_name_to_gda</NAME>
<RETURNS>GType </RETURNS>
GHashTable *h_table,const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gda_data_type_to_string</NAME>
<RETURNS>const gchar *</RETURNS>
GType type
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_value_to_sql_string</NAME>
<RETURNS>gchar *</RETURNS>
GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_check_transaction_started</NAME>
<RETURNS>gboolean </RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_PQexec_wrap</NAME>
<RETURNS>PGresult *</RETURNS>
GdaConnection *cnc, PGconn *conn, const char *query
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_recordset_describe_column</NAME>
<RETURNS>void </RETURNS>
GdaDataModel *model, GdaConnection *cnc, PGresult *pg_res,GdaPostgresTypeOid *type_data, gint ntypes, const gchar *table_name,gint col
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_guess_table_name</NAME>
<RETURNS>gchar *</RETURNS>
GdaConnection *cnc, PGresult *pg_res
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_get_column_types</NAME>
<RETURNS>GType *</RETURNS>
PGresult *pg_res, GdaPostgresTypeOid *type_data, gint ntypes
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_POSTGRES_BLOB_OP</NAME>
#define GDA_TYPE_POSTGRES_BLOB_OP            (gda_postgres_blob_op_get_type())
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_BLOB_OP</NAME>
#define GDA_POSTGRES_BLOB_OP(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_POSTGRES_BLOB_OP, GdaPostgresBlobOp))
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_BLOB_OP_CLASS</NAME>
#define GDA_POSTGRES_BLOB_OP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_POSTGRES_BLOB_OP, GdaPostgresBlobOpClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_POSTGRES_BLOB_OP</NAME>
#define GDA_IS_POSTGRES_BLOB_OP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_POSTGRES_BLOB_OP))
</MACRO>
<MACRO>
<NAME>GDA_IS_POSTGRES_BLOB_OP_CLASS</NAME>
#define GDA_IS_POSTGRES_BLOB_OP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_POSTGRES_BLOB_OP))
</MACRO>
<STRUCT>
<NAME>GdaPostgresBlobOp</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresBlobOpClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresBlobOpPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresBlobOp</NAME>
struct _GdaPostgresBlobOp {
	GdaBlobOp                 parent;
	GdaPostgresBlobOpPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaPostgresBlobOpClass</NAME>
struct _GdaPostgresBlobOpClass {
	GdaBlobOpClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_postgres_blob_op_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_blob_op_new</NAME>
<RETURNS>GdaBlobOp    *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_blob_op_new_with_id</NAME>
<RETURNS>GdaBlobOp    *</RETURNS>
GdaConnection *cnc, const gchar *sql_id
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_blob_op_declare_blob</NAME>
<RETURNS>gboolean      </RETURNS>
GdaPostgresBlobOp *pgop
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_blob_op_get_id</NAME>
<RETURNS>gchar        *</RETURNS>
GdaPostgresBlobOp *pgop
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_blob_op_set_id</NAME>
<RETURNS>void          </RETURNS>
GdaPostgresBlobOp *pgop, const gchar *sql_id
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_POSTGRES_CURSOR_RECORDSET</NAME>
#define GDA_TYPE_POSTGRES_CURSOR_RECORDSET            (gda_postgres_cursor_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_CURSOR_RECORDSET</NAME>
#define GDA_POSTGRES_CURSOR_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_POSTGRES_CURSOR_RECORDSET, GdaPostgresCursorRecordset))
</MACRO>
<MACRO>
<NAME>GDA_POSTGRES_CURSOR_RECORDSET_CLASS</NAME>
#define GDA_POSTGRES_CURSOR_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_POSTGRES_CURSOR_RECORDSET, GdaPostgresCursorRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_POSTGRES_CURSOR_RECORDSET</NAME>
#define GDA_IS_POSTGRES_CURSOR_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, GDA_TYPE_POSTGRES_CURSOR_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_POSTGRES_CURSOR_RECORDSET_CLASS</NAME>
#define GDA_IS_POSTGRES_CURSOR_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GDA_TYPE_POSTGRES_CURSOR_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaPostgresCursorRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresCursorRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresCursorRecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaPostgresCursorRecordset</NAME>
struct _GdaPostgresCursorRecordset {
	GdaObject                  object;
	GdaPostgresCursorRecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaPostgresCursorRecordsetClass</NAME>
struct _GdaPostgresCursorRecordsetClass {
	GdaObjectClass             parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_postgres_cursor_recordset_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_postgres_cursor_recordset_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaConnection *cnc, const gchar *cursor_name, gint chunk_size
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_FIREBIRD_RECORDSET</NAME>
#define GDA_TYPE_FIREBIRD_RECORDSET            (gda_firebird_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_FIREBIRD_RECORDSET</NAME>
#define GDA_FIREBIRD_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_FIREBIRD_RECORDSET, GdaFirebirdRecordset))
</MACRO>
<MACRO>
<NAME>GDA_FIREBIRD_RECORDSET_CLASS</NAME>
#define GDA_FIREBIRD_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_FIREBIRD_RECORDSET, GdaFirebirdRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_FIREBIRD_RECORDSET</NAME>
#define GDA_IS_FIREBIRD_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_FIREBIRD_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_FIREBIRD_RECORDSET_CLASS</NAME>
#define GDA_IS_FIREBIRD_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_FIREBIRD_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaFirebirdRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdRecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdRecordset</NAME>
struct _GdaFirebirdRecordset {
	GdaDataModelRow model;
	GdaFirebirdRecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdRecordsetClass</NAME>
struct _GdaFirebirdRecordsetClass {
	GdaDataModelRowClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdConnection</NAME>
typedef struct {
	gchar *dbname, *server_version;
	isc_db_handle handle;
	ISC_STATUS status[20];
	gchar dpb_buffer[128];
	gshort dpb_length;
} GdaFirebirdConnection;
</STRUCT>
<FUNCTION>
<NAME>gda_firebird_recordset_get_type</NAME>
<RETURNS>GType			 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_firebird_recordset_new</NAME>
<RETURNS>GdaFirebirdRecordset 	*</RETURNS>
GdaConnection *cnc,isc_tr_handle *ftr,const gchar *sql,GObject **non_select_obj,GdaConnectionEvent **event
</FUNCTION>
<MACRO>
<NAME>CONNECTION_DATA</NAME>
#define CONNECTION_DATA "GDA_Firebird_ConnectionData"
</MACRO>
<MACRO>
<NAME>TRANSACTION_DATA</NAME>
#define TRANSACTION_DATA "GDA_Firebird_TransactionData"
</MACRO>
<MACRO>
<NAME>STATEMENT_DATA</NAME>
#define STATEMENT_DATA "GDA_Firebird_StatementData"
</MACRO>
<MACRO>
<NAME>GDA_TYPE_FIREBIRD_PROVIDER</NAME>
#define GDA_TYPE_FIREBIRD_PROVIDER            (gda_firebird_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_FIREBIRD_PROVIDER</NAME>
#define GDA_FIREBIRD_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_FIREBIRD_PROVIDER, GdaFirebirdProvider))
</MACRO>
<MACRO>
<NAME>GDA_FIREBIRD_PROVIDER_CLASS</NAME>
#define GDA_FIREBIRD_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_FIREBIRD_PROVIDER, GdaFirebirdProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_FIREBIRD_PROVIDER</NAME>
#define GDA_IS_FIREBIRD_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_FIREBIRD_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_FIREBIRD_PROVIDER_CLASS</NAME>
#define GDA_IS_FIREBIRD_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_FIREBIRD_PROVIDER))
</MACRO>
<MACRO>
<NAME>PARENT_TYPE</NAME>
#define PARENT_TYPE GDA_TYPE_SERVER_PROVIDER
</MACRO>
<STRUCT>
<NAME>GdaFirebirdProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdProvider</NAME>
struct _GdaFirebirdProvider {
	GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdProviderClass</NAME>
struct _GdaFirebirdProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_firebird_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_firebird_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_firebird_connection_make_error</NAME>
<RETURNS>GdaConnectionEvent *</RETURNS>
GdaConnection *cnc,const gint statement_type
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_FIREBIRD_BLOB_OP</NAME>
#define GDA_TYPE_FIREBIRD_BLOB_OP            (gda_firebird_blob_op_get_type())
</MACRO>
<MACRO>
<NAME>GDA_FIREBIRD_BLOB_OP</NAME>
#define GDA_FIREBIRD_BLOB_OP(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_FIREBIRD_BLOB_OP, GdaFirebirdBlobOp))
</MACRO>
<MACRO>
<NAME>GDA_FIREBIRD_BLOB_OP_CLASS</NAME>
#define GDA_FIREBIRD_BLOB_OP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_FIREBIRD_BLOB_OP, GdaFirebirdBlobOpClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_FIREBIRD_BLOB_OP</NAME>
#define GDA_IS_FIREBIRD_BLOB_OP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_FIREBIRD_BLOB_OP))
</MACRO>
<MACRO>
<NAME>GDA_IS_FIREBIRD_BLOB_OP_CLASS</NAME>
#define GDA_IS_FIREBIRD_BLOB_OP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_FIREBIRD_BLOB_OP))
</MACRO>
<STRUCT>
<NAME>GdaFirebirdBlobOp</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdBlobOpClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdBlobOpPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdBlobOp</NAME>
struct _GdaFirebirdBlobOp {
	GdaBlobOp                 parent;
	GdaFirebirdBlobOpPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaFirebirdBlobOpClass</NAME>
struct _GdaFirebirdBlobOpClass {
	GdaBlobOpClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_firebird_blob_op_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_firebird_blob_op_new</NAME>
<RETURNS>GdaBlobOp    *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_firebird_blob_op_new_with_id</NAME>
<RETURNS>GdaBlobOp    *</RETURNS>
GdaConnection *cnc, const ISC_QUAD *blob_id
</FUNCTION>
<MACRO>
<NAME>TDS_QUERY_CURRENT_DATABASE</NAME>
#define TDS_QUERY_CURRENT_DATABASE \
	"SELECT db_name() AS database"
</MACRO>
<MACRO>
<NAME>TDS_QUERY_SERVER_VERSION</NAME>
#define TDS_QUERY_SERVER_VERSION \
	"SELECT (@@version) AS version"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_DATABASES</NAME>
#define TDS_FIXMODEL_SCHEMA_DATABASES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Database")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_DATABASES</NAME>
#define TDS_SCHEMA_DATABASES \
	"SELECT name " \
	"  FROM master..sysdatabases " \
	" ORDER BY name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_FIELDS</NAME>
#define TDS_FIXMODEL_SCHEMA_FIELDS(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Field Name")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Data type")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Size")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("Scale")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  4, \
		                                 _("Not null?")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  5, \
		                                 _("Primary key?")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  6, \
		                                 _("Unique index?")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  7, \
		                                 _("References")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  8, \
		                                 _("Default value")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_FIELDS</NAME>
#define TDS_SCHEMA_FIELDS \
	"SELECT c.name, t.name AS typename, " \
	       "c.length, c.scale, " \
	       "(CASE WHEN ((c.status & 0x08) = 0x08) " \
	             "THEN convert(bit, 1) " \
	             "ELSE convert(bit, 0) " \
	       " END " \
	       ") AS nullable, " \
	       " convert(bit, 0) AS pkey, " \
	       " convert(bit, 0) AS unique_index, " \
	       " '' AS ref, '' AS def_val" \
	"  FROM syscolumns c, systypes t " \
	"    WHERE (c.id = OBJECT_ID('%s')) " \
	"      AND (c.usertype = t.usertype) " \
	"  ORDER BY c.colid ASC"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_INDEXES</NAME>
#define TDS_FIXMODEL_SCHEMA_INDEXES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Indexes")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_PROCEDURES</NAME>
#define TDS_FIXMODEL_SCHEMA_PROCEDURES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Procedure")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Id")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Owner")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("Comments")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  4, \
		                                 _("Return type")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  5, \
		                                 _("Nb args")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  6, \
		                                 _("Args types")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (recset),  7, \
		                                 _("Definition")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_PROCEDURES</NAME>
#define TDS_SCHEMA_PROCEDURES \
	"SELECT o.name, o.id, u.name as owner, '', " \
	"       '', 0, '', '' " \
        "  FROM sysobjects o, sysusers u" \
	" WHERE ((o.type = 'P') OR (o.type = 'XP')) " \
	"   AND (o.uid = u.uid) " \
	" ORDER BY o.name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_TABLES</NAME>
#define TDS_FIXMODEL_SCHEMA_TABLES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Table")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Owner")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Description")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("Definition")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_TABLES</NAME>
#define TDS_SCHEMA_TABLES \
	"SELECT o.name, u.name AS owner, '', '' " \
	"  FROM sysobjects o, sysusers u " \
	" WHERE ((o.type = 'U') AND " \
	"        (o.name NOT LIKE 'spt_%') AND " \
	"        (o.name != 'syblicenseslog')) " \
	"   AND (o.uid = u.uid) " \
	" ORDER BY o.name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_TYPES</NAME>
#define TDS_FIXMODEL_SCHEMA_TYPES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Type")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Owner")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Comments")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("GDA type")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_TYPES</NAME>
#define TDS_SCHEMA_TYPES \
	"SELECT t.name, u.name AS owner, t.length, t.type " \
	"  FROM systypes t, sysusers u " \
	" WHERE (t.uid = u.uid) " \
	" ORDER BY t.name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_USERS</NAME>
#define TDS_FIXMODEL_SCHEMA_USERS(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Users")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_USERS</NAME>
#define TDS_SCHEMA_USERS \
	"SELECT name " \
	"  FROM master..syslogins " \
	" ORDER BY name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_VIEWS</NAME>
#define TDS_FIXMODEL_SCHEMA_VIEWS(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("View")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Owner")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Comments")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("Definition")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_VIEWS</NAME>
#define TDS_SCHEMA_VIEWS \
	"SELECT o.name, u.name, '', '' " \
	"  FROM sysobjects o, sysusers u " \
	" WHERE (o.type = 'V') AND (o.uid = u.uid)" \
	" ORDER BY o.name"
</MACRO>
<MACRO>
<NAME>GDA_TYPE_FREETDS_RECORDSET</NAME>
#define GDA_TYPE_FREETDS_RECORDSET            (gda_freetds_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_FREETDS_RECORDSET</NAME>
#define GDA_FREETDS_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_FREETDS_RECORDSET, GdaFreeTDSRecordset))
</MACRO>
<MACRO>
<NAME>GDA_FREETDS_RECORDSET_CLASS</NAME>
#define GDA_FREETDS_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_FREETDS_RECORDSET, GdaFreeTDSRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_FREETDS_RECORDSET</NAME>
#define GDA_IS_FREETDS_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_FREETDS_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_FREETDS_RECORDSET_CLASS</NAME>
#define GDA_IS_FREETDS_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_FREETDS_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaFreeTDSRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSRecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSRecordset</NAME>
struct _GdaFreeTDSRecordset {
	GdaDataModelRow model;
	GdaFreeTDSRecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSRecordsetClass</NAME>
struct _GdaFreeTDSRecordsetClass {
	GdaDataModelRowClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSRecordsetPrivate</NAME>
struct _GdaFreeTDSRecordsetPrivate {
	GdaConnection            *cnc;
	GdaFreeTDSConnectionData *tds_cnc;

	TDS_INT                  rc;
	TDSRESULTINFO            *res;
	guint                    colcnt;
	guint                    rowcnt;
	gboolean                 fetched_all_results;

	GPtrArray                *columns;
	GPtrArray                *rows;
};
</STRUCT>
<FUNCTION>
<NAME>gda_freetds_recordset_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_freetds_recordset_new</NAME>
<RETURNS>GdaDataModel  *</RETURNS>
GdaConnection *cnc,gboolean fetchall
</FUNCTION>
<FUNCTION>
<NAME>gda_freetds_set_gdavalue</NAME>
<RETURNS>void </RETURNS>
GValue *field, guchar *val, _TDSCOLINFO *col,GdaFreeTDSConnectionData *tds_cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_freetds_get_value_type</NAME>
<RETURNS>GType </RETURNS>
_TDSCOLINFO *col
</FUNCTION>
<MACRO>
<NAME>TDSCONNECTINFO</NAME>
#define TDSCONNECTINFO TDSCONNECTION
</MACRO>
<MACRO>
<NAME>TDSCOLINFO</NAME>
#define TDSCOLINFO     TDSCOLUMN
</MACRO>
<MACRO>
<NAME>TDSMSGINFO</NAME>
#define TDSMSGINFO     TDSMESSAGE
</MACRO>
<MACRO>
<NAME>GDA_TYPE_FREETDS_PROVIDER</NAME>
#define GDA_TYPE_FREETDS_PROVIDER            (gda_freetds_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_FREETDS_PROVIDER</NAME>
#define GDA_FREETDS_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_FREETDS_PROVIDER, GdaFreeTDSProvider))
</MACRO>
<MACRO>
<NAME>GDA_FREETDS_PROVIDER_CLASS</NAME>
#define GDA_FREETDS_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_FREETDS_PROVIDER, GdaFreeTDSProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_FREETDS_PROVIDER</NAME>
#define GDA_IS_FREETDS_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_FREETDS_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_FREETDS_PROVIDER_CLASS</NAME>
#define GDA_IS_FREETDS_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_FREETDS_PROVIDER))
</MACRO>
<MACRO>
<NAME>PARENT_TYPE</NAME>
#define PARENT_TYPE GDA_TYPE_SERVER_PROVIDER
</MACRO>
<MACRO>
<NAME>OBJECT_DATA_FREETDS_HANDLE</NAME>
#define OBJECT_DATA_FREETDS_HANDLE "GDA_FreeTDS_FreeTDSHandle"
</MACRO>
<STRUCT>
<NAME>GdaFreeTDSProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSProvider</NAME>
struct _GdaFreeTDSProvider {
	GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSProviderClass</NAME>
struct _GdaFreeTDSProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSConnectionData</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSConnectionData</NAME>
struct _GdaFreeTDSConnectionData {
	gint            rc;         /* rc code of last operation */
	GPtrArray       *msg_arr;   /* array containing msgs from server */
	GPtrArray       *err_arr;   /* array containing error msgs from server */
	gchar           *database;  /* database we are connected to */
	
	TDSLOGIN        *login;     /* tds login struct */
#if FREETDS_VERSION >= 6000
	TDSCONTEXT      *ctx;       /* tds context */
#endif
	TDSSOCKET       *tds;       /* connection handle */
	_TDSCONNECTINFO *config;    /* tds connect struct */

	/* Data just got at connection beginning */
	gchar          *server_id; /* Server identifier/version string */
	gboolean       is_sybase;  /* true if cnc to ASE, false for mssql */
	gulong         srv_ver;    /* Server version */
	gint           result_type;
};
</STRUCT>
<FUNCTION>
<NAME>gda_freetds_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_freetds_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_FREETDS_PROVIDER_ID</NAME>
#define GDA_FREETDS_PROVIDER_ID          "GDA FreeTDS provider"
</MACRO>
<FUNCTION>
<NAME>gda_freetds_make_error</NAME>
<RETURNS>GdaConnectionEvent *</RETURNS>
TDSSOCKET *tds, const gchar *message
</FUNCTION>
<FUNCTION>
<NAME>gda_freetds_split_commandlist</NAME>
<RETURNS>gchar **</RETURNS>
const gchar *cmdlist
</FUNCTION>
<STRUCT>
<NAME>GdaFreeTDSMessage</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaFreeTDSMessage</NAME>
struct _GdaFreeTDSMessage {
	gboolean     is_err_msg;

	_TDSMSGINFO  msg;
};
</STRUCT>
<FUNCTION>
<NAME>gda_freetds_message_new</NAME>
<RETURNS>GdaFreeTDSMessage *</RETURNS>
GdaConnection *cnc,_TDSMSGINFO *info,const gboolean is_err_msg
</FUNCTION>
<FUNCTION>
<NAME>gda_freetds_message_add</NAME>
<RETURNS>GdaFreeTDSMessage *</RETURNS>
GdaConnection *cnc,_TDSMSGINFO *info,const gboolean is_err_msg
</FUNCTION>
<FUNCTION>
<NAME>gda_freetds_message_free</NAME>
<RETURNS>void </RETURNS>
GdaFreeTDSMessage *message
</FUNCTION>
<MACRO>
<NAME>FREETDS_VERSION</NAME>
#define FREETDS_VERSION (10000*FREETDS_VERSION_MAJOR+100*FREETDS_VERSION_MINOR)
</MACRO>
<MACRO>
<NAME>GDA_TYPE_IBMDB2_RECORDSET</NAME>
#define GDA_TYPE_IBMDB2_RECORDSET            (gda_ibmdb2_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_IBMDB2_RECORDSET</NAME>
#define GDA_IBMDB2_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_IBMDB2_RECORDSET, GdaIBMDB2Recordset))
</MACRO>
<MACRO>
<NAME>GDA_IBMDB2_RECORDSET_CLASS</NAME>
#define GDA_IBMDB2_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_IBMDB2_RECORDSET, GdaIBMDB2RecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_IBMDB2_RECORDSET</NAME>
#define GDA_IS_IBMDB2_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_IBMDB2_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_IBMDB2_RECORDSET_CLASS</NAME>
#define GDA_IS_IBMDB2_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_IBMDB2_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaIBMDB2Recordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2RecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2RecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2Field</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2Recordset</NAME>
struct _GdaIBMDB2Recordset {
	GdaDataModelRow            model;
	GdaIBMDB2RecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2RecordsetClass</NAME>
struct _GdaIBMDB2RecordsetClass {
	GdaDataModelRowClass       parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2RecordsetPrivate</NAME>
struct _GdaIBMDB2RecordsetPrivate
{
        GdaConnection *cnc;
	GdaIBMDB2ConnectionData *conn_data;
	/* GType *column_types; */
		
	SQLHANDLE hstmt;
		
	gint ncols;
	gint nrows;
	gint num_fetched_row;
	gboolean fetched_all_results;
	gint ntypes;

	GPtrArray *columns;
	GPtrArray *rows;
};
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2Field</NAME>
struct _GdaIBMDB2Field {
        SQLCHAR      column_name[32];
        SQLSMALLINT  column_name_len;
        SQLSMALLINT  column_type;
	SQLUINTEGER  column_size;
        SQLSMALLINT  column_scale;
	SQLSMALLINT  column_nullable;
        SQLPOINTER   column_data;
 	 GType        g_type;
};
</STRUCT>
<FUNCTION>
<NAME>gda_ibmdb2_recordset_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_ibmdb2_recordset_new</NAME>
<RETURNS>GdaDataModel *</RETURNS>
GdaConnection *cnc, SQLHANDLE hstmt
</FUNCTION>
<FUNCTION>
<NAME>gda_ibmdb2_set_gdavalue</NAME>
<RETURNS>void  </RETURNS>
GValue *value, GdaIBMDB2Field *field
</FUNCTION>
<FUNCTION>
<NAME>gda_ibmdb2_set_gdavalue_by_date</NAME>
<RETURNS>void  </RETURNS>
GValue *value, DATE_STRUCT *date
</FUNCTION>
<FUNCTION>
<NAME>gda_ibmdb2_set_gdavalue_by_time</NAME>
<RETURNS>void  </RETURNS>
GValue *value, TIME_STRUCT *time
</FUNCTION>
<FUNCTION>
<NAME>gda_ibmdb2_set_gdavalue_by_timestamp</NAME>
<RETURNS>void  </RETURNS>
GValue *value, TIMESTAMP_STRUCT *timestamp
</FUNCTION>
<FUNCTION>
<NAME>gda_ibmdb2_get_value_type</NAME>
<RETURNS>GType </RETURNS>
GdaIBMDB2Field *col
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_IBMDB2_PROVIDER</NAME>
#define GDA_TYPE_IBMDB2_PROVIDER            (gda_ibmdb2_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_IBMDB2_PROVIDER</NAME>
#define GDA_IBMDB2_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_IBMDB2_PROVIDER, GdaIBMDB2Provider))
</MACRO>
<MACRO>
<NAME>GDA_IBMDB2_PROVIDER_CLASS</NAME>
#define GDA_IBMDB2_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_IBMDB2_PROVIDER, GdaIBMDB2ProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_IBMDB2_PROVIDER</NAME>
#define GDA_IS_IBMDB2_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_IBMDB2_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_IBMDB2_PROVIDER_CLASS</NAME>
#define GDA_IS_IBMDB2_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_IBMDB2_PROVIDER))
</MACRO>
<MACRO>
<NAME>PARENT_TYPE</NAME>
#define PARENT_TYPE GDA_TYPE_SERVER_PROVIDER
</MACRO>
<MACRO>
<NAME>OBJECT_DATA_IBMDB2_HANDLE</NAME>
#define OBJECT_DATA_IBMDB2_HANDLE "GDA_IBMDB2_IBMDB2Handle"
</MACRO>
<STRUCT>
<NAME>GdaIBMDB2Provider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2ProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2ConnectionData</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2Provider</NAME>
struct _GdaIBMDB2Provider {
	GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2ProviderClass</NAME>
struct _GdaIBMDB2ProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaIBMDB2ConnectionData</NAME>
struct _GdaIBMDB2ConnectionData {
	SQLHANDLE henv;
	SQLHANDLE hdbc;
	SQLHANDLE hstmt; /* Only for schema */
	gchar    *database;
	gboolean GetInfo_supported;
	gchar    *server_version;
	SQLRETURN rc;
	SQLCHAR sql_state[5];
	SQLINTEGER native_error;
        SQLCHAR error_msg[SQL_MAX_MESSAGE_LENGTH + 1];
	SQLSMALLINT size_error_msg;
};
</STRUCT>
<FUNCTION>
<NAME>gda_ibmdb2_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_ibmdb2_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_IBMDB2_PROVIDER_ID</NAME>
#define GDA_IBMDB2_PROVIDER_ID          "GDA IBMDB2 provider"
</MACRO>
<FUNCTION>
<NAME>gda_ibmdb2_make_error</NAME>
<RETURNS>GdaConnectionEvent *</RETURNS>
SQLHANDLE henv, SQLHANDLE hdbc, SQLHANDLE hstmt
</FUNCTION>
<FUNCTION>
<NAME>gda_ibmdb2_emit_error</NAME>
<RETURNS>void 	  </RETURNS>
GdaConnection *cnc, SQLHANDLE henv, SQLHANDLE hdbc, SQLHANDLE hstmt
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_ORACLE_BLOB_OP</NAME>
#define GDA_TYPE_ORACLE_BLOB_OP            (gda_oracle_blob_op_get_type())
</MACRO>
<MACRO>
<NAME>GDA_ORACLE_BLOB_OP</NAME>
#define GDA_ORACLE_BLOB_OP(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ORACLE_BLOB_OP, GdaOracleBlobOp))
</MACRO>
<MACRO>
<NAME>GDA_ORACLE_BLOB_OP_CLASS</NAME>
#define GDA_ORACLE_BLOB_OP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_ORACLE_BLOB_OP, GdaOracleBlobOpClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_ORACLE_BLOB_OP</NAME>
#define GDA_IS_ORACLE_BLOB_OP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ORACLE_BLOB_OP))
</MACRO>
<MACRO>
<NAME>GDA_IS_ORACLE_BLOB_OP_CLASS</NAME>
#define GDA_IS_ORACLE_BLOB_OP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_ORACLE_BLOB_OP))
</MACRO>
<STRUCT>
<NAME>GdaOracleBlobOp</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleBlobOpClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleBlobOpPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleBlobOp</NAME>
struct _GdaOracleBlobOp {
	GdaBlobOp               parent;
	GdaOracleBlobOpPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaOracleBlobOpClass</NAME>
struct _GdaOracleBlobOpClass {
	GdaBlobOpClass          parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gda_oracle_blob_op_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_blob_op_new</NAME>
<RETURNS>GdaBlobOp    *</RETURNS>
GdaConnection *cnc, OCILobLocator *lobloc
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_ORACLE_RECORDSET</NAME>
#define GDA_TYPE_ORACLE_RECORDSET            (gda_oracle_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_ORACLE_RECORDSET</NAME>
#define GDA_ORACLE_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ORACLE_RECORDSET, GdaOracleRecordset))
</MACRO>
<MACRO>
<NAME>GDA_ORACLE_RECORDSET_CLASS</NAME>
#define GDA_ORACLE_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_ORACLE_RECORDSET, GdaOracleRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_ORACLE_RECORDSET</NAME>
#define GDA_IS_ORACLE_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ORACLE_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_ORACLE_RECORDSET_CLASS</NAME>
#define GDA_IS_ORACLE_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_ORACLE_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaOracleRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleRecordsetField</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleRecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleValue</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleRecordset</NAME>
struct _GdaOracleRecordset {
	GdaDataModelRow model;
	GdaOracleRecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaOracleRecordsetClass</NAME>
struct _GdaOracleRecordsetClass {
	GdaDataModelRowClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaOracleValue</NAME>
struct _GdaOracleValue {
	OCIDefine *hdef;
	OCIParam *pard;
	sb2 indicator;
	ub2 sql_type;
	ub2 defined_size;
	gpointer value;
	GType g_type;
};
</STRUCT>
<FUNCTION>
<NAME>gda_oracle_recordset_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_recordset_new</NAME>
<RETURNS>GdaOracleRecordset *</RETURNS>
GdaConnection *cnc, GdaOracleConnectionData *cdata,OCIStmt *stmthp, GArray *col_size_array
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_render_CREATE_DB</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_render_DROP_DB</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_render_CREATE_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_render_RENAME_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_render_DROP_TABLE</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_render_ADD_COLUMN</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_render_DROP_COLUMN</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_render_CREATE_INDEX</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_render_DROP_INDEX</NAME>
<RETURNS>gchar *</RETURNS>
GdaServerProvider *provider, GdaConnection *cnc,GdaServerOperation *op, GError **error
</FUNCTION>
<MACRO>
<NAME>OBJECT_DATA_ORACLE_HANDLE</NAME>
#define OBJECT_DATA_ORACLE_HANDLE "GDA_Oracle_OracleHandle"
</MACRO>
<MACRO>
<NAME>GDA_ORACLE_PROVIDER_ID</NAME>
#define GDA_ORACLE_PROVIDER_ID    "GDA Oracle provider"
</MACRO>
<MACRO>
<NAME>ORA_NAME_BUFFER_SIZE</NAME>
#define ORA_NAME_BUFFER_SIZE	  30
</MACRO>
<MACRO>
<NAME>gda_oracle_check_result</NAME>
#define gda_oracle_check_result(result, cnc, priv_data, type, msg) \
	(((result) == OCI_SUCCESS || (result) == OCI_SUCCESS_WITH_INFO) \
	 ? NULL : gda_oracle_handle_error(result, cnc, priv_data,       \
					  type, msg, __FILE__, __LINE__))
</MACRO>
<MACRO>
<NAME>gda_oracle_blob_type</NAME>
#define gda_oracle_blob_type(sqltype) \
	(((sqltype == SQLT_BFILEE) || (sqltype == SQLT_CFILEE)) ? OCI_DTYPE_FILE : OCI_DTYPE_LOB)
</MACRO>
<FUNCTION>
<NAME>gda_oracle_make_error</NAME>
<RETURNS>GdaConnectionEvent *</RETURNS>
dvoid *hndlp, ub4 type,const gchar *file, gint line
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_set_value</NAME>
<RETURNS>void </RETURNS>
GValue *value,GdaOracleValue *thevalue,GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_value_to_sql_string</NAME>
<RETURNS>gchar *</RETURNS>
GValue *value
</FUNCTION>
<FUNCTION>
<NAME>oracle_sqltype_to_g_type</NAME>
<RETURNS>GType  </RETURNS>
const ub2 sqltype
</FUNCTION>
<FUNCTION>
<NAME>oracle_sqltype_to_string</NAME>
<RETURNS>gchar *</RETURNS>
const ub2 sqltype
</FUNCTION>
<FUNCTION>
<NAME>gda_value_to_oracle_value</NAME>
<RETURNS>GdaOracleValue *</RETURNS>
const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_handle_error</NAME>
<RETURNS>GdaConnectionEvent *</RETURNS>
gint result,GdaConnection *cnc,GdaOracleConnectionData *priv_data,ub4 type,const gchar *msg,const gchar *file,gint line
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_ORACLE_PROVIDER</NAME>
#define GDA_TYPE_ORACLE_PROVIDER            (gda_oracle_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_ORACLE_PROVIDER</NAME>
#define GDA_ORACLE_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_ORACLE_PROVIDER, GdaOracleProvider))
</MACRO>
<MACRO>
<NAME>GDA_ORACLE_PROVIDER_CLASS</NAME>
#define GDA_ORACLE_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_ORACLE_PROVIDER, GdaOracleProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_ORACLE_PROVIDER</NAME>
#define GDA_IS_ORACLE_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_ORACLE_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_ORACLE_PROVIDER_CLASS</NAME>
#define GDA_IS_ORACLE_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_ORACLE_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GdaOracleProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaOracleProvider</NAME>
struct _GdaOracleProvider {
	GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaOracleProviderClass</NAME>
struct _GdaOracleProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaOracleConnectionData</NAME>
typedef struct {
	OCIEnv *henv;
	OCIError *herr;
	OCIServer *hserver;
	OCISvcCtx *hservice;
	OCISession *hsession;
        gchar *schema; /* the same as the username which opened the connection */
} GdaOracleConnectionData;
</STRUCT>
<FUNCTION>
<NAME>gda_oracle_provider_get_type</NAME>
<RETURNS>GType                </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_oracle_provider_new</NAME>
<RETURNS>GdaServerProvider   *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDA_TYPE_SYBASE_RECORDSET</NAME>
#define GDA_TYPE_SYBASE_RECORDSET            (gda_sybase_recordset_get_type())
</MACRO>
<MACRO>
<NAME>GDA_SYBASE_RECORDSET</NAME>
#define GDA_SYBASE_RECORDSET(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_SYBASE_RECORDSET, GdaSybaseRecordset))
</MACRO>
<MACRO>
<NAME>GDA_SYBASE_RECORDSET_CLASS</NAME>
#define GDA_SYBASE_RECORDSET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_SYBASE_RECORDSET, GdaSybaseRecordsetClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_SYBASE_RECORDSET</NAME>
#define GDA_IS_SYBASE_RECORDSET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_SYBASE_RECORDSET))
</MACRO>
<MACRO>
<NAME>GDA_IS_SYBASE_RECORDSET_CLASS</NAME>
#define GDA_IS_SYBASE_RECORDSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE (klass, GDA_TYPE_SYBASE_RECORDSET))
</MACRO>
<STRUCT>
<NAME>GdaSybaseRecordset</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSybaseRecordsetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSybaseField</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSybaseRecordsetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSybaseRecordset</NAME>
struct _GdaSybaseRecordset {
	GdaDataModelRow model;
	GdaSybaseRecordsetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdaSybaseRecordsetClass</NAME>
struct _GdaSybaseRecordsetClass {
	GdaDataModelRowClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaSybaseField</NAME>
struct _GdaSybaseField {
	CS_SMALLINT indicator;
	gchar       *data;
	CS_INT      datalen;
	CS_DATAFMT  fmt;
};
</STRUCT>
<STRUCT>
<NAME>GdaSybaseRecordsetPrivate</NAME>
struct _GdaSybaseRecordsetPrivate {
	GdaConnection           *cnc;
	GdaSybaseConnectionData *scnc;

	CS_INT                  rc;
	guint                   colcnt;
	guint                   rowcnt;
	gboolean                fetched_all_results;

	GPtrArray               *columns;
	GPtrArray               *rows;
};
</STRUCT>
<FUNCTION>
<NAME>gda_sybase_recordset_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_process_row_result</NAME>
<RETURNS>GdaSybaseRecordset *</RETURNS>
GdaConnection           *cnc,GdaSybaseConnectionData *scnc,gboolean                fetchall
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_process_msg_result</NAME>
<RETURNS>GdaSybaseRecordset *</RETURNS>
GdaConnection *cnc,GdaSybaseConnectionData *scnc
</FUNCTION>
<MACRO>
<NAME>GDA_SYBASE_PROVIDER_ID</NAME>
#define GDA_SYBASE_PROVIDER_ID		"GDA sybase provider"
</MACRO>
<MACRO>
<NAME>PARENT_TYPE</NAME>
#define PARENT_TYPE GDA_TYPE_SERVER_PROVIDER
</MACRO>
<MACRO>
<NAME>OBJECT_DATA_SYBASE_HANDLE</NAME>
#define OBJECT_DATA_SYBASE_HANDLE "GDA_Sybase_SybaseHandle"
</MACRO>
<MACRO>
<NAME>GDA_SYBASE_COMPONENT_FACTORY_ID</NAME>
#define GDA_SYBASE_COMPONENT_FACTORY_ID "OAFIID:GNOME_Database_Sybase_ComponentFactory"
</MACRO>
<FUNCTION>
<NAME>sybase_check_messages</NAME>
<RETURNS>gboolean </RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_make_error</NAME>
<RETURNS>GdaConnectionEvent *</RETURNS>
GdaSybaseConnectionData *scnc, gchar *fmt, ...
</FUNCTION>
<FUNCTION>
<NAME>sybase_debug_msg</NAME>
<RETURNS>void </RETURNS>
gchar *fmt, ...
</FUNCTION>
<FUNCTION>
<NAME>sybase_error_msg</NAME>
<RETURNS>void </RETURNS>
gchar *fmt, ...
</FUNCTION>
<USER_FUNCTION>
<NAME>sybase_conv_Func</NAME>
<RETURNS>gboolean </RETURNS>
GdaSybaseConnectionData *scnc,
                                      GdaSybaseField          *field,
                                      GValue                *value
</USER_FUNCTION>
<STRUCT>
<NAME>sybase_Types</NAME>
typedef struct _sybase_Types {
  gchar            *name;
  CS_INT           sql_type;
  GType     g_type;
//  sybase_conv_Func conv_sql2gda;
} sybase_Types;
</STRUCT>
<MACRO>
<NAME>GDA_SYBASE_TYPE_CNT</NAME>
#define GDA_SYBASE_TYPE_CNT 23
</MACRO>
<FUNCTION>
<NAME>gda_sybase_get_value_type</NAME>
<RETURNS>GType </RETURNS>
const CS_INT sql_type
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_get_sql_type</NAME>
<RETURNS>CS_INT </RETURNS>
const GType g_type
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_set_value_by_datetime</NAME>
<RETURNS>void </RETURNS>
GValue *value, CS_DATETIME *dt
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_set_value_by_datetime4</NAME>
<RETURNS>void </RETURNS>
GValue *value, CS_DATETIME4 *dt
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_set_gda_value</NAME>
<RETURNS>gboolean </RETURNS>
GdaSybaseConnectionData *scnc,GValue *value,GdaSybaseField *field
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_set_value_general</NAME>
<RETURNS>gboolean </RETURNS>
GdaSybaseConnectionData *scnc,GValue                *value,GdaSybaseField          *field
</FUNCTION>
<MACRO>
<NAME>TDS_QUERY_CURRENT_DATABASE</NAME>
#define TDS_QUERY_CURRENT_DATABASE \
	"SELECT db_name()"
</MACRO>
<MACRO>
<NAME>TDS_QUERY_SERVER_VERSION</NAME>
#define TDS_QUERY_SERVER_VERSION \
	"SELECT (@@version) AS version"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_DATABASES</NAME>
#define TDS_FIXMODEL_SCHEMA_DATABASES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Database")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_DATABASES</NAME>
#define TDS_SCHEMA_DATABASES \
	"SELECT name " \
	"  FROM master..sysdatabases " \
	" ORDER BY name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_FIELDS</NAME>
#define TDS_FIXMODEL_SCHEMA_FIELDS(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Field Name")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Data type")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Size")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("Scale")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  4, \
		                                 _("Not null?")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  5, \
		                                 _("Primary key?")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  6, \
		                                 _("Unique index?")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  7, \
		                                 _("References")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  8, \
		                                 _("Default value")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_FIELDS</NAME>
#define TDS_SCHEMA_FIELDS \
	"SELECT c.name, t.name AS typename, " \
	       "c.length, c.scale, " \
	       "(CASE WHEN ((c.status & 0x08) = 0x08) " \
	             "THEN convert(bit, 1) " \
	             "ELSE convert(bit, 0) " \
	       " END " \
	       ") AS nullable, " \
	       " convert(bit, 0) AS pkey, " \
	       " convert(bit, 0) AS unique_index, " \
	       " '' AS ref, '' AS def_val" \
	"  FROM syscolumns c, systypes t " \
	"    WHERE (c.id = OBJECT_ID('%s')) " \
	"      AND (c.usertype = t.usertype) " \
	"  ORDER BY c.colid ASC"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_INDEXES</NAME>
#define TDS_FIXMODEL_SCHEMA_INDEXES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Indexes")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_PROCEDURES</NAME>
#define TDS_FIXMODEL_SCHEMA_PROCEDURES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Procedure")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Id")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Owner")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("Comments")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  4, \
		                                 _("Return type")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  5, \
		                                 _("Nb args")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  6, \
		                                 _("Args types")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (recset),  7, \
		                                 _("Definition")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_PROCEDURES</NAME>
#define TDS_SCHEMA_PROCEDURES \
	"SELECT o.name, o.id, u.name as owner, '', " \
	"       '', 0, '', '' " \
        "  FROM sysobjects o, sysusers u" \
	" WHERE ((o.type = 'P') OR (o.type = 'XP')) " \
	"   AND (o.uid = u.uid) " \
	" ORDER BY name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_TABLES</NAME>
#define TDS_FIXMODEL_SCHEMA_TABLES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Table")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Owner")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Description")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("Definition")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_TABLES</NAME>
#define TDS_SCHEMA_TABLES \
	"SELECT o.name, u.name AS owner, '', '' " \
	"  FROM sysobjects o, sysusers u " \
	" WHERE ((o.type = 'U') AND " \
	"        (o.name NOT LIKE 'spt_%') AND " \
	"        (o.name != 'syblicenseslog')) " \
	"   AND (o.uid = u.uid) " \
	" ORDER BY name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_TYPES</NAME>
#define TDS_FIXMODEL_SCHEMA_TYPES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Type")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Owner")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Comments")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("GDA type")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_TYPES</NAME>
#define TDS_SCHEMA_TYPES \
	"SELECT t.name, u.name AS owner, t.length, t.type " \
	"  FROM systypes t, sysusers u " \
	" WHERE (t.uid = u.uid) " \
	" ORDER BY name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_USERS</NAME>
#define TDS_FIXMODEL_SCHEMA_USERS(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Users")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_USERS</NAME>
#define TDS_SCHEMA_USERS \
	"SELECT name " \
	"  FROM master..syslogins " \
	" ORDER BY name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_VIEWS</NAME>
#define TDS_FIXMODEL_SCHEMA_VIEWS(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("View")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  1, \
		                                 _("Owner")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  2, \
		                                 _("Comments")); \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  3, \
		                                 _("Definition")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_VIEWS</NAME>
#define TDS_SCHEMA_VIEWS \
	"SELECT o.name, u.name, '', '' " \
	"  FROM sysobjects o, sysusers u " \
	" WHERE (o.type = 'V') AND (o.uid = u.uid)" \
	" ORDER BY name"
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_INDEXES</NAME>
#define TDS_SCHEMA_INDEXES \
 "SELECT name from sysindexes " \
 "order by name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_INDEXES</NAME>
#define TDS_FIXMODEL_SCHEMA_INDEXES(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Indexes")); \
	}
</MACRO>
<MACRO>
<NAME>TDS_SCHEMA_TRIGGERS</NAME>
#define TDS_SCHEMA_TRIGGERS \
 "SELECT name " \
 "from sysobjects " \
 "where type = 'TR' "\
 "order by name"
</MACRO>
<MACRO>
<NAME>TDS_FIXMODEL_SCHEMA_TRIGGERS</NAME>
#define TDS_FIXMODEL_SCHEMA_TRIGGERS(model) \
	if (model) { \
		gda_data_model_set_column_title (GDA_DATA_MODEL (model),  0, \
		                                 _("Triggers")); \
	}
</MACRO>
<MACRO>
<NAME>CS_GDA_VERSION</NAME>
#  define CS_GDA_VERSION CS_CURRENT_VERSION
</MACRO>
<MACRO>
<NAME>CS_GDA_VERSION</NAME>
#  define CS_GDA_VERSION CS_VERSION_125
</MACRO>
<MACRO>
<NAME>CS_GDA_VERSION</NAME>
#  define CS_GDA_VERSION CS_VERSION_120
</MACRO>
<MACRO>
<NAME>CS_GDA_VERSION</NAME>
#  define CS_GDA_VERSION CS_VERSION_110
</MACRO>
<MACRO>
<NAME>CS_GDA_VERSION</NAME>
#  define CS_GDA_VERSION CS_VERSION_100
</MACRO>
<MACRO>
<NAME>GDA_TYPE_SYBASE_PROVIDER</NAME>
#define GDA_TYPE_SYBASE_PROVIDER            (gda_sybase_provider_get_type())
</MACRO>
<MACRO>
<NAME>GDA_SYBASE_PROVIDER</NAME>
#define GDA_SYBASE_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GDA_TYPE_SYBASE_PROVIDER, GdaSybaseProvider))
</MACRO>
<MACRO>
<NAME>GDA_SYBASE_PROVIDER_CLASS</NAME>
#define GDA_SYBASE_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GDA_TYPE_SYBASE_PROVIDER, GdaSybaseProviderClass))
</MACRO>
<MACRO>
<NAME>GDA_IS_SYBASE_PROVIDER</NAME>
#define GDA_IS_SYBASE_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GDA_TYPE_SYBASE_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDA_IS_SYBASE_PROVIDER_CLASS</NAME>
#define GDA_IS_SYBASE_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDA_TYPE_SYBASE_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GdaSybaseProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSybaseProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdaSybaseProvider</NAME>
struct _GdaSybaseProvider {
	GdaServerProvider provider;
};
</STRUCT>
<STRUCT>
<NAME>GdaSybaseProviderClass</NAME>
struct _GdaSybaseProviderClass {
	GdaServerProviderClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdaSybaseConnectionData</NAME>
typedef struct _GdaSybaseConnectionData {
	GdaConnection  *gda_cnc; // "parent"
	gchar          *server_version;
	
	CS_CONTEXT     *context;
	CS_COMMAND     *cmd;
	CS_CONNECTION  *connection;
	CS_CHAR        *mempool;

	CS_RETCODE     ret;      // for client operations
	CS_RETCODE     rret;     // for ct_result operations
	CS_RETCODE     mret;     // for message operations(cs_diag/ct_diag)
	CS_INT         res_type; // resulttype of query in progress
} GdaSybaseConnectionData;
</STRUCT>
<FUNCTION>
<NAME>gda_sybase_provider_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_provider_new</NAME>
<RETURNS>GdaServerProvider *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_connection_data_new</NAME>
<RETURNS>GdaSybaseConnectionData *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gda_sybase_connection_data_free</NAME>
<RETURNS>void </RETURNS>
GdaSybaseConnectionData *
</FUNCTION>
