? pygda_libgda2p0.patch
? gtkmozembed/gtkmozembed.loT
Index: ChangeLog
===================================================================
RCS file: /cvs/gnome/gnome-python-extras/ChangeLog,v
retrieving revision 1.149
diff -u -p -r1.149 ChangeLog
--- ChangeLog	19 Aug 2006 16:40:00 -0000	1.149
+++ ChangeLog	6 Nov 2006 23:40:30 -0000
@@ -1,3 +1,14 @@
+2006-11-07  Murray Cumming  <murrayc@murrayc.com>
+
+	* configure.ac: Use the latest (parallel-installabel) ligbda API, currently 
+	called libgda-2.0.
+	* gda/gda.defs: Regenerated with h2defs.py, removing the private API by hand.
+	* gda/gda.override:
+	* gda/gdaglue.h:
+	* gda/pygdavalue_conversions.c: (pygda_value_from_pyobject),
+	(pygda_value_as_pyobject):
+	* gda/pygdavalue_conversions.h: Updated, using the changed API.
+
 2006-08-19  Gustavo J. A. M. Carneiro  <gjc@gnome.org>
 
 	* examples/gtkhtml2/simple-browser.py (link_clicked): Fix
Index: configure.ac
===================================================================
RCS file: /cvs/gnome/gnome-python-extras/configure.ac,v
retrieving revision 1.129
diff -u -p -r1.129 configure.ac
--- configure.ac	11 Jul 2006 20:48:27 -0000	1.129
+++ configure.ac	6 Nov 2006 23:40:30 -0000
@@ -19,7 +19,7 @@ m4_define(gtkhtml2_required_version,    
 m4_define(mozilla_required_version,           1.2b)
 m4_define(firefox_required_version,           1.0)
 m4_define(xulrunner_required_version,         1.8)
-m4_define(libgda_required_version,            1.2.0)
+m4_define(libgda_required_version,            1.9.101)
 m4_define(gksu_required_version,              1.2.5)
 m4_define(gksuui_required_version,            1.0.3)
 
@@ -203,7 +203,7 @@ fi
 
 dnl should we build the gda module?
 build_gda=false
-PKG_CHECK_MODULES(GDA, [libgda >= libgda_required_version pygtk-2.0 >= pygtk_required_version],
+PKG_CHECK_MODULES(GDA, [libgda-2.0 >= libgda_required_version pygtk-2.0 >= pygtk_required_version],
   build_gda=true,
   build_gda=false)
 AM_CONDITIONAL(BUILD_GDA, $build_gda)
Index: gda/gda.defs
===================================================================
RCS file: /cvs/gnome/gnome-python-extras/gda/gda.defs,v
retrieving revision 1.7
diff -u -p -r1.7 gda.defs
--- gda/gda.defs	14 Jan 2006 14:40:15 -0000	1.7
+++ gda/gda.defs	6 Nov 2006 23:40:31 -0000
@@ -1,5 +1,12 @@
 ;; -*- scheme -*-
 ; object definitions ...
+(define-object Blob
+  (in-module "Gda")
+  (parent "GObject")
+  (c-name "GdaBlob")
+  (gtype-id "GDA_TYPE_BLOB")
+)
+
 (define-object Client
   (in-module "Gda")
   (parent "GObject")
@@ -7,6 +14,20 @@
   (gtype-id "GDA_TYPE_CLIENT")
 )
 
+(define-object Column
+  (in-module "Gda")
+  (parent "GObject")
+  (c-name "GdaColumn")
+  (gtype-id "GDA_TYPE_COLUMN")
+)
+
+(define-object ColumnIndex
+  (in-module "Gda")
+  (parent "GObject")
+  (c-name "GdaColumnIndex")
+  (gtype-id "GDA_TYPE_COLUMN_INDEX")
+)
+
 (define-object Connection
   (in-module "Gda")
   (parent "GObject")
@@ -14,305 +35,319 @@
   (gtype-id "GDA_TYPE_CONNECTION")
 )
 
-(define-object DataModel
+(define-object ConnectionEvent
   (in-module "Gda")
   (parent "GObject")
+  (c-name "GdaConnectionEvent")
+  (gtype-id "GDA_TYPE_CONNECTION_EVENT")
+)
+
+(define-object DataHandler
+  (in-module "Gda")
+  (c-name "GdaDataHandler")
+  (gtype-id "GDA_TYPE_DATA_HANDLER")
+)
+
+(define-object DataModel
+  (in-module "Gda")
   (c-name "GdaDataModel")
   (gtype-id "GDA_TYPE_DATA_MODEL")
 )
 
-(define-object DataModelArray
+(define-object Dict
   (in-module "Gda")
-  (parent "GdaDataModel")
-  (c-name "GdaDataModelArray")
-  (gtype-id "GDA_TYPE_DATA_MODEL_ARRAY")
+  (parent "GObject")
+  (c-name "GdaDict")
+  (gtype-id "GDA_TYPE_DICT")
 )
 
-(define-object DataModelHash
+(define-object Entity
   (in-module "Gda")
-  (parent "GdaDataModel")
-  (c-name "GdaDataModelHash")
-  (gtype-id "GDA_TYPE_DATA_MODEL_HASH")
+  (c-name "GdaEntity")
+  (gtype-id "GDA_TYPE_ENTITY")
 )
 
-(define-object DataModelList
+(define-object EntityField
   (in-module "Gda")
-  (parent "GdaDataModel")
-  (c-name "GdaDataModelList")
-  (gtype-id "GDA_TYPE_DATA_MODEL_LIST")
+  (c-name "GdaEntityField")
+  (gtype-id "GDA_TYPE_ENTITY_FIELD")
 )
 
-(define-object Error
+(define-object Object
   (in-module "Gda")
   (parent "GObject")
-  (c-name "GdaError")
-  (gtype-id "GDA_TYPE_ERROR")
+  (c-name "GdaObject")
+  (gtype-id "GDA_TYPE_OBJECT")
 )
 
-(define-object Select
+(define-object Graphviz
   (in-module "Gda")
-  (parent "GdaDataModelArray")
-  (c-name "GdaSelect")
-  (gtype-id "GDA_TYPE_SELECT")
+  (parent "GdaObject")
+  (c-name "GdaGraphviz")
+  (gtype-id "GDA_TYPE_GRAPHVIZ")
 )
 
-(define-object ServerProvider
+(define-object DictType
   (in-module "Gda")
-  (parent "GObject")
-  (c-name "GdaServerProvider")
-  (gtype-id "GDA_TYPE_SERVER_PROVIDER")
+  (parent "GdaObject")
+  (c-name "GdaDictType")
+  (gtype-id "GDA_TYPE_DICT_TYPE")
 )
 
-(define-object Table
+(define-object DictTable
   (in-module "Gda")
-  (parent "GdaDataModelArray")
-  (c-name "GdaTable")
-  (gtype-id "GDA_TYPE_TABLE")
+  (parent "GdaObject")
+  (c-name "GdaDictTable")
+  (gtype-id "GDA_TYPE_DICT_TABLE")
 )
 
-(define-object Transaction
+(define-object DictFunction
   (in-module "Gda")
-  (parent "GObject")
-  (c-name "GdaTransaction")
-  (gtype-id "GDA_TYPE_TRANSACTION")
+  (parent "GdaObject")
+  (c-name "GdaDictFunction")
+  (gtype-id "GDA_TYPE_DICT_FUNCTION")
 )
 
-(define-object XmlConnection
+(define-object DictField
   (in-module "Gda")
-  (parent "GObject")
-  (c-name "GdaXmlConnection")
-  (gtype-id "GDA_TYPE_XML_CONNECTION")
+  (parent "GdaObject")
+  (c-name "GdaDictField")
+  (gtype-id "GDA_TYPE_DICT_FIELD")
 )
 
-(define-object XmlDatabase
+(define-object DictDatabase
   (in-module "Gda")
-  (parent "GObject")
-  (c-name "GdaXmlDatabase")
-  (gtype-id "GDA_TYPE_XML_DATABASE")
+  (parent "GdaObject")
+  (c-name "GdaDictDatabase")
+  (gtype-id "GDA_TYPE_DICT_DATABASE")
 )
 
-(define-object XmlDocument
+(define-object DictConstraint
   (in-module "Gda")
-  (parent "GObject")
-  (c-name "GdaXmlDocument")
-  (gtype-id "GDA_TYPE_XML_DOCUMENT")
+  (parent "GdaObject")
+  (c-name "GdaDictConstraint")
+  (gtype-id "GDA_TYPE_DICT_CONSTRAINT")
 )
 
-(define-object XqlItem
+(define-object DictAggregate
   (in-module "Gda")
-  (parent "GObject")
-  (c-name "GdaXqlItem")
-  (gtype-id "GDA_TYPE_XQL_ITEM")
+  (parent "GdaObject")
+  (c-name "GdaDictAggregate")
+  (gtype-id "GDA_TYPE_DICT_AGGREGATE")
 )
 
-(define-object XqlDual
+(define-object DataProxy
   (in-module "Gda")
-  (parent "GdaXqlItem")
-  (c-name "GdaXqlDual")
-  (gtype-id "GDA_TYPE_XQL_DUAL")
+  (parent "GdaObject")
+  (c-name "GdaDataProxy")
+  (gtype-id "GDA_TYPE_DATA_PROXY")
 )
 
-(define-object XqlDml
+(define-object DataModelRow
   (in-module "Gda")
-  (parent "GdaXqlItem")
-  (c-name "GdaXqlDml")
-  (gtype-id "GDA_TYPE_XQL_DML")
+  (parent "GdaObject")
+  (c-name "GdaDataModelRow")
+  (gtype-id "GDA_TYPE_DATA_MODEL_ROW")
 )
 
-(define-object XqlInsert
+(define-object DataModelArray
   (in-module "Gda")
-  (parent "GdaXqlDml")
-  (c-name "GdaXqlInsert")
-  (gtype-id "GDA_TYPE_XQL_INSERT")
+  (parent "GdaDataModelRow")
+  (c-name "GdaDataModelArray")
+  (gtype-id "GDA_TYPE_DATA_MODEL_ARRAY")
 )
 
-(define-object XqlDelete
+(define-object DataModelFilterSQL
   (in-module "Gda")
-  (parent "GdaXqlDml")
-  (c-name "GdaXqlDelete")
-  (gtype-id "GDA_TYPE_XQL_DELETE")
+  (parent "GdaDataModelArray")
+  (c-name "GdaDataModelFilterSQL")
+  (gtype-id "GDA_TYPE_DATA_MODEL_FILTER_SQL")
 )
 
-(define-object XqlBin
+(define-object DataModelHash
   (in-module "Gda")
-  (parent "GdaXqlItem")
-  (c-name "GdaXqlBin")
-  (gtype-id "GDA_TYPE_XQL_BIN")
+  (parent "GdaDataModelRow")
+  (c-name "GdaDataModelHash")
+  (gtype-id "GDA_TYPE_DATA_MODEL_HASH")
 )
 
-(define-object XqlFunc
+(define-object DataModelQuery
   (in-module "Gda")
-  (parent "GdaXqlBin")
-  (c-name "GdaXqlFunc")
-  (gtype-id "GDA_TYPE_XQL_FUNC")
+  (parent "GdaObject")
+  (c-name "GdaDataModelQuery")
+  (gtype-id "GDA_TYPE_DATA_MODEL_QUERY")
 )
 
-(define-object XqlAtom
+(define-object DataModelImport
   (in-module "Gda")
-  (parent "GdaXqlItem")
-  (c-name "GdaXqlAtom")
-  (gtype-id "GDA_TYPE_XQL_ATOM")
+  (parent "GdaObject")
+  (c-name "GdaDataModelImport")
+  (gtype-id "GDA_TYPE_DATA_MODEL_IMPORT")
 )
 
-(define-object XqlField
+(define-object DataAccessWrapper
   (in-module "Gda")
-  (parent "GdaXqlAtom")
-  (c-name "GdaXqlField")
-  (gtype-id "GDA_TYPE_XQL_FIELD")
+  (parent "GdaObject")
+  (c-name "GdaDataAccessWrapper")
+  (gtype-id "GDA_TYPE_DATA_ACCESS_WRAPPER")
 )
 
-(define-object XqlConst
+(define-object ObjectRef
   (in-module "Gda")
-  (parent "GdaXqlAtom")
-  (c-name "GdaXqlConst")
-  (gtype-id "GDA_TYPE_XQL_CONST")
+  (parent "GdaObject")
+  (c-name "GdaObjectRef")
+  (gtype-id "GDA_TYPE_OBJECT_REF")
 )
 
-(define-object XqlColumn
+(define-object Parameter
   (in-module "Gda")
-  (parent "GdaXqlAtom")
-  (c-name "GdaXqlColumn")
-  (gtype-id "GDA_TYPE_XQL_COLUMN")
+  (parent "GdaObject")
+  (c-name "GdaParameter")
+  (gtype-id "GDA_TYPE_PARAMETER")
 )
 
-(define-object XqlJoin
+(define-object ParameterList
   (in-module "Gda")
-  (parent "GdaXqlDual")
-  (c-name "GdaXqlJoin")
-  (gtype-id "GDA_TYPE_XQL_JOIN")
+  (parent "GdaObject")
+  (c-name "GdaParameterList")
+  (gtype-id "GDA_TYPE_PARAMETER_LIST")
 )
 
-(define-object XqlList
+(define-object DataModelIter
   (in-module "Gda")
-  (parent "GdaXqlItem")
-  (c-name "GdaXqlList")
-  (gtype-id "GDA_TYPE_XQL_LIST")
+  (parent "GdaParameterList")
+  (c-name "GdaDataModelIter")
+  (gtype-id "GDA_TYPE_DATA_MODEL_ITER")
 )
 
-(define-object XqlQuery
+(define-object QueryObject
   (in-module "Gda")
-  (parent "GdaXqlBin")
-  (c-name "GdaXqlQuery")
-  (gtype-id "GDA_TYPE_XQL_QUERY")
+  (parent "GdaObject")
+  (c-name "GdaQueryObject")
+  (gtype-id "GDA_TYPE_QUERY_OBJECT")
 )
 
-(define-object XqlSelect
+(define-object QueryJoin
   (in-module "Gda")
-  (parent "GdaXqlDml")
-  (c-name "GdaXqlSelect")
-  (gtype-id "GDA_TYPE_XQL_SELECT")
+  (parent "GdaQueryObject")
+  (c-name "GdaQueryJoin")
+  (gtype-id "GDA_TYPE_QUERY_JOIN")
 )
 
-(define-object XqlStack
+(define-object QueryField
   (in-module "Gda")
-  (parent "GObject")
-  (c-name "GdaXqlStack")
-  (gtype-id "GDA_TYPE_XQL_STACK")
+  (parent "GdaQueryObject")
+  (c-name "GdaQueryField")
+  (gtype-id "GDA_TYPE_QUERY_FIELD")
 )
 
-(define-object XqlTarget
+(define-object QueryFieldValue
   (in-module "Gda")
-  (parent "GdaXqlBin")
-  (c-name "GdaXqlTarget")
-  (gtype-id "GDA_TYPE_XQL_TARGET")
+  (parent "GdaQueryField")
+  (c-name "GdaQueryFieldValue")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_VALUE")
 )
 
-(define-object XqlUpdate
+(define-object QueryFieldFunc
   (in-module "Gda")
-  (parent "GdaXqlDml")
-  (c-name "GdaXqlUpdate")
-  (gtype-id "GDA_TYPE_XQL_UPDATE")
+  (parent "GdaQueryField")
+  (c-name "GdaQueryFieldFunc")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_FUNC")
 )
 
-(define-object XqlValue
+(define-object QueryFieldField
   (in-module "Gda")
-  (parent "GdaXqlBin")
-  (c-name "GdaXqlValue")
-  (gtype-id "GDA_TYPE_XQL_VALUE")
+  (parent "GdaQueryField")
+  (c-name "GdaQueryFieldField")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_FIELD")
 )
 
-(define-object XqlValueRef
+(define-object QueryFieldAll
   (in-module "Gda")
-  (parent "GdaXqlAtom")
-  (c-name "GdaXqlValueRef")
-  (gtype-id "GDA_TYPE_XQL_VALUE_REF")
+  (parent "GdaQueryField")
+  (c-name "GdaQueryFieldAll")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_ALL")
 )
 
-; boxed types
-
-(define-boxed Command
+(define-object QueryFieldAgg
   (in-module "Gda")
-  (c-name "GdaCommand")
-  (gtype-id "GDA_TYPE_COMMAND")
-  (copy-func "gda_command_copy")
-  (release-func "gda_command_free")
+  (parent "GdaQueryField")
+  (c-name "GdaQueryFieldAgg")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_AGG")
 )
 
-(define-boxed DataSourceInfo
+(define-object QueryCondition
   (in-module "Gda")
-  (c-name "GdaDataSourceInfo")
-  (gtype-id "GDA_TYPE_DATA_SOURCE_INFO")
-  (copy-func "gda_config_copy_data_source_info")
-  (release-func "gda_config_free_data_source_info")
-  (fields
-    '("gchar*" "name")
-    '("gchar*" "provider")
-    '("gchar*" "cnc_string")
-    '("gchar*" "description")
-    '("gchar*" "username")
-    '("gchar*" "password")
-  )
+  (parent "GdaQueryObject")
+  (c-name "GdaQueryCondition")
+  (gtype-id "GDA_TYPE_QUERY_CONDITION")
 )
 
-(define-boxed FieldAttributes
+(define-object Query
   (in-module "Gda")
-  (c-name "GdaFieldAttributes")
-  (gtype-id "GDA_TYPE_FIELD_ATTRIBUTES")
-  (copy-func "gda_field_attributes_copy")
-  (release-func "gda_field_attributes_free")
+  (parent "GdaQueryObject")
+  (c-name "GdaQuery")
+  (gtype-id "GDA_TYPE_QUERY")
 )
 
-(define-boxed Parameter
+(define-object QueryTarget
   (in-module "Gda")
-  (c-name "GdaParameter")
-  (gtype-id "GDA_TYPE_PARAMETER")
-  (copy-func "gda_parameter_copy")
-  (release-func "gda_parameter_free")
+  (parent "GdaQueryObject")
+  (c-name "GdaQueryTarget")
+  (gtype-id "GDA_TYPE_QUERY_TARGET")
 )
 
-(define-boxed ParameterList
+(define-object Referer
   (in-module "Gda")
-  (c-name "GdaParameterList")
-  (gtype-id "GDA_TYPE_PARAMETER_LIST")
-  (copy-func "gda_parameter_list_copy")
-  (release-func "gda_parameter_list_free")
+  (c-name "GdaReferer")
+  (gtype-id "GDA_TYPE_REFERER")
 )
 
-(define-boxed ProviderInfo
+(define-object Renderer
   (in-module "Gda")
-  (c-name "GdaProviderInfo")
-  (gtype-id "GDA_TYPE_PROVIDER_INFO")
-  (copy-func "gda_provider_info_copy")
-  (release-func "gda_config_free_provider_info")
-  (fields
-    '("gchar*" "id")
-  )
+  (c-name "GdaRenderer")
+  (gtype-id "GDA_TYPE_RENDERER")
 )
 
-(define-boxed Row
+(define-object Row
   (in-module "Gda")
+  (parent "GObject")
   (c-name "GdaRow")
   (gtype-id "GDA_TYPE_ROW")
-  (copy-func "gda_row_copy")
-  (release-func "gda_row_free")
 )
 
-(define-boxed Value
+(define-object ServerOperation
+  (in-module "Gda")
+  (parent "GObject")
+  (c-name "GdaServerOperation")
+  (gtype-id "GDA_TYPE_SERVER_OPERATION")
+)
+
+(define-object ServerProvider
+  (in-module "Gda")
+  (parent "GObject")
+  (c-name "GdaServerProvider")
+  (gtype-id "GDA_TYPE_SERVER_PROVIDER")
+)
+
+(define-object Threader
+  (in-module "Gda")
+  (parent "GObject")
+  (c-name "GdaThreader")
+  (gtype-id "GDA_TYPE_THREADER")
+)
+
+(define-object Transaction
+  (in-module "Gda")
+  (parent "GObject")
+  (c-name "GdaTransaction")
+  (gtype-id "GDA_TYPE_TRANSACTION")
+)
+
+(define-object XmlStorage
   (in-module "Gda")
-  (c-name "GdaValue")
-  (gtype-id "GDA_TYPE_VALUE")
-  (copy-func "gda_value_copy")
-  (release-func "gda_value_free")
+  (c-name "GdaXmlStorage")
+  (gtype-id "GDA_TYPE_XML_STORAGE")
 )
 
 ;; Enumerations and flags ...
@@ -343,6 +378,25 @@
   )
 )
 
+(define-enum ClientError
+  (in-module "Gda")
+  (c-name "GdaClientError")
+  (gtype-id "GDA_TYPE_CLIENT_ERROR")
+  (values
+    '("r" "GDA_CLIENT_GENERAL_ERROR")
+  )
+)
+
+(define-enum Sorting
+  (in-module "Gda")
+  (c-name "GdaSorting")
+  (gtype-id "GDA_TYPE_SORTING")
+  (values
+    '("ascending" "GDA_SORTING_ASCENDING")
+    '("descending" "GDA_SORTING_DESCENDING")
+  )
+)
+
 (define-flags CommandOptions
   (in-module "Gda")
   (c-name "GdaCommandOptions")
@@ -368,6 +422,59 @@
   )
 )
 
+(define-enum ConnectionEventType
+  (in-module "Gda")
+  (c-name "GdaConnectionEventType")
+  (gtype-id "GDA_TYPE_CONNECTION_EVENT_TYPE")
+  (values
+    '("notice" "GDA_CONNECTION_EVENT_NOTICE")
+    '("warning" "GDA_CONNECTION_EVENT_WARNING")
+    '("error" "GDA_CONNECTION_EVENT_ERROR")
+  )
+)
+
+(define-enum ConnectionEventCode
+  (in-module "Gda")
+  (c-name "GdaConnectionEventCode")
+  (gtype-id "GDA_TYPE_CONNECTION_EVENT_CODE")
+  (values
+    '("constraint-violation" "GDA_CONNECTION_EVENT_CODE_CONSTRAINT_VIOLATION")
+    '("restrict-violation" "GDA_CONNECTION_EVENT_CODE_RESTRICT_VIOLATION")
+    '("not-null-violation" "GDA_CONNECTION_EVENT_CODE_NOT_NULL_VIOLATION")
+    '("foreign-key-violation" "GDA_CONNECTION_EVENT_CODE_FOREIGN_KEY_VIOLATION")
+    '("unique-violation" "GDA_CONNECTION_EVENT_CODE_UNIQUE_VIOLATION")
+    '("check-violation" "GDA_CONNECTION_EVENT_CODE_CHECK_VIOLATION")
+    '("insufficient-privileges" "GDA_CONNECTION_EVENT_CODE_INSUFFICIENT_PRIVILEGES")
+    '("undefined-column" "GDA_CONNECTION_EVENT_CODE_UNDEFINED_COLUMN")
+    '("undefined-function" "GDA_CONNECTION_EVENT_CODE_UNDEFINED_FUNCTION")
+    '("undefined-table" "GDA_CONNECTION_EVENT_CODE_UNDEFINED_TABLE")
+    '("duplicate-column" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_COLUMN")
+    '("duplicate-database" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_DATABASE")
+    '("duplicate-function" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_FUNCTION")
+    '("duplicate-schema" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_SCHEMA")
+    '("duplicate-table" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_TABLE")
+    '("duplicate-alias" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_ALIAS")
+    '("duplicate-object" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_OBJECT")
+    '("syntax-error" "GDA_CONNECTION_EVENT_CODE_SYNTAX_ERROR")
+    '("unknown" "GDA_CONNECTION_EVENT_CODE_UNKNOWN")
+  )
+)
+
+(define-enum ConnectionError
+  (in-module "Gda")
+  (c-name "GdaConnectionError")
+  (gtype-id "GDA_TYPE_CONNECTION_ERROR")
+  (values
+    '("conn-open-error" "GDA_CONNECTION_CONN_OPEN_ERROR")
+    '("do-query-error" "GDA_CONNECTION_DO_QUERY_ERROR")
+    '("nonexist-dsn-error" "GDA_CONNECTION_NONEXIST_DSN_ERROR")
+    '("no-cnc-spec-error" "GDA_CONNECTION_NO_CNC_SPEC_ERROR")
+    '("no-provider-spec-error" "GDA_CONNECTION_NO_PROVIDER_SPEC_ERROR")
+    '("open-error" "GDA_CONNECTION_OPEN_ERROR")
+    '("execute-command-error" "GDA_CONNECTION_EXECUTE_COMMAND_ERROR")
+  )
+)
+
 (define-flags ConnectionOptions
   (in-module "Gda")
   (c-name "GdaConnectionOptions")
@@ -419,1975 +526,5196 @@
     '("types" "GDA_CONNECTION_SCHEMA_TYPES")
     '("users" "GDA_CONNECTION_SCHEMA_USERS")
     '("views" "GDA_CONNECTION_SCHEMA_VIEWS")
+    '("constraints" "GDA_CONNECTION_SCHEMA_CONSTRAINTS")
+    '("table-contents" "GDA_CONNECTION_SCHEMA_TABLE_CONTENTS")
   )
 )
 
-(define-enum TransactionIsolation
+(define-flags DataModelAccessFlags
   (in-module "Gda")
-  (c-name "GdaTransactionIsolation")
-  (gtype-id "GDA_TYPE_TRANSACTION_ISOLATION")
+  (c-name "GdaDataModelAccessFlags")
+  (gtype-id "GDA_TYPE_DATA_MODEL_ACCESS_FLAGS")
   (values
-    '("unknown" "GDA_TRANSACTION_ISOLATION_UNKNOWN")
-    '("read-committed" "GDA_TRANSACTION_ISOLATION_READ_COMMITTED")
-    '("read-uncommitted" "GDA_TRANSACTION_ISOLATION_READ_UNCOMMITTED")
-    '("repeatable-read" "GDA_TRANSACTION_ISOLATION_REPEATABLE_READ")
-    '("serializable" "GDA_TRANSACTION_ISOLATION_SERIALIZABLE")
+    '("random" "GDA_DATA_MODEL_ACCESS_RANDOM")
+    '("cursor-forward" "GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD")
+    '("cursor-backward" "GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD")
+    '("insert" "GDA_DATA_MODEL_ACCESS_INSERT")
+    '("update" "GDA_DATA_MODEL_ACCESS_UPDATE")
+    '("delete" "GDA_DATA_MODEL_ACCESS_DELETE")
+    '("write" "GDA_DATA_MODEL_ACCESS_WRITE")
   )
 )
 
-(define-enum ValueType
+(define-enum DataModelHint
   (in-module "Gda")
-  (c-name "GdaValueType")
-  (gtype-id "GDA_TYPE_VALUE_TYPE")
+  (c-name "GdaDataModelHint")
+  (gtype-id "GDA_TYPE_DATA_MODEL_HINT")
   (values
-    '("null" "GDA_VALUE_TYPE_NULL")
-    '("bigint" "GDA_VALUE_TYPE_BIGINT")
-    '("biguint" "GDA_VALUE_TYPE_BIGUINT")
-    '("binary" "GDA_VALUE_TYPE_BINARY")
-    '("blob" "GDA_VALUE_TYPE_BLOB")
-    '("boolean" "GDA_VALUE_TYPE_BOOLEAN")
-    '("date" "GDA_VALUE_TYPE_DATE")
-    '("double" "GDA_VALUE_TYPE_DOUBLE")
-    '("geometric-point" "GDA_VALUE_TYPE_GEOMETRIC_POINT")
-    '("gobject" "GDA_VALUE_TYPE_GOBJECT")
-    '("integer" "GDA_VALUE_TYPE_INTEGER")
-    '("list" "GDA_VALUE_TYPE_LIST")
-    '("money" "GDA_VALUE_TYPE_MONEY")
-    '("numeric" "GDA_VALUE_TYPE_NUMERIC")
-    '("single" "GDA_VALUE_TYPE_SINGLE")
-    '("smallint" "GDA_VALUE_TYPE_SMALLINT")
-    '("smalluint" "GDA_VALUE_TYPE_SMALLUINT")
-    '("string" "GDA_VALUE_TYPE_STRING")
-    '("time" "GDA_VALUE_TYPE_TIME")
-    '("timestamp" "GDA_VALUE_TYPE_TIMESTAMP")
-    '("tinyint" "GDA_VALUE_TYPE_TINYINT")
-    '("tinyuint" "GDA_VALUE_TYPE_TINYUINT")
-    '("type" "GDA_VALUE_TYPE_TYPE")
-    '("uinteger" "GDA_VALUE_TYPE_UINTEGER")
-    '("unknown" "GDA_VALUE_TYPE_UNKNOWN")
+    '("start-batch-update" "GDA_DATA_MODEL_HINT_START_BATCH_UPDATE")
+    '("end-batch-update" "GDA_DATA_MODEL_HINT_END_BATCH_UPDATE")
+    '("refresh" "GDA_DATA_MODEL_HINT_REFRESH")
   )
 )
 
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-blob.h
-
-(define-method open
-  (of-object "GdaBlob")
-  (c-name "gda_blob_open")
-  (return-type "gint")
-  (parameters
-    '("GdaBlobMode" "mode")
+(define-enum DataModelIOFormat
+  (in-module "Gda")
+  (c-name "GdaDataModelIOFormat")
+  (gtype-id "GDA_TYPE_DATA_MODEL_IO_FORMAT")
+  (values
+    '("data-array-xml" "GDA_DATA_MODEL_IO_DATA_ARRAY_XML")
+    '("text-separated" "GDA_DATA_MODEL_IO_TEXT_SEPARATED")
   )
 )
 
-(define-method read
-  (of-object "GdaBlob")
-  (c-name "gda_blob_read")
-  (return-type "gint")
-  (parameters
-    '("gpointer" "buf")
-    '("gint" "size")
-    '("gint*" "bytes_read")
+(define-enum DataModelIterError
+  (in-module "Gda")
+  (c-name "GdaDataModelIterError")
+  (gtype-id "GDA_TYPE_DATA_MODEL_ITER_ERROR")
+  (values
+    '("r" "GDA_DATA_MODEL_ITER_WHAT_ERROR")
   )
 )
 
-(define-method write
-  (of-object "GdaBlob")
-  (c-name "gda_blob_write")
-  (return-type "gint")
-  (parameters
-    '("gpointer" "buf")
-    '("gint" "size")
-    '("gint*" "bytes_written")
+(define-enum DataModelQueryError
+  (in-module "Gda")
+  (c-name "GdaDataModelQueryError")
+  (gtype-id "GDA_TYPE_DATA_MODEL_QUERY_ERROR")
+  (values
+    '("r" "GDA_DATA_MODEL_QUERY_XML_LOAD_ERROR")
   )
 )
 
-(define-method lseek
-  (of-object "GdaBlob")
-  (c-name "gda_blob_lseek")
-  (return-type "gint")
-  (parameters
-    '("gint" "offset")
-    '("gint" "whence")
+(define-enum DataProxyError
+  (in-module "Gda")
+  (c-name "GdaDataProxyError")
+  (gtype-id "GDA_TYPE_DATA_PROXY_ERROR")
+  (values
+    '("r" "GDA_DATA_PROXY_COMMIT_ERROR")
   )
 )
 
-(define-method close
-  (of-object "GdaBlob")
-  (c-name "gda_blob_close")
-  (return-type "gint")
+(define-enum DictAggregateError
+  (in-module "Gda")
+  (c-name "GdaDictAggregateError")
+  (gtype-id "GDA_TYPE_DICT_AGGREGATE_ERROR")
+  (values
+    '("r" "GDA_DICT_AGGREGATE_XML_LOAD_ERROR")
+  )
 )
 
-(define-method remove
-  (of-object "GdaBlob")
-  (c-name "gda_blob_remove")
-  (return-type "gint")
+(define-enum DictConstraintError
+  (in-module "Gda")
+  (c-name "GdaDictConstraintError")
+  (gtype-id "GDA_TYPE_DICT_CONSTRAINT_ERROR")
+  (values
+    '("save-error" "GDA_DICT_CONSTRAINT_XML_SAVE_ERROR")
+    '("load-error" "GDA_DICT_CONSTRAINT_XML_LOAD_ERROR")
+  )
 )
 
-(define-method free_data
-  (of-object "GdaBlob")
-  (c-name "gda_blob_free_data")
-  (return-type "none")
+(define-enum DictConstraintType
+  (in-module "Gda")
+  (c-name "GdaDictConstraintType")
+  (gtype-id "GDA_TYPE_DICT_CONSTRAINT_TYPE")
+  (values
+    '("primary-key" "CONSTRAINT_PRIMARY_KEY")
+    '("foreign-key" "CONSTRAINT_FOREIGN_KEY")
+    '("unique" "CONSTRAINT_UNIQUE")
+    '("not-null" "CONSTRAINT_NOT_NULL")
+    '("check-expr" "CONSTRAINT_CHECK_EXPR")
+    '("check-in-list" "CONSTRAINT_CHECK_IN_LIST")
+    '("check-setof-list" "CONSTRAINT_CHECK_SETOF_LIST")
+    '("unknown" "CONSTRAINT_UNKNOWN")
+  )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-client.h
-
-(define-function gda_client_get_type
-  (c-name "gda_client_get_type")
-  (return-type "GType")
+(define-enum DictConstraintFkAction
+  (in-module "Gda")
+  (c-name "GdaDictConstraintFkAction")
+  (gtype-id "GDA_TYPE_DICT_CONSTRAINT_FK_ACTION")
+  (values
+    '("cascade" "CONSTRAINT_FK_ACTION_CASCADE")
+    '("set-null" "CONSTRAINT_FK_ACTION_SET_NULL")
+    '("set-default" "CONSTRAINT_FK_ACTION_SET_DEFAULT")
+    '("set-value" "CONSTRAINT_FK_ACTION_SET_VALUE")
+    '("no-action" "CONSTRAINT_FK_ACTION_NO_ACTION")
+  )
 )
 
-(define-function gda_client_new
-  (c-name "gda_client_new")
-  (is-constructor-of "GdaClient")
-  (return-type "GdaClient*")
+(define-enum DictDatabaseError
+  (in-module "Gda")
+  (c-name "GdaDictDatabaseError")
+  (gtype-id "GDA_TYPE_DICT_DATABASE_ERROR")
+  (values
+    '("xml-save-error" "GDA_DICT_DATABASE_XML_SAVE_ERROR")
+    '("xml-load-error" "GDA_DICT_DATABASE_XML_LOAD_ERROR")
+    '("meta-data-update" "GDA_DICT_DATABASE_META_DATA_UPDATE")
+    '("meta-data-update-user-stopped" "GDA_DICT_DATABASE_META_DATA_UPDATE_USER_STOPPED")
+    '("tables-error" "GDA_DICT_DATABASE_TABLES_ERROR")
+    '("sequences-error" "GDA_DICT_DATABASE_SEQUENCES_ERROR")
+  )
 )
 
-(define-method open_connection
-  (of-object "GdaClient")
-  (c-name "gda_client_open_connection")
-  (return-type "GdaConnection*")
-  (parameters
-    '("const-gchar*" "dsn")
-    '("const-gchar*" "username")
-    '("const-gchar*" "password")
-    '("GdaConnectionOptions" "options" (default "0"))
+(define-enum DictFieldError
+  (in-module "Gda")
+  (c-name "GdaDictFieldError")
+  (gtype-id "GDA_TYPE_DICT_FIELD_ERROR")
+  (values
+    '("r" "GDA_DICT_FIELD_XML_LOAD_ERROR")
   )
 )
 
-(define-method open_connection_from_string
-  (of-object "GdaClient")
-  (c-name "gda_client_open_connection_from_string")
-  (return-type "GdaConnection*")
-  (parameters
-    '("const-gchar*" "provider_id")
-    '("const-gchar*" "cnc_string")
-    '("GdaConnectionOptions" "options")
+(define-flags DictFieldAttribute
+  (in-module "Gda")
+  (c-name "GdaDictFieldAttribute")
+  (gtype-id "GDA_TYPE_DICT_FIELD_ATTRIBUTE")
+  (values
+    '("t" "FIELD_AUTO_INCREMENT")
   )
 )
 
-(define-method get_connection_list
-  (of-object "GdaClient")
-  (c-name "gda_client_get_connection_list")
-  (return-type "const-GList*")
+(define-enum DictFunctionError
+  (in-module "Gda")
+  (c-name "GdaDictFunctionError")
+  (gtype-id "GDA_TYPE_DICT_FUNCTION_ERROR")
+  (values
+    '("r" "GDA_DICT_FUNCTION_XML_LOAD_ERROR")
+  )
 )
 
-(define-method find_connection
-  (of-object "GdaClient")
-  (c-name "gda_client_find_connection")
-  (return-type "GdaConnection*")
-  (parameters
-    '("const-gchar*" "dsn")
-    '("const-gchar*" "username")
-    '("const-gchar*" "password")
+(define-enum DictError
+  (in-module "Gda")
+  (c-name "GdaDictError")
+  (gtype-id "GDA_TYPE_DICT_ERROR")
+  (values
+    '("meta-data-update-error" "GDA_DICT_META_DATA_UPDATE_ERROR")
+    '("meta-data-update-user-stopped" "GDA_DICT_META_DATA_UPDATE_USER_STOPPED")
+    '("load-file-not-exist-error" "GDA_DICT_LOAD_FILE_NOT_EXIST_ERROR")
+    '("file-load-error" "GDA_DICT_FILE_LOAD_ERROR")
+    '("file-save-error" "GDA_DICT_FILE_SAVE_ERROR")
+    '("datatype-error" "GDA_DICT_DATATYPE_ERROR")
+    '("functions-error" "GDA_DICT_FUNCTIONS_ERROR")
+    '("aggregates-error" "GDA_DICT_AGGREGATES_ERROR")
   )
 )
 
-(define-method close_all_connections
-  (of-object "GdaClient")
-  (c-name "gda_client_close_all_connections")
-  (return-type "none")
+(define-enum DictTableError
+  (in-module "Gda")
+  (c-name "GdaDictTableError")
+  (gtype-id "GDA_TYPE_DICT_TABLE_ERROR")
+  (values
+    '("table-xml-load-error" "GDA_DICT_TABLE_XML_LOAD_ERROR")
+    '("table-meta-data-update" "GDA_DICT_TABLE_META_DATA_UPDATE")
+    '("fields-error" "GDA_DICT_FIELDS_ERROR")
+  )
 )
 
-(define-method notify_event
-  (of-object "GdaClient")
-  (c-name "gda_client_notify_event")
-  (return-type "none")
-  (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaClientEvent" "event")
-    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
+(define-enum DictTypeError
+  (in-module "Gda")
+  (c-name "GdaDictTypeError")
+  (gtype-id "GDA_TYPE_DICT_TYPE_ERROR")
+  (values
+    '("r" "GDA_DICT_TYPE_XML_LOAD_ERROR")
   )
 )
 
-(define-method notify_error_event
-  (of-object "GdaClient")
-  (c-name "gda_client_notify_error_event")
-  (return-type "none")
-  (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaError*" "error")
+(define-flags Attribute
+  (in-module "GValue")
+  (c-name "GdaValueAttribute")
+  (gtype-id "GDA_TYPE_VALUE_ATTRIBUTE")
+  (values
+    '("is-null" "GDA_VALUE_ATTR_IS_NULL")
+    '("can-be-null" "GDA_VALUE_ATTR_CAN_BE_NULL")
+    '("is-default" "GDA_VALUE_ATTR_IS_DEFAULT")
+    '("can-be-default" "GDA_VALUE_ATTR_CAN_BE_DEFAULT")
+    '("is-unchanged" "GDA_VALUE_ATTR_IS_UNCHANGED")
+    '("actions-shown" "GDA_VALUE_ATTR_ACTIONS_SHOWN")
+    '("data-non-valid" "GDA_VALUE_ATTR_DATA_NON_VALID")
+    '("has-value-orig" "GDA_VALUE_ATTR_HAS_VALUE_ORIG")
+    '("no-modif" "GDA_VALUE_ATTR_NO_MODIF")
   )
 )
 
-(define-method notify_connection_opened_event
-  (of-object "GdaClient")
-  (c-name "gda_client_notify_connection_opened_event")
-  (return-type "none")
-  (parameters
-    '("GdaConnection*" "cnc")
+(define-enum GraphType
+  (in-module "Gda")
+  (c-name "GdaGraphType")
+  (gtype-id "GDA_TYPE_GRAPH_TYPE")
+  (values
+    '("db-relations" "GDA_GRAPH_DB_RELATIONS")
+    '("query-joins" "GDA_GRAPH_QUERY_JOINS")
+    '("modelling" "GDA_GRAPH_MODELLING")
   )
 )
 
-(define-method notify_connection_closed_event
+(define-flags QueryFieldState
+  (in-module "Gda")
+  (c-name "GdaQueryFieldState")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_STATE")
+  (values
+    '("visible" "GDA_ENTITY_FIELD_VISIBLE")
+    '("invisible" "GDA_ENTITY_FIELD_INVISIBLE")
+    '("any" "GDA_ENTITY_FIELD_ANY")
+  )
+)
+
+(define-enum ObjectRefType
+  (in-module "Gda")
+  (c-name "GdaObjectRefType")
+  (gtype-id "GDA_TYPE_OBJECT_REF_TYPE")
+  (values
+    '("xml-id" "REFERENCE_BY_XML_ID")
+    '("name" "REFERENCE_BY_NAME")
+  )
+)
+
+(define-enum ObjectRefError
+  (in-module "Gda")
+  (c-name "GdaObjectRefError")
+  (gtype-id "GDA_TYPE_OBJECT_REF_ERROR")
+  (values
+    '("r" "GDA_OBJECT_REF_XML_LOAD_ERROR")
+  )
+)
+
+(define-enum ParameterError
+  (in-module "Gda")
+  (c-name "GdaParameterError")
+  (gtype-id "GDA_TYPE_PARAMETER_ERROR")
+  (values
+    '("r" "GDA_PARAMETER_QUERY_LIMIT_ERROR")
+  )
+)
+
+(define-enum ParameterListError
+  (in-module "Gda")
+  (c-name "GdaParameterListError")
+  (gtype-id "GDA_TYPE_PARAMETER_LIST_ERROR")
+  (values
+    '("no-node-error" "GDA_PARAMETER_LIST_NO_NODE_ERROR")
+    '("node-outdated-error" "GDA_PARAMETER_LIST_NODE_OUTDATED_ERROR")
+    '("value-prov-obj-type-error" "GDA_PARAMETER_LIST_VALUE_PROV_OBJ_TYPE_ERROR")
+    '("value-prov-data-type-error" "GDA_PARAMETER_LIST_VALUE_PROV_DATA_TYPE_ERROR")
+    '("value-prov-invisible-error" "GDA_PARAMETER_LIST_VALUE_PROV_INVISIBLE_ERROR")
+    '("value-prov-query-type-error" "GDA_PARAMETER_LIST_VALUE_PROV_QUERY_TYPE_ERROR")
+    '("dependency-not-in-paramlist-error" "GDA_PARAMETER_LIST_DEPENDENCY_NOT_IN_PARAMLIST_ERROR")
+    '("dependency-position-error" "GDA_PARAMETER_LIST_DEPENDENCY_POSITION_ERROR")
+    '("xml-spec-error" "GDA_PARAMETER_LIST_XML_SPEC_ERROR")
+  )
+)
+
+(define-flags ParameterListParamHint
+  (in-module "Gda")
+  (c-name "GdaParameterListParamHint")
+  (gtype-id "GDA_TYPE_PARAMETER_LIST_PARAM_HINT")
+  (values
+    '("read-only" "GDA_PARAMETER_LIST_PARAM_READ_ONLY")
+    '("hide" "GDA_PARAMETER_LIST_PARAM_HIDE")
+  )
+)
+
+(define-enum QueryConditionType
+  (in-module "Gda")
+  (c-name "GdaQueryConditionType")
+  (gtype-id "GDA_TYPE_QUERY_CONDITION_TYPE")
+  (values
+    '("node-and" "GDA_QUERY_CONDITION_NODE_AND")
+    '("node-or" "GDA_QUERY_CONDITION_NODE_OR")
+    '("node-not" "GDA_QUERY_CONDITION_NODE_NOT")
+    '("leaf-equal" "GDA_QUERY_CONDITION_LEAF_EQUAL")
+    '("leaf-diff" "GDA_QUERY_CONDITION_LEAF_DIFF")
+    '("leaf-sup" "GDA_QUERY_CONDITION_LEAF_SUP")
+    '("leaf-supequal" "GDA_QUERY_CONDITION_LEAF_SUPEQUAL")
+    '("leaf-inf" "GDA_QUERY_CONDITION_LEAF_INF")
+    '("leaf-infequal" "GDA_QUERY_CONDITION_LEAF_INFEQUAL")
+    '("leaf-like" "GDA_QUERY_CONDITION_LEAF_LIKE")
+    '("leaf-similar" "GDA_QUERY_CONDITION_LEAF_SIMILAR")
+    '("leaf-regex" "GDA_QUERY_CONDITION_LEAF_REGEX")
+    '("leaf-regex-nocase" "GDA_QUERY_CONDITION_LEAF_REGEX_NOCASE")
+    '("leaf-not-regex" "GDA_QUERY_CONDITION_LEAF_NOT_REGEX")
+    '("leaf-not-regex-nocase" "GDA_QUERY_CONDITION_LEAF_NOT_REGEX_NOCASE")
+    '("leaf-in" "GDA_QUERY_CONDITION_LEAF_IN")
+    '("leaf-between" "GDA_QUERY_CONDITION_LEAF_BETWEEN")
+    '("type-unknown" "GDA_QUERY_CONDITION_TYPE_UNKNOWN")
+  )
+)
+
+(define-enum QueryConditionOperator
+  (in-module "Gda")
+  (c-name "GdaQueryConditionOperator")
+  (gtype-id "GDA_TYPE_QUERY_CONDITION_OPERATOR")
+  (values
+    '("left" "GDA_QUERY_CONDITION_OP_LEFT")
+    '("right" "GDA_QUERY_CONDITION_OP_RIGHT")
+    '("right2" "GDA_QUERY_CONDITION_OP_RIGHT2")
+  )
+)
+
+(define-enum QueryConditionError
+  (in-module "Gda")
+  (c-name "GdaQueryConditionError")
+  (gtype-id "GDA_TYPE_QUERY_CONDITION_ERROR")
+  (values
+    '("xml-load-error" "GDA_QUERY_CONDITION_XML_LOAD_ERROR")
+    '("renderer-error" "GDA_QUERY_CONDITION_RENDERER_ERROR")
+    '("parent-error" "GDA_QUERY_CONDITION_PARENT_ERROR")
+  )
+)
+
+(define-enum QueryFieldAggError
+  (in-module "Gda")
+  (c-name "GdaQueryFieldAggError")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_AGG_ERROR")
+  (values
+    '("xml-load-error" "GDA_QUERY_FIELD_AGG_XML_LOAD_ERROR")
+    '("render-error" "GDA_QUERY_FIELD_AGG_RENDER_ERROR")
+  )
+)
+
+(define-enum QueryFieldAllError
+  (in-module "Gda")
+  (c-name "GdaQueryFieldAllError")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_ALL_ERROR")
+  (values
+    '("xml-load-error" "GDA_QUERY_FIELD_ALL_XML_LOAD_ERROR")
+    '("render-error" "GDA_QUERY_FIELD_ALL_RENDER_ERROR")
+  )
+)
+
+(define-enum QueryFieldFieldError
+  (in-module "Gda")
+  (c-name "GdaQueryFieldFieldError")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_FIELD_ERROR")
+  (values
+    '("xml-load-error" "GDA_QUERY_FIELD_FIELD_XML_LOAD_ERROR")
+    '("render-error" "GDA_QUERY_FIELD_FIELD_RENDER_ERROR")
+  )
+)
+
+(define-enum QueryFieldFuncError
+  (in-module "Gda")
+  (c-name "GdaQueryFieldFuncError")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_FUNC_ERROR")
+  (values
+    '("xml-load-error" "GDA_QUERY_FIELD_FUNC_XML_LOAD_ERROR")
+    '("render-error" "GDA_QUERY_FIELD_FUNC_RENDER_ERROR")
+  )
+)
+
+(define-enum QueryFieldError
+  (in-module "Gda")
+  (c-name "GdaQueryFieldError")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_ERROR")
+  (values
+    '("r" "GDA_QUERY_FIELD_XML_LOAD_ERROR")
+  )
+)
+
+(define-enum QueryFieldValueError
+  (in-module "Gda")
+  (c-name "GdaQueryFieldValueError")
+  (gtype-id "GDA_TYPE_QUERY_FIELD_VALUE_ERROR")
+  (values
+    '("xml-load-error" "GDA_QUERY_FIELD_VALUE_XML_LOAD_ERROR")
+    '("render-error" "GDA_QUERY_FIELD_VALUE_RENDER_ERROR")
+    '("param-error" "GDA_QUERY_FIELD_VALUE_PARAM_ERROR")
+    '("default-param-error" "GDA_QUERY_FIELD_VALUE_DEFAULT_PARAM_ERROR")
+  )
+)
+
+(define-enum QueryType
+  (in-module "Gda")
+  (c-name "GdaQueryType")
+  (gtype-id "GDA_TYPE_QUERY_TYPE")
+  (values
+    '("select" "GDA_QUERY_TYPE_SELECT")
+    '("insert" "GDA_QUERY_TYPE_INSERT")
+    '("update" "GDA_QUERY_TYPE_UPDATE")
+    '("delete" "GDA_QUERY_TYPE_DELETE")
+    '("union" "GDA_QUERY_TYPE_UNION")
+    '("intersect" "GDA_QUERY_TYPE_INTERSECT")
+    '("except" "GDA_QUERY_TYPE_EXCEPT")
+    '("non-parsed-sql" "GDA_QUERY_TYPE_NON_PARSED_SQL")
+  )
+)
+
+(define-enum QueryError
+  (in-module "Gda")
+  (c-name "GdaQueryError")
+  (gtype-id "GDA_TYPE_QUERY_ERROR")
+  (values
+    '("xml-load-error" "GDA_QUERY_XML_LOAD_ERROR")
+    '("meta-data-update" "GDA_QUERY_META_DATA_UPDATE")
+    '("fields-error" "GDA_QUERY_FIELDS_ERROR")
+    '("targets-error" "GDA_QUERY_TARGETS_ERROR")
+    '("render-error" "GDA_QUERY_RENDER_ERROR")
+    '("parse-error" "GDA_QUERY_PARSE_ERROR")
+    '("syntax-error" "GDA_QUERY_SYNTAX_ERROR")
+    '("structure-error" "GDA_QUERY_STRUCTURE_ERROR")
+    '("sql-analyse-error" "GDA_QUERY_SQL_ANALYSE_ERROR")
+    '("no-cnc-error" "GDA_QUERY_NO_CNC_ERROR")
+    '("cnc-closed-error" "GDA_QUERY_CNC_CLOSED_ERROR")
+  )
+)
+
+(define-enum QueryJoinType
+  (in-module "Gda")
+  (c-name "GdaQueryJoinType")
+  (gtype-id "GDA_TYPE_QUERY_JOIN_TYPE")
+  (values
+    '("inner" "GDA_QUERY_JOIN_TYPE_INNER")
+    '("left-outer" "GDA_QUERY_JOIN_TYPE_LEFT_OUTER")
+    '("right-outer" "GDA_QUERY_JOIN_TYPE_RIGHT_OUTER")
+    '("full-outer" "GDA_QUERY_JOIN_TYPE_FULL_OUTER")
+    '("cross" "GDA_QUERY_JOIN_TYPE_CROSS")
+    '("last" "GDA_QUERY_JOIN_TYPE_LAST")
+  )
+)
+
+(define-enum QueryJoinError
+  (in-module "Gda")
+  (c-name "GdaQueryJoinError")
+  (gtype-id "GDA_TYPE_QUERY_JOIN_ERROR")
+  (values
+    '("xml-load-error" "GDA_QUERY_JOIN_XML_LOAD_ERROR")
+    '("meta-data-update" "GDA_QUERY_JOIN_META_DATA_UPDATE")
+    '("fields-error" "GDA_QUERY_JOIN_FIELDS_ERROR")
+    '("sql-analyse-error" "GDA_QUERY_JOIN_SQL_ANALYSE_ERROR")
+    '("parse-error" "GDA_QUERY_JOIN_PARSE_ERROR")
+  )
+)
+
+(define-enum QueryTargetError
+  (in-module "Gda")
+  (c-name "GdaQueryTargetError")
+  (gtype-id "GDA_TYPE_QUERY_TARGET_ERROR")
+  (values
+    '("xml-load-error" "GDA_QUERY_TARGET_XML_LOAD_ERROR")
+    '("xml-save-error" "GDA_QUERY_TARGET_XML_SAVE_ERROR")
+    '("meta-data-update" "GDA_QUERY_TARGET_META_DATA_UPDATE")
+    '("fields-error" "GDA_QUERY_TARGET_FIELDS_ERROR")
+  )
+)
+
+(define-flags RendererOptions
+  (in-module "Gda")
+  (c-name "GdaRendererOptions")
+  (gtype-id "GDA_TYPE_RENDERER_OPTIONS")
+  (values
+    '("extra-pretty-sql" "GDA_RENDERER_EXTRA_PRETTY_SQL")
+    '("extra-val-attrs" "GDA_RENDERER_EXTRA_VAL_ATTRS")
+    '("error-if-default" "GDA_RENDERER_ERROR_IF_DEFAULT")
+    '("fields-no-target-alias" "GDA_RENDERER_FIELDS_NO_TARGET_ALIAS")
+  )
+)
+
+(define-enum ServerOperationType
+  (in-module "Gda")
+  (c-name "GdaServerOperationType")
+  (gtype-id "GDA_TYPE_SERVER_OPERATION_TYPE")
+  (values
+    '("create-db" "GDA_SERVER_OPERATION_CREATE_DB")
+    '("drop-db" "GDA_SERVER_OPERATION_DROP_DB")
+    '("create-table" "GDA_SERVER_OPERATION_CREATE_TABLE")
+    '("drop-table" "GDA_SERVER_OPERATION_DROP_TABLE")
+    '("rename-table" "GDA_SERVER_OPERATION_RENAME_TABLE")
+    '("add-column" "GDA_SERVER_OPERATION_ADD_COLUMN")
+    '("drop-column" "GDA_SERVER_OPERATION_DROP_COLUMN")
+    '("create-index" "GDA_SERVER_OPERATION_CREATE_INDEX")
+    '("drop-index" "GDA_SERVER_OPERATION_DROP_INDEX")
+    '("nb" "GDA_SERVER_OPERATION_NB")
+  )
+)
+
+(define-enum ServerOperationNodeType
+  (in-module "Gda")
+  (c-name "GdaServerOperationNodeType")
+  (gtype-id "GDA_TYPE_SERVER_OPERATION_NODE_TYPE")
+  (values
+    '("paramlist" "GDA_SERVER_OPERATION_NODE_PARAMLIST")
+    '("data-model" "GDA_SERVER_OPERATION_NODE_DATA_MODEL")
+    '("param" "GDA_SERVER_OPERATION_NODE_PARAM")
+    '("sequence" "GDA_SERVER_OPERATION_NODE_SEQUENCE")
+    '("sequence-item" "GDA_SERVER_OPERATION_NODE_SEQUENCE_ITEM")
+    '("data-model-column" "GDA_SERVER_OPERATION_NODE_DATA_MODEL_COLUMN")
+    '("unknown" "GDA_SERVER_OPERATION_NODE_UNKNOWN")
+  )
+)
+
+(define-enum ServerOperationNodeStatus
+  (in-module "Gda")
+  (c-name "GdaServerOperationNodeStatus")
+  (gtype-id "GDA_TYPE_SERVER_OPERATION_NODE_STATUS")
+  (values
+    '("optional" "GDA_SERVER_OPERATION_STATUS_OPTIONAL")
+    '("required" "GDA_SERVER_OPERATION_STATUS_REQUIRED")
+    '("unknown" "GDA_SERVER_OPERATION_STATUS_UNKNOWN")
+  )
+)
+
+(define-enum TransactionIsolation
+  (in-module "Gda")
+  (c-name "GdaTransactionIsolation")
+  (gtype-id "GDA_TYPE_TRANSACTION_ISOLATION")
+  (values
+    '("unknown" "GDA_TRANSACTION_ISOLATION_UNKNOWN")
+    '("read-committed" "GDA_TRANSACTION_ISOLATION_READ_COMMITTED")
+    '("read-uncommitted" "GDA_TRANSACTION_ISOLATION_READ_UNCOMMITTED")
+    '("repeatable-read" "GDA_TRANSACTION_ISOLATION_REPEATABLE_READ")
+    '("serializable" "GDA_TRANSACTION_ISOLATION_SERIALIZABLE")
+  )
+)
+
+(define-enum GeneralError
+  (in-module "Gda")
+  (c-name "GdaGeneralError")
+  (gtype-id "GDA_TYPE_GENERAL_ERROR")
+  (values
+    '("object-name-error" "GDA_GENERAL_OBJECT_NAME_ERROR")
+    '("incorrect-value-error" "GDA_GENERAL_INCORRECT_VALUE_ERROR")
+    '("operation-error" "GDA_GENERAL_OPERATION_ERROR")
+  )
+)
+
+
+;; From gda-blob.h
+
+(define-function gda_blob_get_type
+  (c-name "gda_blob_get_type")
+  (return-type "GType")
+)
+
+(define-method open
+  (of-object "GdaBlob")
+  (c-name "gda_blob_open")
+  (return-type "gint")
+  (parameters
+    '("GdaBlobMode" "mode")
+  )
+)
+
+(define-method read
+  (of-object "GdaBlob")
+  (c-name "gda_blob_read")
+  (return-type "gint")
+  (parameters
+    '("gpointer" "buf")
+    '("gint" "size")
+    '("gint*" "bytes_read")
+  )
+)
+
+(define-method write
+  (of-object "GdaBlob")
+  (c-name "gda_blob_write")
+  (return-type "gint")
+  (parameters
+    '("gpointer" "buf")
+    '("gint" "size")
+    '("gint*" "bytes_written")
+  )
+)
+
+(define-method lseek
+  (of-object "GdaBlob")
+  (c-name "gda_blob_lseek")
+  (return-type "gint")
+  (parameters
+    '("gint" "offset")
+    '("gint" "whence")
+  )
+)
+
+(define-method close
+  (of-object "GdaBlob")
+  (c-name "gda_blob_close")
+  (return-type "gint")
+)
+
+(define-method remove
+  (of-object "GdaBlob")
+  (c-name "gda_blob_remove")
+  (return-type "gint")
+)
+
+(define-method get_sql_id
+  (of-object "GdaBlob")
+  (c-name "gda_blob_get_sql_id")
+  (return-type "gchar*")
+)
+
+
+
+;; From gda-client.h
+
+(define-function gda_client_get_type
+  (c-name "gda_client_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_client_new
+  (c-name "gda_client_new")
+  (is-constructor-of "GdaClient")
+  (return-type "GdaClient*")
+)
+
+(define-method open_connection
   (of-object "GdaClient")
-  (c-name "gda_client_notify_connection_closed_event")
-  (return-type "none")
+  (c-name "gda_client_open_connection")
+  (return-type "GdaConnection*")
   (parameters
-    '("GdaConnection*" "cnc")
+    '("const-gchar*" "dsn")
+    '("const-gchar*" "username")
+    '("const-gchar*" "password")
+    '("GdaConnectionOptions" "options")
+    '("GError**" "error")
   )
 )
 
-(define-method notify_transaction_started_event
+(define-method declare_connection
   (of-object "GdaClient")
-  (c-name "gda_client_notify_transaction_started_event")
+  (c-name "gda_client_declare_connection")
   (return-type "none")
   (parameters
     '("GdaConnection*" "cnc")
-    '("GdaTransaction*" "xaction")
   )
 )
 
-(define-method notify_transaction_committed_event
+(define-method open_connection_from_string
   (of-object "GdaClient")
-  (c-name "gda_client_notify_transaction_committed_event")
-  (return-type "none")
+  (c-name "gda_client_open_connection_from_string")
+  (return-type "GdaConnection*")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaTransaction*" "xaction")
+    '("const-gchar*" "provider_id")
+    '("const-gchar*" "cnc_string")
+    '("const-gchar*" "username")
+    '("const-gchar*" "password")
+    '("GdaConnectionOptions" "options")
+    '("GError**" "error")
   )
 )
 
-(define-method notify_transaction_cancelled_event
+(define-method get_connections
   (of-object "GdaClient")
-  (c-name "gda_client_notify_transaction_cancelled_event")
+  (c-name "gda_client_get_connections")
+  (return-type "const-GList*")
+)
+
+(define-method find_connection
+  (of-object "GdaClient")
+  (c-name "gda_client_find_connection")
+  (return-type "GdaConnection*")
+  (parameters
+    '("const-gchar*" "dsn")
+    '("const-gchar*" "username")
+    '("const-gchar*" "password")
+  )
+)
+
+(define-method close_all_connections
+  (of-object "GdaClient")
+  (c-name "gda_client_close_all_connections")
+  (return-type "none")
+)
+
+(define-method notify_event
+  (of-object "GdaClient")
+  (c-name "gda_client_notify_event")
+  (return-type "none")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaClientEvent" "event")
+    '("GdaParameterList*" "params")
+  )
+)
+
+(define-method notify_error_event
+  (of-object "GdaClient")
+  (c-name "gda_client_notify_error_event")
+  (return-type "none")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaConnectionEvent*" "error")
+  )
+)
+
+(define-method notify_connection_opened_event
+  (of-object "GdaClient")
+  (c-name "gda_client_notify_connection_opened_event")
+  (return-type "none")
+  (parameters
+    '("GdaConnection*" "cnc")
+  )
+)
+
+(define-method notify_connection_closed_event
+  (of-object "GdaClient")
+  (c-name "gda_client_notify_connection_closed_event")
+  (return-type "none")
+  (parameters
+    '("GdaConnection*" "cnc")
+  )
+)
+
+(define-method notify_transaction_started_event
+  (of-object "GdaClient")
+  (c-name "gda_client_notify_transaction_started_event")
+  (return-type "none")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+(define-method notify_transaction_committed_event
+  (of-object "GdaClient")
+  (c-name "gda_client_notify_transaction_committed_event")
+  (return-type "none")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+(define-method notify_transaction_cancelled_event
+  (of-object "GdaClient")
+  (c-name "gda_client_notify_transaction_cancelled_event")
+  (return-type "none")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+(define-method get_dsn_specs
+  (of-object "GdaClient")
+  (c-name "gda_client_get_dsn_specs")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "provider")
+  )
+)
+
+(define-method prepare_create_database
+  (of-object "GdaClient")
+  (c-name "gda_client_prepare_create_database")
+  (return-type "GdaServerOperation*")
+  (parameters
+    '("const-gchar*" "provider")
+  )
+)
+
+(define-method perform_create_database
+  (of-object "GdaClient")
+  (c-name "gda_client_perform_create_database")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "provider")
+    '("GdaServerOperation*" "op")
+    '("GError**" "error")
+  )
+)
+
+(define-method prepare_drop_database
+  (of-object "GdaClient")
+  (c-name "gda_client_prepare_drop_database")
+  (return-type "GdaServerOperation*")
+  (parameters
+    '("const-gchar*" "provider")
+  )
+)
+
+(define-method perform_drop_database
+  (of-object "GdaClient")
+  (c-name "gda_client_perform_drop_database")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "provider")
+    '("GdaServerOperation*" "op")
+    '("GError**" "error")
+  )
+)
+
+(define-method begin_transaction
+  (of-object "GdaClient")
+  (c-name "gda_client_begin_transaction")
+  (return-type "gboolean")
+  (parameters
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+(define-method commit_transaction
+  (of-object "GdaClient")
+  (c-name "gda_client_commit_transaction")
+  (return-type "gboolean")
+  (parameters
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+(define-method rollback_transaction
+  (of-object "GdaClient")
+  (c-name "gda_client_rollback_transaction")
+  (return-type "gboolean")
+  (parameters
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+
+
+;; From gda-column.h
+
+(define-function gda_column_get_type
+  (c-name "gda_column_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_column_new
+  (c-name "gda_column_new")
+  (is-constructor-of "GdaColumn")
+  (return-type "GdaColumn*")
+)
+
+(define-method copy
+  (of-object "GdaColumn")
+  (c-name "gda_column_copy")
+  (return-type "GdaColumn*")
+)
+
+(define-method get_title
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_title")
+  (return-type "const-gchar*")
+)
+
+(define-method set_title
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_title")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "title")
+  )
+)
+
+(define-method get_defined_size
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_defined_size")
+  (return-type "glong")
+)
+
+(define-method set_defined_size
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_defined_size")
+  (return-type "none")
+  (parameters
+    '("glong" "size")
+  )
+)
+
+(define-method get_name
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_name")
+  (return-type "const-gchar*")
+)
+
+(define-method set_name
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_name")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method get_table
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_table")
+  (return-type "const-gchar*")
+)
+
+(define-method set_table
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_table")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "table")
+  )
+)
+
+(define-method get_caption
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_caption")
+  (return-type "const-gchar*")
+)
+
+(define-method set_caption
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_caption")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "caption")
+  )
+)
+
+(define-method get_scale
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_scale")
+  (return-type "glong")
+)
+
+(define-method set_scale
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_scale")
+  (return-type "none")
+  (parameters
+    '("glong" "scale")
+  )
+)
+
+(define-method get_dbms_type
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_dbms_type")
+  (return-type "const-gchar*")
+)
+
+(define-method set_dbms_type
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_dbms_type")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "dbms_type")
+  )
+)
+
+(define-method get_g_type
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_g_type")
+  (return-type "GType")
+)
+
+(define-method set_g_type
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_g_type")
+  (return-type "none")
+  (parameters
+    '("GType" "type")
+  )
+)
+
+(define-method get_allow_null
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_allow_null")
+  (return-type "gboolean")
+)
+
+(define-method set_allow_null
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_allow_null")
+  (return-type "none")
+  (parameters
+    '("gboolean" "allow")
+  )
+)
+
+(define-method get_primary_key
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_primary_key")
+  (return-type "gboolean")
+)
+
+(define-method set_primary_key
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_primary_key")
+  (return-type "none")
+  (parameters
+    '("gboolean" "pk")
+  )
+)
+
+(define-method get_unique_key
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_unique_key")
+  (return-type "gboolean")
+)
+
+(define-method set_unique_key
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_unique_key")
+  (return-type "none")
+  (parameters
+    '("gboolean" "uk")
+  )
+)
+
+(define-method get_references
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_references")
+  (return-type "const-gchar*")
+)
+
+(define-method set_references
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_references")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "ref")
+  )
+)
+
+(define-method get_auto_increment
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_auto_increment")
+  (return-type "gboolean")
+)
+
+(define-method set_auto_increment
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_auto_increment")
+  (return-type "none")
+  (parameters
+    '("gboolean" "is_auto")
+  )
+)
+
+(define-method get_position
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_position")
+  (return-type "gint")
+)
+
+(define-method set_position
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_position")
+  (return-type "none")
+  (parameters
+    '("gint" "position")
+  )
+)
+
+(define-method get_default_value
+  (of-object "GdaColumn")
+  (c-name "gda_column_get_default_value")
+  (return-type "const-GValue*")
+)
+
+(define-method set_default_value
+  (of-object "GdaColumn")
+  (c-name "gda_column_set_default_value")
+  (return-type "none")
+  (parameters
+    '("const-GValue*" "default_value")
+  )
+)
+
+
+
+;; From gda-column-index.h
+
+(define-function gda_column_index_get_type
+  (c-name "gda_column_index_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_column_index_new
+  (c-name "gda_column_index_new")
+  (is-constructor-of "GdaColumnIndex")
+  (return-type "GdaColumnIndex*")
+)
+
+(define-method copy
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_copy")
+  (return-type "GdaColumnIndex*")
+)
+
+(define-method equal
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_equal")
+  (return-type "gboolean")
+  (parameters
+    '("const-GdaColumnIndex*" "rhs")
+  )
+)
+
+(define-method get_column_name
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_get_column_name")
+  (return-type "const-gchar*")
+)
+
+(define-method set_column_name
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_set_column_name")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "column_name")
+  )
+)
+
+(define-method get_defined_size
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_get_defined_size")
+  (return-type "glong")
+)
+
+(define-method set_defined_size
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_set_defined_size")
+  (return-type "none")
+  (parameters
+    '("glong" "size")
+  )
+)
+
+(define-method get_sorting
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_get_sorting")
+  (return-type "GdaSorting")
+)
+
+(define-method set_sorting
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_set_sorting")
+  (return-type "none")
+  (parameters
+    '("GdaSorting" "sorting")
+  )
+)
+
+(define-method get_references
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_get_references")
+  (return-type "const-gchar*")
+)
+
+(define-method set_references
+  (of-object "GdaColumnIndex")
+  (c-name "gda_column_index_set_references")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "ref")
+  )
+)
+
+
+
+;; From gda-command.h
+
+(define-function gda_command_get_type
+  (c-name "gda_command_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_command_new
+  (c-name "gda_command_new")
+  (is-constructor-of "GdaCommand")
+  (return-type "GdaCommand*")
+  (parameters
+    '("const-gchar*" "text")
+    '("GdaCommandType" "type")
+    '("GdaCommandOptions" "options")
+  )
+)
+
+(define-method free
+  (of-object "GdaCommand")
+  (c-name "gda_command_free")
+  (return-type "none")
+)
+
+(define-method copy
+  (of-object "GdaCommand")
+  (c-name "gda_command_copy")
+  (return-type "GdaCommand*")
+)
+
+(define-method get_text
+  (of-object "GdaCommand")
+  (c-name "gda_command_get_text")
+  (return-type "const-gchar*")
+)
+
+(define-method set_text
+  (of-object "GdaCommand")
+  (c-name "gda_command_set_text")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "text")
+  )
+)
+
+(define-method get_command_type
+  (of-object "GdaCommand")
+  (c-name "gda_command_get_command_type")
+  (return-type "GdaCommandType")
+)
+
+(define-method set_command_type
+  (of-object "GdaCommand")
+  (c-name "gda_command_set_command_type")
+  (return-type "none")
+  (parameters
+    '("GdaCommandType" "type")
+  )
+)
+
+(define-method get_options
+  (of-object "GdaCommand")
+  (c-name "gda_command_get_options")
+  (return-type "GdaCommandOptions")
+)
+
+(define-method set_options
+  (of-object "GdaCommand")
+  (c-name "gda_command_set_options")
+  (return-type "none")
+  (parameters
+    '("GdaCommandOptions" "options")
+  )
+)
+
+(define-method get_transaction
+  (of-object "GdaCommand")
+  (c-name "gda_command_get_transaction")
+  (return-type "GdaTransaction*")
+)
+
+(define-method set_transaction
+  (of-object "GdaCommand")
+  (c-name "gda_command_set_transaction")
+  (return-type "none")
+  (parameters
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+
+
+;; From gda-config.h
+
+(define-function gda_config_get_string
+  (c-name "gda_config_get_string")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_get_int
+  (c-name "gda_config_get_int")
+  (return-type "gint")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_get_float
+  (c-name "gda_config_get_float")
+  (return-type "gdouble")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_get_boolean
+  (c-name "gda_config_get_boolean")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_set_string
+  (c-name "gda_config_set_string")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "path")
+    '("const-gchar*" "new_value")
+  )
+)
+
+(define-function gda_config_set_int
+  (c-name "gda_config_set_int")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "path")
+    '("gint" "new_value")
+  )
+)
+
+(define-function gda_config_set_float
+  (c-name "gda_config_set_float")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "path")
+    '("gdouble" "new_value")
+  )
+)
+
+(define-function gda_config_set_boolean
+  (c-name "gda_config_set_boolean")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "path")
+    '("gboolean" "new_value")
+  )
+)
+
+(define-function gda_config_remove_section
+  (c-name "gda_config_remove_section")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_remove_key
+  (c-name "gda_config_remove_key")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_has_section
+  (c-name "gda_config_has_section")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_has_key
+  (c-name "gda_config_has_key")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_list_sections
+  (c-name "gda_config_list_sections")
+  (return-type "GList*")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_list_keys
+  (c-name "gda_config_list_keys")
+  (return-type "GList*")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_get_type
+  (c-name "gda_config_get_type")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function gda_config_free_list
+  (c-name "gda_config_free_list")
+  (return-type "none")
+  (parameters
+    '("GList*" "list")
+  )
+)
+
+(define-function gda_config_add_listener
+  (c-name "gda_config_add_listener")
+  (return-type "guint")
+  (parameters
+    '("const-gchar*" "path")
+    '("GdaConfigListenerFunc" "func")
+    '("gpointer" "user_data")
+  )
+)
+
+(define-function gda_config_remove_listener
+  (c-name "gda_config_remove_listener")
+  (return-type "none")
+  (parameters
+    '("guint" "id")
+  )
+)
+
+(define-function gda_provider_info_get_type
+  (c-name "gda_provider_info_get_type")
+  (return-type "GType")
+)
+
+(define-method copy
+  (of-object "GdaProviderInfo")
+  (c-name "gda_provider_info_copy")
+  (return-type "GdaProviderInfo*")
+)
+
+(define-method free
+  (of-object "GdaProviderInfo")
+  (c-name "gda_provider_info_free")
+  (return-type "none")
+)
+
+(define-function gda_config_get_provider_list
+  (c-name "gda_config_get_provider_list")
+  (return-type "GList*")
+)
+
+(define-function gda_config_free_provider_list
+  (c-name "gda_config_free_provider_list")
+  (return-type "none")
+  (parameters
+    '("GList*" "list")
+  )
+)
+
+(define-function gda_config_get_provider_by_name
+  (c-name "gda_config_get_provider_by_name")
+  (return-type "GdaProviderInfo*")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-function gda_config_get_provider_model
+  (c-name "gda_config_get_provider_model")
+  (return-type "GdaDataModel*")
+)
+
+(define-function gda_data_source_info_get_type
+  (c-name "gda_data_source_info_get_type")
+  (return-type "GType")
+)
+
+(define-method copy
+  (of-object "GdaDataSourceInfo")
+  (c-name "gda_data_source_info_copy")
+  (return-type "GdaDataSourceInfo*")
+)
+
+(define-method equal
+  (of-object "GdaDataSourceInfo")
+  (c-name "gda_data_source_info_equal")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataSourceInfo*" "info2")
+  )
+)
+
+(define-function gda_config_find_data_source
+  (c-name "gda_config_find_data_source")
+  (return-type "GdaDataSourceInfo*")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method free
+  (of-object "GdaDataSourceInfo")
+  (c-name "gda_data_source_info_free")
+  (return-type "none")
+)
+
+(define-function gda_config_get_data_source_list
+  (c-name "gda_config_get_data_source_list")
+  (return-type "GList*")
+)
+
+(define-function gda_config_free_data_source_list
+  (c-name "gda_config_free_data_source_list")
+  (return-type "none")
+  (parameters
+    '("GList*" "list")
+  )
+)
+
+(define-function gda_config_get_data_source_model
+  (c-name "gda_config_get_data_source_model")
+  (return-type "GdaDataModel*")
+)
+
+(define-function gda_config_can_modify_global_config
+  (c-name "gda_config_can_modify_global_config")
+  (return-type "gboolean")
+)
+
+(define-function gda_config_save_data_source
+  (c-name "gda_config_save_data_source")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "name")
+    '("const-gchar*" "provider")
+    '("const-gchar*" "cnc_string")
+    '("const-gchar*" "description")
+    '("const-gchar*" "username")
+    '("const-gchar*" "password")
+    '("gboolean" "is_global")
+  )
+)
+
+(define-function gda_config_save_data_source_info
+  (c-name "gda_config_save_data_source_info")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataSourceInfo*" "dsn_info")
+  )
+)
+
+(define-function gda_config_remove_data_source
+  (c-name "gda_config_remove_data_source")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+
+
+;; From gda-connection-event.h
+
+(define-function gda_connection_event_get_type
+  (c-name "gda_connection_event_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_connection_event_new
+  (c-name "gda_connection_event_new")
+  (is-constructor-of "GdaConnectionEvent")
+  (return-type "GdaConnectionEvent*")
+  (parameters
+    '("GdaConnectionEventType" "type")
+  )
+)
+
+(define-method free
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_free")
+  (return-type "none")
+)
+
+(define-function gda_connection_event_list_copy
+  (c-name "gda_connection_event_list_copy")
+  (return-type "GList*")
+  (parameters
+    '("const-GList*" "events")
+  )
+)
+
+(define-function gda_connection_event_list_free
+  (c-name "gda_connection_event_list_free")
+  (return-type "none")
+  (parameters
+    '("GList*" "events")
+  )
+)
+
+(define-method set_event_type
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_set_event_type")
+  (return-type "none")
+  (parameters
+    '("GdaConnectionEventType" "type")
+  )
+)
+
+(define-method get_event_type
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_get_event_type")
+  (return-type "GdaConnectionEventType")
+)
+
+(define-method get_description
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_get_description")
+  (return-type "const-gchar*")
+)
+
+(define-method set_description
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_set_description")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "description")
+  )
+)
+
+(define-method get_code
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_get_code")
+  (return-type "glong")
+)
+
+(define-method set_code
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_set_code")
+  (return-type "none")
+  (parameters
+    '("glong" "code")
+  )
+)
+
+(define-method get_gda_code
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_get_gda_code")
+  (return-type "GdaConnectionEventCode")
+)
+
+(define-method set_gda_code
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_set_gda_code")
+  (return-type "none")
+  (parameters
+    '("GdaConnectionEventCode" "code")
+  )
+)
+
+(define-method get_source
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_get_source")
+  (return-type "const-gchar*")
+)
+
+(define-method set_source
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_set_source")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "source")
+  )
+)
+
+(define-method get_sqlstate
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_get_sqlstate")
+  (return-type "const-gchar*")
+)
+
+(define-method set_sqlstate
+  (of-object "GdaConnectionEvent")
+  (c-name "gda_connection_event_set_sqlstate")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "sqlstate")
+  )
+)
+
+
+
+;; From gda-connection.h
+
+(define-function gda_connection_get_type
+  (c-name "gda_connection_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_connection_new
+  (c-name "gda_connection_new")
+  (is-constructor-of "GdaConnection")
+  (return-type "GdaConnection*")
+  (parameters
+    '("GdaClient*" "client")
+    '("GdaServerProvider*" "provider")
+    '("const-gchar*" "dsn")
+    '("const-gchar*" "username")
+    '("const-gchar*" "password")
+    '("guint" "options")
+  )
+)
+
+(define-method open
+  (of-object "GdaConnection")
+  (c-name "gda_connection_open")
+  (return-type "gboolean")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
+(define-method close
+  (of-object "GdaConnection")
+  (c-name "gda_connection_close")
+  (return-type "none")
+)
+
+(define-method close_no_warning
+  (of-object "GdaConnection")
+  (c-name "gda_connection_close_no_warning")
+  (return-type "none")
+)
+
+(define-method is_opened
+  (of-object "GdaConnection")
+  (c-name "gda_connection_is_opened")
+  (return-type "gboolean")
+)
+
+(define-method get_client
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_client")
+  (return-type "GdaClient*")
+)
+
+(define-method get_provider
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_provider")
+  (return-type "const-gchar*")
+)
+
+(define-method get_provider_obj
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_provider_obj")
+  (return-type "GdaServerProvider*")
+)
+
+(define-method get_infos
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_infos")
+  (return-type "GdaServerProviderInfo*")
+)
+
+(define-method get_options
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_options")
+  (return-type "guint")
+)
+
+(define-method get_server_version
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_server_version")
+  (return-type "const-gchar*")
+)
+
+(define-method get_database
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_database")
+  (return-type "const-gchar*")
+)
+
+(define-method get_dsn
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_dsn")
+  (return-type "const-gchar*")
+)
+
+(define-method set_dsn
+  (of-object "GdaConnection")
+  (c-name "gda_connection_set_dsn")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "datasource")
+  )
+)
+
+(define-method get_cnc_string
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_cnc_string")
+  (return-type "const-gchar*")
+)
+
+(define-method get_username
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_username")
+  (return-type "const-gchar*")
+)
+
+(define-method set_username
+  (of-object "GdaConnection")
+  (c-name "gda_connection_set_username")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "username")
+  )
+)
+
+(define-method get_password
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_password")
+  (return-type "const-gchar*")
+)
+
+(define-method set_password
+  (of-object "GdaConnection")
+  (c-name "gda_connection_set_password")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "password")
+  )
+)
+
+(define-method add_event
+  (of-object "GdaConnection")
+  (c-name "gda_connection_add_event")
+  (return-type "none")
+  (parameters
+    '("GdaConnectionEvent*" "error")
+  )
+)
+
+(define-method add_event_string
+  (of-object "GdaConnection")
+  (c-name "gda_connection_add_event_string")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "str")
+  )
+  (varargs #t)
+)
+
+(define-method add_events_list
+  (of-object "GdaConnection")
+  (c-name "gda_connection_add_events_list")
+  (return-type "none")
+  (parameters
+    '("GList*" "events_list")
+  )
+)
+
+(define-method clear_events_list
+  (of-object "GdaConnection")
+  (c-name "gda_connection_clear_events_list")
+  (return-type "none")
+)
+
+(define-method get_events
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_events")
+  (return-type "const-GList*")
+)
+
+(define-method change_database
+  (of-object "GdaConnection")
+  (c-name "gda_connection_change_database")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method execute_select_command
+  (of-object "GdaConnection")
+  (c-name "gda_connection_execute_select_command")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("GdaCommand*" "cmd")
+    '("GdaParameterList*" "params")
+    '("GError**" "error")
+  )
+)
+
+(define-method execute_non_select_command
+  (of-object "GdaConnection")
+  (c-name "gda_connection_execute_non_select_command")
+  (return-type "gint")
+  (parameters
+    '("GdaCommand*" "cmd")
+    '("GdaParameterList*" "params")
+    '("GError**" "error")
+  )
+)
+
+(define-method execute_command
+  (of-object "GdaConnection")
+  (c-name "gda_connection_execute_command")
+  (return-type "GList*")
+  (parameters
+    '("GdaCommand*" "cmd")
+    '("GdaParameterList*" "params")
+    '("GError**" "error")
+  )
+)
+
+(define-method get_last_insert_id
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_last_insert_id")
+  (return-type "gchar*")
+  (parameters
+    '("GdaDataModel*" "recset")
+  )
+)
+
+(define-method begin_transaction
+  (of-object "GdaConnection")
+  (c-name "gda_connection_begin_transaction")
+  (return-type "gboolean")
+  (parameters
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+(define-method commit_transaction
+  (of-object "GdaConnection")
+  (c-name "gda_connection_commit_transaction")
+  (return-type "gboolean")
+  (parameters
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+(define-method rollback_transaction
+  (of-object "GdaConnection")
+  (c-name "gda_connection_rollback_transaction")
+  (return-type "gboolean")
+  (parameters
+    '("GdaTransaction*" "xaction")
+  )
+)
+
+(define-method create_blob
+  (of-object "GdaConnection")
+  (c-name "gda_connection_create_blob")
+  (return-type "GdaBlob*")
+)
+
+(define-method fetch_blob_by_id
+  (of-object "GdaConnection")
+  (c-name "gda_connection_fetch_blob_by_id")
+  (return-type "GdaBlob*")
+  (parameters
+    '("const-gchar*" "sql_id")
+  )
+)
+
+(define-method value_to_sql_string
+  (of-object "GdaConnection")
+  (c-name "gda_connection_value_to_sql_string")
+  (return-type "gchar*")
+  (parameters
+    '("GValue*" "from")
+  )
+)
+
+(define-method supports_feature
+  (of-object "GdaConnection")
+  (c-name "gda_connection_supports_feature")
+  (return-type "gboolean")
+  (parameters
+    '("GdaConnectionFeature" "feature")
+  )
+)
+
+(define-method get_schema
+  (of-object "GdaConnection")
+  (c-name "gda_connection_get_schema")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("GdaConnectionSchema" "schema")
+    '("GdaParameterList*" "params")
+    '("GError**" "error")
+  )
+)
+
+
+
+;; From gda-data-access-wrapper.h
+
+(define-function gda_data_access_wrapper_get_type
+  (c-name "gda_data_access_wrapper_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_data_access_wrapper_new
+  (c-name "gda_data_access_wrapper_new")
+  (is-constructor-of "GdaDataAccessWrapper")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("GdaDataModel*" "model")
+  )
+)
+
+(define-method row_exists
+  (of-object "GdaDataAccessWrapper")
+  (c-name "gda_data_access_wrapper_row_exists")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "row")
+  )
+)
+
+
+
+;; From gda-data-handler.h
+
+(define-function gda_data_handler_get_type
+  (c-name "gda_data_handler_get_type")
+  (return-type "GType")
+)
+
+(define-method get_sql_from_value
+  (of-object "GdaDataHandler")
+  (c-name "gda_data_handler_get_sql_from_value")
+  (return-type "gchar*")
+  (parameters
+    '("const-GValue*" "value")
+  )
+)
+
+(define-method get_str_from_value
+  (of-object "GdaDataHandler")
+  (c-name "gda_data_handler_get_str_from_value")
+  (return-type "gchar*")
+  (parameters
+    '("const-GValue*" "value")
+  )
+)
+
+(define-method get_value_from_sql
+  (of-object "GdaDataHandler")
+  (c-name "gda_data_handler_get_value_from_sql")
+  (return-type "GValue*")
+  (parameters
+    '("const-gchar*" "sql")
+    '("GType" "type")
+  )
+)
+
+(define-method get_value_from_str
+  (of-object "GdaDataHandler")
+  (c-name "gda_data_handler_get_value_from_str")
+  (return-type "GValue*")
+  (parameters
+    '("const-gchar*" "str")
+    '("GType" "type")
+  )
+)
+
+(define-method get_sane_init_value
+  (of-object "GdaDataHandler")
+  (c-name "gda_data_handler_get_sane_init_value")
+  (return-type "GValue*")
+  (parameters
+    '("GType" "type")
+  )
+)
+
+(define-method get_nb_g_types
+  (of-object "GdaDataHandler")
+  (c-name "gda_data_handler_get_nb_g_types")
+  (return-type "guint")
+)
+
+(define-method get_g_type_index
+  (of-object "GdaDataHandler")
+  (c-name "gda_data_handler_get_g_type_index")
+  (return-type "GType")
+  (parameters
+    '("guint" "index")
+  )
+)
+
+(define-method accepts_g_type
+  (of-object "GdaDataHandler")
+  (c-name "gda_data_handler_accepts_g_type")
+  (return-type "gboolean")
+  (parameters
+    '("GType" "type")
+  )
+)
+
+(define-method get_descr
+  (of-object "GdaDataHandler")
+  (c-name "gda_data_handler_get_descr")
+  (return-type "const-gchar*")
+)
+
+
+
+;; From gda-data-model-array.h
+
+(define-function gda_data_model_array_get_type
+  (c-name "gda_data_model_array_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_data_model_array_new_with_g_types
+  (c-name "gda_data_model_array_new_with_g_types")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("gint" "cols")
+  )
+  (varargs #t)
+)
+
+(define-function gda_data_model_array_new
+  (c-name "gda_data_model_array_new")
+  (is-constructor-of "GdaDataModelArray")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("gint" "cols")
+  )
+)
+
+(define-method array_copy_model
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_array_copy_model")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
+(define-method set_n_columns
+  (of-object "GdaDataModelArray")
+  (c-name "gda_data_model_array_set_n_columns")
+  (return-type "none")
+  (parameters
+    '("gint" "cols")
+  )
+)
+
+(define-method clear
+  (of-object "GdaDataModelArray")
+  (c-name "gda_data_model_array_clear")
+  (return-type "none")
+)
+
+
+
+;; From gda-data-model-extra.h
+
+(define-method signal_emit_changed
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_signal_emit_changed")
+  (return-type "none")
+)
+
+(define-method row_inserted
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_row_inserted")
+  (return-type "none")
+  (parameters
+    '("gint" "row")
+  )
+)
+
+(define-method row_updated
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_row_updated")
+  (return-type "none")
+  (parameters
+    '("gint" "row")
+  )
+)
+
+(define-method row_removed
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_row_removed")
+  (return-type "none")
+  (parameters
+    '("gint" "row")
+  )
+)
+
+(define-method move_iter_at_row_default
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_move_iter_at_row_default")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataModelIter*" "iter")
+    '("gint" "row")
+  )
+)
+
+(define-method move_iter_next_default
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_move_iter_next_default")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataModelIter*" "iter")
+  )
+)
+
+(define-method move_iter_prev_default
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_move_iter_prev_default")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataModelIter*" "iter")
+  )
+)
+
+
+
+;; From gda-data-model-filter-sql.h
+
+(define-function gda_data_model_filter_sql_get_type
+  (c-name "gda_data_model_filter_sql_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_data_model_filter_sql_new
+  (c-name "gda_data_model_filter_sql_new")
+  (is-constructor-of "GdaDataModelFilterSql")
+  (return-type "GdaDataModel*")
+)
+
+(define-method add_source
+  (of-object "GdaDataModelFilterSQL")
+  (c-name "gda_data_model_filter_sql_add_source")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+    '("GdaDataModel*" "source")
+  )
+)
+
+(define-method set_sql
+  (of-object "GdaDataModelFilterSQL")
+  (c-name "gda_data_model_filter_sql_set_sql")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "sql")
+  )
+)
+
+(define-method run
+  (of-object "GdaDataModelFilterSQL")
+  (c-name "gda_data_model_filter_sql_run")
+  (return-type "gboolean")
+)
+
+
+
+;; From gda-data-model.h
+
+(define-function gda_data_model_get_type
+  (c-name "gda_data_model_get_type")
+  (return-type "GType")
+)
+
+(define-method is_updatable
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_is_updatable")
+  (return-type "gboolean")
+)
+
+(define-method get_access_flags
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_get_access_flags")
+  (return-type "guint")
+)
+
+(define-method get_n_rows
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_get_n_rows")
+  (return-type "gint")
+)
+
+(define-method get_n_columns
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_get_n_columns")
+  (return-type "gint")
+)
+
+(define-method describe_column
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_describe_column")
+  (return-type "GdaColumn*")
+  (parameters
+    '("gint" "col")
+  )
+)
+
+(define-method get_column_index_by_name
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_get_column_index_by_name")
+  (return-type "gint")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method get_column_title
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_get_column_title")
+  (return-type "const-gchar*")
+  (parameters
+    '("gint" "col")
+  )
+)
+
+(define-method set_column_title
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_set_column_title")
+  (return-type "none")
+  (parameters
+    '("gint" "col")
+    '("const-gchar*" "title")
+  )
+)
+
+(define-method get_value_at
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_get_value_at")
+  (return-type "const-GValue*")
+  (parameters
+    '("gint" "col")
+    '("gint" "row")
+  )
+)
+
+(define-method get_value_at_col_name
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_get_value_at_col_name")
+  (return-type "const-GValue*")
+  (parameters
+    '("const-gchar*" "column_name")
+    '("gint" "row")
+  )
+)
+
+(define-method get_attributes_at
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_get_attributes_at")
+  (return-type "guint")
+  (parameters
+    '("gint" "col")
+    '("gint" "row")
+  )
+)
+
+(define-method create_iter
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_create_iter")
+  (return-type "GdaDataModelIter*")
+)
+
+(define-method move_iter_at_row
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_move_iter_at_row")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataModelIter*" "iter")
+    '("gint" "row")
+  )
+)
+
+(define-method move_iter_next
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_move_iter_next")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataModelIter*" "iter")
+  )
+)
+
+(define-method move_iter_prev
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_move_iter_prev")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataModelIter*" "iter")
+  )
+)
+
+(define-method freeze
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_freeze")
+  (return-type "none")
+)
+
+(define-method thaw
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_thaw")
+  (return-type "none")
+)
+
+(define-method set_value_at
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_set_value_at")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "col")
+    '("gint" "row")
+    '("const-GValue*" "value")
+    '("GError**" "error")
+  )
+)
+
+(define-method set_values
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_set_values")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "row")
+    '("GList*" "values")
+    '("GError**" "error")
+  )
+)
+
+(define-method append_row
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_append_row")
+  (return-type "gint")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
+(define-method append_values
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_append_values")
+  (return-type "gint")
+  (parameters
+    '("const-GList*" "values")
+    '("GError**" "error")
+  )
+)
+
+(define-method remove_row
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_remove_row")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "row")
+    '("GError**" "error")
+  )
+)
+
+(define-method get_row_from_values
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_get_row_from_values")
+  (return-type "gint")
+  (parameters
+    '("GSList*" "values")
+    '("gint*" "cols_index")
+  )
+)
+
+(define-method send_hint
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_send_hint")
+  (return-type "none")
+  (parameters
+    '("GdaDataModelHint" "hint")
+    '("const-GValue*" "hint_value")
+  )
+)
+
+(define-method export_to_string
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_export_to_string")
+  (return-type "gchar*")
+  (parameters
+    '("GdaDataModelIOFormat" "format")
+    '("const-gint*" "cols")
+    '("gint" "nb_cols")
+    '("const-gint*" "rows")
+    '("gint" "nb_rows")
+    '("GdaParameterList*" "options")
+  )
+)
+
+(define-method export_to_file
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_export_to_file")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataModelIOFormat" "format")
+    '("const-gchar*" "file")
+    '("const-gint*" "cols")
+    '("gint" "nb_cols")
+    '("const-gint*" "rows")
+    '("gint" "nb_rows")
+    '("GdaParameterList*" "options")
+    '("GError**" "error")
+  )
+)
+
+(define-method import_from_model
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_import_from_model")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataModel*" "from")
+    '("GHashTable*" "cols_trans")
+    '("GError**" "error")
+  )
+)
+
+(define-method import_from_string
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_import_from_string")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "string")
+    '("GHashTable*" "cols_trans")
+    '("GdaParameterList*" "options")
+    '("GError**" "error")
+  )
+)
+
+(define-method import_from_file
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_import_from_file")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "file")
+    '("GHashTable*" "cols_trans")
+    '("GdaParameterList*" "options")
+    '("GError**" "error")
+  )
+)
+
+(define-method dump
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_dump")
+  (return-type "none")
+  (parameters
+    '("FILE*" "to_stream")
+  )
+)
+
+(define-method dump_as_string
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_dump_as_string")
+  (return-type "gchar*")
+)
+
+
+
+;; From gda-data-model-hash.h
+
+(define-function gda_data_model_hash_get_type
+  (c-name "gda_data_model_hash_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_data_model_hash_new
+  (c-name "gda_data_model_hash_new")
+  (is-constructor-of "GdaDataModelHash")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("gint" "cols")
+  )
+)
+
+(define-method clear
+  (of-object "GdaDataModelHash")
+  (c-name "gda_data_model_hash_clear")
+  (return-type "none")
+)
+
+(define-method set_n_columns
+  (of-object "GdaDataModelHash")
+  (c-name "gda_data_model_hash_set_n_columns")
+  (return-type "none")
+  (parameters
+    '("gint" "cols")
+  )
+)
+
+(define-method insert_row
+  (of-object "GdaDataModelHash")
+  (c-name "gda_data_model_hash_insert_row")
+  (return-type "none")
+  (parameters
+    '("gint" "rownum")
+    '("GdaRow*" "row")
+  )
+)
+
+
+
+;; From gda-data-model-import.h
+
+(define-function gda_data_model_import_get_type
+  (c-name "gda_data_model_import_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_data_model_import_new_file
+  (c-name "gda_data_model_import_new_file")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("const-gchar*" "filename")
+    '("gboolean" "random_access")
+    '("GdaParameterList*" "options")
+  )
+)
+
+(define-function gda_data_model_import_new_mem
+  (c-name "gda_data_model_import_new_mem")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("const-gchar*" "data")
+    '("gboolean" "random_access")
+    '("GdaParameterList*" "options")
+  )
+)
+
+(define-function gda_data_model_import_new_xml_node
+  (c-name "gda_data_model_import_new_xml_node")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("xmlNodePtr" "node")
+  )
+)
+
+(define-method get_errors
+  (of-object "GdaDataModelImport")
+  (c-name "gda_data_model_import_get_errors")
+  (return-type "GSList*")
+)
+
+(define-method clean_errors
+  (of-object "GdaDataModelImport")
+  (c-name "gda_data_model_import_clean_errors")
+  (return-type "none")
+)
+
+
+
+;; From gda-data-model-index.h
+
+(define-function gda_data_model_index_get_type
+  (c-name "gda_data_model_index_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_data_model_index_new
+  (c-name "gda_data_model_index_new")
+  (is-constructor-of "GdaDataModelIndex")
+  (return-type "GdaDataModelIndex*")
+)
+
+(define-method copy
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_copy")
+  (return-type "GdaDataModelIndex*")
+)
+
+(define-method free
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_free")
+  (return-type "none")
+)
+
+(define-method equal
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_equal")
+  (return-type "gboolean")
+  (parameters
+    '("const-GdaDataModelIndex*" "rhs")
+  )
+)
+
+(define-method get_name
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_get_name")
+  (return-type "const-gchar*")
+)
+
+(define-method set_name
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_set_name")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method get_table_name
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_get_table_name")
+  (return-type "const-gchar*")
+)
+
+(define-method set_table_name
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_set_table_name")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method get_primary_key
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_get_primary_key")
+  (return-type "gboolean")
+)
+
+(define-method set_primary_key
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_set_primary_key")
+  (return-type "none")
+  (parameters
+    '("gboolean" "pk")
+  )
+)
+
+(define-method get_unique_key
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_get_unique_key")
+  (return-type "gboolean")
+)
+
+(define-method set_unique_key
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_set_unique_key")
+  (return-type "none")
+  (parameters
+    '("gboolean" "uk")
+  )
+)
+
+(define-method get_references
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_get_references")
+  (return-type "const-gchar*")
+)
+
+(define-method set_references
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_set_references")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "ref")
+  )
+)
+
+(define-method get_column_index_list
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_get_column_index_list")
+  (return-type "GList*")
+)
+
+(define-method set_column_index_list
+  (of-object "GdaDataModelIndex")
+  (c-name "gda_data_model_index_set_column_index_list")
+  (return-type "none")
+  (parameters
+    '("GList*" "col_idx_list")
+  )
+)
+
+
+
+;; From gda-data-model-iter.h
+
+(define-function gda_data_model_iter_get_type
+  (c-name "gda_data_model_iter_get_type")
+  (return-type "GType")
+)
+
+(define-method iter_new
+  (of-object "GdaDataModel")
+  (c-name "gda_data_model_iter_new")
+  (return-type "GdaDataModelIter*")
+)
+
+(define-method set_at_row
+  (of-object "GdaDataModelIter")
+  (c-name "gda_data_model_iter_set_at_row")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "row")
+  )
+)
+
+(define-method move_next
+  (of-object "GdaDataModelIter")
+  (c-name "gda_data_model_iter_move_next")
+  (return-type "gboolean")
+)
+
+(define-method move_prev
+  (of-object "GdaDataModelIter")
+  (c-name "gda_data_model_iter_move_prev")
+  (return-type "gboolean")
+)
+
+(define-method get_row
+  (of-object "GdaDataModelIter")
+  (c-name "gda_data_model_iter_get_row")
+  (return-type "gint")
+)
+
+(define-method invalidate_contents
+  (of-object "GdaDataModelIter")
+  (c-name "gda_data_model_iter_invalidate_contents")
+  (return-type "none")
+)
+
+(define-method is_valid
+  (of-object "GdaDataModelIter")
+  (c-name "gda_data_model_iter_is_valid")
+  (return-type "gboolean")
+)
+
+(define-method get_column_for_param
+  (of-object "GdaDataModelIter")
+  (c-name "gda_data_model_iter_get_column_for_param")
+  (return-type "gint")
+  (parameters
+    '("GdaParameter*" "param")
+  )
+)
+
+(define-method get_param_for_column
+  (of-object "GdaDataModelIter")
+  (c-name "gda_data_model_iter_get_param_for_column")
+  (return-type "GdaParameter*")
+  (parameters
+    '("gint" "col")
+  )
+)
+
+
+;; From gda-data-model-query.h
+
+(define-function gda_data_model_query_get_type
+  (c-name "gda_data_model_query_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_data_model_query_new
+  (c-name "gda_data_model_query_new")
+  (is-constructor-of "GdaDataModelQuery")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("GdaQuery*" "query")
+  )
+)
+
+(define-method get_parameter_list
+  (of-object "GdaDataModelQuery")
+  (c-name "gda_data_model_query_get_parameter_list")
+  (return-type "GdaParameterList*")
+)
+
+(define-method refresh
+  (of-object "GdaDataModelQuery")
+  (c-name "gda_data_model_query_refresh")
+  (return-type "gboolean")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
+(define-method set_modification_query
+  (of-object "GdaDataModelQuery")
+  (c-name "gda_data_model_query_set_modification_query")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "query")
+    '("GError**" "error")
+  )
+)
+
+
+
+;; From gda-data-model-row.h
+
+(define-function gda_data_model_row_get_type
+  (c-name "gda_data_model_row_get_type")
+  (return-type "GType")
+)
+
+(define-method get_row
+  (of-object "GdaDataModelRow")
+  (c-name "gda_data_model_row_get_row")
+  (return-type "GdaRow*")
+  (parameters
+    '("gint" "row")
+    '("GError**" "error")
+  )
+)
+
+
+
+;; From gda-data-proxy.h
+
+(define-function gda_data_proxy_get_type
+  (c-name "gda_data_proxy_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_data_proxy_new
+  (c-name "gda_data_proxy_new")
+  (is-constructor-of "GdaDataProxy")
+  (return-type "GObject*")
+  (parameters
+    '("GdaDataModel*" "model")
+  )
+)
+
+(define-method get_proxied_model
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_proxied_model")
+  (return-type "GdaDataModel*")
+)
+
+(define-method get_proxied_model_n_cols
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_proxied_model_n_cols")
+  (return-type "gint")
+)
+
+(define-method get_proxied_model_n_rows
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_proxied_model_n_rows")
+  (return-type "gint")
+)
+
+(define-method is_read_only
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_is_read_only")
+  (return-type "gboolean")
+)
+
+(define-method get_values
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_values")
+  (return-type "GSList*")
+  (parameters
+    '("gint" "proxy_row")
+    '("gint*" "cols_index")
+    '("gint" "n_cols")
+  )
+)
+
+(define-method get_value_attributes
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_value_attributes")
+  (return-type "guint")
+  (parameters
+    '("gint" "proxy_row")
+    '("gint" "col")
+  )
+)
+
+(define-method alter_value_attributes
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_alter_value_attributes")
+  (return-type "none")
+  (parameters
+    '("gint" "proxy_row")
+    '("gint" "col")
+    '("guint" "alter_flags")
+  )
+)
+
+(define-method get_proxied_model_row
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_proxied_model_row")
+  (return-type "gint")
+  (parameters
+    '("gint" "proxy_row")
+  )
+)
+
+(define-method delete
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_delete")
+  (return-type "none")
+  (parameters
+    '("gint" "proxy_row")
+  )
+)
+
+(define-method undelete
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_undelete")
+  (return-type "none")
+  (parameters
+    '("gint" "proxy_row")
+  )
+)
+
+(define-method row_is_deleted
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_row_is_deleted")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "proxy_row")
+  )
+)
+
+(define-method row_is_inserted
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_row_is_inserted")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "proxy_row")
+  )
+)
+
+(define-method find_row_from_values
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_find_row_from_values")
+  (return-type "gint")
+  (parameters
+    '("GSList*" "values")
+    '("gint*" "cols_index")
+  )
+)
+
+(define-method row_has_changed
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_row_has_changed")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "proxy_row")
+  )
+)
+
+(define-method has_changed
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_has_changed")
+  (return-type "gboolean")
+)
+
+(define-method get_n_new_rows
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_n_new_rows")
+  (return-type "gint")
+)
+
+(define-method apply_row_changes
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_apply_row_changes")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "proxy_row")
+    '("GError**" "error")
+  )
+)
+
+(define-method cancel_row_changes
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_cancel_row_changes")
+  (return-type "none")
+  (parameters
+    '("gint" "proxy_row")
+    '("gint" "col")
+  )
+)
+
+(define-method apply_all_changes
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_apply_all_changes")
+  (return-type "gboolean")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
+(define-method cancel_all_changes
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_cancel_all_changes")
+  (return-type "gboolean")
+)
+
+(define-method set_sample_size
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_set_sample_size")
+  (return-type "none")
+  (parameters
+    '("gint" "sample_size")
+  )
+)
+
+(define-method get_sample_size
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_sample_size")
+  (return-type "gint")
+)
+
+(define-method set_sample_start
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_set_sample_start")
+  (return-type "none")
+  (parameters
+    '("gint" "sample_start")
+  )
+)
+
+(define-method get_sample_start
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_sample_start")
+  (return-type "gint")
+)
+
+(define-method get_sample_end
+  (of-object "GdaDataProxy")
+  (c-name "gda_data_proxy_get_sample_end")
+  (return-type "gint")
+)
+
+
+
+;; From gda-decl.h
+
+
+
+;; From gda-dict-aggregate.h
+
+(define-function gda_dict_aggregate_get_type
+  (c-name "gda_dict_aggregate_get_type")
+  (return-type "GType")
+)
+
+(define-method aggregate_new
+  (of-object "GdaDict")
+  (c-name "gda_dict_aggregate_new")
+  (return-type "GObject*")
+)
+
+(define-method set_dbms_id
+  (of-object "GdaDictAggregate")
+  (c-name "gda_dict_aggregate_set_dbms_id")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "id")
+  )
+)
+
+(define-method get_dbms_id
+  (of-object "GdaDictAggregate")
+  (c-name "gda_dict_aggregate_get_dbms_id")
+  (return-type "gchar*")
+)
+
+(define-method set_sqlname
+  (of-object "GdaDictAggregate")
+  (c-name "gda_dict_aggregate_set_sqlname")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "sqlname")
+  )
+)
+
+(define-method get_sqlname
+  (of-object "GdaDictAggregate")
+  (c-name "gda_dict_aggregate_get_sqlname")
+  (return-type "const-gchar*")
+)
+
+(define-method set_arg_dict_type
+  (of-object "GdaDictAggregate")
+  (c-name "gda_dict_aggregate_set_arg_dict_type")
+  (return-type "none")
+  (parameters
+    '("GdaDictType*" "dt")
+  )
+)
+
+(define-method get_arg_dict_type
+  (of-object "GdaDictAggregate")
+  (c-name "gda_dict_aggregate_get_arg_dict_type")
+  (return-type "GdaDictType*")
+)
+
+(define-method set_ret_dict_type
+  (of-object "GdaDictAggregate")
+  (c-name "gda_dict_aggregate_set_ret_dict_type")
+  (return-type "none")
+  (parameters
+    '("GdaDictType*" "dt")
+  )
+)
+
+(define-method get_ret_dict_type
+  (of-object "GdaDictAggregate")
+  (c-name "gda_dict_aggregate_get_ret_dict_type")
+  (return-type "GdaDictType*")
+)
+
+
+
+;; From gda-dict-constraint.h
+
+(define-function gda_dict_constraint_get_type
+  (c-name "gda_dict_constraint_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_dict_constraint_new
+  (c-name "gda_dict_constraint_new")
+  (is-constructor-of "GdaDictConstraint")
+  (return-type "GdaDictConstraint*")
+  (parameters
+    '("GdaDictTable*" "table")
+    '("GdaDictConstraintType" "type")
+  )
+)
+
+(define-function gda_dict_constraint_new_with_db
+  (c-name "gda_dict_constraint_new_with_db")
+  (return-type "GdaDictConstraint*")
+  (parameters
+    '("GdaDictDatabase*" "db")
+  )
+)
+
+(define-method get_constraint_type
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_get_constraint_type")
+  (return-type "GdaDictConstraintType")
+)
+
+(define-method equal
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_equal")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDictConstraint*" "cstr2")
+  )
+)
+
+(define-method get_table
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_get_table")
+  (return-type "GdaDictTable*")
+)
+
+(define-method uses_field
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_uses_field")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDictField*" "field")
+  )
+)
+
+(define-method pkey_set_fields
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_pkey_set_fields")
+  (return-type "none")
+  (parameters
+    '("const-GSList*" "fields")
+  )
+)
+
+(define-method pkey_get_fields
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_pkey_get_fields")
+  (return-type "GSList*")
+)
+
+(define-method fkey_set_fields
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_fkey_set_fields")
+  (return-type "none")
+  (parameters
+    '("const-GSList*" "pairs")
+  )
+)
+
+(define-method fkey_get_ref_table
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_fkey_get_ref_table")
+  (return-type "GdaDictTable*")
+)
+
+(define-method fkey_get_fields
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_fkey_get_fields")
+  (return-type "GSList*")
+)
+
+(define-method fkey_set_actions
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_fkey_set_actions")
   (return-type "none")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaTransaction*" "xaction")
+    '("GdaDictConstraintFkAction" "on_update")
+    '("GdaDictConstraintFkAction" "on_delete")
   )
 )
 
-(define-method begin_transaction
-  (of-object "GdaClient")
-  (c-name "gda_client_begin_transaction")
-  (return-type "gboolean")
+(define-method fkey_get_actions
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_fkey_get_actions")
+  (return-type "none")
   (parameters
-    '("GdaTransaction*" "xaction")
+    '("GdaDictConstraintFkAction*" "on_update")
+    '("GdaDictConstraintFkAction*" "on_delete")
   )
 )
 
-(define-method commit_transaction
-  (of-object "GdaClient")
-  (c-name "gda_client_commit_transaction")
-  (return-type "gboolean")
+(define-method unique_set_fields
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_unique_set_fields")
+  (return-type "none")
   (parameters
-    '("GdaTransaction*" "xaction")
+    '("const-GSList*" "fields")
   )
 )
 
-(define-method rollback_transaction
-  (of-object "GdaClient")
-  (c-name "gda_client_rollback_transaction")
-  (return-type "gboolean")
+(define-method unique_get_fields
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_unique_get_fields")
+  (return-type "GSList*")
+)
+
+(define-method not_null_set_field
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_not_null_set_field")
+  (return-type "none")
   (parameters
-    '("GdaTransaction*" "xaction")
+    '("GdaDictField*" "field")
   )
 )
 
+(define-method not_null_get_field
+  (of-object "GdaDictConstraint")
+  (c-name "gda_dict_constraint_not_null_get_field")
+  (return-type "GdaDictField*")
+)
+
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-command.h
+;; From gda-dict-database.h
 
-(define-function gda_command_get_type
-  (c-name "gda_command_get_type")
+(define-function gda_dict_database_get_type
+  (c-name "gda_dict_database_get_type")
   (return-type "GType")
 )
 
-(define-function gda_command_new
-  (c-name "gda_command_new")
-  (is-constructor-of "GdaCommand")
-  (return-type "GdaCommand*")
+(define-method database_new
+  (of-object "GdaDict")
+  (c-name "gda_dict_database_new")
+  (return-type "GObject*")
+)
+
+(define-method get_dict
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_dict")
+  (return-type "GdaDict*")
+)
+
+(define-method update_dbms_data
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_update_dbms_data")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "text")
-    '("GdaCommandType" "type" (default "GDA_COMMAND_TYPE_SQL"))
-    '("GdaCommandOptions" "options" (default "GDA_COMMAND_OPTION_STOP_ON_ERRORS"))
+    '("GType" "limit_to_type")
+    '("const-gchar*" "limit_obj_name")
+    '("GError**" "error")
   )
 )
 
-(define-method free
-  (of-object "GdaCommand")
-  (c-name "gda_command_free")
+(define-method stop_update_dbms_data
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_stop_update_dbms_data")
   (return-type "none")
 )
 
-(define-method copy
-  (of-object "GdaCommand")
-  (c-name "gda_command_copy")
-  (return-type "GdaCommand*")
-)
-
-(define-method get_text
-  (of-object "GdaCommand")
-  (c-name "gda_command_get_text")
-  (return-type "const-gchar*")
+(define-method get_tables
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_tables")
+  (return-type "GSList*")
 )
 
-(define-method set_text
-  (of-object "GdaCommand")
-  (c-name "gda_command_set_text")
-  (return-type "none")
+(define-method get_table_by_name
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_table_by_name")
+  (return-type "GdaDictTable*")
   (parameters
-    '("const-gchar*" "text")
+    '("const-gchar*" "name")
   )
 )
 
-(define-method get_command_type
-  (of-object "GdaCommand")
-  (c-name "gda_command_get_command_type")
-  (return-type "GdaCommandType")
+(define-method get_table_by_xml_id
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_table_by_xml_id")
+  (return-type "GdaDictTable*")
+  (parameters
+    '("const-gchar*" "xml_id")
+  )
 )
 
-(define-method set_command_type
-  (of-object "GdaCommand")
-  (c-name "gda_command_set_command_type")
-  (return-type "none")
+(define-method get_field_by_name
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_field_by_name")
+  (return-type "GdaDictField*")
   (parameters
-    '("GdaCommandType" "type")
+    '("const-gchar*" "fullname")
   )
 )
 
-(define-method get_options
-  (of-object "GdaCommand")
-  (c-name "gda_command_get_options")
-  (return-type "GdaCommandOptions")
+(define-method get_field_by_xml_id
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_field_by_xml_id")
+  (return-type "GdaDictField*")
+  (parameters
+    '("const-gchar*" "xml_id")
+  )
 )
 
-(define-method set_options
-  (of-object "GdaCommand")
-  (c-name "gda_command_set_options")
+(define-method add_constraint
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_add_constraint")
   (return-type "none")
   (parameters
-    '("GdaCommandOptions" "options")
+    '("GdaDictConstraint*" "cstr")
   )
 )
 
-(define-method get_transaction
-  (of-object "GdaCommand")
-  (c-name "gda_command_get_transaction")
-  (return-type "GdaTransaction*")
+(define-method get_all_constraints
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_all_constraints")
+  (return-type "GSList*")
 )
 
-(define-method set_transaction
-  (of-object "GdaCommand")
-  (c-name "gda_command_set_transaction")
-  (return-type "none")
+(define-method get_all_fk_constraints
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_all_fk_constraints")
+  (return-type "GSList*")
+)
+
+(define-method get_table_constraints
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_table_constraints")
+  (return-type "GSList*")
   (parameters
-    '("GdaTransaction*" "xaction")
+    '("GdaDictTable*" "table")
   )
 )
 
+(define-method get_tables_fk_constraints
+  (of-object "GdaDictDatabase")
+  (c-name "gda_dict_database_get_tables_fk_constraints")
+  (return-type "GSList*")
+  (parameters
+    '("GdaDictTable*" "table1")
+    '("GdaDictTable*" "table2")
+    '("gboolean" "table1_has_fk")
+  )
+)
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-config.h
 
-(define-function config_get_string
-  (c-name "gda_config_get_string")
-  (return-type "gchar*")
-  (parameters
-    '("const-gchar*" "path")
-  )
+;; From gda-dict-field.h
+
+(define-function gda_dict_field_get_type
+  (c-name "gda_dict_field_get_type")
+  (return-type "GType")
 )
 
-(define-function config_get_int
-  (c-name "gda_config_get_int")
-  (return-type "gint")
+(define-method field_new
+  (of-object "GdaDict")
+  (c-name "gda_dict_field_new")
+  (return-type "GObject*")
   (parameters
-    '("const-gchar*" "path")
+    '("GdaDictType*" "type")
   )
 )
 
-(define-function config_get_float
-  (c-name "gda_config_get_float")
-  (return-type "gdouble")
+(define-method set_length
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_set_length")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "path")
+    '("gint" "length")
   )
 )
 
-(define-function config_get_boolean
-  (c-name "gda_config_get_boolean")
-  (return-type "gboolean")
+(define-method get_length
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_get_length")
+  (return-type "gint")
+)
+
+(define-method set_scale
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_set_scale")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "path")
+    '("gint" "length")
   )
 )
 
-(define-function config_set_string
-  (c-name "gda_config_set_string")
+(define-method get_scale
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_get_scale")
+  (return-type "gint")
+)
+
+(define-method get_constraints
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_get_constraints")
+  (return-type "GSList*")
+)
+
+(define-method set_dict_type
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_set_dict_type")
   (return-type "none")
   (parameters
-    '("const-gchar*" "path")
-    '("const-gchar*" "new_value")
+    '("GdaDictType*" "type")
   )
 )
 
-(define-function config_set_int
-  (c-name "gda_config_set_int")
+(define-method set_default_value
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_set_default_value")
   (return-type "none")
   (parameters
-    '("const-gchar*" "path")
-    '("gint" "new_value")
+    '("const-GValue*" "value")
   )
 )
 
-(define-function config_set_float
-  (c-name "gda_config_set_float")
+(define-method get_default_value
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_get_default_value")
+  (return-type "const-GValue*")
+)
+
+(define-method is_null_allowed
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_is_null_allowed")
+  (return-type "gboolean")
+)
+
+(define-method is_pkey_part
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_is_pkey_part")
+  (return-type "gboolean")
+)
+
+(define-method is_pkey_alone
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_is_pkey_alone")
+  (return-type "gboolean")
+)
+
+(define-method is_fkey_part
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_is_fkey_part")
+  (return-type "gboolean")
+)
+
+(define-method is_fkey_alone
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_is_fkey_alone")
+  (return-type "gboolean")
+)
+
+(define-method set_attributes
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_set_attributes")
   (return-type "none")
   (parameters
-    '("const-gchar*" "path")
-    '("gdouble" "new_value")
+    '("guint" "attributes")
   )
 )
 
-(define-function config_set_boolean
-  (c-name "gda_config_set_boolean")
+(define-method get_attributes
+  (of-object "GdaDictField")
+  (c-name "gda_dict_field_get_attributes")
+  (return-type "guint")
+)
+
+
+
+;; From gda-dict-function.h
+
+(define-function gda_dict_function_get_type
+  (c-name "gda_dict_function_get_type")
+  (return-type "GType")
+)
+
+(define-method function_new
+  (of-object "GdaDict")
+  (c-name "gda_dict_function_new")
+  (return-type "GObject*")
+)
+
+(define-method set_dbms_id
+  (of-object "GdaDictFunction")
+  (c-name "gda_dict_function_set_dbms_id")
   (return-type "none")
   (parameters
-    '("const-gchar*" "path")
-    '("gboolean" "new_value")
+    '("const-gchar*" "id")
   )
 )
 
-(define-function config_remove_section
-  (c-name "gda_config_remove_section")
+(define-method get_dbms_id
+  (of-object "GdaDictFunction")
+  (c-name "gda_dict_function_get_dbms_id")
+  (return-type "gchar*")
+)
+
+(define-method set_sqlname
+  (of-object "GdaDictFunction")
+  (c-name "gda_dict_function_set_sqlname")
   (return-type "none")
   (parameters
-    '("const-gchar*" "path")
+    '("const-gchar*" "sqlname")
   )
 )
 
-(define-function config_remove_key
-  (c-name "gda_config_remove_key")
+(define-method get_sqlname
+  (of-object "GdaDictFunction")
+  (c-name "gda_dict_function_get_sqlname")
+  (return-type "const-gchar*")
+)
+
+(define-method set_arg_dict_types
+  (of-object "GdaDictFunction")
+  (c-name "gda_dict_function_set_arg_dict_types")
   (return-type "none")
   (parameters
-    '("const-gchar*" "path")
+    '("const-GSList*" "arg_types")
   )
 )
 
-(define-function config_has_section
-  (c-name "gda_config_has_section")
-  (return-type "gboolean")
+(define-method get_arg_dict_types
+  (of-object "GdaDictFunction")
+  (c-name "gda_dict_function_get_arg_dict_types")
+  (return-type "const-GSList*")
+)
+
+(define-method set_ret_dict_type
+  (of-object "GdaDictFunction")
+  (c-name "gda_dict_function_set_ret_dict_type")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "path")
+    '("GdaDictType*" "dt")
   )
 )
 
-(define-function config_has_key
-  (c-name "gda_config_has_key")
+(define-method get_ret_dict_type
+  (of-object "GdaDictFunction")
+  (c-name "gda_dict_function_get_ret_dict_type")
+  (return-type "GdaDictType*")
+)
+
+(define-method accepts_arg_dict_types
+  (of-object "GdaDictFunction")
+  (c-name "gda_dict_function_accepts_arg_dict_types")
   (return-type "gboolean")
   (parameters
-    '("const-gchar*" "path")
+    '("const-GSList*" "arg_types")
   )
 )
 
-(define-function config_list_sections
-  (c-name "gda_config_list_sections")
-  (return-type "GList*")
-  (parameters
-    '("const-gchar*" "path")
-  )
+
+
+;; From gda-dict.h
+
+(define-function gda_dict_get_type
+  (c-name "gda_dict_get_type")
+  (return-type "GType")
 )
 
-(define-function config_list_keys
-  (c-name "gda_config_list_keys")
-  (return-type "GList*")
-  (parameters
-    '("const-gchar*" "path")
-  )
+(define-function gda_dict_new
+  (c-name "gda_dict_new")
+  (is-constructor-of "GdaDict")
+  (return-type "GdaDict*")
 )
 
-(define-function config_get_type
-  (c-name "gda_config_get_type")
-  (return-type "gchar*")
-  (parameters
-    '("const-gchar*" "path")
-  )
+(define-method extend_with_functions
+  (of-object "GdaDict")
+  (c-name "gda_dict_extend_with_functions")
+  (return-type "none")
 )
 
-(define-function config_free_list
-  (c-name "gda_config_free_list")
+(define-method set_connection
+  (of-object "GdaDict")
+  (c-name "gda_dict_set_connection")
   (return-type "none")
   (parameters
-    '("GList*" "list")
+    '("GdaConnection*" "cnc")
   )
 )
 
-(define-function config_add_listener
-  (c-name "gda_config_add_listener")
-  (return-type "guint")
-  (parameters
-    '("const-gchar*" "path")
-    '("GdaConfigListenerFunc" "func")
-    '("gpointer" "user_data")
-  )
+(define-method get_connection
+  (of-object "GdaDict")
+  (c-name "gda_dict_get_connection")
+  (return-type "GdaConnection*")
 )
 
-(define-function config_remove_listener
-  (c-name "gda_config_remove_listener")
+(define-method get_database
+  (of-object "GdaDict")
+  (c-name "gda_dict_get_database")
+  (return-type "GdaDictDatabase*")
+)
+
+(define-method declare_object_string_id_change
+  (of-object "GdaDict")
+  (c-name "gda_dict_declare_object_string_id_change")
   (return-type "none")
   (parameters
-    '("guint" "id")
+    '("GdaObject*" "obj")
+    '("const-gchar*" "oldid")
   )
 )
 
-(define-function gda_provider_parameter_info_get_type
-  (c-name "gda_provider_parameter_info_get_type")
-  (return-type "GType")
-)
-
-(define-function gda_provider_parameter_info_new_full
-  (c-name "gda_provider_parameter_info_new_full")
-  (return-type "GdaProviderParameterInfo*")
+(define-method get_object_by_string_id
+  (of-object "GdaDict")
+  (c-name "gda_dict_get_object_by_string_id")
+  (return-type "GdaObject*")
   (parameters
-    '("const-gchar*" "name")
-    '("const-gchar*" "short_description")
-    '("const-gchar*" "long_description")
-    '("GdaValueType" "type")
+    '("const-gchar*" "strid")
   )
 )
 
-(define-method copy
-  (of-object "GdaProviderParameterInfo")
-  (c-name "gda_provider_parameter_info_copy")
-  (return-type "GdaProviderParameterInfo*")
+(define-method update_dbms_meta_data
+  (of-object "GdaDict")
+  (c-name "gda_dict_update_dbms_meta_data")
+  (return-type "gboolean")
+  (parameters
+    '("GType" "limit_to_type")
+    '("const-gchar*" "limit_obj_name")
+    '("GError**" "error")
+  )
 )
 
-(define-method free
-  (of-object "GdaProviderParameterInfo")
-  (c-name "gda_provider_parameter_info_free")
+(define-method stop_update_dbms_meta_data
+  (of-object "GdaDict")
+  (c-name "gda_dict_stop_update_dbms_meta_data")
   (return-type "none")
 )
 
-(define-function gda_provider_info_get_type
-  (c-name "gda_provider_info_get_type")
-  (return-type "GType")
+(define-method compute_xml_filename
+  (of-object "GdaDict")
+  (c-name "gda_dict_compute_xml_filename")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "datasource")
+    '("const-gchar*" "app_id")
+    '("GError**" "error")
+  )
 )
 
-(define-method copy
-  (of-object "GdaProviderInfo")
-  (c-name "gda_provider_info_copy")
-  (return-type "GdaProviderInfo*")
+(define-method set_xml_filename
+  (of-object "GdaDict")
+  (c-name "gda_dict_set_xml_filename")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "xmlfile")
+  )
 )
 
-(define-method free
-  (of-object "GdaProviderInfo")
-  (c-name "gda_provider_info_free")
-  (return-type "none")
+(define-method get_xml_filename
+  (of-object "GdaDict")
+  (c-name "gda_dict_get_xml_filename")
+  (return-type "const-gchar*")
 )
 
-(define-function config_get_provider_list
-  (c-name "gda_config_get_provider_list")
-  (return-type "GList*")
+(define-method load
+  (of-object "GdaDict")
+  (c-name "gda_dict_load")
+  (return-type "gboolean")
+  (parameters
+    '("GError**" "error")
+  )
 )
 
-(define-function config_free_provider_list
-  (c-name "gda_config_free_provider_list")
-  (return-type "none")
+(define-method save
+  (of-object "GdaDict")
+  (c-name "gda_dict_save")
+  (return-type "gboolean")
   (parameters
-    '("GList*" "list")
+    '("GError**" "error")
   )
 )
 
-(define-function config_get_data_source_list
-  (c-name "gda_config_get_data_source_list")
-  (return-type "GList*")
+(define-method load_xml_file
+  (of-object "GdaDict")
+  (c-name "gda_dict_load_xml_file")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "xmlfile")
+    '("GError**" "error")
+  )
 )
 
-(define-function config_get_provider_by_name
-  (c-name "gda_config_get_provider_by_name")
-  (return-type "GdaProviderInfo*")
+(define-method save_xml_file
+  (of-object "GdaDict")
+  (c-name "gda_dict_save_xml_file")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "name")
+    '("const-gchar*" "xmlfile")
+    '("GError**" "error")
   )
 )
 
-(define-function config_get_provider_model
-  (c-name "gda_config_get_provider_model")
-  (return-type "GdaDataModel*")
+(define-method get_handler
+  (of-object "GdaDict")
+  (c-name "gda_dict_get_handler")
+  (return-type "GdaDataHandler*")
+  (parameters
+    '("GType" "for_type")
+  )
 )
 
-(define-function gda_data_source_info_get_type
-  (c-name "gda_data_source_info_get_type")
-  (return-type "GType")
+(define-method get_default_handler
+  (of-object "GdaDict")
+  (c-name "gda_dict_get_default_handler")
+  (return-type "GdaDataHandler*")
+  (parameters
+    '("GType" "for_type")
+  )
 )
 
-(define-function gda_data_source_info_new
-  (c-name "gda_data_source_info_new")
-  (is-constructor-of "GdaDataSourceInfo")
-  (return-type "GdaDataSourceInfo")
+(define-method declare_object
+  (of-object "GdaDict")
+  (c-name "gda_dict_declare_object")
+  (return-type "none")
+  (parameters
+    '("GdaObject*" "object")
+  )
 )
 
-(define-function config_copy_data_source_info
-  (c-name "gda_config_copy_data_source_info")
-  (return-type "GdaDataSourceInfo*")
+(define-method declare_object_as
+  (of-object "GdaDict")
+  (c-name "gda_dict_declare_object_as")
+  (return-type "none")
   (parameters
-    '("GdaDataSourceInfo*" "src")
+    '("GdaObject*" "object")
+    '("GType" "as_type")
   )
 )
 
-(define-function config_find_data_source
-  (c-name "gda_config_find_data_source")
-  (return-type "GdaDataSourceInfo*")
+(define-method assume_object
+  (of-object "GdaDict")
+  (c-name "gda_dict_assume_object")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "name")
+    '("GdaObject*" "object")
   )
 )
 
-(define-function config_free_data_source_list
-  (c-name "gda_config_free_data_source_list")
+(define-method assume_object_as
+  (of-object "GdaDict")
+  (c-name "gda_dict_assume_object_as")
   (return-type "none")
   (parameters
-    '("GList*" "list")
+    '("GdaObject*" "object")
+    '("GType" "as_type")
   )
 )
 
-(define-function config_get_data_source_model
-  (c-name "gda_config_get_data_source_model")
-  (return-type "GdaDataModel*")
+(define-method unassume_object
+  (of-object "GdaDict")
+  (c-name "gda_dict_unassume_object")
+  (return-type "none")
+  (parameters
+    '("GdaObject*" "object")
+  )
 )
 
-(define-function config_save_data_source
-  (c-name "gda_config_save_data_source")
-  (return-type "none")
+(define-method object_is_assumed
+  (of-object "GdaDict")
+  (c-name "gda_dict_object_is_assumed")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "name")
-    '("const-gchar*" "provider")
-    '("const-gchar*" "cnc_string")
-    '("const-gchar*" "description")
-    '("const-gchar*" "username")
-    '("const-gchar*" "password")
+    '("GdaObject*" "object")
   )
 )
 
-(define-function config_save_data_source_info
-  (c-name "gda_config_save_data_source_info")
-  (return-type "none")
+(define-method get_objects
+  (of-object "GdaDict")
+  (c-name "gda_dict_get_objects")
+  (return-type "GSList*")
   (parameters
-    '("GdaDataSourceInfo*" "dsn_info")
+    '("GType" "type")
   )
 )
 
-(define-function config_remove_data_source
-  (c-name "gda_config_remove_data_source")
-  (return-type "none")
+(define-method get_object_by_name
+  (of-object "GdaDict")
+  (c-name "gda_dict_get_object_by_name")
+  (return-type "GdaObject*")
   (parameters
+    '("GType" "type")
     '("const-gchar*" "name")
   )
 )
 
+(define-method get_object_by_xml_id
+  (of-object "GdaDict")
+  (c-name "gda_dict_get_object_by_xml_id")
+  (return-type "GdaObject*")
+  (parameters
+    '("GType" "type")
+    '("const-gchar*" "xml_id")
+  )
+)
 
+(define-method dump
+  (of-object "GdaDict")
+  (c-name "gda_dict_dump")
+  (return-type "none")
+)
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-connection.h
+;; From gda-dict-table.h
 
-(define-function gda_connection_get_type
-  (c-name "gda_connection_get_type")
+(define-function gda_dict_table_get_type
+  (c-name "gda_dict_table_get_type")
   (return-type "GType")
 )
 
-(define-function gda_connection_new
-  (c-name "gda_connection_new")
-  (is-constructor-of "GdaConnection")
-  (return-type "GdaConnection*")
-  (parameters
-    '("GdaClient*" "client")
-    '("GdaServerProvider*" "provider")
-    '("const-gchar*" "dsn")
-    '("const-gchar*" "username")
-    '("const-gchar*" "password")
-    '("GdaConnectionOptions" "options")
-  )
+(define-method table_new
+  (of-object "GdaDict")
+  (c-name "gda_dict_table_new")
+  (return-type "GObject*")
 )
 
-(define-method reset
-  (of-object "GdaConnection")
-  (c-name "gda_connection_reset")
-  (return-type "gboolean")
+(define-method get_database
+  (of-object "GdaDictTable")
+  (c-name "gda_dict_table_get_database")
+  (return-type "GdaDictDatabase*")
 )
 
-(define-method close
-  (of-object "GdaConnection")
-  (c-name "gda_connection_close")
+(define-method is_view
+  (of-object "GdaDictTable")
+  (c-name "gda_dict_table_is_view")
   (return-type "gboolean")
 )
 
-(define-method is_open
-  (of-object "GdaConnection")
-  (c-name "gda_connection_is_open")
-  (return-type "gboolean")
+(define-method get_parents
+  (of-object "GdaDictTable")
+  (c-name "gda_dict_table_get_parents")
+  (return-type "const-GSList*")
 )
 
-(define-method get_client
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_client")
-  (return-type "GdaClient*")
+(define-method get_constraints
+  (of-object "GdaDictTable")
+  (c-name "gda_dict_table_get_constraints")
+  (return-type "GSList*")
 )
 
-(define-method set_client
-  (of-object "GdaConnection")
-  (c-name "gda_connection_set_client")
-  (return-type "none")
-  (parameters
-    '("GdaClient*" "client")
-  )
+(define-method get_pk_constraint
+  (of-object "GdaDictTable")
+  (c-name "gda_dict_table_get_pk_constraint")
+  (return-type "GdaDictConstraint*")
 )
 
-(define-method get_options
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_options")
-  (return-type "GdaConnectionOptions")
+(define-method update_dbms_data
+  (of-object "GdaDictTable")
+  (c-name "gda_dict_table_update_dbms_data")
+  (return-type "gboolean")
+  (parameters
+    '("GError**" "error")
+  )
 )
 
-(define-method get_server_version
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_server_version")
-  (return-type "const-gchar*")
-)
 
-(define-method get_database
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_database")
-  (return-type "const-gchar*")
-)
 
-(define-method get_dsn
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_dsn")
-  (return-type "const-gchar*")
-)
+;; From gda-dict-type.h
 
-(define-method get_cnc_string
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_cnc_string")
-  (return-type "const-gchar*")
+(define-function gda_dict_type_get_type
+  (c-name "gda_dict_type_get_type")
+  (return-type "GType")
 )
 
-(define-method get_provider
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_provider")
-  (return-type "const-gchar*")
+(define-method type_new
+  (of-object "GdaDict")
+  (c-name "gda_dict_type_new")
+  (return-type "GdaDictType*")
 )
 
-(define-method get_username
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_username")
-  (return-type "const-gchar*")
+(define-method set_sqlname
+  (of-object "GdaDictType")
+  (c-name "gda_dict_type_set_sqlname")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "sqlname")
+  )
 )
 
-(define-method get_password
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_password")
+(define-method get_sqlname
+  (of-object "GdaDictType")
+  (c-name "gda_dict_type_get_sqlname")
   (return-type "const-gchar*")
 )
 
-(define-method add_error
-  (of-object "GdaConnection")
-  (c-name "gda_connection_add_error")
+(define-method set_g_type
+  (of-object "GdaDictType")
+  (c-name "gda_dict_type_set_g_type")
   (return-type "none")
   (parameters
-    '("GdaError*" "error")
+    '("GType" "g_type")
   )
 )
 
-(define-method add_error_string
-  (of-object "GdaConnection")
-  (c-name "gda_connection_add_error_string")
-  (return-type "none")
-  (parameters
-    '("const-gchar*" "str")
-  )
-  (varargs #t)
+(define-method get_g_type
+  (of-object "GdaDictType")
+  (c-name "gda_dict_type_get_g_type")
+  (return-type "GType")
 )
 
-(define-method add_error_list
-  (of-object "GdaConnection")
-  (c-name "gda_connection_add_error_list")
+(define-method add_synonym
+  (of-object "GdaDictType")
+  (c-name "gda_dict_type_add_synonym")
   (return-type "none")
   (parameters
-    '("GList*" "error_list")
+    '("const-gchar*" "synonym")
   )
 )
 
-(define-method clear_error_list
-  (of-object "GdaConnection")
-  (c-name "gda_connection_clear_error_list")
+(define-method get_synonyms
+  (of-object "GdaDictType")
+  (c-name "gda_dict_type_get_synonyms")
+  (return-type "const-GSList*")
+)
+
+(define-method clear_synonyms
+  (of-object "GdaDictType")
+  (c-name "gda_dict_type_clear_synonyms")
   (return-type "none")
 )
 
-(define-method change_database
-  (of-object "GdaConnection")
-  (c-name "gda_connection_change_database")
-  (return-type "gboolean")
-  (parameters
-    '("const-gchar*" "name")
-  )
+
+
+;; From gda-entity-field.h
+
+(define-function gda_entity_field_get_type
+  (c-name "gda_entity_field_get_type")
+  (return-type "GType")
 )
 
-(define-method create_database
-  (of-object "GdaConnection")
-  (c-name "gda_connection_create_database")
-  (return-type "gboolean")
-  (parameters
-    '("const-gchar*" "name")
-  )
+(define-method get_entity
+  (of-object "GdaEntityField")
+  (c-name "gda_entity_field_get_entity")
+  (return-type "GdaEntity*")
 )
 
-(define-method drop_database
-  (of-object "GdaConnection")
-  (c-name "gda_connection_drop_database")
-  (return-type "gboolean")
-  (parameters
-    '("const-gchar*" "name")
-  )
+(define-method get_g_type
+  (of-object "GdaEntityField")
+  (c-name "gda_entity_field_get_g_type")
+  (return-type "GType")
 )
 
-(define-method create_table
-  (of-object "GdaConnection")
-  (c-name "gda_connection_create_table")
-  (return-type "gboolean")
-  (parameters
-    '("const-gchar*" "table_name")
-    '("const-GdaFieldAttributes*[]" "attributes")
-  )
+(define-method get_dict_type
+  (of-object "GdaEntityField")
+  (c-name "gda_entity_field_get_dict_type")
+  (return-type "GdaDictType*")
 )
 
-(define-method drop_table
-  (of-object "GdaConnection")
-  (c-name "gda_connection_drop_table")
+(define-method get_name
+  (of-object "GdaEntityField")
+  (c-name "gda_entity_field_get_name")
+  (return-type "const-gchar*")
+)
+
+(define-method get_description
+  (of-object "GdaEntityField")
+  (c-name "gda_entity_field_get_description")
+  (return-type "const-gchar*")
+)
+
+
+
+;; From gda-entity.h
+
+(define-function gda_entity_get_type
+  (c-name "gda_entity_get_type")
+  (return-type "GType")
+)
+
+(define-method has_field
+  (of-object "GdaEntity")
+  (c-name "gda_entity_has_field")
   (return-type "gboolean")
   (parameters
-    '("const-gchar*" "table_name")
+    '("GdaEntityField*" "field")
   )
 )
 
-(define-method execute_command
-  (of-object "GdaConnection")
-  (c-name "gda_connection_execute_command")
-  (return-type "GList*")
+(define-method get_fields
+  (of-object "GdaEntity")
+  (c-name "gda_entity_get_fields")
+  (return-type "GSList*")
+)
+
+(define-method get_n_fields
+  (of-object "GdaEntity")
+  (c-name "gda_entity_get_n_fields")
+  (return-type "gint")
+)
+
+(define-method get_field_by_name
+  (of-object "GdaEntity")
+  (c-name "gda_entity_get_field_by_name")
+  (return-type "GdaEntityField*")
   (parameters
-    '("GdaCommand*" "cmd")
-    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
+    '("const-gchar*" "name")
   )
 )
 
-(define-method get_last_insert_id
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_last_insert_id")
-  (return-type "gchar*")
+(define-method get_field_by_xml_id
+  (of-object "GdaEntity")
+  (c-name "gda_entity_get_field_by_xml_id")
+  (return-type "GdaEntityField*")
   (parameters
-    '("GdaDataModel*" "recset")
+    '("const-gchar*" "xml_id")
   )
 )
 
-(define-method execute_single_command
-  (of-object "GdaConnection")
-  (c-name "gda_connection_execute_single_command")
-  (return-type "GdaDataModel*")
+(define-method get_field_by_index
+  (of-object "GdaEntity")
+  (c-name "gda_entity_get_field_by_index")
+  (return-type "GdaEntityField*")
   (parameters
-    '("GdaCommand*" "cmd")
-    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
+    '("gint" "index")
   )
 )
 
-(define-method execute_non_query
-  (of-object "GdaConnection")
-  (c-name "gda_connection_execute_non_query")
+(define-method get_field_index
+  (of-object "GdaEntity")
+  (c-name "gda_entity_get_field_index")
   (return-type "gint")
   (parameters
-    '("GdaCommand*" "cmd")
-    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
+    '("GdaEntityField*" "field")
   )
 )
 
-(define-method begin_transaction
-  (of-object "GdaConnection")
-  (c-name "gda_connection_begin_transaction")
-  (return-type "gboolean")
+(define-method add_field
+  (of-object "GdaEntity")
+  (c-name "gda_entity_add_field")
+  (return-type "none")
   (parameters
-    '("GdaTransaction*" "xaction")
+    '("GdaEntityField*" "field")
   )
 )
 
-(define-method commit_transaction
-  (of-object "GdaConnection")
-  (c-name "gda_connection_commit_transaction")
-  (return-type "gboolean")
+(define-method add_field_before
+  (of-object "GdaEntity")
+  (c-name "gda_entity_add_field_before")
+  (return-type "none")
   (parameters
-    '("GdaTransaction*" "xaction")
+    '("GdaEntityField*" "field")
+    '("GdaEntityField*" "field_before")
   )
 )
 
-(define-method rollback_transaction
-  (of-object "GdaConnection")
-  (c-name "gda_connection_rollback_transaction")
-  (return-type "gboolean")
+(define-method swap_fields
+  (of-object "GdaEntity")
+  (c-name "gda_entity_swap_fields")
+  (return-type "none")
   (parameters
-    '("GdaTransaction*" "xaction")
+    '("GdaEntityField*" "field1")
+    '("GdaEntityField*" "field2")
   )
 )
 
-(define-method create_blob
-  (of-object "GdaConnection")
-  (c-name "gda_connection_create_blob")
-  (return-type "gboolean")
+(define-method remove_field
+  (of-object "GdaEntity")
+  (c-name "gda_entity_remove_field")
+  (return-type "none")
   (parameters
-    '("GdaBlob*" "blob")
+    '("GdaEntityField*" "field")
   )
 )
 
-(define-method escape_string
-  (of-object "GdaConnection")
-  (c-name "gda_connection_escape_string")
+(define-method is_writable
+  (of-object "GdaEntity")
+  (c-name "gda_entity_is_writable")
   (return-type "gboolean")
-  (parameters
-    '("const-gchar*" "from")
-    '("gchar*" "to")
-  )
 )
 
-(define-method get_errors
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_errors")
-  (return-type "const-GList*")
+
+
+;; From gda-enums.h
+
+
+
+;; From gda-enum-types.h
+
+(define-function gda_blob_mode_get_type
+  (c-name "gda_blob_mode_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_client_event_get_type
+  (c-name "gda_client_event_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_client_error_get_type
+  (c-name "gda_client_error_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_sorting_get_type
+  (c-name "gda_sorting_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_command_options_get_type
+  (c-name "gda_command_options_get_type")
+  (return-type "GType")
 )
 
-(define-method supports
-  (of-object "GdaConnection")
-  (c-name "gda_connection_supports")
-  (return-type "gboolean")
-  (parameters
-    '("GdaConnectionFeature" "feature")
-  )
+(define-function gda_command_type_get_type
+  (c-name "gda_command_type_get_type")
+  (return-type "GType")
 )
 
-(define-method get_schema
-  (of-object "GdaConnection")
-  (c-name "gda_connection_get_schema")
-  (return-type "GdaDataModel*")
-  (parameters
-    '("GdaConnectionSchema" "schema")
-    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
-  )
+(define-function gda_connection_event_type_get_type
+  (c-name "gda_connection_event_type_get_type")
+  (return-type "GType")
 )
 
+(define-function gda_connection_event_code_get_type
+  (c-name "gda_connection_event_code_get_type")
+  (return-type "GType")
+)
 
+(define-function gda_connection_error_get_type
+  (c-name "gda_connection_error_get_type")
+  (return-type "GType")
+)
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-data-model-array.h
+(define-function gda_connection_options_get_type
+  (c-name "gda_connection_options_get_type")
+  (return-type "GType")
+)
 
-(define-function gda_data_model_array_get_type
-  (c-name "gda_data_model_array_get_type")
+(define-function gda_connection_feature_get_type
+  (c-name "gda_connection_feature_get_type")
   (return-type "GType")
 )
 
-(define-function gda_data_model_array_new
-  (c-name "gda_data_model_array_new")
-  (is-constructor-of "GdaDataModelArray")
-  (return-type "GdaDataModel*")
-  (parameters
-    '("gint" "cols")
-  )
+(define-function gda_connection_schema_get_type
+  (c-name "gda_connection_schema_get_type")
+  (return-type "GType")
 )
 
-(define-method set_n_columns
-  (of-object "GdaDataModelArray")
-  (c-name "gda_data_model_array_set_n_columns")
-  (return-type "none")
-  (parameters
-    '("gint" "cols")
-  )
+(define-function gda_data_model_access_flags_get_type
+  (c-name "gda_data_model_access_flags_get_type")
+  (return-type "GType")
 )
 
-(define-method clear
-  (of-object "GdaDataModelArray")
-  (c-name "gda_data_model_array_clear")
-  (return-type "none")
+(define-function gda_data_model_hint_get_type
+  (c-name "gda_data_model_hint_get_type")
+  (return-type "GType")
 )
 
+(define-function gda_data_model_io_format_get_type
+  (c-name "gda_data_model_io_format_get_type")
+  (return-type "GType")
+)
 
+(define-function gda_data_model_iter_error_get_type
+  (c-name "gda_data_model_iter_error_get_type")
+  (return-type "GType")
+)
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-data-model.h
+(define-function gda_data_model_query_error_get_type
+  (c-name "gda_data_model_query_error_get_type")
+  (return-type "GType")
+)
 
-(define-function gda_data_model_get_type
-  (c-name "gda_data_model_get_type")
+(define-function gda_data_proxy_error_get_type
+  (c-name "gda_data_proxy_error_get_type")
   (return-type "GType")
 )
 
-(define-method changed
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_changed")
-  (return-type "none")
+(define-function gda_dict_aggregate_error_get_type
+  (c-name "gda_dict_aggregate_error_get_type")
+  (return-type "GType")
 )
 
-(define-method row_inserted
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_row_inserted")
-  (return-type "none")
-  (parameters
-    '("gint" "row")
-  )
+(define-function gda_dict_constraint_error_get_type
+  (c-name "gda_dict_constraint_error_get_type")
+  (return-type "GType")
 )
 
-(define-method row_updated
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_row_updated")
-  (return-type "none")
-  (parameters
-    '("gint" "row")
-  )
+(define-function gda_dict_constraint_type_get_type
+  (c-name "gda_dict_constraint_type_get_type")
+  (return-type "GType")
 )
 
-(define-method row_removed
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_row_removed")
-  (return-type "none")
-  (parameters
-    '("gint" "row")
-  )
+(define-function gda_dict_constraint_fk_action_get_type
+  (c-name "gda_dict_constraint_fk_action_get_type")
+  (return-type "GType")
 )
 
-(define-method column_inserted
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_column_inserted")
-  (return-type "none")
-  (parameters
-    '("gint" "col")
-  )
+(define-function gda_dict_database_error_get_type
+  (c-name "gda_dict_database_error_get_type")
+  (return-type "GType")
 )
 
-(define-method column_updated
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_column_updated")
-  (return-type "none")
-  (parameters
-    '("gint" "col")
-  )
+(define-function gda_dict_field_error_get_type
+  (c-name "gda_dict_field_error_get_type")
+  (return-type "GType")
 )
 
-(define-method column_removed
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_column_removed")
-  (return-type "none")
-  (parameters
-    '("gint" "col")
-  )
+(define-function gda_dict_field_attribute_get_type
+  (c-name "gda_dict_field_attribute_get_type")
+  (return-type "GType")
 )
 
-(define-method freeze
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_freeze")
-  (return-type "none")
+(define-function gda_dict_function_error_get_type
+  (c-name "gda_dict_function_error_get_type")
+  (return-type "GType")
 )
 
-(define-method thaw
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_thaw")
-  (return-type "none")
+(define-function gda_dict_error_get_type
+  (c-name "gda_dict_error_get_type")
+  (return-type "GType")
 )
 
-(define-method get_n_rows
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_get_n_rows")
-  (return-type "gint")
+(define-function gda_dict_table_error_get_type
+  (c-name "gda_dict_table_error_get_type")
+  (return-type "GType")
 )
 
-(define-method get_n_columns
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_get_n_columns")
-  (return-type "gint")
+(define-function gda_dict_type_error_get_type
+  (c-name "gda_dict_type_error_get_type")
+  (return-type "GType")
 )
 
-(define-method describe_column
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_describe_column")
-  (return-type "GdaFieldAttributes*")
-  (parameters
-    '("gint" "col")
-  )
+(define-function g_value_attribute_get_type
+  (c-name "g_value_attribute_get_type")
+  (return-type "GType")
 )
 
-(define-method get_column_title
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_get_column_title")
-  (return-type "const-gchar*")
-  (parameters
-    '("gint" "col")
-  )
+(define-function gda_graph_type_get_type
+  (c-name "gda_graph_type_get_type")
+  (return-type "GType")
 )
 
-(define-method set_column_title
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_set_column_title")
-  (return-type "none")
-  (parameters
-    '("gint" "col")
-    '("const-gchar*" "title")
-  )
+(define-function gda_query_field_state_get_type
+  (c-name "gda_query_field_state_get_type")
+  (return-type "GType")
 )
 
-(define-method get_column_position
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_get_column_position")
-  (return-type "gint")
-  (parameters
-    '("const-gchar*" "title")
-  )
+(define-function gda_object_ref_type_get_type
+  (c-name "gda_object_ref_type_get_type")
+  (return-type "GType")
 )
 
-(define-method get_row
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_get_row")
-  (return-type "const-GdaRow*")
-  (parameters
-    '("gint" "row")
-  )
+(define-function gda_object_ref_error_get_type
+  (c-name "gda_object_ref_error_get_type")
+  (return-type "GType")
 )
 
-(define-method get_value_at
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_get_value_at")
-  (return-type "const-GdaValue*")
-  (parameters
-    '("gint" "col")
-    '("gint" "row")
-  )
+(define-function gda_parameter_error_get_type
+  (c-name "gda_parameter_error_get_type")
+  (return-type "GType")
 )
 
-(define-method is_updatable
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_is_updatable")
-  (return-type "gboolean")
+(define-function gda_parameter_list_error_get_type
+  (c-name "gda_parameter_list_error_get_type")
+  (return-type "GType")
 )
 
-(define-method append_row
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_append_row")
-  (return-type "const-GdaRow*")
-  (parameters
-    '("const-GList*" "values")
-  )
+(define-function gda_parameter_list_param_hint_get_type
+  (c-name "gda_parameter_list_param_hint_get_type")
+  (return-type "GType")
 )
 
-(define-method remove_row
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_remove_row")
-  (return-type "gboolean")
-  (parameters
-    '("const-GdaRow*" "row")
-  )
+(define-function gda_query_condition_type_get_type
+  (c-name "gda_query_condition_type_get_type")
+  (return-type "GType")
 )
 
-(define-method update_row
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_update_row")
-  (return-type "gboolean")
-  (parameters
-    '("const-GdaRow*" "row")
-  )
+(define-function gda_query_condition_operator_get_type
+  (c-name "gda_query_condition_operator_get_type")
+  (return-type "GType")
 )
 
-(define-method append_column
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_append_column")
-  (return-type "gboolean")
-  (parameters
-    '("const-GdaFieldAttributes*" "attrs")
-  )
+(define-function gda_query_condition_error_get_type
+  (c-name "gda_query_condition_error_get_type")
+  (return-type "GType")
 )
 
-(define-method update_column
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_update_column")
-  (return-type "gboolean")
-  (parameters
-    '("gint" "col")
-    '("const-GdaFieldAttributes*" "attrs")
-  )
+(define-function gda_query_field_agg_error_get_type
+  (c-name "gda_query_field_agg_error_get_type")
+  (return-type "GType")
 )
 
-(define-method remove_column
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_remove_column")
-  (return-type "gboolean")
-  (parameters
-    '("gint" "col")
-  )
+(define-function gda_query_field_all_error_get_type
+  (c-name "gda_query_field_all_error_get_type")
+  (return-type "GType")
 )
 
-(define-method foreach
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_foreach")
-  (return-type "none")
-  (parameters
-    '("GdaDataModelForeachFunc" "func")
-    '("gpointer" "user_data")
-  )
+(define-function gda_query_field_field_error_get_type
+  (c-name "gda_query_field_field_error_get_type")
+  (return-type "GType")
 )
 
-(define-method has_changed
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_has_changed")
-  (return-type "gboolean")
+(define-function gda_query_field_func_error_get_type
+  (c-name "gda_query_field_func_error_get_type")
+  (return-type "GType")
 )
 
-(define-method begin_update
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_begin_update")
-  (return-type "gboolean")
+(define-function gda_query_field_error_get_type
+  (c-name "gda_query_field_error_get_type")
+  (return-type "GType")
 )
 
-(define-method cancel_update
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_cancel_update")
-  (return-type "gboolean")
+(define-function gda_query_field_value_error_get_type
+  (c-name "gda_query_field_value_error_get_type")
+  (return-type "GType")
 )
 
-(define-method end_update
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_end_update")
-  (return-type "gboolean")
+(define-function gda_query_type_get_type
+  (c-name "gda_query_type_get_type")
+  (return-type "GType")
 )
 
-(define-method to_comma_separated
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_to_comma_separated")
-  (return-type "gchar*")
+(define-function gda_query_error_get_type
+  (c-name "gda_query_error_get_type")
+  (return-type "GType")
 )
 
-(define-method to_tab_separated
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_to_tab_separated")
-  (return-type "gchar*")
+(define-function gda_query_join_type_get_type
+  (c-name "gda_query_join_type_get_type")
+  (return-type "GType")
 )
 
-(define-method to_xml
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_to_xml")
-  (return-type "gchar*")
-  (parameters
-    '("gboolean" "standalone")
-  )
+(define-function gda_query_join_error_get_type
+  (c-name "gda_query_join_error_get_type")
+  (return-type "GType")
 )
 
-(define-method to_xml_node
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_to_xml_node")
-  (return-type "xmlNodePtr")
-  (parameters
-    '("const-gchar*" "name")
-  )
+(define-function gda_query_target_error_get_type
+  (c-name "gda_query_target_error_get_type")
+  (return-type "GType")
 )
 
-(define-method add_data_from_xml_node
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_add_data_from_xml_node")
-  (return-type "gboolean")
-  (parameters
-    '("xmlNodePtr" "node")
-  )
+(define-function gda_renderer_options_get_type
+  (c-name "gda_renderer_options_get_type")
+  (return-type "GType")
 )
 
-(define-method get_command_text
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_get_command_text")
-  (return-type "const-gchar*")
+(define-function gda_server_operation_type_get_type
+  (c-name "gda_server_operation_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_server_operation_node_type_get_type
+  (c-name "gda_server_operation_node_type_get_type")
+  (return-type "GType")
 )
 
-(define-method set_command_text
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_set_command_text")
-  (return-type "none")
-  (parameters
-    '("const-gchar*" "txt")
-  )
+(define-function gda_server_operation_node_status_get_type
+  (c-name "gda_server_operation_node_status_get_type")
+  (return-type "GType")
 )
 
-(define-method get_command_type
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_get_command_type")
-  (return-type "GdaCommandType")
+(define-function gda_transaction_isolation_get_type
+  (c-name "gda_transaction_isolation_get_type")
+  (return-type "GType")
 )
 
-(define-method set_command_type
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_set_command_type")
-  (return-type "none")
-  (parameters
-    '("GdaCommandType" "type")
-  )
+(define-function gda_general_error_get_type
+  (c-name "gda_general_error_get_type")
+  (return-type "GType")
 )
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-data-model-hash.h
+;; From gda-graphviz.h
 
-(define-function gda_data_model_hash_get_type
-  (c-name "gda_data_model_hash_get_type")
+(define-function gda_graphviz_get_type
+  (c-name "gda_graphviz_get_type")
   (return-type "GType")
 )
 
-(define-function gda_data_model_hash_new
-  (c-name "gda_data_model_hash_new")
-  (is-constructor-of "GdaDataModelHash")
-  (return-type "GdaDataModel*")
+(define-function gda_graphviz_new
+  (c-name "gda_graphviz_new")
+  (is-constructor-of "GdaGraphviz")
+  (return-type "GObject*")
   (parameters
-    '("gint" "cols")
+    '("GdaDict*" "dict")
   )
 )
 
-(define-method hash_get_value_at
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_hash_get_value_at")
-  (return-type "const-GdaValue*")
+(define-method add_to_graph
+  (of-object "GdaGraphviz")
+  (c-name "gda_graphviz_add_to_graph")
+  (return-type "none")
   (parameters
-    '("gint" "col")
-    '("gint" "row")
+    '("GObject*" "obj")
   )
 )
 
-(define-method clear
-  (of-object "GdaDataModelHash")
-  (c-name "gda_data_model_hash_clear")
+(define-method save_file
+  (of-object "GdaGraphviz")
+  (c-name "gda_graphviz_save_file")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "filename")
+    '("GError**" "error")
+  )
+)
+
+
+
+;; From gda-log.h
+
+(define-function gda_log_enable
+  (c-name "gda_log_enable")
   (return-type "none")
 )
 
-(define-method set_n_columns
-  (of-object "GdaDataModelHash")
-  (c-name "gda_data_model_hash_set_n_columns")
+(define-function gda_log_disable
+  (c-name "gda_log_disable")
   (return-type "none")
-  (parameters
-    '("gint" "cols")
-  )
 )
 
-(define-method insert_row
-  (of-object "GdaDataModelHash")
-  (c-name "gda_data_model_hash_insert_row")
+(define-function gda_log_is_enabled
+  (c-name "gda_log_is_enabled")
+  (return-type "gboolean")
+)
+
+(define-function gda_log_message
+  (c-name "gda_log_message")
   (return-type "none")
   (parameters
-    '("gint" "rownum")
-    '("GdaRow*" "row")
+    '("const-gchar*" "format")
   )
+  (varargs #t)
 )
 
-(define-method hash_get_row
-  (of-object "GdaDataModel")
-  (c-name "gda_data_model_hash_get_row")
-  (return-type "const-GdaRow*")
+(define-function gda_log_error
+  (c-name "gda_log_error")
+  (return-type "none")
   (parameters
-    '("gint" "row")
+    '("const-gchar*" "format")
   )
+  (varargs #t)
 )
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-data-model-list.h
+;; From gda-marshal.h
+
+
 
-(define-function gda_data_model_list_get_type
-  (c-name "gda_data_model_list_get_type")
+;; From gda-object.h
+
+(define-function gda_object_get_type
+  (c-name "gda_object_get_type")
   (return-type "GType")
 )
 
-(define-function gda_data_model_list_new
-  (c-name "gda_data_model_list_new")
-  (is-constructor-of "GdaDataModelList")
-  (return-type "GdaDataModel*")
+(define-method get_dict
+  (of-object "GdaObject")
+  (c-name "gda_object_get_dict")
+  (return-type "GdaDict*")
 )
 
-(define-function gda_data_model_list_new_from_string_list
-  (c-name "gda_data_model_list_new_from_string_list")
-  (return-type "GdaDataModel*")
+(define-method set_id
+  (of-object "GdaObject")
+  (c-name "gda_object_set_id")
+  (return-type "none")
   (parameters
-    '("const-GList*" "list")
+    '("const-gchar*" "strid")
   )
 )
 
-(define-method append_value
-  (of-object "GdaDataModelList")
-  (c-name "gda_data_model_list_append_value")
-  (return-type "const-GdaRow*")
+(define-method set_name
+  (of-object "GdaObject")
+  (c-name "gda_object_set_name")
+  (return-type "none")
   (parameters
-    '("const-GdaValue*" "value")
+    '("const-gchar*" "name")
   )
 )
 
+(define-method set_description
+  (of-object "GdaObject")
+  (c-name "gda_object_set_description")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "descr")
+  )
+)
 
+(define-method set_owner
+  (of-object "GdaObject")
+  (c-name "gda_object_set_owner")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "owner")
+  )
+)
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-enum-types.h
-
-(define-function gda_blob_mode_get_type
-  (c-name "gda_blob_mode_get_type")
-  (return-type "GType")
+(define-method get_id
+  (of-object "GdaObject")
+  (c-name "gda_object_get_id")
+  (return-type "const-gchar*")
 )
 
-(define-function gda_client_event_get_type
-  (c-name "gda_client_event_get_type")
-  (return-type "GType")
+(define-method get_name
+  (of-object "GdaObject")
+  (c-name "gda_object_get_name")
+  (return-type "const-gchar*")
 )
 
-(define-function gda_command_options_get_type
-  (c-name "gda_command_options_get_type")
-  (return-type "GType")
+(define-method get_description
+  (of-object "GdaObject")
+  (c-name "gda_object_get_description")
+  (return-type "const-gchar*")
 )
 
-(define-function gda_command_type_get_type
-  (c-name "gda_command_type_get_type")
-  (return-type "GType")
+(define-method get_owner
+  (of-object "GdaObject")
+  (c-name "gda_object_get_owner")
+  (return-type "const-gchar*")
 )
 
-(define-function gda_connection_options_get_type
-  (c-name "gda_connection_options_get_type")
-  (return-type "GType")
+(define-method destroy
+  (of-object "GdaObject")
+  (c-name "gda_object_destroy")
+  (return-type "none")
 )
 
-(define-function gda_connection_feature_get_type
-  (c-name "gda_connection_feature_get_type")
-  (return-type "GType")
+(define-method destroy_check
+  (of-object "GdaObject")
+  (c-name "gda_object_destroy_check")
+  (return-type "none")
 )
 
-(define-function gda_connection_schema_get_type
-  (c-name "gda_connection_schema_get_type")
-  (return-type "GType")
+(define-function gda_object_connect_destroy
+  (c-name "gda_object_connect_destroy")
+  (return-type "gulong")
+  (parameters
+    '("gpointer" "object")
+    '("GCallback" "callback")
+    '("gpointer" "data")
+  )
 )
 
-(define-function gda_transaction_isolation_get_type
-  (c-name "gda_transaction_isolation_get_type")
-  (return-type "GType")
+(define-method signal_emit_changed
+  (of-object "GdaObject")
+  (c-name "gda_object_signal_emit_changed")
+  (return-type "none")
 )
 
-(define-function gda_value_type_get_type
-  (c-name "gda_value_type_get_type")
-  (return-type "GType")
+(define-method block_changed
+  (of-object "GdaObject")
+  (c-name "gda_object_block_changed")
+  (return-type "none")
 )
 
+(define-method unblock_changed
+  (of-object "GdaObject")
+  (c-name "gda_object_unblock_changed")
+  (return-type "none")
+)
 
+(define-method dump
+  (of-object "GdaObject")
+  (c-name "gda_object_dump")
+  (return-type "none")
+  (parameters
+    '("guint" "offset")
+  )
+)
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-error.h
 
-(define-function gda_error_get_type
-  (c-name "gda_error_get_type")
-  (return-type "GType")
-)
 
-(define-function gda_error_new
-  (c-name "gda_error_new")
-  (is-constructor-of "GdaError")
-  (return-type "GdaError*")
-)
+;; From gda-object-ref.h
 
-(define-method free
-  (of-object "GdaError")
-  (c-name "gda_error_free")
-  (return-type "none")
+(define-function gda_object_ref_get_type
+  (c-name "gda_object_ref_get_type")
+  (return-type "GType")
 )
 
-(define-function gda_error_list_copy
-  (c-name "gda_error_list_copy")
-  (return-type "GList*")
+(define-function gda_object_ref_new
+  (c-name "gda_object_ref_new")
+  (is-constructor-of "GdaObjectRef")
+  (return-type "GObject*")
   (parameters
-    '("const-GList*" "errors")
+    '("GdaDict*" "dict")
   )
 )
 
-(define-function gda_error_list_free
-  (c-name "gda_error_list_free")
-  (return-type "none")
+(define-function gda_object_ref_new_no_ref_count
+  (c-name "gda_object_ref_new_no_ref_count")
+  (return-type "GObject*")
   (parameters
-    '("GList*" "errors")
+    '("GdaDict*" "dict")
   )
 )
 
-(define-method get_description
-  (of-object "GdaError")
-  (c-name "gda_error_get_description")
-  (return-type "const-gchar*")
+(define-method new_copy
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_new_copy")
+  (return-type "GObject*")
 )
 
-(define-method set_description
-  (of-object "GdaError")
-  (c-name "gda_error_set_description")
+(define-method set_ref_name
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_set_ref_name")
   (return-type "none")
   (parameters
-    '("const-gchar*" "description")
+    '("GType" "ref_type")
+    '("GdaObjectRefType" "type")
+    '("const-gchar*" "name")
   )
 )
 
-(define-method get_number
-  (of-object "GdaError")
-  (c-name "gda_error_get_number")
-  (return-type "glong")
-)
-
-(define-method set_number
-  (of-object "GdaError")
-  (c-name "gda_error_set_number")
-  (return-type "none")
+(define-method get_ref_name
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_get_ref_name")
+  (return-type "const-gchar*")
   (parameters
-    '("glong" "number")
+    '("GType*" "ref_type")
+    '("GdaObjectRefType*" "type")
   )
 )
 
-(define-method get_source
-  (of-object "GdaError")
-  (c-name "gda_error_get_source")
+(define-method get_ref_object_name
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_get_ref_object_name")
   (return-type "const-gchar*")
 )
 
-(define-method set_source
-  (of-object "GdaError")
-  (c-name "gda_error_set_source")
+(define-method get_ref_type
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_get_ref_type")
+  (return-type "GType")
+)
+
+(define-method set_ref_object
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_set_ref_object")
   (return-type "none")
   (parameters
-    '("const-gchar*" "source")
+    '("GdaObject*" "object")
   )
 )
 
-(define-method get_sqlstate
-  (of-object "GdaError")
-  (c-name "gda_error_get_sqlstate")
-  (return-type "const-gchar*")
-)
-
-(define-method set_sqlstate
-  (of-object "GdaError")
-  (c-name "gda_error_set_sqlstate")
+(define-method set_ref_object_type
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_set_ref_object_type")
   (return-type "none")
   (parameters
-    '("const-gchar*" "sqlstate")
+    '("GdaObject*" "object")
+    '("GType" "type")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-field.h
-
-(define-function gda_field_attributes_get_type
-  (c-name "gda_field_attributes_get_type")
-  (return-type "GType")
+(define-method replace_ref_object
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_replace_ref_object")
+  (return-type "none")
+  (parameters
+    '("GHashTable*" "replacements")
+  )
 )
 
-(define-function gda_field_attributes_new
-  (c-name "gda_field_attributes_new")
-  (is-constructor-of "GdaFieldAttributes")
-  (return-type "GdaFieldAttributes*")
+(define-method get_ref_object
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_get_ref_object")
+  (return-type "GdaObject*")
 )
 
-(define-method copy
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_copy")
-  (return-type "GdaFieldAttributes*")
+(define-method activate
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_activate")
+  (return-type "gboolean")
 )
 
-(define-method free
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_free")
+(define-method deactivate
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_deactivate")
   (return-type "none")
 )
 
-(define-method equal
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_equal")
+(define-method is_active
+  (of-object "GdaObjectRef")
+  (c-name "gda_object_ref_is_active")
   (return-type "gboolean")
-  (parameters
-    '("const-GdaFieldAttributes*" "rhs")
-  )
 )
 
-(define-method get_defined_size
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_defined_size")
-  (return-type "glong")
+
+
+;; From gda-parameter.h
+
+(define-function gda_parameter_get_type
+  (c-name "gda_parameter_get_type")
+  (return-type "GType")
 )
 
-(define-method set_defined_size
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_defined_size")
-  (return-type "none")
+(define-function gda_parameter_new
+  (c-name "gda_parameter_new")
+  (is-constructor-of "GdaParameter")
+  (return-type "GdaParameter*")
   (parameters
-    '("glong" "size")
+    '("GType" "type")
   )
 )
 
-(define-method get_name
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_name")
-  (return-type "const-gchar*")
+(define-method new_copy
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_new_copy")
+  (return-type "GdaParameter*")
 )
 
-(define-method set_name
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_name")
-  (return-type "none")
+(define-method get_g_type
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_get_g_type")
+  (return-type "GType")
+)
+
+(define-function gda_parameter_new_string
+  (c-name "gda_parameter_new_string")
+  (return-type "GdaParameter*")
   (parameters
     '("const-gchar*" "name")
+    '("const-gchar*" "str")
   )
 )
 
-(define-method get_table
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_table")
-  (return-type "const-gchar*")
-)
-
-(define-method set_table
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_table")
-  (return-type "none")
+(define-function gda_parameter_new_boolean
+  (c-name "gda_parameter_new_boolean")
+  (return-type "GdaParameter*")
   (parameters
-    '("const-gchar*" "table")
+    '("const-gchar*" "name")
+    '("gboolean" "value")
   )
 )
 
-(define-method get_caption
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_caption")
-  (return-type "const-gchar*")
-)
-
-(define-method set_caption
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_caption")
+(define-method declare_param_user
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_declare_param_user")
   (return-type "none")
   (parameters
-    '("const-gchar*" "caption")
+    '("GdaObject*" "user")
   )
 )
 
-(define-method get_scale
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_scale")
-  (return-type "glong")
+(define-method get_param_users
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_get_param_users")
+  (return-type "GSList*")
 )
 
-(define-method set_scale
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_scale")
+(define-method replace_param_users
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_replace_param_users")
   (return-type "none")
   (parameters
-    '("glong" "scale")
+    '("GHashTable*" "replacements")
   )
 )
 
-(define-method get_gdatype
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_gdatype")
-  (return-type "GdaValueType")
+(define-method get_value
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_get_value")
+  (return-type "const-GValue*")
 )
 
-(define-method set_gdatype
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_gdatype")
+(define-method set_value
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_set_value")
   (return-type "none")
   (parameters
-    '("GdaValueType" "type")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method get_allow_null
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_allow_null")
+(define-method set_value_str
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_set_value_str")
   (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "value")
+  )
 )
 
-(define-method set_allow_null
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_allow_null")
+(define-method declare_invalid
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_declare_invalid")
   (return-type "none")
-  (parameters
-    '("gboolean" "allow")
-  )
 )
 
-(define-method get_primary_key
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_primary_key")
+(define-method is_valid
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_is_valid")
   (return-type "gboolean")
 )
 
-(define-method set_primary_key
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_primary_key")
+(define-method get_default_value
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_get_default_value")
+  (return-type "const-GValue*")
+)
+
+(define-method set_default_value
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_set_default_value")
   (return-type "none")
   (parameters
-    '("gboolean" "pk")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method get_unique_key
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_unique_key")
+(define-method get_exists_default_value
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_get_exists_default_value")
   (return-type "gboolean")
 )
 
-(define-method set_unique_key
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_unique_key")
+(define-method set_exists_default_value
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_set_exists_default_value")
   (return-type "none")
   (parameters
-    '("gboolean" "uk")
+    '("gboolean" "default_value_exists")
   )
 )
 
-(define-method get_references
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_references")
-  (return-type "const-gchar*")
-)
-
-(define-method set_references
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_references")
+(define-method set_not_null
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_set_not_null")
   (return-type "none")
   (parameters
-    '("const-gchar*" "ref")
+    '("gboolean" "not_null")
   )
 )
 
-(define-method get_auto_increment
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_auto_increment")
+(define-method get_not_null
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_get_not_null")
   (return-type "gboolean")
 )
 
-(define-method set_auto_increment
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_auto_increment")
-  (return-type "none")
+(define-method restrict_values
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_restrict_values")
+  (return-type "gboolean")
   (parameters
-    '("gboolean" "is_auto")
+    '("GdaDataModel*" "model")
+    '("gint" "col")
+    '("GError**" "error")
   )
 )
 
-(define-method get_position
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_position")
-  (return-type "gint")
-)
-
-(define-method set_position
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_position")
-  (return-type "none")
+(define-method has_restrict_values
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_has_restrict_values")
+  (return-type "gboolean")
   (parameters
-    '("gint" "position")
+    '("GdaDataModel**" "model")
+    '("gint*" "col")
   )
 )
 
-(define-method get_default_value
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_get_default_value")
-  (return-type "const-GdaValue*")
-)
-
-(define-method set_default_value
-  (of-object "GdaFieldAttributes")
-  (c-name "gda_field_attributes_set_default_value")
+(define-method bind_to_param
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_bind_to_param")
   (return-type "none")
   (parameters
-    '("const-GdaValue*" "default_value")
+    '("GdaParameter*" "bind_to")
   )
 )
 
+(define-method get_bind_param
+  (of-object "GdaParameter")
+  (c-name "gda_parameter_get_bind_param")
+  (return-type "GdaParameter*")
+)
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-log.h
 
-(define-function gda_log_enable
-  (c-name "gda_log_enable")
-  (return-type "none")
-)
+;; From gda-parameter-list.h
 
-(define-function gda_log_disable
-  (c-name "gda_log_disable")
-  (return-type "none")
+(define-function gda_parameter_list_get_type
+  (c-name "gda_parameter_list_get_type")
+  (return-type "GType")
 )
 
-(define-function gda_log_is_enabled
-  (c-name "gda_log_is_enabled")
-  (return-type "gboolean")
+(define-function gda_parameter_list_new
+  (c-name "gda_parameter_list_new")
+  (is-constructor-of "GdaParameterList")
+  (return-type "GdaParameterList*")
+  (parameters
+    '("GSList*" "params")
+  )
 )
 
-(define-function gda_log_message
-  (c-name "gda_log_message")
-  (return-type "none")
+(define-function gda_parameter_list_new_inline
+  (c-name "gda_parameter_list_new_inline")
+  (return-type "GdaParameterList*")
   (parameters
-    '("const-gchar*" "format")
+    '("GdaDict*" "dict")
   )
   (varargs #t)
 )
 
-(define-function gda_log_error
-  (c-name "gda_log_error")
-  (return-type "none")
+(define-function gda_parameter_list_new_from_spec_string
+  (c-name "gda_parameter_list_new_from_spec_string")
+  (return-type "GdaParameterList*")
   (parameters
-    '("const-gchar*" "format")
+    '("GdaDict*" "dict")
+    '("const-gchar*" "xml_spec")
+    '("GError**" "error")
   )
-  (varargs #t)
 )
 
+(define-function gda_parameter_list_new_from_spec_node
+  (c-name "gda_parameter_list_new_from_spec_node")
+  (return-type "GdaParameterList*")
+  (parameters
+    '("GdaDict*" "dict")
+    '("xmlNodePtr" "xml_spec")
+    '("GError**" "error")
+  )
+)
 
+(define-method get_spec
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_get_spec")
+  (return-type "gchar*")
+)
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-marshal.h
-
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-parameter.h
-
-(define-function gda_parameter_get_type
-  (c-name "gda_parameter_get_type")
-  (return-type "GType")
+(define-method get_length
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_get_length")
+  (return-type "guint")
 )
 
-(define-function gda_parameter_new_from_value
-  (c-name "gda_parameter_new_from_value")
-  (return-type "GdaParameter*")
+(define-method add_param
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_add_param")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "name")
-    '("const-GdaValue*" "value")
+    '("GdaParameter*" "param")
   )
 )
 
-(define-function gda_parameter_new_boolean
-  (c-name "gda_parameter_new_boolean")
+(define-method add_param_from_string
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_add_param_from_string")
   (return-type "GdaParameter*")
   (parameters
     '("const-gchar*" "name")
-    '("gboolean" "value")
+    '("GType" "type")
+    '("const-gchar*" "str")
   )
 )
 
-(define-function gda_parameter_new_double
-  (c-name "gda_parameter_new_double")
+(define-method add_param_from_value
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_add_param_from_value")
   (return-type "GdaParameter*")
   (parameters
     '("const-gchar*" "name")
-    '("gdouble" "value")
+    '("GValue*" "value")
   )
 )
 
-(define-function gda_parameter_new_gobject
-  (c-name "gda_parameter_new_gobject")
-  (return-type "GdaParameter*")
+(define-method merge
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_merge")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "name")
-    '("const-GObject*" "value")
+    '("GdaParameterList*" "paramlist_to_merge")
   )
 )
 
-(define-function gda_parameter_new_string
-  (c-name "gda_parameter_new_string")
-  (return-type "GdaParameter*")
+(define-method is_coherent
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_is_coherent")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "name")
-    '("const-gchar*" "value")
+    '("GError**" "error")
   )
 )
 
-(define-method copy
-  (of-object "GdaParameter")
-  (c-name "gda_parameter_copy")
-  (return-type "GdaParameter*")
-)
-
-(define-method free
-  (of-object "GdaParameter")
-  (c-name "gda_parameter_free")
-  (return-type "none")
-)
-
-(define-method get_name
-  (of-object "GdaParameter")
-  (c-name "gda_parameter_get_name")
-  (return-type "const-gchar*")
+(define-method is_valid
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_is_valid")
+  (return-type "gboolean")
 )
 
-(define-method set_name
-  (of-object "GdaParameter")
-  (c-name "gda_parameter_set_name")
-  (return-type "none")
+(define-method find_param
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_find_param")
+  (return-type "GdaParameter*")
   (parameters
-    '("const-gchar*" "name")
+    '("const-gchar*" "param_name")
   )
 )
 
-(define-method get_value
-  (of-object "GdaParameter")
-  (c-name "gda_parameter_get_value")
-  (return-type "const-GdaValue*")
-)
-
-(define-method set_value
-  (of-object "GdaParameter")
-  (c-name "gda_parameter_set_value")
-  (return-type "none")
+(define-method find_param_for_user
+  (of-object "GdaParameterList")
+  (c-name "gda_parameter_list_find_param_for_user")
+  (return-type "GdaParameter*")
   (parameters
-    '("GdaValue*" "value")
+    '("GdaObject*" "user")
   )
 )
 
-(define-function gda_parameter_list_get_type
-  (c-name "gda_parameter_list_get_type")
-  (return-type "GType")
-)
-
-(define-function gda_parameter_list_new
-  (c-name "gda_parameter_list_new")
-  (is-constructor-of "GdaParameterList")
-  (return-type "GdaParameterList*")
-)
-
-(define-method free
+(define-method find_node_for_param
   (of-object "GdaParameterList")
-  (c-name "gda_parameter_list_free")
-  (return-type "none")
+  (c-name "gda_parameter_list_find_node_for_param")
+  (return-type "GdaParameterListNode*")
+  (parameters
+    '("GdaParameter*" "param")
+  )
 )
 
-(define-method copy
+(define-method find_source
   (of-object "GdaParameterList")
-  (c-name "gda_parameter_list_copy")
-  (return-type "GdaParameterList*")
+  (c-name "gda_parameter_list_find_source")
+  (return-type "GdaParameterListSource*")
+  (parameters
+    '("GdaDataModel*" "model")
+  )
 )
 
-(define-method add_parameter
+(define-method find_source_for_param
   (of-object "GdaParameterList")
-  (c-name "gda_parameter_list_add_parameter")
-  (return-type "none")
+  (c-name "gda_parameter_list_find_source_for_param")
+  (return-type "GdaParameterListSource*")
   (parameters
     '("GdaParameter*" "param")
   )
 )
 
-(define-method get_names
+(define-method find_group_for_param
   (of-object "GdaParameterList")
-  (c-name "gda_parameter_list_get_names")
-  (return-type "GList*")
+  (c-name "gda_parameter_list_find_group_for_param")
+  (return-type "GdaParameterListGroup*")
+  (parameters
+    '("GdaParameter*" "param")
+  )
 )
 
-(define-method find
+(define-method set_param_default_value
   (of-object "GdaParameterList")
-  (c-name "gda_parameter_list_find")
-  (return-type "GdaParameter*")
+  (c-name "gda_parameter_list_set_param_default_value")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "name")
+    '("GdaParameter*" "param")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method clear
+(define-method set_param_default_alias
   (of-object "GdaParameterList")
-  (c-name "gda_parameter_list_clear")
+  (c-name "gda_parameter_list_set_param_default_alias")
   (return-type "none")
+  (parameters
+    '("GdaParameter*" "param")
+    '("GdaParameter*" "alias")
+  )
 )
 
-(define-method get_length
+(define-method get_param_default_value
   (of-object "GdaParameterList")
-  (c-name "gda_parameter_list_get_length")
-  (return-type "guint")
+  (c-name "gda_parameter_list_get_param_default_value")
+  (return-type "const-GValue*")
+  (parameters
+    '("GdaParameter*" "param")
+  )
 )
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-quark-list.h
+;; From gda-quark-list.h
 
 (define-function gda_quark_list_get_type
   (c-name "gda_quark_list_get_type")
@@ -2456,2557 +5784,2864 @@
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-row.h
+;; From gda-query-condition.h
 
-(define-function gda_row_get_type
-  (c-name "gda_row_get_type")
+(define-function gda_query_condition_get_type
+  (c-name "gda_query_condition_get_type")
   (return-type "GType")
 )
 
-(define-function gda_row_new
-  (c-name "gda_row_new")
-  (is-constructor-of "GdaRow")
-  (return-type "GdaRow*")
+(define-method condition_new
+  (of-object "GdaQuery")
+  (c-name "gda_query_condition_new")
+  (return-type "GdaQueryCondition*")
   (parameters
-    '("GdaDataModel*" "model")
-    '("gint" "count")
+    '("GdaQueryConditionType" "type")
   )
 )
 
-(define-function gda_row_new_from_list
-  (c-name "gda_row_new_from_list")
-  (return-type "GdaRow*")
+(define-method new_copy
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_new_copy")
+  (return-type "GdaQueryCondition*")
   (parameters
-    '("GdaDataModel*" "model")
-    '("const-GList*" "values")
+    '("GHashTable*" "replacements")
   )
 )
 
-(define-method copy
-  (of-object "GdaRow")
-  (c-name "gda_row_copy")
-  (return-type "GdaRow*")
+(define-method condition_new_from_sql
+  (of-object "GdaQuery")
+  (c-name "gda_query_condition_new_from_sql")
+  (return-type "GdaQueryCondition*")
+  (parameters
+    '("const-gchar*" "sql_cond")
+    '("GSList**" "targets")
+    '("GError**" "error")
+  )
 )
 
-(define-method free
-  (of-object "GdaRow")
-  (c-name "gda_row_free")
+(define-method set_cond_type
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_set_cond_type")
   (return-type "none")
+  (parameters
+    '("GdaQueryConditionType" "type")
+  )
 )
 
-(define-method get_model
-  (of-object "GdaRow")
-  (c-name "gda_row_get_model")
-  (return-type "GdaDataModel*")
+(define-method get_cond_type
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_get_cond_type")
+  (return-type "GdaQueryConditionType")
 )
 
-(define-method get_number
-  (of-object "GdaRow")
-  (c-name "gda_row_get_number")
-  (return-type "gint")
+(define-method get_children
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_get_children")
+  (return-type "GSList*")
+)
+
+(define-method get_parent
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_get_parent")
+  (return-type "GdaQueryCondition*")
+)
+
+(define-method get_child_by_xml_id
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_get_child_by_xml_id")
+  (return-type "GdaQueryCondition*")
+  (parameters
+    '("const-gchar*" "xml_id")
+  )
+)
+
+(define-method is_ancestor
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_is_ancestor")
+  (return-type "gboolean")
+  (parameters
+    '("GdaQueryCondition*" "ancestor")
+  )
+)
+
+(define-method is_leaf
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_is_leaf")
+  (return-type "gboolean")
+)
+
+(define-method node_add_child
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_node_add_child")
+  (return-type "gboolean")
+  (parameters
+    '("GdaQueryCondition*" "child")
+    '("GError**" "error")
+  )
+)
+
+(define-method node_del_child
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_node_del_child")
+  (return-type "none")
+  (parameters
+    '("GdaQueryCondition*" "child")
+  )
+)
+
+(define-method leaf_set_operator
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_leaf_set_operator")
+  (return-type "none")
+  (parameters
+    '("GdaQueryConditionOperator" "op")
+    '("GdaQueryField*" "field")
+  )
+)
+
+(define-method leaf_get_operator
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_leaf_get_operator")
+  (return-type "GdaQueryField*")
+  (parameters
+    '("GdaQueryConditionOperator" "op")
+  )
+)
+
+(define-method get_ref_objects_all
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_get_ref_objects_all")
+  (return-type "GSList*")
+)
+
+(define-method represents_join
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_represents_join")
+  (return-type "gboolean")
+  (parameters
+    '("GdaQueryTarget**" "target1")
+    '("GdaQueryTarget**" "target2")
+    '("gboolean*" "is_equi_join")
+  )
 )
 
-(define-method set_number
-  (of-object "GdaRow")
-  (c-name "gda_row_set_number")
-  (return-type "none")
+(define-method represents_join_strict
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_represents_join_strict")
+  (return-type "gboolean")
   (parameters
-    '("gint" "number")
+    '("GdaQueryTarget**" "target1")
+    '("GdaQueryTarget**" "target2")
   )
 )
 
-(define-method get_id
-  (of-object "GdaRow")
-  (c-name "gda_row_get_id")
-  (return-type "const-gchar*")
+(define-method get_main_conditions
+  (of-object "GdaQueryCondition")
+  (c-name "gda_query_condition_get_main_conditions")
+  (return-type "GSList*")
 )
 
-(define-method set_id
-  (of-object "GdaRow")
-  (c-name "gda_row_set_id")
-  (return-type "none")
+
+
+;; From gda-query-field-agg.h
+
+(define-function gda_query_field_agg_get_type
+  (c-name "gda_query_field_agg_get_type")
+  (return-type "GType")
+)
+
+(define-method field_agg_new
+  (of-object "GdaQuery")
+  (c-name "gda_query_field_agg_new")
+  (return-type "GdaQueryField*")
   (parameters
-    '("const-gchar*" "id")
+    '("const-gchar*" "agg_name")
   )
 )
 
-(define-method get_value
-  (of-object "GdaRow")
-  (c-name "gda_row_get_value")
-  (return-type "GdaValue*")
+(define-method get_ref_agg
+  (of-object "GdaQueryFieldAgg")
+  (c-name "gda_query_field_agg_get_ref_agg")
+  (return-type "GdaDictAggregate*")
+)
+
+(define-method set_arg
+  (of-object "GdaQueryFieldAgg")
+  (c-name "gda_query_field_agg_set_arg")
+  (return-type "gboolean")
   (parameters
-    '("gint" "num")
+    '("GdaQueryField*" "arg")
   )
 )
 
-(define-method get_length
-  (of-object "GdaRow")
-  (c-name "gda_row_get_length")
-  (return-type "gint")
+(define-method get_arg
+  (of-object "GdaQueryFieldAgg")
+  (c-name "gda_query_field_agg_get_arg")
+  (return-type "GdaQueryField*")
 )
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-select.h
+;; From gda-query-field-all.h
 
-(define-function gda_select_get_type
-  (c-name "gda_select_get_type")
+(define-function gda_query_field_all_get_type
+  (c-name "gda_query_field_all_get_type")
   (return-type "GType")
 )
 
-(define-function gda_select_new
-  (c-name "gda_select_new")
-  (is-constructor-of "GdaSelect")
-  (return-type "GdaDataModel*")
-)
-
-(define-method add_source
-  (of-object "GdaSelect")
-  (c-name "gda_select_add_source")
-  (return-type "none")
+(define-method field_all_new
+  (of-object "GdaQuery")
+  (c-name "gda_query_field_all_new")
+  (return-type "GdaQueryField*")
   (parameters
-    '("const-gchar*" "name")
-    '("GdaDataModel*" "source")
+    '("const-gchar*" "target")
   )
 )
 
-(define-method set_sql
-  (of-object "GdaSelect")
-  (c-name "gda_select_set_sql")
-  (return-type "none")
+(define-method get_target
+  (of-object "GdaQueryFieldAll")
+  (c-name "gda_query_field_all_get_target")
+  (return-type "GdaQueryTarget*")
+)
+
+
+
+;; From gda-query-field-field.h
+
+(define-function gda_query_field_field_get_type
+  (c-name "gda_query_field_field_get_type")
+  (return-type "GType")
+)
+
+(define-method field_field_new
+  (of-object "GdaQuery")
+  (c-name "gda_query_field_field_new")
+  (return-type "GdaQueryField*")
   (parameters
-    '("const-gchar*" "sql")
+    '("const-gchar*" "field")
   )
 )
 
-(define-method run
-  (of-object "GdaSelect")
-  (c-name "gda_select_run")
-  (return-type "gboolean")
+(define-method get_ref_field_name
+  (of-object "GdaQueryFieldField")
+  (c-name "gda_query_field_field_get_ref_field_name")
+  (return-type "gchar*")
+)
+
+(define-method get_ref_field
+  (of-object "GdaQueryFieldField")
+  (c-name "gda_query_field_field_get_ref_field")
+  (return-type "GdaEntityField*")
 )
 
+(define-method get_target
+  (of-object "GdaQueryFieldField")
+  (c-name "gda_query_field_field_get_target")
+  (return-type "GdaQueryTarget*")
+)
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-server-provider.h
 
-(define-function gda_server_provider_get_type
-  (c-name "gda_server_provider_get_type")
+;; From gda-query-field-func.h
+
+(define-function gda_query_field_func_get_type
+  (c-name "gda_query_field_func_get_type")
   (return-type "GType")
 )
 
-(define-method get_version
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_get_version")
+(define-method field_func_new
+  (of-object "GdaQuery")
+  (c-name "gda_query_field_func_new")
+  (return-type "GdaQueryField*")
+  (parameters
+    '("const-gchar*" "func_name")
+  )
+)
+
+(define-method get_ref_func
+  (of-object "GdaQueryFieldFunc")
+  (c-name "gda_query_field_func_get_ref_func")
+  (return-type "GdaDictFunction*")
+)
+
+(define-method get_ref_func_name
+  (of-object "GdaQueryFieldFunc")
+  (c-name "gda_query_field_func_get_ref_func_name")
   (return-type "const-gchar*")
 )
 
-(define-method open_connection
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_open_connection")
+(define-method set_args
+  (of-object "GdaQueryFieldFunc")
+  (c-name "gda_query_field_func_set_args")
   (return-type "gboolean")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaQuarkList*" "params")
-    '("const-gchar*" "username")
-    '("const-gchar*" "password")
+    '("GSList*" "args")
   )
 )
 
-(define-method reset_connection
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_reset_connection")
-  (return-type "gboolean")
+(define-method get_args
+  (of-object "GdaQueryFieldFunc")
+  (c-name "gda_query_field_func_get_args")
+  (return-type "GSList*")
+)
+
+
+
+;; From gda-query-field.h
+
+(define-function gda_query_field_get_type
+  (c-name "gda_query_field_get_type")
+  (return-type "GType")
+)
+
+(define-method field_new_from_xml
+  (of-object "GdaQuery")
+  (c-name "gda_query_field_new_from_xml")
+  (return-type "GdaQueryField*")
   (parameters
-    '("GdaConnection*" "cnc")
+    '("xmlNodePtr" "node")
+    '("GError**" "error")
   )
 )
 
-(define-method close_connection
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_close_connection")
-  (return-type "gboolean")
+(define-method new_copy
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_new_copy")
+  (return-type "GdaQueryField*")
+)
+
+(define-method field_new_from_sql
+  (of-object "GdaQuery")
+  (c-name "gda_query_field_new_from_sql")
+  (return-type "GdaQueryField*")
   (parameters
-    '("GdaConnection*" "cnc")
+    '("const-gchar*" "sqlfield")
+    '("GError**" "error")
   )
 )
 
-(define-method get_server_version
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_get_server_version")
-  (return-type "const-gchar*")
+(define-method get_dict_type
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_get_dict_type")
+  (return-type "GdaDictType*")
+)
+
+(define-method get_parameters
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_get_parameters")
+  (return-type "GSList*")
+)
+
+(define-method set_alias
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_set_alias")
+  (return-type "none")
   (parameters
-    '("GdaConnection*" "cnc")
+    '("const-gchar*" "alias")
   )
 )
 
-(define-method get_database
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_get_database")
+(define-method get_alias
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_get_alias")
   (return-type "const-gchar*")
-  (parameters
-    '("GdaConnection*" "cnc")
-  )
 )
 
-(define-method change_database
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_change_database")
-  (return-type "gboolean")
+(define-method set_visible
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_set_visible")
+  (return-type "none")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("const-gchar*" "name")
+    '("gboolean" "visible")
   )
 )
 
-(define-method create_database
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_create_database")
+(define-method is_visible
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_is_visible")
   (return-type "gboolean")
+)
+
+(define-method set_internal
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_set_internal")
+  (return-type "none")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("const-gchar*" "name")
+    '("gboolean" "internal")
   )
 )
 
-(define-method drop_database
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_drop_database")
+(define-method is_internal
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_is_internal")
   (return-type "gboolean")
-  (parameters
-    '("GdaConnection*" "cnc")
-    '("const-gchar*" "name")
-  )
 )
 
-(define-method create_table
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_create_table")
+(define-method is_equal
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_is_equal")
   (return-type "gboolean")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("const-gchar*" "table_name")
-    '("const-GdaFieldAttributes*[]" "attributes")
+    '("GdaQueryField*" "qfield2")
   )
 )
 
-(define-method drop_table
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_drop_table")
+(define-method is_list
+  (of-object "GdaQueryField")
+  (c-name "gda_query_field_is_list")
   (return-type "gboolean")
-  (parameters
-    '("GdaConnection*" "cnc")
-    '("const-gchar*" "table_name")
-  )
 )
 
-(define-method execute_command
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_execute_command")
-  (return-type "GList*")
+
+
+;; From gda-query-field-value.h
+
+(define-function gda_query_field_value_get_type
+  (c-name "gda_query_field_value_get_type")
+  (return-type "GType")
+)
+
+(define-method field_value_new
+  (of-object "GdaQuery")
+  (c-name "gda_query_field_value_new")
+  (return-type "GdaQueryField*")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaCommand*" "cmd")
-    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
+    '("GType" "type")
   )
 )
 
-(define-method get_last_insert_id
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_get_last_insert_id")
-  (return-type "gchar*")
+(define-method set_value
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_set_value")
+  (return-type "none")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaDataModel*" "recset")
+    '("const-GValue*" "val")
   )
 )
 
-(define-method begin_transaction
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_begin_transaction")
-  (return-type "gboolean")
+(define-method get_value
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_get_value")
+  (return-type "const-GValue*")
+)
+
+(define-method set_default_value
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_set_default_value")
+  (return-type "none")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaTransaction*" "xaction")
+    '("const-GValue*" "default_val")
   )
 )
 
-(define-method commit_transaction
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_commit_transaction")
-  (return-type "gboolean")
+(define-method get_default_value
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_get_default_value")
+  (return-type "const-GValue*")
+)
+
+(define-method get_g_type
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_get_g_type")
+  (return-type "GType")
+)
+
+(define-method set_dict_type
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_set_dict_type")
+  (return-type "none")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaTransaction*" "xaction")
+    '("GdaDictType*" "type")
   )
 )
 
-(define-method rollback_transaction
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_rollback_transaction")
-  (return-type "gboolean")
+(define-method get_dict_type
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_get_dict_type")
+  (return-type "GdaDictType*")
+)
+
+(define-method set_is_parameter
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_set_is_parameter")
+  (return-type "none")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaTransaction*" "xaction")
+    '("gboolean" "is_param")
   )
 )
 
-(define-method supports
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_supports")
+(define-method is_parameter
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_is_parameter")
   (return-type "gboolean")
-  (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaConnectionFeature" "feature")
-  )
 )
 
-(define-method get_schema
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_get_schema")
-  (return-type "GdaDataModel*")
+(define-method set_not_null
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_set_not_null")
+  (return-type "none")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaConnectionSchema" "schema")
-    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
+    '("gboolean" "not_null")
   )
 )
 
-(define-method create_blob
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_create_blob")
+(define-method get_not_null
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_get_not_null")
+  (return-type "gboolean")
+)
+
+(define-method is_value_null
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_is_value_null")
   (return-type "gboolean")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("GdaBlob*" "blob")
+    '("GdaParameterList*" "context")
   )
 )
 
-(define-method escape_string
-  (of-object "GdaServerProvider")
-  (c-name "gda_server_provider_escape_string")
+(define-method restrict
+  (of-object "GdaQueryFieldValue")
+  (c-name "gda_query_field_value_restrict")
   (return-type "gboolean")
   (parameters
-    '("GdaConnection*" "cnc")
-    '("const-gchar*" "from")
-    '("gchar*" "to")
+    '("GdaDataModel*" "model")
+    '("gint" "col")
+    '("GError**" "error")
   )
 )
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-table.h
+;; From gda-query.h
 
-(define-function gda_table_get_type
-  (c-name "gda_table_get_type")
+(define-function gda_query_get_type
+  (c-name "gda_query_get_type")
   (return-type "GType")
 )
 
-(define-function gda_table_new
-  (c-name "gda_table_new")
-  (is-constructor-of "GdaTable")
-  (return-type "GdaTable*")
+(define-function gda_query_new
+  (c-name "gda_query_new")
+  (is-constructor-of "GdaQuery")
+  (return-type "GdaQuery*")
   (parameters
-    '("const-gchar*" "name")
+    '("GdaDict*" "dict")
   )
 )
 
-(define-function gda_table_new_from_model
-  (c-name "gda_table_new_from_model")
-  (return-type "GdaTable*")
+(define-method new_copy
+  (of-object "GdaQuery")
+  (c-name "gda_query_new_copy")
+  (return-type "GdaQuery*")
   (parameters
-    '("const-gchar*" "name")
-    '("const-GdaDataModel*" "model")
-    '("gboolean" "add_data")
+    '("GHashTable*" "replacements")
   )
 )
 
-(define-method get_name
-  (of-object "GdaTable")
-  (c-name "gda_table_get_name")
-  (return-type "const-gchar*")
-)
-
-(define-method set_name
-  (of-object "GdaTable")
-  (c-name "gda_table_set_name")
-  (return-type "none")
+(define-function gda_query_new_from_sql
+  (c-name "gda_query_new_from_sql")
+  (return-type "GdaQuery*")
   (parameters
-    '("const-gchar*" "name")
+    '("GdaDict*" "dict")
+    '("const-gchar*" "sql")
+    '("GError**" "error")
   )
 )
 
-(define-method add_field
-  (of-object "GdaTable")
-  (c-name "gda_table_add_field")
+(define-method set_query_type
+  (of-object "GdaQuery")
+  (c-name "gda_query_set_query_type")
   (return-type "none")
   (parameters
-    '("const-GdaFieldAttributes*" "fa")
+    '("GdaQueryType" "type")
   )
 )
 
-(define-method add_data_from_model
-  (of-object "GdaTable")
-  (c-name "gda_table_add_data_from_model")
-  (return-type "none")
-  (parameters
-    '("const-GdaDataModel*" "model")
-  )
+(define-method get_query_type
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_query_type")
+  (return-type "GdaQueryType")
 )
 
+(define-method get_query_type_string
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_query_type_string")
+  (return-type "const-gchar*")
+)
 
+(define-method is_select_query
+  (of-object "GdaQuery")
+  (c-name "gda_query_is_select_query")
+  (return-type "gboolean")
+)
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-transaction.h
+(define-method is_insert_query
+  (of-object "GdaQuery")
+  (c-name "gda_query_is_insert_query")
+  (return-type "gboolean")
+)
 
-(define-function gda_transaction_get_type
-  (c-name "gda_transaction_get_type")
-  (return-type "GType")
+(define-method is_update_query
+  (of-object "GdaQuery")
+  (c-name "gda_query_is_update_query")
+  (return-type "gboolean")
 )
 
-(define-function gda_transaction_new
-  (c-name "gda_transaction_new")
-  (is-constructor-of "GdaTransaction")
-  (return-type "GdaTransaction*")
-  (parameters
-    '("const-gchar*" "name")
-  )
+(define-method is_delete_query
+  (of-object "GdaQuery")
+  (c-name "gda_query_is_delete_query")
+  (return-type "gboolean")
 )
 
-(define-method get_isolation_level
-  (of-object "GdaTransaction")
-  (c-name "gda_transaction_get_isolation_level")
-  (return-type "GdaTransactionIsolation")
+(define-method is_modif_query
+  (of-object "GdaQuery")
+  (c-name "gda_query_is_modif_query")
+  (return-type "gboolean")
+)
+
+(define-method get_parent_query
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_parent_query")
+  (return-type "GdaQuery*")
+)
+
+(define-method get_parameters
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_parameters")
+  (return-type "GSList*")
 )
 
-(define-method set_isolation_level
-  (of-object "GdaTransaction")
-  (c-name "gda_transaction_set_isolation_level")
-  (return-type "none")
-  (parameters
-    '("GdaTransactionIsolation" "level")
-  )
+(define-method get_parameter_list
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_parameter_list")
+  (return-type "GdaParameterList*")
 )
 
-(define-method get_name
-  (of-object "GdaTransaction")
-  (c-name "gda_transaction_get_name")
-  (return-type "const-gchar*")
+(define-method execute
+  (of-object "GdaQuery")
+  (c-name "gda_query_execute")
+  (return-type "GdaObject*")
+  (parameters
+    '("GdaParameterList*" "params")
+    '("gboolean" "iter_model_only_requested")
+    '("GError**" "error")
+  )
 )
 
-(define-method set_name
-  (of-object "GdaTransaction")
-  (c-name "gda_transaction_set_name")
+(define-method set_sql_text
+  (of-object "GdaQuery")
+  (c-name "gda_query_set_sql_text")
   (return-type "none")
   (parameters
-    '("const-gchar*" "name")
+    '("const-gchar*" "sql")
+    '("GError**" "error")
   )
 )
 
+(define-method get_sql_text
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_sql_text")
+  (return-type "const-gchar*")
+)
 
+(define-method get_sub_queries
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_sub_queries")
+  (return-type "GSList*")
+)
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-util.h
-
-(define-function gda_type_to_string
-  (c-name "gda_type_to_string")
-  (return-type "const-gchar*")
+(define-method add_sub_query
+  (of-object "GdaQuery")
+  (c-name "gda_query_add_sub_query")
+  (return-type "none")
   (parameters
-    '("GdaValueType" "type")
+    '("GdaQuery*" "sub_query")
   )
 )
 
-(define-function gda_type_from_string
-  (c-name "gda_type_from_string")
-  (return-type "GdaValueType")
+(define-method del_sub_query
+  (of-object "GdaQuery")
+  (c-name "gda_query_del_sub_query")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "str")
+    '("GdaQuery*" "sub_query")
   )
 )
 
-(define-function gda_string_hash_to_list
-  (c-name "gda_string_hash_to_list")
-  (return-type "GList*")
+(define-method add_param_source
+  (of-object "GdaQuery")
+  (c-name "gda_query_add_param_source")
+  (return-type "none")
   (parameters
-    '("GHashTable*" "hash_table")
+    '("GdaDataModel*" "param_source")
   )
 )
 
-(define-function gda_sql_replace_placeholders
-  (c-name "gda_sql_replace_placeholders")
-  (return-type "gchar*")
+(define-method del_param_source
+  (of-object "GdaQuery")
+  (c-name "gda_query_del_param_source")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "sql")
-    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
+    '("GdaDataModel*" "param_source")
   )
 )
 
-(define-function gda_file_load
-  (c-name "gda_file_load")
-  (return-type "gchar*")
-  (parameters
-    '("const-gchar*" "filename")
-  )
+(define-method get_param_sources
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_param_sources")
+  (return-type "const-GSList*")
 )
 
-(define-function gda_file_save
-  (c-name "gda_file_save")
+(define-method add_target
+  (of-object "GdaQuery")
+  (c-name "gda_query_add_target")
   (return-type "gboolean")
   (parameters
-    '("const-gchar*" "filename")
-    '("const-gchar*" "buffer")
-    '("gint" "len")
+    '("GdaQueryTarget*" "target")
+    '("GError**" "error")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-value.h
-
-(define-function gda_value_get_gtype
-  (c-name "gda_value_get_gtype")
-  (return-type "GType")
+(define-method del_target
+  (of-object "GdaQuery")
+  (c-name "gda_query_del_target")
+  (return-type "none")
+  (parameters
+    '("GdaQueryTarget*" "target")
+  )
 )
 
-(define-function gda_value_new_null
-  (c-name "gda_value_new_null")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_targets
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_targets")
+  (return-type "GSList*")
 )
 
-(define-function gda_value_new_bigint
-  (c-name "gda_value_new_bigint")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_target_by_xml_id
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_target_by_xml_id")
+  (return-type "GdaQueryTarget*")
   (parameters
-    '("gint64" "val")
+    '("const-gchar*" "xml_id")
   )
 )
 
-(define-function gda_value_new_biguint
-  (c-name "gda_value_new_biguint")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_target_by_alias
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_target_by_alias")
+  (return-type "GdaQueryTarget*")
   (parameters
-    '("guint64" "val")
+    '("const-gchar*" "alias_or_name")
   )
 )
 
-(define-function gda_value_new_binary
-  (c-name "gda_value_new_binary")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_target_pkfields
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_target_pkfields")
+  (return-type "GSList*")
   (parameters
-    '("gconstpointer" "val")
-    '("glong" "size")
+    '("GdaQueryTarget*" "target")
   )
 )
 
-(define-function gda_value_new_blob
-  (c-name "gda_value_new_blob")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
-  (parameters
-    '("const-GdaBlob*" "val")
-  )
+(define-method get_joins
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_joins")
+  (return-type "GSList*")
 )
 
-(define-function gda_value_new_boolean
-  (c-name "gda_value_new_boolean")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_join_by_targets
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_join_by_targets")
+  (return-type "GdaQueryJoin*")
   (parameters
-    '("gboolean" "val")
+    '("GdaQueryTarget*" "target1")
+    '("GdaQueryTarget*" "target2")
   )
 )
 
-(define-function gda_value_new_date
-  (c-name "gda_value_new_date")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method add_join
+  (of-object "GdaQuery")
+  (c-name "gda_query_add_join")
+  (return-type "gboolean")
   (parameters
-    '("const-GdaDate*" "val")
+    '("GdaQueryJoin*" "join")
   )
 )
 
-(define-function gda_value_new_double
-  (c-name "gda_value_new_double")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method del_join
+  (of-object "GdaQuery")
+  (c-name "gda_query_del_join")
+  (return-type "none")
   (parameters
-    '("gdouble" "val")
+    '("GdaQueryJoin*" "join")
   )
 )
 
-(define-function gda_value_new_geometric_point
-  (c-name "gda_value_new_geometric_point")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method set_condition
+  (of-object "GdaQuery")
+  (c-name "gda_query_set_condition")
+  (return-type "none")
   (parameters
-    '("const-GdaGeometricPoint*" "val")
+    '("GdaQueryCondition*" "cond")
   )
 )
 
-(define-function gda_value_new_gobject
-  (c-name "gda_value_new_gobject")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
-  (parameters
-    '("const-GObject*" "val")
-  )
+(define-method get_condition
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_condition")
+  (return-type "GdaQueryCondition*")
 )
 
-(define-function gda_value_new_integer
-  (c-name "gda_value_new_integer")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
-  (parameters
-    '("gint" "val")
-  )
+(define-method get_main_conditions
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_main_conditions")
+  (return-type "GSList*")
 )
 
-(define-function gda_value_new_list
-  (c-name "gda_value_new_list")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method append_condition
+  (of-object "GdaQuery")
+  (c-name "gda_query_append_condition")
+  (return-type "none")
   (parameters
-    '("const-GdaValueList*" "val")
+    '("GdaQueryCondition*" "cond")
+    '("gboolean" "append_as_and")
   )
 )
 
-(define-function gda_value_new_money
-  (c-name "gda_value_new_money")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method set_order_by_field
+  (of-object "GdaQuery")
+  (c-name "gda_query_set_order_by_field")
+  (return-type "none")
   (parameters
-    '("const-GdaMoney*" "val")
+    '("GdaQueryField*" "field")
+    '("gint" "order")
+    '("gboolean" "ascendant")
   )
 )
 
-(define-function gda_value_new_numeric
-  (c-name "gda_value_new_numeric")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_order_by_field
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_order_by_field")
+  (return-type "gint")
   (parameters
-    '("const-GdaNumeric*" "val")
+    '("GdaQueryField*" "field")
+    '("gboolean*" "ascendant")
   )
 )
 
-(define-function gda_value_new_single
-  (c-name "gda_value_new_single")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method add_field_from_sql
+  (of-object "GdaQuery")
+  (c-name "gda_query_add_field_from_sql")
+  (return-type "GdaQueryField*")
   (parameters
-    '("gfloat" "val")
+    '("const-gchar*" "field")
+    '("GError**" "error")
   )
 )
 
-(define-function gda_value_new_smallint
-  (c-name "gda_value_new_smallint")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_all_fields
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_all_fields")
+  (return-type "GSList*")
+)
+
+(define-method get_field_by_sql_naming
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_field_by_sql_naming")
+  (return-type "GdaQueryField*")
   (parameters
-    '("gshort" "val")
+    '("const-gchar*" "sql_naming")
   )
 )
 
-(define-function gda_value_new_smalluint
-  (c-name "gda_value_new_smalluint")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_field_by_param_name
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_field_by_param_name")
+  (return-type "GdaQueryField*")
   (parameters
-    '("gushort" "val")
+    '("const-gchar*" "param_name")
   )
 )
 
-(define-function gda_value_new_string
-  (c-name "gda_value_new_string")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_field_by_ref_field
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_field_by_ref_field")
+  (return-type "GdaQueryField*")
   (parameters
-    '("const-gchar*" "val")
+    '("GdaQueryTarget*" "target")
+    '("GdaEntityField*" "ref_field")
+    '("GdaQueryFieldState" "field_state")
   )
 )
 
-(define-function gda_value_new_time
-  (c-name "gda_value_new_time")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method get_first_field_for_target
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_first_field_for_target")
+  (return-type "GdaQueryField*")
   (parameters
-    '("const-GdaTime*" "val")
+    '("GdaQueryTarget*" "target")
   )
 )
 
-(define-function gda_value_new_timestamp
-  (c-name "gda_value_new_timestamp")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method expand_all_field
+  (of-object "GdaQuery")
+  (c-name "gda_query_expand_all_field")
+  (return-type "GSList*")
   (parameters
-    '("const-GdaTimestamp*" "val")
+    '("GdaQueryTarget*" "target")
   )
 )
 
-(define-function gda_value_new_timestamp_from_timet
-  (c-name "gda_value_new_timestamp_from_timet")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method order_fields_using_join_conds
+  (of-object "GdaQuery")
+  (c-name "gda_query_order_fields_using_join_conds")
+  (return-type "none")
+)
+
+(define-method get_fields_by_target
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_fields_by_target")
+  (return-type "GSList*")
   (parameters
-    '("time_t" "val")
+    '("GdaQueryTarget*" "target")
+    '("gboolean" "visible_fields_only")
   )
 )
 
-(define-function gda_value_new_tinyint
-  (c-name "gda_value_new_tinyint")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method declare_condition
+  (of-object "GdaQuery")
+  (c-name "gda_query_declare_condition")
+  (return-type "none")
   (parameters
-    '("gchar" "val")
+    '("GdaQueryCondition*" "cond")
   )
 )
 
-(define-function gda_value_new_tinyuint
-  (c-name "gda_value_new_tinyuint")
-  (return-type "GdaValue*")
+(define-method undeclare_condition
+  (of-object "GdaQuery")
+  (c-name "gda_query_undeclare_condition")
+  (return-type "none")
   (parameters
-    '("guchar" "val")
+    '("GdaQueryCondition*" "cond")
   )
 )
 
-(define-function gda_value_new_type
-  (c-name "gda_value_new_type")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+
+
+;; From gda-query-join.h
+
+(define-function gda_query_join_get_type
+  (c-name "gda_query_join_get_type")
+  (return-type "GType")
+)
+
+(define-method join_new_with_targets
+  (of-object "GdaQuery")
+  (c-name "gda_query_join_new_with_targets")
+  (return-type "GdaQueryJoin*")
   (parameters
-    '("GdaValueType" "val")
+    '("GdaQueryTarget*" "target_1")
+    '("GdaQueryTarget*" "target_2")
   )
 )
 
-(define-function gda_value_new_uinteger
-  (c-name "gda_value_new_uinteger")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method join_new_with_xml_ids
+  (of-object "GdaQuery")
+  (c-name "gda_query_join_new_with_xml_ids")
+  (return-type "GdaQueryJoin*")
   (parameters
-    '("guint" "val")
+    '("const-gchar*" "target_1_xml_id")
+    '("const-gchar*" "target_2_xml_id")
   )
 )
 
-(define-function gda_value_new_from_string
-  (c-name "gda_value_new_from_string")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method new_copy
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_new_copy")
+  (return-type "GdaQueryJoin*")
   (parameters
-    '("const-gchar*" "as_string")
-    '("GdaValueType" "type")
+    '("GHashTable*" "replacements")
   )
 )
 
-(define-function gda_value_new_from_xml
-  (c-name "gda_value_new_from_xml")
-  (is-constructor-of "GdaValue")
-  (return-type "GdaValue*")
+(define-method set_join_type
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_set_join_type")
+  (return-type "none")
   (parameters
-    '("const-xmlNodePtr" "node")
+    '("GdaQueryJoinType" "type")
   )
 )
 
-(define-method free
-  (of-object "GdaValue")
-  (c-name "gda_value_free")
+(define-method get_join_type
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_get_join_type")
+  (return-type "GdaQueryJoinType")
+)
+
+(define-method get_query
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_get_query")
+  (return-type "GdaQuery*")
+)
+
+(define-method get_target_1
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_get_target_1")
+  (return-type "GdaQueryTarget*")
+)
+
+(define-method get_target_2
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_get_target_2")
+  (return-type "GdaQueryTarget*")
+)
+
+(define-method swap_targets
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_swap_targets")
   (return-type "none")
 )
 
-(define-method get_type
-  (of-object "GdaValue")
-  (c-name "gda_value_get_type")
-  (return-type "GdaValueType")
+(define-method set_condition
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_set_condition")
+  (return-type "gboolean")
+  (parameters
+    '("GdaQueryCondition*" "cond")
+  )
+)
+
+(define-method get_condition
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_get_condition")
+  (return-type "GdaQueryCondition*")
 )
 
-(define-method is_null
-  (of-object "GdaValue")
-  (c-name "gda_value_is_null")
+(define-method set_condition_from_fkcons
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_set_condition_from_fkcons")
   (return-type "gboolean")
 )
 
-(define-method is_number
-  (of-object "GdaValue")
-  (c-name "gda_value_is_number")
+(define-method set_condition_from_sql
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_set_condition_from_sql")
   (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "cond")
+    '("GError**" "error")
+  )
 )
 
-(define-method copy
-  (of-object "GdaValue")
-  (c-name "gda_value_copy")
-  (return-type "GdaValue*")
+(define-method render_type
+  (of-object "GdaQueryJoin")
+  (c-name "gda_query_join_render_type")
+  (return-type "const-gchar*")
 )
 
-(define-method get_bigint
-  (of-object "GdaValue")
-  (c-name "gda_value_get_bigint")
-  (return-type "gint64")
+
+
+;; From gda-query-object.h
+
+(define-function gda_query_object_get_type
+  (c-name "gda_query_object_get_type")
+  (return-type "GType")
 )
 
-(define-method set_bigint
-  (of-object "GdaValue")
-  (c-name "gda_value_set_bigint")
+(define-method set_int_id
+  (of-object "GdaQueryObject")
+  (c-name "gda_query_object_set_int_id")
   (return-type "none")
   (parameters
-    '("gint64" "val")
+    '("guint" "id")
   )
 )
 
-(define-method get_biguint
-  (of-object "GdaValue")
-  (c-name "gda_value_get_biguint")
-  (return-type "guint64")
+(define-method get_int_id
+  (of-object "GdaQueryObject")
+  (c-name "gda_query_object_get_int_id")
+  (return-type "guint")
 )
 
-(define-method set_biguint
-  (of-object "GdaValue")
-  (c-name "gda_value_set_biguint")
-  (return-type "none")
+
+
+;; From gda-query-parsing.h
+
+(define-function parse_data_new
+  (c-name "parse_data_new")
+  (is-constructor-of "ParseData")
+  (return-type "ParseData*")
   (parameters
-    '("guint64" "val")
+    '("GdaQuery*" "query")
   )
 )
 
-(define-method get_binary
-  (of-object "GdaValue")
-  (c-name "gda_value_get_binary")
-  (return-type "const-gpointer")
+(define-method destroy
+  (of-object "ParseData")
+  (c-name "parse_data_destroy")
+  (return-type "none")
+)
+
+(define-function parse_data_compute_targets_hash
+  (c-name "parse_data_compute_targets_hash")
+  (return-type "none")
   (parameters
-    '("glong*" "size")
+    '("GdaQuery*" "query")
+    '("ParseData*" "pdata")
   )
 )
 
-(define-method set_binary
-  (of-object "GdaValue")
-  (c-name "gda_value_set_binary")
-  (return-type "none")
+(define-function parsed_create_select_query
+  (c-name "parsed_create_select_query")
+  (return-type "gboolean")
   (parameters
-    '("gconstpointer" "val")
-    '("glong" "size")
+    '("GdaQuery*" "query")
+    '("sql_select_statement*" "select")
+    '("GError**" "error")
   )
 )
 
-(define-method get_blob
-  (of-object "GdaValue")
-  (c-name "gda_value_get_blob")
-  (return-type "const-GdaBlob*")
+(define-function parsed_create_update_query
+  (c-name "parsed_create_update_query")
+  (return-type "gboolean")
+  (parameters
+    '("GdaQuery*" "query")
+    '("sql_update_statement*" "update")
+    '("GError**" "error")
+  )
 )
 
-(define-method set_blob
-  (of-object "GdaValue")
-  (c-name "gda_value_set_blob")
-  (return-type "none")
+(define-function parsed_create_insert_query
+  (c-name "parsed_create_insert_query")
+  (return-type "gboolean")
   (parameters
-    '("const-GdaBlob*" "val")
+    '("GdaQuery*" "query")
+    '("sql_insert_statement*" "insert")
+    '("GError**" "error")
   )
 )
 
-(define-method get_boolean
-  (of-object "GdaValue")
-  (c-name "gda_value_get_boolean")
+(define-function parsed_create_delete_query
+  (c-name "parsed_create_delete_query")
   (return-type "gboolean")
+  (parameters
+    '("GdaQuery*" "query")
+    '("sql_delete_statement*" "del")
+    '("GError**" "error")
+  )
 )
 
-(define-method set_boolean
-  (of-object "GdaValue")
-  (c-name "gda_value_set_boolean")
-  (return-type "none")
+(define-function parsed_create_global_query_field
+  (c-name "parsed_create_global_query_field")
+  (return-type "GdaEntityField*")
   (parameters
-    '("gboolean" "val")
+    '("GdaQuery*" "query")
+    '("gboolean" "add_to_query")
+    '("ParseData*" "pdata")
+    '("sql_field*" "field")
+    '("gboolean" "try_existing_field")
+    '("gboolean*" "new_field")
+    '("GdaQueryTarget**" "target_return")
+    '("GError**" "error")
   )
 )
 
-(define-method get_date
-  (of-object "GdaValue")
-  (c-name "gda_value_get_date")
-  (return-type "const-GdaDate*")
+(define-function parsed_create_complex_condition
+  (c-name "parsed_create_complex_condition")
+  (return-type "GdaQueryCondition*")
+  (parameters
+    '("GdaQuery*" "query")
+    '("ParseData*" "pdata")
+    '("sql_where*" "where")
+    '("gboolean" "try_existing_field")
+    '("GSList**" "targets_return")
+    '("GError**" "error")
+  )
 )
 
-(define-method set_date
-  (of-object "GdaValue")
-  (c-name "gda_value_set_date")
-  (return-type "none")
+(define-method get_field_by_sql_naming_fields
+  (of-object "GdaQuery")
+  (c-name "gda_query_get_field_by_sql_naming_fields")
+  (return-type "GdaQueryField*")
   (parameters
-    '("const-GdaDate*" "val")
+    '("const-gchar*" "sql_name")
+    '("GSList*" "fields_list")
   )
 )
 
-(define-method get_double
-  (of-object "GdaValue")
-  (c-name "gda_value_get_double")
-  (return-type "gdouble")
+
+
+;; From gda-query-private.h
+
+
+
+;; From gda-query-target.h
+
+(define-function gda_query_target_get_type
+  (c-name "gda_query_target_get_type")
+  (return-type "GType")
 )
 
-(define-method set_double
-  (of-object "GdaValue")
-  (c-name "gda_value_set_double")
-  (return-type "none")
+(define-method target_new
+  (of-object "GdaQuery")
+  (c-name "gda_query_target_new")
+  (return-type "GdaQueryTarget*")
   (parameters
-    '("gdouble" "val")
+    '("const-gchar*" "table")
   )
 )
 
-(define-method get_geometric_point
-  (of-object "GdaValue")
-  (c-name "gda_value_get_geometric_point")
-  (return-type "const-GdaGeometricPoint*")
+(define-method new_copy
+  (of-object "GdaQueryTarget")
+  (c-name "gda_query_target_new_copy")
+  (return-type "GdaQueryTarget*")
 )
 
-(define-method set_geometric_point
-  (of-object "GdaValue")
-  (c-name "gda_value_set_geometric_point")
-  (return-type "none")
-  (parameters
-    '("const-GdaGeometricPoint*" "val")
-  )
+(define-method get_query
+  (of-object "GdaQueryTarget")
+  (c-name "gda_query_target_get_query")
+  (return-type "GdaQuery*")
 )
 
-(define-method get_gobject
-  (of-object "GdaValue")
-  (c-name "gda_value_get_gobject")
-  (return-type "const-GObject*")
+(define-method get_represented_entity
+  (of-object "GdaQueryTarget")
+  (c-name "gda_query_target_get_represented_entity")
+  (return-type "GdaEntity*")
 )
 
-(define-method set_gobject
-  (of-object "GdaValue")
-  (c-name "gda_value_set_gobject")
+(define-method get_represented_table_name
+  (of-object "GdaQueryTarget")
+  (c-name "gda_query_target_get_represented_table_name")
+  (return-type "const-gchar*")
+)
+
+(define-method set_alias
+  (of-object "GdaQueryTarget")
+  (c-name "gda_query_target_set_alias")
   (return-type "none")
   (parameters
-    '("const-GObject*" "val")
+    '("const-gchar*" "alias")
   )
 )
 
-(define-method get_integer
-  (of-object "GdaValue")
-  (c-name "gda_value_get_integer")
-  (return-type "gint")
+(define-method get_alias
+  (of-object "GdaQueryTarget")
+  (c-name "gda_query_target_get_alias")
+  (return-type "const-gchar*")
+)
+
+(define-method get_complete_name
+  (of-object "GdaQueryTarget")
+  (c-name "gda_query_target_get_complete_name")
+  (return-type "gchar*")
+)
+
+
+
+;; From gda-referer.h
+
+(define-function gda_referer_get_type
+  (c-name "gda_referer_get_type")
+  (return-type "GType")
+)
+
+(define-method activate
+  (of-object "GdaReferer")
+  (c-name "gda_referer_activate")
+  (return-type "gboolean")
 )
 
-(define-method set_integer
-  (of-object "GdaValue")
-  (c-name "gda_value_set_integer")
+(define-method deactivate
+  (of-object "GdaReferer")
+  (c-name "gda_referer_deactivate")
   (return-type "none")
-  (parameters
-    '("gint" "val")
-  )
 )
 
-(define-method get_list
-  (of-object "GdaValue")
-  (c-name "gda_value_get_list")
-  (return-type "const-GdaValueList*")
+(define-method is_active
+  (of-object "GdaReferer")
+  (c-name "gda_referer_is_active")
+  (return-type "gboolean")
 )
 
-(define-method set_list
-  (of-object "GdaValue")
-  (c-name "gda_value_set_list")
+(define-method get_ref_objects
+  (of-object "GdaReferer")
+  (c-name "gda_referer_get_ref_objects")
+  (return-type "GSList*")
+)
+
+(define-method replace_refs
+  (of-object "GdaReferer")
+  (c-name "gda_referer_replace_refs")
   (return-type "none")
   (parameters
-    '("const-GdaValueList*" "val")
+    '("GHashTable*" "replacements")
   )
 )
 
-(define-method set_null
-  (of-object "GdaValue")
-  (c-name "gda_value_set_null")
-  (return-type "none")
+
+
+;; From gda-renderer.h
+
+(define-function gda_renderer_get_type
+  (c-name "gda_renderer_get_type")
+  (return-type "GType")
 )
 
-(define-method get_money
-  (of-object "GdaValue")
-  (c-name "gda_value_get_money")
-  (return-type "const-GdaMoney*")
+(define-method render_as_sql
+  (of-object "GdaRenderer")
+  (c-name "gda_renderer_render_as_sql")
+  (return-type "gchar*")
+  (parameters
+    '("GdaParameterList*" "context")
+    '("guint" "options")
+    '("GError**" "error")
+  )
 )
 
-(define-method set_money
-  (of-object "GdaValue")
-  (c-name "gda_value_set_money")
-  (return-type "none")
+(define-method render_as_str
+  (of-object "GdaRenderer")
+  (c-name "gda_renderer_render_as_str")
+  (return-type "gchar*")
   (parameters
-    '("const-GdaMoney*" "val")
+    '("GdaParameterList*" "context")
   )
 )
 
-(define-method get_numeric
-  (of-object "GdaValue")
-  (c-name "gda_value_get_numeric")
-  (return-type "const-GdaNumeric*")
+(define-method is_valid
+  (of-object "GdaRenderer")
+  (c-name "gda_renderer_is_valid")
+  (return-type "gboolean")
+  (parameters
+    '("GdaParameterList*" "context")
+    '("GError**" "error")
+  )
+)
+
+
+
+;; From gda-row.h
+
+(define-function gda_row_get_type
+  (c-name "gda_row_get_type")
+  (return-type "GType")
+)
+
+(define-function gda_row_new
+  (c-name "gda_row_new")
+  (is-constructor-of "GdaRow")
+  (return-type "GdaRow*")
+  (parameters
+    '("GdaDataModel*" "model")
+    '("gint" "count")
+  )
 )
 
-(define-method set_numeric
-  (of-object "GdaValue")
-  (c-name "gda_value_set_numeric")
-  (return-type "none")
+(define-function gda_row_new_from_list
+  (c-name "gda_row_new_from_list")
+  (return-type "GdaRow*")
   (parameters
-    '("const-GdaNumeric*" "val")
+    '("GdaDataModel*" "model")
+    '("const-GList*" "values")
   )
 )
 
-(define-method get_single
-  (of-object "GdaValue")
-  (c-name "gda_value_get_single")
-  (return-type "gfloat")
+(define-method copy
+  (of-object "GdaRow")
+  (c-name "gda_row_copy")
+  (return-type "GdaRow*")
 )
 
-(define-method set_single
-  (of-object "GdaValue")
-  (c-name "gda_value_set_single")
+(define-method set_model
+  (of-object "GdaRow")
+  (c-name "gda_row_set_model")
   (return-type "none")
   (parameters
-    '("gfloat" "val")
+    '("GdaDataModel*" "model")
   )
 )
 
-(define-method get_smallint
-  (of-object "GdaValue")
-  (c-name "gda_value_get_smallint")
-  (return-type "gshort")
+(define-method get_model
+  (of-object "GdaRow")
+  (c-name "gda_row_get_model")
+  (return-type "GdaDataModel*")
 )
 
-(define-method set_smallint
-  (of-object "GdaValue")
-  (c-name "gda_value_set_smallint")
-  (return-type "none")
-  (parameters
-    '("gshort" "val")
-  )
+(define-method get_length
+  (of-object "GdaRow")
+  (c-name "gda_row_get_length")
+  (return-type "gint")
 )
 
-(define-method get_smalluint
-  (of-object "GdaValue")
-  (c-name "gda_value_get_smalluint")
-  (return-type "gushort")
+(define-method get_number
+  (of-object "GdaRow")
+  (c-name "gda_row_get_number")
+  (return-type "gint")
 )
 
-(define-method set_smalluint
-  (of-object "GdaValue")
-  (c-name "gda_value_set_smalluint")
+(define-method set_number
+  (of-object "GdaRow")
+  (c-name "gda_row_set_number")
   (return-type "none")
   (parameters
-    '("gushort" "val")
+    '("gint" "number")
   )
 )
 
-(define-method get_string
-  (of-object "GdaValue")
-  (c-name "gda_value_get_string")
+(define-method get_id
+  (of-object "GdaRow")
+  (c-name "gda_row_get_id")
   (return-type "const-gchar*")
 )
 
-(define-method set_string
-  (of-object "GdaValue")
-  (c-name "gda_value_set_string")
+(define-method set_id
+  (of-object "GdaRow")
+  (c-name "gda_row_set_id")
   (return-type "none")
   (parameters
-    '("const-gchar*" "val")
+    '("const-gchar*" "id")
   )
 )
 
-(define-method get_time
-  (of-object "GdaValue")
-  (c-name "gda_value_get_time")
-  (return-type "const-GdaTime*")
-)
-
-(define-method set_time
-  (of-object "GdaValue")
-  (c-name "gda_value_set_time")
-  (return-type "none")
+(define-method get_value
+  (of-object "GdaRow")
+  (c-name "gda_row_get_value")
+  (return-type "GValue*")
   (parameters
-    '("const-GdaTime*" "val")
+    '("gint" "num")
   )
 )
 
-(define-method get_timestamp
-  (of-object "GdaValue")
-  (c-name "gda_value_get_timestamp")
-  (return-type "const-GdaTimestamp*")
+(define-method set_value
+  (of-object "GdaRow")
+  (c-name "gda_row_set_value")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "num")
+    '("const-GValue*" "value")
+  )
 )
 
-(define-method set_timestamp
-  (of-object "GdaValue")
-  (c-name "gda_value_set_timestamp")
+(define-method set_is_default
+  (of-object "GdaRow")
+  (c-name "gda_row_set_is_default")
   (return-type "none")
   (parameters
-    '("const-GdaTimestamp*" "val")
+    '("gint" "num")
+    '("gboolean" "is_default")
   )
 )
 
-(define-method get_tinyint
-  (of-object "GdaValue")
-  (c-name "gda_value_get_tinyint")
-  (return-type "gchar")
-)
-
-(define-method set_tinyint
-  (of-object "GdaValue")
-  (c-name "gda_value_set_tinyint")
-  (return-type "none")
+(define-method get_is_default
+  (of-object "GdaRow")
+  (c-name "gda_row_get_is_default")
+  (return-type "gboolean")
   (parameters
-    '("gchar" "val")
+    '("gint" "num")
   )
 )
 
-(define-method get_tinyuint
-  (of-object "GdaValue")
-  (c-name "gda_value_get_tinyuint")
-  (return-type "guchar")
+
+
+;; From gda-server-operation.h
+
+(define-function gda_server_operation_get_type
+  (c-name "gda_server_operation_get_type")
+  (return-type "GType")
 )
 
-(define-method set_tinyuint
-  (of-object "GdaValue")
-  (c-name "gda_value_set_tinyuint")
-  (return-type "none")
+(define-function gda_server_operation_new
+  (c-name "gda_server_operation_new")
+  (is-constructor-of "GdaServerOperation")
+  (return-type "GdaServerOperation*")
   (parameters
-    '("guchar" "val")
+    '("GdaServerOperationType" "op_type")
+    '("const-gchar*" "xml_file")
   )
 )
 
-(define-method get_uinteger
-  (of-object "GdaValue")
-  (c-name "gda_value_get_uinteger")
-  (return-type "guint")
+(define-method get_op_type
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_op_type")
+  (return-type "GdaServerOperationType")
 )
 
-(define-method set_uinteger
-  (of-object "GdaValue")
-  (c-name "gda_value_set_uinteger")
-  (return-type "none")
+(define-function gda_server_operation_op_type_to_string
+  (c-name "gda_server_operation_op_type_to_string")
+  (return-type "const-gchar*")
   (parameters
-    '("guint" "val")
+    '("GdaServerOperationType" "type")
   )
 )
 
-(define-method get_vtype
-  (of-object "GdaValue")
-  (c-name "gda_value_get_vtype")
-  (return-type "GdaValueType")
-)
-
-(define-method set_vtype
-  (of-object "GdaValue")
-  (c-name "gda_value_set_vtype")
-  (return-type "none")
+(define-method get_node_info
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_node_info")
+  (return-type "GdaServerOperationNode*")
   (parameters
-    '("GdaValueType" "type")
+    '("const-gchar*" "path_format")
   )
+  (varargs #t)
 )
 
-(define-method set_from_string
-  (of-object "GdaValue")
-  (c-name "gda_value_set_from_string")
-  (return-type "gboolean")
+(define-method get_value_at
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_value_at")
+  (return-type "const-GValue*")
   (parameters
-    '("const-gchar*" "as_string")
-    '("GdaValueType" "type")
+    '("const-gchar*" "path_format")
   )
+  (varargs #t)
 )
 
-(define-method set_from_value
-  (of-object "GdaValue")
-  (c-name "gda_value_set_from_value")
+(define-method set_value_at
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_set_value_at")
   (return-type "gboolean")
   (parameters
-    '("const-GdaValue*" "from")
+    '("const-gchar*" "value")
+    '("GError**" "error")
+    '("const-gchar*" "path_format")
   )
+  (varargs #t)
 )
 
-(define-method compare
-  (of-object "GdaValue")
-  (c-name "gda_value_compare")
-  (return-type "gint")
+(define-method save_data_to_xml
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_save_data_to_xml")
+  (return-type "xmlNodePtr")
   (parameters
-    '("GdaValue*" "value2")
+    '("GError**" "error")
   )
 )
 
-(define-method stringify
-  (of-object "GdaValue")
-  (c-name "gda_value_stringify")
-  (return-type "gchar*")
-)
-
-(define-method to_xml
-  (of-object "GdaValue")
-  (c-name "gda_value_to_xml")
-  (return-type "xmlNodePtr")
+(define-method load_data_from_xml
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_load_data_from_xml")
+  (return-type "gboolean")
+  (parameters
+    '("xmlNodePtr" "node")
+    '("GError**" "error")
+  )
 )
 
-(define-function gda_money_get_type
-  (c-name "gda_money_get_type")
-  (return-type "GType")
+(define-method get_root_nodes
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_root_nodes")
+  (return-type "gchar**")
 )
 
-(define-method copy
-  (of-object "GdaMoney")
-  (c-name "gda_money_copy")
-  (return-type "GdaMoney*")
+(define-method get_node_type
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_node_type")
+  (return-type "GdaServerOperationNodeType")
+  (parameters
+    '("const-gchar*" "path")
+    '("GdaServerOperationNodeStatus*" "status")
+  )
 )
 
-(define-method free
-  (of-object "GdaMoney")
-  (c-name "gda_money_free")
-  (return-type "none")
+(define-method get_node_parent
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_node_parent")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "path")
+  )
 )
 
-(define-function gda_numeric_get_type
-  (c-name "gda_numeric_get_type")
-  (return-type "GType")
+(define-method get_node_path_portion
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_node_path_portion")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "path")
+  )
 )
 
-(define-method copy
-  (of-object "GdaNumeric")
-  (c-name "gda_numeric_copy")
-  (return-type "GdaNumeric*")
+(define-method get_sequence_name
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_sequence_name")
+  (return-type "const-gchar*")
+  (parameters
+    '("const-gchar*" "path")
+  )
 )
 
-(define-method free
-  (of-object "GdaNumeric")
-  (c-name "gda_numeric_free")
-  (return-type "none")
+(define-method get_sequence_size
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_sequence_size")
+  (return-type "guint")
+  (parameters
+    '("const-gchar*" "path")
+  )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xml-connection.h
-
-(define-function gda_xml_connection_get_type
-  (c-name "gda_xml_connection_get_type")
-  (return-type "GType")
+(define-method get_sequence_max_size
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_sequence_max_size")
+  (return-type "guint")
+  (parameters
+    '("const-gchar*" "path")
+  )
 )
 
-(define-function gda_xml_connection_new
-  (c-name "gda_xml_connection_new")
-  (is-constructor-of "GdaXmlConnection")
-  (return-type "GdaXmlConnection*")
+(define-method get_sequence_min_size
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_sequence_min_size")
+  (return-type "guint")
+  (parameters
+    '("const-gchar*" "path")
+  )
 )
 
-(define-function gda_xml_connection_new_from_file
-  (c-name "gda_xml_connection_new_from_file")
-  (return-type "GdaXmlConnection*")
+(define-method get_sequence_item_names
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_get_sequence_item_names")
+  (return-type "gchar**")
   (parameters
-    '("const-gchar*" "filename")
+    '("const-gchar*" "path")
   )
 )
 
-(define-function gda_xml_connection_new_from_string
-  (c-name "gda_xml_connection_new_from_string")
-  (return-type "GdaXmlConnection*")
+(define-method add_item_to_sequence
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_add_item_to_sequence")
+  (return-type "guint")
   (parameters
-    '("const-gchar*" "string")
+    '("const-gchar*" "path")
   )
 )
 
-(define-method set_from_file
-  (of-object "GdaXmlConnection")
-  (c-name "gda_xml_connection_set_from_file")
+(define-method del_item_from_sequence
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_del_item_from_sequence")
   (return-type "gboolean")
   (parameters
-    '("const-gchar*" "filename")
+    '("const-gchar*" "item_path")
   )
 )
 
-(define-method set_from_string
-  (of-object "GdaXmlConnection")
-  (c-name "gda_xml_connection_set_from_string")
+(define-method is_valid
+  (of-object "GdaServerOperation")
+  (c-name "gda_server_operation_is_valid")
   (return-type "gboolean")
   (parameters
-    '("const-gchar*" "string")
+    '("const-gchar*" "xml_file")
+    '("GError**" "error")
   )
 )
 
-(define-method get_dsn
-  (of-object "GdaXmlConnection")
-  (c-name "gda_xml_connection_get_dsn")
-  (return-type "const-gchar*")
-)
 
-(define-method set_dsn
-  (of-object "GdaXmlConnection")
-  (c-name "gda_xml_connection_set_dsn")
-  (return-type "none")
+
+;; From gda-server-provider-extra.h
+
+(define-function gda_server_provider_get_schema_nb_columns
+  (c-name "gda_server_provider_get_schema_nb_columns")
+  (return-type "gint")
   (parameters
-    '("const-gchar*" "dsn")
+    '("GdaConnectionSchema" "schema")
   )
 )
 
-(define-method get_username
-  (of-object "GdaXmlConnection")
-  (c-name "gda_xml_connection_get_username")
-  (return-type "const-gchar*")
+(define-function gda_server_provider_init_schema_model
+  (c-name "gda_server_provider_init_schema_model")
+  (return-type "gboolean")
+  (parameters
+    '("GdaDataModel*" "model")
+    '("GdaConnectionSchema" "schema")
+  )
 )
 
-(define-method set_username
-  (of-object "GdaXmlConnection")
-  (c-name "gda_xml_connection_set_username")
-  (return-type "none")
+(define-function gda_server_provider_test_schema_model
+  (c-name "gda_server_provider_test_schema_model")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "username")
+    '("GdaDataModel*" "model")
+    '("GdaConnectionSchema" "schema")
+    '("GError**" "error")
   )
 )
 
-(define-method get_password
-  (of-object "GdaXmlConnection")
-  (c-name "gda_xml_connection_get_password")
-  (return-type "const-gchar*")
+(define-method hash_func
+  (of-object "GdaServerProviderHandlerInfo")
+  (c-name "gda_server_provider_handler_info_hash_func")
+  (return-type "guint")
 )
 
-(define-method set_password
-  (of-object "GdaXmlConnection")
-  (c-name "gda_xml_connection_set_password")
-  (return-type "none")
+(define-method equal_func
+  (of-object "GdaServerProviderHandlerInfo")
+  (c-name "gda_server_provider_handler_info_equal_func")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "password")
+    '("GdaServerProviderHandlerInfo*" "b")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xml-database.h
-
-(define-function gda_xml_database_get_type
-  (c-name "gda_xml_database_get_type")
-  (return-type "GType")
-)
-
-(define-function gda_xml_database_new
-  (c-name "gda_xml_database_new")
-  (is-constructor-of "GdaXmlDatabase")
-  (return-type "GdaXmlDatabase*")
+(define-method free
+  (of-object "GdaServerProviderHandlerInfo")
+  (c-name "gda_server_provider_handler_info_free")
+  (return-type "none")
 )
 
-(define-function gda_xml_database_new_from_uri
-  (c-name "gda_xml_database_new_from_uri")
-  (return-type "GdaXmlDatabase*")
+(define-method handler_find
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_handler_find")
+  (return-type "GdaDataHandler*")
   (parameters
-    '("const-gchar*" "uri")
+    '("GdaConnection*" "cnc")
+    '("GType" "g_type")
+    '("const-gchar*" "dbms_type")
   )
 )
 
-(define-method get_name
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_get_name")
-  (return-type "const-gchar*")
-)
-
-(define-method set_name
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_set_name")
+(define-method handler_declare
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_handler_declare")
   (return-type "none")
   (parameters
-    '("const-gchar*" "name")
+    '("GdaDataHandler*" "dh")
+    '("GdaConnection*" "cnc")
+    '("GType" "g_type")
+    '("const-gchar*" "dbms_type")
   )
 )
 
-(define-method get_user_version
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_get_user_version")
-  (return-type "const-gchar*")
-)
 
-(define-method set_user_version
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_set_user_version")
-  (return-type "none")
-  (parameters
-    '("const-gchar*" "user_version")
-  )
+
+;; From gda-server-provider.h
+
+(define-function gda_server_provider_get_type
+  (c-name "gda_server_provider_get_type")
+  (return-type "GType")
 )
 
 (define-method get_version
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_get_version")
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_get_version")
   (return-type "const-gchar*")
 )
 
-(define-method get_uri
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_get_uri")
+(define-method get_server_version
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_get_server_version")
   (return-type "const-gchar*")
+  (parameters
+    '("GdaConnection*" "cnc")
+  )
 )
 
-(define-method set_uri
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_set_uri")
-  (return-type "none")
+(define-method get_info
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_get_info")
+  (return-type "GdaServerProviderInfo*")
   (parameters
-    '("const-gchar*" "uri")
+    '("GdaConnection*" "cnc")
   )
 )
 
-(define-method changed
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_changed")
-  (return-type "none")
+(define-method supports_feature
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_supports_feature")
+  (return-type "gboolean")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaConnectionFeature" "feature")
+  )
 )
 
-(define-method reload
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_reload")
-  (return-type "none")
+(define-method get_schema
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_get_schema")
+  (return-type "GdaDataModel*")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaConnectionSchema" "schema")
+    '("GdaParameterList*" "params")
+    '("GError**" "error")
+  )
 )
 
-(define-method save
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_save")
-  (return-type "gboolean")
+(define-method get_data_handler_gtype
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_get_data_handler_gtype")
+  (return-type "GdaDataHandler*")
   (parameters
-    '("const-gchar*" "uri")
+    '("GdaConnection*" "cnc")
+    '("GType" "for_type")
   )
 )
 
-(define-method to_string
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_to_string")
-  (return-type "gchar*")
+(define-method get_data_handler_dbms
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_get_data_handler_dbms")
+  (return-type "GdaDataHandler*")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("const-gchar*" "for_type")
+  )
 )
 
-(define-method get_tables
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_get_tables")
-  (return-type "GList*")
+(define-method string_to_value
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_string_to_value")
+  (return-type "GValue*")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("const-gchar*" "string")
+    '("GType" "prefered_type")
+    '("gchar**" "dbms_type")
+  )
 )
 
-(define-function gda_xml_database_free_table_list
-  (c-name "gda_xml_database_free_table_list")
-  (return-type "none")
+(define-method value_to_sql_string
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_value_to_sql_string")
+  (return-type "gchar*")
   (parameters
-    '("GList*" "list")
+    '("GdaConnection*" "cnc")
+    '("GValue*" "from")
   )
 )
 
-(define-method find_table
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_find_table")
-  (return-type "GdaTable*")
+(define-method get_default_dbms_type
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_get_default_dbms_type")
+  (return-type "const-gchar*")
   (parameters
-    '("const-gchar*" "name")
+    '("GdaConnection*" "cnc")
+    '("GType" "type")
   )
 )
 
-(define-method new_table
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_new_table")
-  (return-type "GdaTable*")
+(define-method open_connection
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_open_connection")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "name")
+    '("GdaConnection*" "cnc")
+    '("GdaQuarkList*" "params")
+    '("const-gchar*" "username")
+    '("const-gchar*" "password")
   )
 )
 
-(define-method new_table_from_model
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_new_table_from_model")
-  (return-type "GdaTable*")
+(define-method reset_connection
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_reset_connection")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "name")
-    '("const-GdaDataModel*" "model")
-    '("gboolean" "add_data")
+    '("GdaConnection*" "cnc")
   )
 )
 
-(define-method new_table_from_node
-  (of-object "GdaXmlDatabase")
-  (c-name "gda_xml_database_new_table_from_node")
-  (return-type "GdaTable*")
+(define-method close_connection
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_close_connection")
+  (return-type "gboolean")
   (parameters
-    '("xmlNodePtr" "node")
+    '("GdaConnection*" "cnc")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xml-document.h
-
-(define-function gda_xml_document_get_type
-  (c-name "gda_xml_document_get_type")
-  (return-type "GType")
-)
-
-(define-function gda_xml_document_new
-  (c-name "gda_xml_document_new")
-  (is-constructor-of "GdaXmlDocument")
-  (return-type "GdaXmlDocument*")
+(define-method get_database
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_get_database")
+  (return-type "const-gchar*")
   (parameters
-    '("const-gchar*" "root_doc")
+    '("GdaConnection*" "cnc")
   )
 )
 
-(define-method construct
-  (of-object "GdaXmlDocument")
-  (c-name "gda_xml_document_construct")
-  (return-type "none")
+(define-method change_database
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_change_database")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "root_doc")
+    '("GdaConnection*" "cnc")
+    '("const-gchar*" "name")
   )
 )
 
-(define-method get_compress_mode
-  (of-object "GdaXmlDocument")
-  (c-name "gda_xml_document_get_compress_mode")
-  (return-type "gint")
-)
-
-(define-method set_compress_mode
-  (of-object "GdaXmlDocument")
-  (c-name "gda_xml_document_set_compress_mode")
-  (return-type "none")
+(define-method supports_operation
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_supports_operation")
+  (return-type "gboolean")
   (parameters
-    '("gint" "mode")
+    '("GdaConnection*" "cnc")
+    '("GdaServerOperationType" "type")
+    '("GdaParameterList*" "options")
   )
 )
 
-(define-method to_file
-  (of-object "GdaXmlDocument")
-  (c-name "gda_xml_document_to_file")
-  (return-type "gboolean")
+(define-method create_operation
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_create_operation")
+  (return-type "GdaServerOperation*")
   (parameters
-    '("const-gchar*" "uri")
+    '("GdaConnection*" "cnc")
+    '("GdaServerOperationType" "type")
+    '("GdaParameterList*" "options")
+    '("GError**" "error")
   )
 )
 
-(define-method stringify
-  (of-object "GdaXmlDocument")
-  (c-name "gda_xml_document_stringify")
+(define-method render_operation
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_render_operation")
   (return-type "gchar*")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaServerOperation*" "op")
+    '("GError**" "error")
+  )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-atom.h
-
-(define-function gda_xql_atom_get_type
-  (c-name "gda_xql_atom_get_type")
-  (return-type "GType")
-)
-
-(define-function gda_xql_atom_new
-  (c-name "gda_xql_atom_new")
-  (is-constructor-of "GdaXqlAtom")
-  (return-type "GdaXqlItem*")
+(define-method perform_operation
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_perform_operation")
+  (return-type "gboolean")
   (parameters
-    '("gchar*" "tag")
+    '("GdaConnection*" "cnc")
+    '("GdaServerOperation*" "op")
+    '("GError**" "error")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-bin.h
-
-(define-function gda_xql_bin_get_type
-  (c-name "gda_xql_bin_get_type")
-  (return-type "GType")
+(define-method execute_command
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_execute_command")
+  (return-type "GList*")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaCommand*" "cmd")
+    '("GdaParameterList*" "params")
+  )
 )
 
-(define-function gda_xql_bin_new
-  (c-name "gda_xql_bin_new")
-  (is-constructor-of "GdaXqlBin")
-  (return-type "GdaXqlItem*")
+(define-method get_last_insert_id
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_get_last_insert_id")
+  (return-type "gchar*")
   (parameters
-    '("gchar*" "tag")
-    '("gchar*" "sqlfmt")
-    '("gchar*" "sqlop")
+    '("GdaConnection*" "cnc")
+    '("GdaDataModel*" "recset")
   )
 )
 
-(define-function gda_xql_bin_new_with_data
-  (c-name "gda_xql_bin_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-method begin_transaction
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_begin_transaction")
+  (return-type "gboolean")
   (parameters
-    '("gchar*" "tag")
-    '("gchar*" "sqlfmt")
-    '("gchar*" "sqlop")
-    '("GdaXqlItem*" "child")
+    '("GdaConnection*" "cnc")
+    '("GdaTransaction*" "xaction")
   )
 )
 
-(define-method get_child
-  (of-object "GdaXqlBin")
-  (c-name "gda_xql_bin_get_child")
-  (return-type "GdaXqlItem*")
+(define-method commit_transaction
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_commit_transaction")
+  (return-type "gboolean")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("GdaTransaction*" "xaction")
+  )
 )
 
-(define-method set_child
-  (of-object "GdaXqlBin")
-  (c-name "gda_xql_bin_set_child")
-  (return-type "none")
+(define-method rollback_transaction
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_rollback_transaction")
+  (return-type "gboolean")
   (parameters
-    '("GdaXqlItem*" "item")
+    '("GdaConnection*" "cnc")
+    '("GdaTransaction*" "xaction")
   )
 )
 
-(define-function gda_xql_bin_new_union
-  (c-name "gda_xql_bin_new_union")
-  (return-type "GdaXqlItem*")
+(define-method create_blob
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_create_blob")
+  (return-type "GdaBlob*")
+  (parameters
+    '("GdaConnection*" "cnc")
+  )
 )
 
-(define-function gda_xql_bin_new_unionall
-  (c-name "gda_xql_bin_new_unionall")
-  (return-type "GdaXqlItem*")
+(define-method fetch_blob_by_id
+  (of-object "GdaServerProvider")
+  (c-name "gda_server_provider_fetch_blob_by_id")
+  (return-type "GdaBlob*")
+  (parameters
+    '("GdaConnection*" "cnc")
+    '("const-gchar*" "sql_id")
+  )
 )
 
-(define-function gda_xql_bin_new_intersect
-  (c-name "gda_xql_bin_new_intersect")
-  (return-type "GdaXqlItem*")
-)
 
-(define-function gda_xql_bin_new_minus
-  (c-name "gda_xql_bin_new_minus")
-  (return-type "GdaXqlItem*")
-)
 
-(define-function gda_xql_bin_new_where
-  (c-name "gda_xql_bin_new_where")
-  (return-type "GdaXqlItem*")
-)
+;; From gda-server-provider-private.h
 
-(define-function gda_xql_bin_new_where_with_data
-  (c-name "gda_xql_bin_new_where_with_data")
-  (return-type "GdaXqlItem*")
-  (parameters
-    '("GdaXqlItem*" "data")
-  )
-)
 
-(define-function gda_xql_bin_new_having
-  (c-name "gda_xql_bin_new_having")
-  (return-type "GdaXqlItem*")
-)
 
-(define-function gda_xql_bin_new_having_with_data
-  (c-name "gda_xql_bin_new_having_with_data")
-  (return-type "GdaXqlItem*")
-  (parameters
-    '("GdaXqlItem*" "data")
-  )
-)
+;; From gda-threader.h
 
-(define-function gda_xql_bin_new_on
-  (c-name "gda_xql_bin_new_on")
-  (return-type "GdaXqlItem*")
+(define-function gda_threader_get_type
+  (c-name "gda_threader_get_type")
+  (return-type "GType")
 )
 
-(define-function gda_xql_bin_new_not
-  (c-name "gda_xql_bin_new_not")
-  (return-type "GdaXqlItem*")
+(define-function gda_threader_new
+  (c-name "gda_threader_new")
+  (is-constructor-of "GdaThreader")
+  (return-type "GObject*")
 )
 
-(define-function gda_xql_bin_new_not_with_data
-  (c-name "gda_xql_bin_new_not_with_data")
-  (return-type "GdaXqlItem*")
+(define-method start_thread
+  (of-object "GdaThreader")
+  (c-name "gda_threader_start_thread")
+  (return-type "guint")
   (parameters
-    '("GdaXqlItem*" "data")
+    '("GThreadFunc" "func")
+    '("gpointer" "func_arg")
+    '("GdaThreaderFunc" "ok_callback")
+    '("GdaThreaderFunc" "cancel_callback")
+    '("GError**" "error")
   )
 )
 
-(define-function gda_xql_bin_new_exists
-  (c-name "gda_xql_bin_new_exists")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_bin_new_null
-  (c-name "gda_xql_bin_new_null")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_bin_new_null_with_data
-  (c-name "gda_xql_bin_new_null_with_data")
-  (return-type "GdaXqlItem*")
+(define-method cancel
+  (of-object "GdaThreader")
+  (c-name "gda_threader_cancel")
+  (return-type "none")
   (parameters
-    '("GdaXqlItem*" "data")
+    '("guint" "job_id")
   )
 )
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-column.h
+;; From gda-transaction.h
 
-(define-function gda_xql_column_get_type
-  (c-name "gda_xql_column_get_type")
+(define-function gda_transaction_get_type
+  (c-name "gda_transaction_get_type")
   (return-type "GType")
 )
 
-(define-function gda_xql_column_new
-  (c-name "gda_xql_column_new")
-  (is-constructor-of "GdaXqlColumn")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_column_new_with_data
-  (c-name "gda_xql_column_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_transaction_new
+  (c-name "gda_transaction_new")
+  (is-constructor-of "GdaTransaction")
+  (return-type "GdaTransaction*")
   (parameters
-    '("gint" "num")
-    '("gboolean" "asc")
+    '("const-gchar*" "name")
   )
 )
 
+(define-method get_isolation_level
+  (of-object "GdaTransaction")
+  (c-name "gda_transaction_get_isolation_level")
+  (return-type "GdaTransactionIsolation")
+)
 
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-const.h
-
-(define-function gda_xql_const_get_type
-  (c-name "gda_xql_const_get_type")
-  (return-type "GType")
+(define-method set_isolation_level
+  (of-object "GdaTransaction")
+  (c-name "gda_transaction_set_isolation_level")
+  (return-type "none")
+  (parameters
+    '("GdaTransactionIsolation" "level")
+  )
 )
 
-(define-function gda_xql_const_new
-  (c-name "gda_xql_const_new")
-  (is-constructor-of "GdaXqlConst")
-  (return-type "GdaXqlItem*")
+(define-method get_name
+  (of-object "GdaTransaction")
+  (c-name "gda_transaction_get_name")
+  (return-type "const-gchar*")
 )
 
-(define-function gda_xql_const_new_with_data
-  (c-name "gda_xql_const_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-method set_name
+  (of-object "GdaTransaction")
+  (c-name "gda_transaction_set_name")
+  (return-type "none")
   (parameters
-    '("gchar*" "value")
-    '("gchar*" "alias")
-    '("gchar*" "type")
-    '("gchar*" "null")
+    '("const-gchar*" "name")
   )
 )
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-delete.h
+;; From gda-util.h
 
-(define-function gda_xql_delete_get_type
-  (c-name "gda_xql_delete_get_type")
-  (return-type "GType")
+(define-method to_string
+  (of-object "GType")
+  (c-name "g_type_to_string")
+  (return-type "const-gchar*")
 )
 
-(define-function gda_xql_delete_new
-  (c-name "gda_xql_delete_new")
-  (is-constructor-of "GdaXqlDelete")
-  (return-type "GdaXqlItem*")
+(define-function g_type_from_string
+  (c-name "g_type_from_string")
+  (return-type "GType")
+  (parameters
+    '("const-gchar*" "str")
+  )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-dml.h
-
-(define-function gda_xql_dml_get_type
-  (c-name "gda_xql_dml_get_type")
-  (return-type "GType")
+(define-function gda_string_hash_to_list
+  (c-name "gda_string_hash_to_list")
+  (return-type "GList*")
+  (parameters
+    '("GHashTable*" "hash_table")
+  )
 )
 
-(define-method add_target_from_text
-  (of-object "GdaXqlDml")
-  (c-name "gda_xql_dml_add_target_from_text")
+(define-function gda_default_escape_chars
+  (c-name "gda_default_escape_chars")
   (return-type "gchar*")
   (parameters
-    '("gchar*" "name")
-    '("GdaXqlItem*" "join")
+    '("const-gchar*" "string")
   )
 )
 
-(define-method add_field_from_text
-  (of-object "GdaXqlDml")
-  (c-name "gda_xql_dml_add_field_from_text")
-  (return-type "GdaXqlItem*")
+(define-function gda_default_unescape_chars
+  (c-name "gda_default_unescape_chars")
+  (return-type "gchar*")
   (parameters
-    '("gchar*" "id")
-    '("gchar*" "name")
-    '("gchar*" "alias")
-    '("gboolean" "group")
+    '("const-gchar*" "string")
   )
 )
 
-(define-method add_const_from_text
-  (of-object "GdaXqlDml")
-  (c-name "gda_xql_dml_add_const_from_text")
-  (return-type "GdaXqlItem*")
+(define-function gda_file_load
+  (c-name "gda_file_load")
+  (return-type "gchar*")
   (parameters
-    '("gchar*" "value")
-    '("gchar*" "type")
-    '("gboolean" "null")
+    '("const-gchar*" "filename")
   )
 )
 
-(define-method add_func
-  (of-object "GdaXqlDml")
-  (c-name "gda_xql_dml_add_func")
-  (return-type "none")
+(define-function gda_file_save
+  (c-name "gda_file_save")
+  (return-type "gboolean")
   (parameters
-    '("GdaXqlItem*" "item")
+    '("const-gchar*" "filename")
+    '("const-gchar*" "buffer")
+    '("gint" "len")
   )
 )
 
-(define-method add_query
-  (of-object "GdaXqlDml")
-  (c-name "gda_xql_dml_add_query")
-  (return-type "none")
+(define-function utility_table_field_attrs_stringify
+  (c-name "utility_table_field_attrs_stringify")
+  (return-type "gchar*")
   (parameters
-    '("GdaXqlItem*" "item")
+    '("guint" "attributes")
   )
 )
 
-(define-method add_row_condition
-  (of-object "GdaXqlDml")
-  (c-name "gda_xql_dml_add_row_condition")
-  (return-type "none")
+(define-function utility_table_field_attrs_parse
+  (c-name "utility_table_field_attrs_parse")
+  (return-type "guint")
   (parameters
-    '("GdaXqlItem*" "cond")
-    '("gchar*" "type")
+    '("const-gchar*" "str")
   )
 )
 
-(define-method add_group_condition
-  (of-object "GdaXqlDml")
-  (c-name "gda_xql_dml_add_group_condition")
-  (return-type "none")
+(define-function utility_build_encoded_id
+  (c-name "utility_build_encoded_id")
+  (return-type "gchar*")
   (parameters
-    '("GdaXqlItem*" "cond")
-    '("gchar*" "type")
+    '("const-gchar*" "prefix")
+    '("const-gchar*" "id")
   )
 )
 
-(define-method add_order
-  (of-object "GdaXqlDml")
-  (c-name "gda_xql_dml_add_order")
-  (return-type "none")
+(define-function utility_build_decoded_id
+  (c-name "utility_build_decoded_id")
+  (return-type "gchar*")
   (parameters
-    '("gint" "column")
-    '("gboolean" "asc")
+    '("const-gchar*" "prefix")
+    '("const-gchar*" "id")
   )
 )
 
-(define-method add_set
-  (of-object "GdaXqlDml")
-  (c-name "gda_xql_dml_add_set")
-  (return-type "none")
+(define-function utility_check_data_model
+  (c-name "utility_check_data_model")
+  (return-type "gboolean")
   (parameters
-    '("GdaXqlItem*" "item")
+    '("GdaDataModel*" "model")
+    '("gint" "nbcols")
   )
+  (varargs #t)
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-dual.h
-
-(define-function gda_xql_dual_get_type
-  (c-name "gda_xql_dual_get_type")
-  (return-type "GType")
+(define-function utility_data_model_dump_data_to_xml
+  (c-name "utility_data_model_dump_data_to_xml")
+  (return-type "none")
+  (parameters
+    '("GdaDataModel*" "model")
+    '("xmlNodePtr" "parent")
+    '("const-gint*" "cols")
+    '("gint" "nb_cols")
+    '("const-gint*" "rows")
+    '("gint" "nb_rows")
+    '("gboolean" "use_col_ids")
+  )
 )
 
-(define-function gda_xql_dual_new
-  (c-name "gda_xql_dual_new")
-  (is-constructor-of "GdaXqlDual")
-  (return-type "GdaXqlItem*")
+(define-function utility_parameter_load_attributes
+  (c-name "utility_parameter_load_attributes")
+  (return-type "none")
   (parameters
-    '("gchar*" "tag")
-    '("gchar*" "sqlfmt")
-    '("gchar*" "sqlop")
+    '("GdaParameter*" "param")
+    '("xmlNodePtr" "node")
+    '("GSList*" "sources")
   )
 )
 
-(define-function gda_xql_dual_new_with_data
-  (c-name "gda_xql_dual_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-function utility_find_or_create_data_type
+  (c-name "utility_find_or_create_data_type")
+  (return-type "GdaDictType*")
   (parameters
-    '("gchar*" "tag")
-    '("gchar*" "sqlfmt")
-    '("gchar*" "sqlop")
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("GdaDict*" "dict")
+    '("GdaServerProvider*" "prov")
+    '("GdaConnection*" "cnc")
+    '("const-gchar*" "dbms_type")
+    '("const-gchar*" "g_type")
+    '("gboolean*" "created")
   )
 )
 
-(define-method get_left
-  (of-object "GdaXqlDual")
-  (c-name "gda_xql_dual_get_left")
-  (return-type "GdaXqlItem*")
-)
 
-(define-method get_right
-  (of-object "GdaXqlDual")
-  (c-name "gda_xql_dual_get_right")
-  (return-type "GdaXqlItem*")
-)
 
-(define-function gda_xql_dual_new_eq
-  (c-name "gda_xql_dual_new_eq")
-  (return-type "GdaXqlItem*")
-)
+;; From gda-value.h
 
-(define-function gda_xql_dual_new_eq_with_data
-  (c-name "gda_xql_dual_new_eq_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_new
+  (c-name "gda_value_new")
+  (is-constructor-of "GdaValue")
+  (return-type "GValue*")
   (parameters
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("GType" "type")
   )
 )
 
-(define-function gda_xql_dual_new_ne
-  (c-name "gda_xql_dual_new_ne")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_dual_new_ne_with_data
-  (c-name "gda_xql_dual_new_ne_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_new_binary
+  (c-name "gda_value_new_binary")
+  (return-type "GValue*")
   (parameters
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("guchar*" "val")
+    '("glong" "size")
   )
 )
 
-(define-function gda_xql_dual_new_lt
-  (c-name "gda_xql_dual_new_lt")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_dual_new_lt_with_data
-  (c-name "gda_xql_dual_new_lt_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_new_timestamp_from_timet
+  (c-name "gda_value_new_timestamp_from_timet")
+  (return-type "GValue*")
   (parameters
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("time_t" "val")
   )
 )
 
-(define-function gda_xql_dual_new_le
-  (c-name "gda_xql_dual_new_le")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_dual_new_le_with_data
-  (c-name "gda_xql_dual_new_le_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_new_from_string
+  (c-name "gda_value_new_from_string")
+  (return-type "GValue*")
   (parameters
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("const-gchar*" "as_string")
+    '("GType" "type")
   )
 )
 
-(define-function gda_xql_dual_new_gt
-  (c-name "gda_xql_dual_new_gt")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_dual_new_gt_with_data
-  (c-name "gda_xql_dual_new_gt_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_new_from_xml
+  (c-name "gda_value_new_from_xml")
+  (return-type "GValue*")
   (parameters
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("const-xmlNodePtr" "node")
   )
 )
 
-(define-function gda_xql_dual_new_ge
-  (c-name "gda_xql_dual_new_ge")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_dual_new_ge_with_data
-  (c-name "gda_xql_dual_new_ge_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_free
+  (c-name "gda_value_free")
+  (return-type "none")
   (parameters
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("GValue*" "value")
   )
 )
 
-(define-function gda_xql_dual_new_like
-  (c-name "gda_xql_dual_new_like")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_reset_with_type
+  (c-name "gda_value_reset_with_type")
+  (return-type "none")
+  (parameters
+    '("GValue*" "value")
+    '("GType" "type")
+  )
 )
 
-(define-function gda_xql_dual_new_like_with_data
-  (c-name "gda_xql_dual_new_like_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_is_null
+  (c-name "gda_value_is_null")
+  (return-type "gboolean")
   (parameters
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("const-GValue*" "value")
   )
 )
 
-(define-function gda_xql_dual_new_in
-  (c-name "gda_xql_dual_new_in")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_is_number
+  (c-name "gda_value_is_number")
+  (return-type "gboolean")
+  (parameters
+    '("const-GValue*" "value")
+  )
 )
 
-(define-function gda_xql_dual_new_in_with_data
-  (c-name "gda_xql_dual_new_in_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_copy
+  (c-name "gda_value_copy")
+  (return-type "GValue*")
   (parameters
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("const-GValue*" "value")
   )
 )
 
-(define-function gda_xql_dual_new_set
-  (c-name "gda_xql_dual_new_set")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_get_binary
+  (c-name "gda_value_get_binary")
+  (return-type "const-GdaBinary*")
+  (parameters
+    '("const-GValue*" "value")
+  )
 )
 
-(define-function gda_xql_dual_new_set_with_data
-  (c-name "gda_xql_dual_new_set_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_set_binary
+  (c-name "gda_value_set_binary")
+  (return-type "none")
   (parameters
-    '("GdaXqlItem*" "left")
-    '("GdaXqlItem*" "right")
+    '("GValue*" "value")
+    '("const-GdaBinary*" "binary")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-field.h
-
-(define-function gda_xql_field_get_type
-  (c-name "gda_xql_field_get_type")
-  (return-type "GType")
+(define-function gda_value_take_binary
+  (c-name "gda_value_take_binary")
+  (return-type "none")
+  (parameters
+    '("GValue*" "value")
+    '("const-GdaBinary*" "binary")
+  )
 )
 
-(define-function gda_xql_field_new
-  (c-name "gda_xql_field_new")
-  (is-constructor-of "GdaXqlField")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_get_blob
+  (c-name "gda_value_get_blob")
+  (return-type "const-GdaBlob*")
+  (parameters
+    '("const-GValue*" "value")
+  )
 )
 
-(define-function gda_xql_field_new_with_data
-  (c-name "gda_xql_field_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_set_blob
+  (c-name "gda_value_set_blob")
+  (return-type "none")
   (parameters
-    '("gchar*" "source")
-    '("gchar*" "name")
-    '("gchar*" "alias")
+    '("GValue*" "value")
+    '("const-GdaBlob*" "val")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-func.h
-
-(define-function gda_xql_func_get_type
-  (c-name "gda_xql_func_get_type")
-  (return-type "GType")
+(define-function gda_value_get_geometric_point
+  (c-name "gda_value_get_geometric_point")
+  (return-type "const-GdaGeometricPoint*")
+  (parameters
+    '("const-GValue*" "value")
+  )
 )
 
-(define-function gda_xql_func_new
-  (c-name "gda_xql_func_new")
-  (is-constructor-of "GdaXqlFunc")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_set_geometric_point
+  (c-name "gda_value_set_geometric_point")
+  (return-type "none")
+  (parameters
+    '("GValue*" "value")
+    '("const-GdaGeometricPoint*" "val")
+  )
 )
 
-(define-function gda_xql_func_new_with_data
-  (c-name "gda_xql_func_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_get_list
+  (c-name "gda_value_get_list")
+  (return-type "const-GdaValueList*")
   (parameters
-    '("gchar*" "name")
-    '("gchar*" "alias")
-    '("gchar*" "aggregate")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method add_const_from_text
-  (of-object "GdaXqlFunc")
-  (c-name "gda_xql_func_add_const_from_text")
+(define-function gda_value_set_list
+  (c-name "gda_value_set_list")
   (return-type "none")
   (parameters
-    '("gchar*" "value")
-    '("gchar*" "type")
-    '("gchar*" "null")
+    '("GValue*" "value")
+    '("const-GdaValueList*" "val")
   )
 )
 
-(define-method add_field_from_text
-  (of-object "GdaXqlFunc")
-  (c-name "gda_xql_func_add_field_from_text")
+(define-function gda_value_set_null
+  (c-name "gda_value_set_null")
   (return-type "none")
   (parameters
-    '("gchar*" "id")
-    '("gchar*" "name")
-    '("gchar*" "alias")
+    '("GValue*" "value")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-insert.h
-
-(define-function gda_xql_insert_get_type
-  (c-name "gda_xql_insert_get_type")
-  (return-type "GType")
-)
-
-(define-function gda_xql_insert_new
-  (c-name "gda_xql_insert_new")
-  (is-constructor-of "GdaXqlInsert")
-  (return-type "GdaXqlItem*")
-)
-
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-item.h
-
-(define-function gda_xql_item_get_type
-  (c-name "gda_xql_item_get_type")
-  (return-type "GType")
+(define-function gda_value_get_numeric
+  (c-name "gda_value_get_numeric")
+  (return-type "const-GdaNumeric*")
+  (parameters
+    '("const-GValue*" "value")
+  )
 )
 
-(define-method set_attrib
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_set_attrib")
+(define-function gda_value_set_numeric
+  (c-name "gda_value_set_numeric")
   (return-type "none")
   (parameters
-    '("gchar*" "attrib")
-    '("gchar*" "value")
+    '("GValue*" "value")
+    '("const-GdaNumeric*" "val")
   )
 )
 
-(define-method get_parent
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_get_parent")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_get_short
+  (c-name "gda_value_get_short")
+  (return-type "gshort")
+  (parameters
+    '("const-GValue*" "value")
+  )
 )
 
-(define-method set_parent
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_set_parent")
+(define-function gda_value_set_short
+  (c-name "gda_value_set_short")
   (return-type "none")
   (parameters
-    '("GdaXqlItem*" "parent")
+    '("GValue*" "value")
+    '("const-gshort" "val")
   )
 )
 
-(define-method get_attrib
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_get_attrib")
-  (return-type "gchar*")
+(define-function gda_value_get_ushort
+  (c-name "gda_value_get_ushort")
+  (return-type "gushort")
   (parameters
-    '("gchar*" "attrib")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method to_dom
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_to_dom")
-  (return-type "xmlNode*")
+(define-function gda_value_set_ushort
+  (c-name "gda_value_set_ushort")
+  (return-type "none")
   (parameters
-    '("xmlNode*" "parent")
+    '("GValue*" "value")
+    '("const-gushort" "val")
   )
 )
 
-(define-method add
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_add")
-  (return-type "none")
+(define-function gda_value_get_time
+  (c-name "gda_value_get_time")
+  (return-type "const-GdaTime*")
   (parameters
-    '("GdaXqlItem*" "child")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method set_tag
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_set_tag")
+(define-function gda_value_set_time
+  (c-name "gda_value_set_time")
   (return-type "none")
   (parameters
-    '("gchar*" "tag")
+    '("GValue*" "value")
+    '("const-GdaTime*" "val")
   )
 )
 
-(define-method get_tag
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_get_tag")
-  (return-type "gchar*")
+(define-function gda_value_get_timestamp
+  (c-name "gda_value_get_timestamp")
+  (return-type "const-GdaTimestamp*")
+  (parameters
+    '("const-GValue*" "value")
+  )
 )
 
-(define-method find_root
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_find_root")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_set_timestamp
+  (c-name "gda_value_set_timestamp")
+  (return-type "none")
+  (parameters
+    '("GValue*" "value")
+    '("const-GdaTimestamp*" "val")
+  )
 )
 
-(define-method find_id
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_find_id")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_set_from_string
+  (c-name "gda_value_set_from_string")
+  (return-type "gboolean")
   (parameters
-    '("gchar*" "id")
+    '("GValue*" "value")
+    '("const-gchar*" "as_string")
+    '("GType" "type")
   )
 )
 
-(define-method find_ref
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_find_ref")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_set_from_value
+  (c-name "gda_value_set_from_value")
+  (return-type "gboolean")
   (parameters
-    '("gchar*" "ref")
+    '("GValue*" "value")
+    '("const-GValue*" "from")
   )
 )
 
-(define-method add_id
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_add_id")
-  (return-type "none")
+(define-function gda_value_compare
+  (c-name "gda_value_compare")
+  (return-type "gint")
   (parameters
-    '("gchar*" "id")
+    '("const-GValue*" "value1")
+    '("const-GValue*" "value2")
   )
 )
 
-(define-method add_ref
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_add_ref")
-  (return-type "none")
+(define-function gda_value_compare_ext
+  (c-name "gda_value_compare_ext")
+  (return-type "gint")
   (parameters
-    '("gchar*" "ref")
+    '("const-GValue*" "value1")
+    '("const-GValue*" "value2")
   )
 )
 
-(define-method get_ref
-  (of-object "GdaXqlItem")
-  (c-name "gda_xql_item_get_ref")
-  (return-type "GdaXqlItem*")
+(define-function gda_value_stringify
+  (c-name "gda_value_stringify")
+  (return-type "gchar*")
   (parameters
-    '("gchar*" "ref")
+    '("const-GValue*" "value")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-join.h
-
-(define-function gda_xql_join_get_type
-  (c-name "gda_xql_join_get_type")
-  (return-type "GType")
+(define-function gda_value_to_xml
+  (c-name "gda_value_to_xml")
+  (return-type "xmlNodePtr")
+  (parameters
+    '("const-GValue*" "value")
+  )
 )
 
-(define-function gda_xql_join_new
-  (c-name "gda_xql_join_new")
-  (is-constructor-of "GdaXqlJoin")
-  (return-type "GdaXqlItem*")
+(define-method to_string
+  (of-object "GdaBinary")
+  (c-name "gda_binary_to_string")
+  (return-type "gchar*")
+  (parameters
+    '("guint" "maxlen")
+  )
 )
 
-(define-function gda_xql_join_new_with_data
-  (c-name "gda_xql_join_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_string_to_binary
+  (c-name "gda_string_to_binary")
+  (return-type "gboolean")
   (parameters
-    '("GdaXqlItem*" "target")
-    '("GdaXqlItem*" "cond")
-    '("gchar*" "type")
+    '("const-gchar*" "str")
+    '("GdaBinary*" "bin")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-list.h
-
-(define-function gda_xql_list_get_type
-  (c-name "gda_xql_list_get_type")
+(define-function gda_numeric_get_type
+  (c-name "gda_numeric_get_type")
   (return-type "GType")
 )
 
-(define-function gda_xql_list_new
-  (c-name "gda_xql_list_new")
-  (is-constructor-of "GdaXqlList")
-  (return-type "GdaXqlItem*")
+(define-function gda_numeric_copy
+  (c-name "gda_numeric_copy")
+  (return-type "gpointer")
   (parameters
-    '("gchar*" "tag")
+    '("gpointer" "boxed")
   )
 )
 
-(define-function gda_xql_list_unref_list
-  (c-name "gda_xql_list_unref_list")
+(define-function gda_numeric_free
+  (c-name "gda_numeric_free")
   (return-type "none")
   (parameters
-    '("GSList*" "list")
+    '("gpointer" "boxed")
   )
 )
 
-(define-function gda_xql_list_new_setlist
-  (c-name "gda_xql_list_new_setlist")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_list_new_sourcelist
-  (c-name "gda_xql_list_new_sourcelist")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_list_new_targetlist
-  (c-name "gda_xql_list_new_targetlist")
-  (return-type "GdaXqlItem*")
+(define-function gda_time_get_type
+  (c-name "gda_time_get_type")
+  (return-type "GType")
 )
 
-(define-function gda_xql_list_new_order
-  (c-name "gda_xql_list_new_order")
-  (return-type "GdaXqlItem*")
+(define-function gda_time_copy
+  (c-name "gda_time_copy")
+  (return-type "gpointer")
+  (parameters
+    '("gpointer" "boxed")
+  )
 )
 
-(define-function gda_xql_list_new_dest
-  (c-name "gda_xql_list_new_dest")
-  (return-type "GdaXqlItem*")
+(define-function gda_time_free
+  (c-name "gda_time_free")
+  (return-type "none")
+  (parameters
+    '("gpointer" "boxed")
+  )
 )
 
-(define-function gda_xql_list_new_arglist
-  (c-name "gda_xql_list_new_arglist")
-  (return-type "GdaXqlItem*")
+(define-function gda_timestamp_get_type
+  (c-name "gda_timestamp_get_type")
+  (return-type "GType")
 )
 
-(define-function gda_xql_list_new_valuelist
-  (c-name "gda_xql_list_new_valuelist")
-  (return-type "GdaXqlItem*")
+(define-function gda_timestamp_copy
+  (c-name "gda_timestamp_copy")
+  (return-type "gpointer")
+  (parameters
+    '("gpointer" "boxed")
+  )
 )
 
-(define-function gda_xql_list_new_joinlist
-  (c-name "gda_xql_list_new_joinlist")
-  (return-type "GdaXqlItem*")
+(define-function gda_timestamp_free
+  (c-name "gda_timestamp_free")
+  (return-type "none")
+  (parameters
+    '("gpointer" "boxed")
+  )
 )
 
-(define-function gda_xql_list_new_and
-  (c-name "gda_xql_list_new_and")
-  (return-type "GdaXqlItem*")
+(define-function gda_geometricpoint_get_type
+  (c-name "gda_geometricpoint_get_type")
+  (return-type "GType")
 )
 
-(define-function gda_xql_list_new_or
-  (c-name "gda_xql_list_new_or")
-  (return-type "GdaXqlItem*")
+(define-function gda_geometricpoint_copy
+  (c-name "gda_geometricpoint_copy")
+  (return-type "gpointer")
+  (parameters
+    '("gpointer" "boxed")
+  )
 )
 
-(define-function gda_xql_list_new_group
-  (c-name "gda_xql_list_new_group")
-  (return-type "GdaXqlItem*")
+(define-function gda_geometricpoint_free
+  (c-name "gda_geometricpoint_free")
+  (return-type "none")
+  (parameters
+    '("gpointer" "boxed")
+  )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-query.h
-
-(define-function gda_xql_query_get_type
-  (c-name "gda_xql_query_get_type")
+(define-function gda_binary_get_type
+  (c-name "gda_binary_get_type")
   (return-type "GType")
 )
 
-(define-function gda_xql_query_new
-  (c-name "gda_xql_query_new")
-  (is-constructor-of "GdaXqlQuery")
-  (return-type "GdaXqlItem*")
+(define-function gda_binary_copy
+  (c-name "gda_binary_copy")
+  (return-type "gpointer")
+  (parameters
+    '("gpointer" "boxed")
+  )
 )
 
-(define-function gda_xql_query_new_with_data
-  (c-name "gda_xql_query_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_binary_free
+  (c-name "gda_binary_free")
+  (return-type "none")
   (parameters
-    '("GdaXqlItem*" "xqlitem")
+    '("gpointer" "boxed")
   )
 )
 
+(define-function gda_value_list_get_type
+  (c-name "gda_value_list_get_type")
+  (return-type "GType")
+)
 
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-select.h
-
-(define-function gda_xql_select_get_type
-  (c-name "gda_xql_select_get_type")
+(define-function gda_short_get_type
+  (c-name "gda_short_get_type")
   (return-type "GType")
 )
 
-(define-function gda_xql_select_new
-  (c-name "gda_xql_select_new")
-  (is-constructor-of "GdaXqlSelect")
-  (return-type "GdaXqlItem*")
+(define-function gda_ushort_get_type
+  (c-name "gda_ushort_get_type")
+  (return-type "GType")
 )
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-stack.h
+;; From gda-xml-storage.h
 
-(define-function gda_xql_stack_get_type
-  (c-name "gda_xql_stack_get_type")
+(define-function gda_xml_storage_get_type
+  (c-name "gda_xml_storage_get_type")
   (return-type "GType")
 )
 
-(define-function gda_xql_stack_new
-  (c-name "gda_xql_stack_new")
-  (is-constructor-of "GdaXqlStack")
-  (return-type "GdaXqlStack*")
+(define-method get_xml_id
+  (of-object "GdaXmlStorage")
+  (c-name "gda_xml_storage_get_xml_id")
+  (return-type "gchar*")
 )
 
-(define-method push
-  (of-object "GdaXqlStack")
-  (c-name "gda_xql_stack_push")
-  (return-type "none")
+(define-method save_to_xml
+  (of-object "GdaXmlStorage")
+  (c-name "gda_xml_storage_save_to_xml")
+  (return-type "xmlNodePtr")
   (parameters
-    '("GdaXqlItem*" "item")
+    '("GError**" "error")
   )
 )
 
-(define-method pop
-  (of-object "GdaXqlStack")
-  (c-name "gda_xql_stack_pop")
-  (return-type "GdaXqlItem*")
-)
-
-(define-method empty
-  (of-object "GdaXqlStack")
-  (c-name "gda_xql_stack_empty")
+(define-method load_from_xml
+  (of-object "GdaXmlStorage")
+  (c-name "gda_xml_storage_load_from_xml")
   (return-type "gboolean")
+  (parameters
+    '("xmlNodePtr" "node")
+    '("GError**" "error")
+  )
 )
 
 
 
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-target.h
+;; From libgda.h
 
-(define-function gda_xql_target_get_type
-  (c-name "gda_xql_target_get_type")
-  (return-type "GType")
+(define-function gda_init
+  (c-name "gda_init")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "app_id")
+    '("const-gchar*" "version")
+    '("gint" "nargs")
+    '("gchar*[]" "args")
+  )
 )
 
-(define-function gda_xql_target_new
-  (c-name "gda_xql_target_new")
-  (is-constructor-of "GdaXqlTarget")
-  (return-type "GdaXqlItem*")
+(define-function gda_get_default_dict
+  (c-name "gda_get_default_dict")
+  (return-type "GdaDict*")
 )
 
-(define-function gda_xql_target_new_with_data
-  (c-name "gda_xql_target_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_main_run
+  (c-name "gda_main_run")
+  (return-type "none")
   (parameters
-    '("gchar*" "id")
-    '("gchar*" "name")
-    '("GdaXqlItem*" "join")
+    '("GdaInitFunc" "init_func")
+    '("gpointer" "user_data")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-update.h
-
-(define-function gda_xql_update_get_type
-  (c-name "gda_xql_update_get_type")
-  (return-type "GType")
-)
-
-(define-function gda_xql_update_new
-  (c-name "gda_xql_update_new")
-  (is-constructor-of "GdaXqlUpdate")
-  (return-type "GdaXqlItem*")
+(define-function gda_main_quit
+  (c-name "gda_main_quit")
+  (return-type "none")
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-utils.h
-
-(define-function gda_xql_gensym
-  (c-name "gda_xql_gensym")
-  (return-type "gchar*")
+(define-function gda_open_connection
+  (c-name "gda_open_connection")
+  (return-type "GdaConnection*")
   (parameters
-    '("gchar*" "sym")
+    '("const-gchar*" "dsn")
+    '("const-gchar*" "username")
+    '("const-gchar*" "password")
+    '("GdaConnectionOptions" "options")
+    '("GError**" "error")
   )
 )
 
-(define-function gda_xql_destroy_hash_pair
-  (c-name "gda_xql_destroy_hash_pair")
+(define-function gda_insert_row_into_table
+  (c-name "gda_insert_row_into_table")
   (return-type "gboolean")
   (parameters
-    '("gchar*" "key")
-    '("gpointer*" "value")
-    '("GFreeFunc" "func")
+    '("GdaConnection*" "cnn")
+    '("const-gchar*" "table_name")
+    '("GError**" "error")
   )
+  (varargs #t)
 )
 
-(define-function gda_xql_dom_to_xml
-  (c-name "gda_xql_dom_to_xml")
-  (return-type "gchar*")
+(define-function gda_insert_row_into_table_from_string
+  (c-name "gda_insert_row_into_table_from_string")
+  (return-type "gboolean")
   (parameters
-    '("xmlNode*" "node")
-    '("gboolean" "freedoc")
+    '("GdaConnection*" "cnn")
+    '("const-gchar*" "table_name")
+    '("GError**" "error")
   )
+  (varargs #t)
 )
 
-(define-function gda_xql_dom_to_sql
-  (c-name "gda_xql_dom_to_sql")
-  (return-type "gchar*")
+(define-function gda_update_value_in_table
+  (c-name "gda_update_value_in_table")
+  (return-type "gboolean")
   (parameters
-    '("xmlNode*" "node")
-    '("gboolean" "freedoc")
+    '("GdaConnection*" "cnn")
+    '("const-gchar*" "table_name")
+    '("const-gchar*" "search_for_column")
+    '("const-GValue*" "condition")
+    '("const-gchar*" "column_name")
+    '("const-GValue*" "new_value")
+    '("GError**" "error")
   )
 )
 
-(define-function gda_xql_new_node
-  (c-name "gda_xql_new_node")
-  (return-type "xmlNode*")
+(define-function gda_update_values_in_table
+  (c-name "gda_update_values_in_table")
+  (return-type "gboolean")
   (parameters
-    '("gchar*" "tag")
-    '("xmlNode*" "parNode")
+    '("GdaConnection*" "cnn")
+    '("const-gchar*" "table_name")
+    '("const-gchar*" "condition_column_name")
+    '("const-GValue*" "condition")
+    '("GError**" "error")
   )
+  (varargs #t)
 )
 
-(define-function gda_xql_new_attr
-  (c-name "gda_xql_new_attr")
-  (return-type "none")
+(define-function gda_delete_row_from_table
+  (c-name "gda_delete_row_from_table")
+  (return-type "gboolean")
   (parameters
-    '("gchar*" "key")
-    '("gchar*" "value")
-    '("xmlNode*" "node")
+    '("GdaConnection*" "cnn")
+    '("const-gchar*" "table_name")
+    '("const-gchar*" "condition_column_name")
+    '("const-GValue*" "condition")
+    '("GError**" "error")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-value.h
-
-(define-function gda_xql_value_get_type
-  (c-name "gda_xql_value_get_type")
-  (return-type "GType")
-)
-
-(define-function gda_xql_value_new
-  (c-name "gda_xql_value_new")
-  (is-constructor-of "GdaXqlValue")
-  (return-type "GdaXqlItem*")
-)
-
-(define-function gda_xql_value_new_with_data
-  (c-name "gda_xql_value_new_with_data")
-  (return-type "GdaXqlItem*")
+(define-function gda_execute_select_command
+  (c-name "gda_execute_select_command")
+  (return-type "GdaDataModel*")
   (parameters
-    '("gchar*" "id")
+    '("GdaConnection*" "cnn")
+    '("const-gchar*" "sql")
+    '("GError**" "error")
   )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/gda-xql-valueref.h
-
-(define-function gda_xql_valueref_get_type
-  (c-name "gda_xql_valueref_get_type")
-  (return-type "GType")
-)
-
-(define-function gda_xql_valueref_new
-  (c-name "gda_xql_valueref_new")
-  (is-constructor-of "GdaXqlValueref")
-  (return-type "GdaXqlItem*")
+(define-function gda_execute_sql_command
+  (c-name "gda_execute_sql_command")
+  (return-type "gint")
+  (parameters
+    '("GdaConnection*" "cnn")
+    '("const-gchar*" "sql")
+    '("GError**" "error")
+  )
 )
 
-
-
-;; From /opt/gnome212/include/libgda-1.2/libgda/libgda.h
-
-(define-function gda_init
-  (c-name "gda_init")
-  (return-type "none")
+(define-function gda_create_table
+  (c-name "gda_create_table")
+  (return-type "gboolean")
   (parameters
-    '("const-gchar*" "app_id")
-    '("const-gchar*" "version")
-    '("gint" "nargs")
-    '("gchar*[]" "args")
+    '("GdaConnection*" "cnn")
+    '("const-gchar*" "table_name")
+    '("GError**" "error")
   )
+  (varargs #t)
 )
 
-(define-function gda_main_run
-  (c-name "gda_main_run")
-  (return-type "none")
+(define-function gda_drop_table
+  (c-name "gda_drop_table")
+  (return-type "gboolean")
   (parameters
-    '("GdaInitFunc" "init_func")
-    '("gpointer" "user_data")
+    '("GdaConnection*" "cnn")
+    '("const-gchar*" "table_name")
+    '("GError**" "error")
   )
 )
 
-(define-function gda_main_quit
-  (c-name "gda_main_quit")
-  (return-type "none")
-)
+
+
 
 
Index: gda/gda.override
===================================================================
RCS file: /cvs/gnome/gnome-python-extras/gda/gda.override,v
retrieving revision 1.9
diff -u -p -r1.9 gda.override
--- gda/gda.override	14 Jan 2006 14:40:15 -0000	1.9
+++ gda/gda.override	6 Nov 2006 23:40:31 -0000
@@ -3,34 +3,13 @@ headers
 #include <Python.h>
 #include <pygobject.h>
 #include <libgda/gda-server-provider.h>
-#include <libgda/gda-xql-column.h>
-#include <libgda/gda-xql-const.h>
-#include <libgda/gda-xql-delete.h>
-#include <libgda/gda-xql-dml.h>
-#include <libgda/gda-xql-dual.h>
-#include <libgda/gda-xql-field.h>
-#include <libgda/gda-xql-func.h>
-#include <libgda/gda-xql-insert.h>
-#include <libgda/gda-xql-join.h>
-#include <libgda/gda-xql-list.h>
-#include <libgda/gda-xql-query.h>
-#include <libgda/gda-xql-list.h>
-#include <libgda/gda-xql-query.h>
-#include <libgda/gda-xql-select.h>
-#include <libgda/gda-xql-stack.h>
-#include <libgda/gda-xql-stack.h>
-#include <libgda/gda-xql-target.h>
-#include <libgda/gda-xql-update.h>
-#include <libgda/gda-xql-utils.h>
-#include <libgda/gda-xql-value.h>
-#include <libgda/gda-xql-valueref.h>
 #include <libgda/libgda.h>
+#include <libgda/gda-data-model-extra.h>
+#include <libgda/gda-server-provider-extra.h>
+#include <libgda/gda-enum-types.h>
 #include "gdaglue.h"
 #include "pygdavalue_conversions.h"
 
-//TODO: Fix this in libgda itself:
-#define GDA_TYPE_XQL_VALUE_REF GDA_TYPE_XQL_VALUEREF
-
 %%
 modulename gda
 %%
@@ -46,15 +25,6 @@ ignore
   gda_config_get_boolean
   gda_init
 %%
-ignore-glob
-  gda_xql_*
-%%
-ignore-glob
-  GdaXql*
-%%
-ignore-glob
-  Xql*
-%%
 override gda_config_get_data_source_list kwargs
 static PyObject*
 _wrap_gda_config_get_data_source_list (PyObject* self) {
@@ -218,8 +188,12 @@ _wrap_gda_connection_execute_command (Py
 		return Py_None;
 	}
 
+        GError* error = NULL;
 	GList *tmp, *list = gda_connection_execute_command (GDA_CONNECTION (self->obj),
-	      GDA_COMMAND (cmd->obj), GDA_PARAMETER_LIST (params->obj));
+	      GDA_COMMAND (cmd->obj), GDA_PARAMETER_LIST (params->obj), &error);
+
+        if (pyg_error_check(&error))
+          return Py_None;
 
 	for (tmp = list; tmp != NULL; tmp = tmp->next) {
 		PyObject* obj = pygobject_new (G_OBJECT (tmp->data));
@@ -228,6 +202,7 @@ _wrap_gda_connection_execute_command (Py
 	}
 
 	g_list_free (list);
+
 	return plist;
 }
 %%
@@ -333,6 +308,8 @@ ignore
   gda_value_get_tinyint
   gda_value_get_tinyuint
   gda_value_get_uinteger
+  gda_dict_dump
+  gda_object_dump
 %%
 define GdaValue.get
 static PyObject*
Index: gda/gdaglue.h
===================================================================
RCS file: /cvs/gnome/gnome-python-extras/gda/gdaglue.h,v
retrieving revision 1.1
diff -u -p -r1.1 gdaglue.h
--- gda/gdaglue.h	4 Apr 2005 09:46:22 -0000	1.1
+++ gda/gdaglue.h	6 Nov 2006 23:40:31 -0000
@@ -2,8 +2,10 @@
 #define __GDAGLUE_H
 
 #define GDA_COMMAND(x)        ((GdaCommand*) x)
+/*
 #define GDA_PARAMETER(x)      ((GdaParameter*) x)
 #define GDA_PARAMETER_LIST(x) ((GdaParameterList*) x)
 #define GDA_PROVIDER_INFO(x)  ((GdaProviderInfo*) x)
+*/
 
 #endif
Index: gda/pygdavalue_conversions.c
===================================================================
RCS file: /cvs/gnome/gnome-python-extras/gda/pygdavalue_conversions.c,v
retrieving revision 1.6
diff -u -p -r1.6 pygdavalue_conversions.c
--- gda/pygdavalue_conversions.c	14 Jan 2006 14:40:15 -0000	1.6
+++ gda/pygdavalue_conversions.c	6 Nov 2006 23:40:31 -0000
@@ -7,33 +7,33 @@
 
 /**
  * pygda_value_from_pyobject:
- * @value: the GdaValue object to store the converted value in.
+ * @value: the GValue object to store the converted value in.
  * @obj: the Python object to convert.
  *
  * This function converts a Python object and stores the result in a
- * GdaValue. If the Python object can't be converted to the
- * type of the GdaValue, then an error is returned.
+ * GValue. If the Python object can't be converted to the
+ * type of the GValue, then an error is returned.
  *
  * Returns: 0 on success, -1 on error.
  */
 int
-pygda_value_from_pyobject(GdaValue *boxed, PyObject *input)
+pygda_value_from_pyobject(GValue *boxed, PyObject *input)
 {
     /* Use an appropriate gda_value_set_*() function.
-       We can not know what GdaValue type is actually wanted, so
+       We can not know what GValue type is actually wanted, so
        we must still have the get_*() functions in the python API.
      */
     if (PyString_Check (input)) {
       const char* text = PyString_AsString (input);
-      gda_value_set_string (boxed, text);
+      g_value_set_string (boxed, text);
     } else if (PyInt_Check (input)) {
-      gda_value_set_integer (boxed, PyInt_AsLong (input));
+      g_value_set_int (boxed, PyInt_AsLong (input));
     } else if (PyLong_Check (input)) {
-      gda_value_set_integer (boxed, PyInt_AsLong (input));
+      g_value_set_int (boxed, PyInt_AsLong (input));
     } else if (PyFloat_Check (input)) {
-      gda_value_set_double (boxed, PyFloat_AsDouble (input));
+      g_value_set_double (boxed, PyFloat_AsDouble (input));
     } else if (PyBool_Check (input)) {
-      gda_value_set_boolean (boxed, (input == Py_True));
+      g_value_set_boolean (boxed, (input == Py_True));
 #if PY_VERSION_HEX >= 0x02040000
     } else if (PyDateTime_Check (input)) {
          GdaTimestamp gda;
@@ -46,11 +46,11 @@ pygda_value_from_pyobject(GdaValue *boxe
          gda.timezone = 0;
          gda_value_set_timestamp (boxed, &gda);
      } else if (PyDate_Check (input)) {
-         GdaDate gda;
+         GDate gda;
          gda.year = PyDateTime_GET_YEAR(input);
          gda.month = PyDateTime_GET_MONTH(input);
          gda.day = PyDateTime_GET_DAY(input);
-         gda_value_set_date(boxed, &gda);
+         g_value_set_boxed(boxed, &gda);
      } else if (PyTime_Check (input)) {
          GdaTime gda;
          gda.hour = PyDateTime_TIME_GET_HOUR(input);
@@ -69,86 +69,82 @@ pygda_value_from_pyobject(GdaValue *boxe
 
 /**
  * pygda_value_as_pyobject:
- * @value: the GdaValue object.
+ * @value: the GValue object.
  * @copy_boxed: true if boxed values should be copied.
  *
  * This function creates/returns a Python wrapper object that
- * represents the GdaValue passed as an argument.
+ * represents the GValue passed as an argument.
  *
  * Returns: a PyObject representing the value.
  */
 PyObject *
-pygda_value_as_pyobject(const GdaValue *boxed, gboolean copy_boxed)
+pygda_value_as_pyobject(const GValue *boxed, gboolean copy_boxed)
 {
-    GdaValueType value_type = GDA_VALUE_TYPE_UNKNOWN;
+    GType value_type = GDA_TYPE_NULL;
     PyObject* ret = 0;
 
-    value_type = gda_value_get_type ((GdaValue*)boxed);
+    value_type = G_VALUE_TYPE ((GValue*)boxed);
 
 #if PY_VERSION_HEX >= 0x02040000
     PyDateTime_IMPORT; /* So we can use PyDate*() functions. */
 #endif
 
-    if (value_type == GDA_VALUE_TYPE_NULL) {
+    if (value_type == GDA_TYPE_NULL) {
       Py_INCREF (Py_None);
       ret = Py_None;
-    } else if (value_type == GDA_VALUE_TYPE_BIGINT) {
-        ret = PyLong_FromLong (gda_value_get_bigint ((GdaValue*)boxed));
-    } else if (value_type == GDA_VALUE_TYPE_BIGUINT) {
-        ret = PyLong_FromLong (gda_value_get_biguint ((GdaValue*)boxed));
-    } else if (value_type == GDA_VALUE_TYPE_BINARY) {
-        glong size = 0;
-        const gchar* val = (const gchar*)gda_value_get_binary ((GdaValue*)boxed, &size);
-        ret = PyString_FromString (val); //TODO: Use the size.
-    } else if (value_type == GDA_VALUE_TYPE_BLOB) {
-        /* const GdaBlob* val = gda_value_get_blob ((GdaValue*)boxed); */
+    } else if (value_type == G_TYPE_INT64) {
+        ret = PyLong_FromLong (g_value_get_int64 ((GValue*)boxed));
+    } else if (value_type == G_TYPE_UINT64) {
+        ret = PyLong_FromLong (g_value_get_uint64 ((GValue*)boxed));
+    } else if (value_type == GDA_TYPE_BINARY) {
+        const GdaBinary* gdabinary = gda_value_get_binary((GValue*)boxed);
+        ret = PyString_FromString ((const char*)gdabinary->data); //TODO: Use the size. TODO: Check for null GdaBinary.
+    } else if (value_type == GDA_TYPE_BLOB) {
+        /* const GdaBlob* val = gda_value_get_blob ((GValue*)boxed); */
         ret = 0; /* TODO: This thing has a whole read/write API. */
-    } else if (value_type == GDA_VALUE_TYPE_BOOLEAN) {
-        ret = PyBool_FromLong (gda_value_get_boolean ((GdaValue*)boxed));
+    } else if (value_type == G_TYPE_BOOLEAN) {
+        ret = PyBool_FromLong (g_value_get_boolean ((GValue*)boxed));
 #if PY_VERSION_HEX >= 0x02040000
-    } else if (value_type == GDA_VALUE_TYPE_DATE) {
-        const GdaDate* val = gda_value_get_date ((GdaValue*)boxed);
+    } else if (value_type == G_TYPE_DATE) {
+        const GDate* val = (const GDate*)g_value_get_boxed ((GValue*)boxed);
         if(val)
           ret = PyDate_FromDate(val->year, val->month, val->day);
 #endif
-    } else if (value_type == GDA_VALUE_TYPE_DOUBLE) {
-        ret = PyFloat_FromDouble (gda_value_get_double ((GdaValue*)boxed));
-    } else if (value_type == GDA_VALUE_TYPE_GEOMETRIC_POINT) {
-        const GdaGeometricPoint* val = gda_value_get_geometric_point ((GdaValue*)boxed);
+    } else if (value_type == G_TYPE_DOUBLE) {
+        ret = PyFloat_FromDouble (g_value_get_double ((GValue*)boxed));
+    } else if (value_type == GDA_TYPE_GEOMETRIC_POINT) {
+        const GdaGeometricPoint* val = gda_value_get_geometric_point ((GValue*)boxed);
         ret = Py_BuildValue ("(ii)", val->x, val->y);
-    } else if (value_type == GDA_VALUE_TYPE_INTEGER) {
-        ret = PyInt_FromLong (gda_value_get_integer ((GdaValue*)boxed));
-    } else if (value_type == GDA_VALUE_TYPE_MONEY) {
-        const GdaMoney* val = gda_value_get_money ((GdaValue*)boxed);
-        ret = PyFloat_FromDouble(val->amount); /* TODO: We ignore the currency. */
-    } else if (value_type == GDA_VALUE_TYPE_NUMERIC) {
-        const GdaNumeric* val = gda_value_get_numeric ((GdaValue*)boxed);
+    } else if (value_type == G_TYPE_INT) {
+        ret = PyInt_FromLong (g_value_get_int ((GValue*)boxed));
+    } else if (value_type == GDA_TYPE_NUMERIC) {
+        const GdaNumeric* val = gda_value_get_numeric ((GValue*)boxed);
         const gchar* number_as_text = val->number; /* Formatted according to the C locale, probably. */
         /* This would need a string _object_: ret = PyFloat_FromString(number_as_text, 0); */
         ret = PyFloat_FromDouble (g_ascii_strtod (number_as_text, NULL));
-    } else if (value_type == GDA_VALUE_TYPE_SINGLE) {
-        ret = PyFloat_FromDouble (gda_value_get_single ((GdaValue*)boxed));
-    } else if (value_type == GDA_VALUE_TYPE_SMALLINT) {
-        ret = PyInt_FromLong (gda_value_get_smallint ((GdaValue*)boxed));
-    } else if (value_type == GDA_VALUE_TYPE_STRING) {
-        const gchar* val = gda_value_get_string ((GdaValue*)boxed);
+    } else if (value_type == G_TYPE_FLOAT) {
+        ret = PyFloat_FromDouble (g_value_get_float ((GValue*)boxed));
+    } else if (value_type == GDA_TYPE_SHORT) {
+        ret = PyInt_FromLong (gda_value_get_short ((GValue*)boxed));
+    } else if (value_type == G_TYPE_STRING) {
+        const gchar* val = g_value_get_string ((GValue*)boxed);
         ret = PyString_FromString (val);
-    } else if (value_type == GDA_VALUE_TYPE_TIME) {
+    } else if (value_type == GDA_TYPE_TIME) {
 #if PY_VERSION_HEX >= 0x02040000
-        const GdaTime* val = gda_value_get_time ((GdaValue*)boxed);
-        ret = PyTime_FromTime(val->hour, val->minute, val->second, 0); /* TODO: Should we ignore GdaDate::timezone ? */
-    } else if (value_type == GDA_VALUE_TYPE_TIMESTAMP) {
-        const GdaTimestamp* val = gda_value_get_timestamp ((GdaValue*)boxed);
+        const GdaTime* val = gda_value_get_time ((GValue*)boxed);
+        ret = PyTime_FromTime(val->hour, val->minute, val->second, 0); /* TODO: Should we ignore GDate::timezone ? */
+    } else if (value_type == GDA_TYPE_TIMESTAMP) {
+        const GdaTimestamp* val = gda_value_get_timestamp ((GValue*)boxed);
         ret = PyDateTime_FromDateAndTime(val->year, val->month, val->day, val->hour, val->minute, val->second, 0); /* TODO: Should we ignore GdaTimestamp::timezone ? */
 #endif
-    } else if (value_type == GDA_VALUE_TYPE_TINYINT) {
-        ret = PyInt_FromLong (gda_value_get_tinyint ((GdaValue*)boxed));
-    } else if (value_type == GDA_VALUE_TYPE_TINYUINT) {
-        ret = PyInt_FromLong (gda_value_get_tinyuint ((GdaValue*)boxed));
-    } else if (value_type == GDA_VALUE_TYPE_UINTEGER) {
-        ret = PyInt_FromLong (gda_value_get_uinteger ((GdaValue*)boxed));
+    } else if (value_type == GDA_TYPE_SHORT) {
+        ret = PyInt_FromLong (gda_value_get_short ((GValue*)boxed));
+    } else if (value_type == GDA_TYPE_USHORT) {
+        ret = PyInt_FromLong (gda_value_get_ushort ((GValue*)boxed));
+    } else if (value_type == G_TYPE_UINT) {
+        ret = PyInt_FromLong (gda_value_get_uint ((GValue*)boxed));
     } else {
-      g_warning ("gda_value_get_type() returned unknown type %d", value_type);
+      g_warning ("G_VALUE_TYPE() returned unknown type %d", value_type);
 
       Py_INCREF (Py_None);
       ret = Py_None;
Index: gda/pygdavalue_conversions.h
===================================================================
RCS file: /cvs/gnome/gnome-python-extras/gda/pygdavalue_conversions.h,v
retrieving revision 1.2
diff -u -p -r1.2 pygdavalue_conversions.h
--- gda/pygdavalue_conversions.h	16 Apr 2005 12:23:26 -0000	1.2
+++ gda/pygdavalue_conversions.h	6 Nov 2006 23:40:31 -0000
@@ -7,10 +7,10 @@
 G_BEGIN_DECLS
 
 int
-pygda_value_from_pyobject(GdaValue *boxed, PyObject *input);
+pygda_value_from_pyobject(GValue *boxed, PyObject *input);
 
 PyObject *
-pygda_value_as_pyobject(const GdaValue *value, gboolean copy_boxed);
+pygda_value_as_pyobject(const GValue *value, gboolean copy_boxed);
 
 G_END_DECLS
 
