xref: /dports/databases/libgdamm5/libgdamm-4.99.11/libgda/src/libgda_methods.defs

;; -*- scheme -*-
; object definitions ...
(define-object Batch
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaBatch")
  (gtype-id "GDA_TYPE_BATCH")
)

(define-object BlobOp
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaBlobOp")
  (gtype-id "GDA_TYPE_BLOB_OP")
)

(define-object Column
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaColumn")
  (gtype-id "GDA_TYPE_COLUMN")
)

(define-object Config
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaConfig")
  (gtype-id "GDA_TYPE_CONFIG")
)

(define-object Connection
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaConnection")
  (gtype-id "GDA_TYPE_CONNECTION")
)

(define-object ConnectionEvent
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaConnectionEvent")
  (gtype-id "GDA_TYPE_CONNECTION_EVENT")
)

(define-object DataAccessWrapper
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataAccessWrapper")
  (gtype-id "GDA_TYPE_DATA_ACCESS_WRAPPER")
)

(define-object DataComparator
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataComparator")
  (gtype-id "GDA_TYPE_DATA_COMPARATOR")
)

(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
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataModelArray")
  (gtype-id "GDA_TYPE_DATA_MODEL_ARRAY")
)

(define-object DataModelBdb
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataModelBdb")
  (gtype-id "GDA_TYPE_DATA_MODEL_BDB")
)

(define-object DataModelDir
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataModelDir")
  (gtype-id "GDA_TYPE_DATA_MODEL_DIR")
)

(define-object DataModelImport
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataModelImport")
  (gtype-id "GDA_TYPE_DATA_MODEL_IMPORT")
)

(define-object DataModelLdap
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataModelLdap")
  (gtype-id "GDA_TYPE_DATA_MODEL_LDAP")
)

(define-object DataPivot
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataPivot")
  (gtype-id "GDA_TYPE_DATA_PIVOT")
)

(define-object DataProxy
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataProxy")
  (gtype-id "GDA_TYPE_DATA_PROXY")
)

(define-object DataSelect
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDataSelect")
  (gtype-id "GDA_TYPE_DATA_SELECT")
)

(define-object Holder
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaHolder")
  (gtype-id "GDA_TYPE_HOLDER")
)

(define-object Lockable
  (in-module "Gda")
  (c-name "GdaLockable")
  (gtype-id "GDA_TYPE_LOCKABLE")
)

(define-object MetaStore
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaMetaStore")
  (gtype-id "GDA_TYPE_META_STORE")
)

(define-object MetaStruct
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaMetaStruct")
  (gtype-id "GDA_TYPE_META_STRUCT")
)

(define-object RepetitiveStatement
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaRepetitiveStatement")
  (gtype-id "GDA_TYPE_REPETITIVE_STATEMENT")
)

(define-object ReportDocument
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaReportDocument")
  (gtype-id "GDA_TYPE_REPORT_DOCUMENT")
)

(define-object ReportDocbookDocument
  (in-module "Gda")
  (parent "GdaReportDocument")
  (c-name "GdaReportDocbookDocument")
  (gtype-id "GDA_TYPE_REPORT_DOCBOOK_DOCUMENT")
)

(define-object ReportEngine
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaReportEngine")
  (gtype-id "GDA_TYPE_REPORT_ENGINE")
)

(define-object ReportRmlDocument
  (in-module "Gda")
  (parent "GdaReportDocument")
  (c-name "GdaReportRmlDocument")
  (gtype-id "GDA_TYPE_REPORT_RML_DOCUMENT")
)

(define-object Row
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaRow")
  (gtype-id "GDA_TYPE_ROW")
)

(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 Set
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaSet")
  (gtype-id "GDA_TYPE_SET")
)

(define-object DataModelIter
  (in-module "Gda")
  (parent "GdaSet")
  (c-name "GdaDataModelIter")
  (gtype-id "GDA_TYPE_DATA_MODEL_ITER")
)

(define-object SqlBuilder
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaSqlBuilder")
  (gtype-id "GDA_TYPE_SQL_BUILDER")
)

(define-object SqlParser
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaSqlParser")
  (gtype-id "GDA_TYPE_SQL_PARSER")
)

(define-object Statement
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaStatement")
  (gtype-id "GDA_TYPE_STATEMENT")
)

(define-object TransactionStatus
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaTransactionStatus")
  (gtype-id "GDA_TYPE_TRANSACTION_STATUS")
)

(define-object Tree
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaTree")
  (gtype-id "GDA_TYPE_TREE")
)

(define-object TreeManager
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaTreeManager")
  (gtype-id "GDA_TYPE_TREE_MANAGER")
)

(define-object TreeMgrColumns
  (in-module "Gda")
  (parent "GdaTreeManager")
  (c-name "GdaTreeMgrColumns")
  (gtype-id "GDA_TYPE_TREE_MGR_COLUMNS")
)

(define-object TreeMgrLabel
  (in-module "Gda")
  (parent "GdaTreeManager")
  (c-name "GdaTreeMgrLabel")
  (gtype-id "GDA_TYPE_TREE_MGR_LABEL")
)

(define-object TreeMgrLdap
  (in-module "Gda")
  (parent "GdaTreeManager")
  (c-name "GdaTreeMgrLdap")
  (gtype-id "GDA_TYPE_TREE_MGR_LDAP")
)

(define-object TreeMgrSchemas
  (in-module "Gda")
  (parent "GdaTreeManager")
  (c-name "GdaTreeMgrSchemas")
  (gtype-id "GDA_TYPE_TREE_MGR_SCHEMAS")
)

(define-object TreeMgrSelect
  (in-module "Gda")
  (parent "GdaTreeManager")
  (c-name "GdaTreeMgrSelect")
  (gtype-id "GDA_TYPE_TREE_MGR_SELECT")
)

(define-object TreeMgrTables
  (in-module "Gda")
  (parent "GdaTreeManager")
  (c-name "GdaTreeMgrTables")
  (gtype-id "GDA_TYPE_TREE_MGR_TABLES")
)

(define-object TreeNode
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaTreeNode")
  (gtype-id "GDA_TYPE_TREE_NODE")
)

(define-object XaTransaction
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaXaTransaction")
  (gtype-id "GDA_TYPE_XA_TRANSACTION")
)

;; Enumerations and flags ...

(define-enum BatchError
  (in-module "Gda")
  (c-name "GdaBatchError")
  (gtype-id "GDA_TYPE_BATCH_ERROR")
  (values
    '("error" "GDA_BATCH_CONFLICTING_PARAMETER_ERROR")
  )
)

(define-enum PrefixDir
  (in-module "Gda")
  (c-name "GdaPrefixDir")
  (gtype-id "GDA_TYPE_PREFIX_DIR")
  (values
    '("no-dir" "GDA_NO_DIR")
    '("bin-dir" "GDA_BIN_DIR")
    '("sbin-dir" "GDA_SBIN_DIR")
    '("data-dir" "GDA_DATA_DIR")
    '("locale-dir" "GDA_LOCALE_DIR")
    '("lib-dir" "GDA_LIB_DIR")
    '("libexec-dir" "GDA_LIBEXEC_DIR")
    '("etc-dir" "GDA_ETC_DIR")
  )
)

(define-enum ConfigError
  (in-module "Gda")
  (c-name "GdaConfigError")
  (gtype-id "GDA_TYPE_CONFIG_ERROR")
  (values
    '("dsn-not-found-error" "GDA_CONFIG_DSN_NOT_FOUND_ERROR")
    '("permission-error" "GDA_CONFIG_PERMISSION_ERROR")
    '("provider-not-found-error" "GDA_CONFIG_PROVIDER_NOT_FOUND_ERROR")
    '("provider-creation-error" "GDA_CONFIG_PROVIDER_CREATION_ERROR")
  )
)

(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")
    '("command" "GDA_CONNECTION_EVENT_COMMAND")
  )
)

(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
    '("dsn-not-found-error" "GDA_CONNECTION_DSN_NOT_FOUND_ERROR")
    '("provider-not-found-error" "GDA_CONNECTION_PROVIDER_NOT_FOUND_ERROR")
    '("provider-error" "GDA_CONNECTION_PROVIDER_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")
    '("statement-type-error" "GDA_CONNECTION_STATEMENT_TYPE_ERROR")
    '("cant-lock-error" "GDA_CONNECTION_CANT_LOCK_ERROR")
    '("task-not-found-error" "GDA_CONNECTION_TASK_NOT_FOUND_ERROR")
    '("unsupported-threads-error" "GDA_CONNECTION_UNSUPPORTED_THREADS_ERROR")
    '("closed-error" "GDA_CONNECTION_CLOSED_ERROR")
    '("meta-data-context-error" "GDA_CONNECTION_META_DATA_CONTEXT_ERROR")
  )
)

(define-flags ConnectionOptions
  (in-module "Gda")
  (c-name "GdaConnectionOptions")
  (gtype-id "GDA_TYPE_CONNECTION_OPTIONS")
  (values
    '("none" "GDA_CONNECTION_OPTIONS_NONE")
    '("read-only" "GDA_CONNECTION_OPTIONS_READ_ONLY")
    '("sql-identifiers-case-sensitive" "GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS_CASE_SENSITIVE")
    '("thread-safe" "GDA_CONNECTION_OPTIONS_THREAD_SAFE")
    '("thread-isolated" "GDA_CONNECTION_OPTIONS_THREAD_ISOLATED")
    '("auto-meta-data" "GDA_CONNECTION_OPTIONS_AUTO_META_DATA")
  )
)

(define-enum ConnectionFeature
  (in-module "Gda")
  (c-name "GdaConnectionFeature")
  (gtype-id "GDA_TYPE_CONNECTION_FEATURE")
  (values
    '("aggregates" "GDA_CONNECTION_FEATURE_AGGREGATES")
    '("blobs" "GDA_CONNECTION_FEATURE_BLOBS")
    '("indexes" "GDA_CONNECTION_FEATURE_INDEXES")
    '("inheritance" "GDA_CONNECTION_FEATURE_INHERITANCE")
    '("namespaces" "GDA_CONNECTION_FEATURE_NAMESPACES")
    '("procedures" "GDA_CONNECTION_FEATURE_PROCEDURES")
    '("sequences" "GDA_CONNECTION_FEATURE_SEQUENCES")
    '("sql" "GDA_CONNECTION_FEATURE_SQL")
    '("transactions" "GDA_CONNECTION_FEATURE_TRANSACTIONS")
    '("savepoints" "GDA_CONNECTION_FEATURE_SAVEPOINTS")
    '("savepoints-remove" "GDA_CONNECTION_FEATURE_SAVEPOINTS_REMOVE")
    '("triggers" "GDA_CONNECTION_FEATURE_TRIGGERS")
    '("updatable-cursor" "GDA_CONNECTION_FEATURE_UPDATABLE_CURSOR")
    '("users" "GDA_CONNECTION_FEATURE_USERS")
    '("views" "GDA_CONNECTION_FEATURE_VIEWS")
    '("xa-transactions" "GDA_CONNECTION_FEATURE_XA_TRANSACTIONS")
    '("multi-threading" "GDA_CONNECTION_FEATURE_MULTI_THREADING")
    '("last" "GDA_CONNECTION_FEATURE_LAST")
  )
)

(define-enum ConnectionMetaType
  (in-module "Gda")
  (c-name "GdaConnectionMetaType")
  (gtype-id "GDA_TYPE_CONNECTION_META_TYPE")
  (values
    '("namespaces" "GDA_CONNECTION_META_NAMESPACES")
    '("types" "GDA_CONNECTION_META_TYPES")
    '("tables" "GDA_CONNECTION_META_TABLES")
    '("views" "GDA_CONNECTION_META_VIEWS")
    '("fields" "GDA_CONNECTION_META_FIELDS")
    '("indexes" "GDA_CONNECTION_META_INDEXES")
  )
)

(define-enum DataComparatorError
  (in-module "Gda")
  (c-name "GdaDataComparatorError")
  (gtype-id "GDA_TYPE_DATA_COMPARATOR_ERROR")
  (values
    '("missing-data-model-error" "GDA_DATA_COMPARATOR_MISSING_DATA_MODEL_ERROR")
    '("column-types-mismatch-error" "GDA_DATA_COMPARATOR_COLUMN_TYPES_MISMATCH_ERROR")
    '("model-access-error" "GDA_DATA_COMPARATOR_MODEL_ACCESS_ERROR")
    '("user-cancelled-error" "GDA_DATA_COMPARATOR_USER_CANCELLED_ERROR")
  )
)

(define-enum DiffType
  (in-module "Gda")
  (c-name "GdaDiffType")
  (gtype-id "GDA_TYPE_DIFF_TYPE")
  (values
    '("add-row" "GDA_DIFF_ADD_ROW")
    '("remove-row" "GDA_DIFF_REMOVE_ROW")
    '("modify-row" "GDA_DIFF_MODIFY_ROW")
  )
)

(define-flags DataModelAccessFlags
  (in-module "Gda")
  (c-name "GdaDataModelAccessFlags")
  (gtype-id "GDA_TYPE_DATA_MODEL_ACCESS_FLAGS")
  (values
    '("random" "GDA_DATA_MODEL_ACCESS_RANDOM")
    '("cursor-forward" "GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD")
    '("cursor-backward" "GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD")
    '("cursor" "GDA_DATA_MODEL_ACCESS_CURSOR")
    '("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 DataModelHint
  (in-module "Gda")
  (c-name "GdaDataModelHint")
  (gtype-id "GDA_TYPE_DATA_MODEL_HINT")
  (values
    '("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")
  )
)

(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-enum DataModelError
  (in-module "Gda")
  (c-name "GdaDataModelError")
  (gtype-id "GDA_TYPE_DATA_MODEL_ERROR")
  (values
    '("row-out-of-range-error" "GDA_DATA_MODEL_ROW_OUT_OF_RANGE_ERROR")
    '("column-out-of-range-error" "GDA_DATA_MODEL_COLUMN_OUT_OF_RANGE_ERROR")
    '("values-list-error" "GDA_DATA_MODEL_VALUES_LIST_ERROR")
    '("value-type-error" "GDA_DATA_MODEL_VALUE_TYPE_ERROR")
    '("row-not-found-error" "GDA_DATA_MODEL_ROW_NOT_FOUND_ERROR")
    '("access-error" "GDA_DATA_MODEL_ACCESS_ERROR")
    '("feature-non-supported-error" "GDA_DATA_MODEL_FEATURE_NON_SUPPORTED_ERROR")
    '("file-exist-error" "GDA_DATA_MODEL_FILE_EXIST_ERROR")
    '("xml-format-error" "GDA_DATA_MODEL_XML_FORMAT_ERROR")
    '("truncated-error" "GDA_DATA_MODEL_TRUNCATED_ERROR")
    '("other-error" "GDA_DATA_MODEL_OTHER_ERROR")
  )
)

(define-enum DataModelIterError
  (in-module "Gda")
  (c-name "GdaDataModelIterError")
  (gtype-id "GDA_TYPE_DATA_MODEL_ITER_ERROR")
  (values
    '("error" "GDA_DATA_MODEL_ITER_COLUMN_OUT_OF_RANGE_ERROR")
  )
)

(define-enum LdapSearchScope
  (in-module "Gda")
  (c-name "GdaLdapSearchScope")
  (gtype-id "GDA_TYPE_LDAP_SEARCH_SCOPE")
  (values
    '("base" "GDA_LDAP_SEARCH_BASE")
    '("onelevel" "GDA_LDAP_SEARCH_ONELEVEL")
    '("subtree" "GDA_LDAP_SEARCH_SUBTREE")
  )
)

(define-enum DataPivotError
  (in-module "Gda")
  (c-name "GdaDataPivotError")
  (gtype-id "GDA_TYPE_DATA_PIVOT_ERROR")
  (values
    '("internal-error" "GDA_DATA_PIVOT_INTERNAL_ERROR")
    '("source-model-error" "GDA_DATA_PIVOT_SOURCE_MODEL_ERROR")
    '("field-format-error" "GDA_DATA_PIVOT_FIELD_FORMAT_ERROR")
    '("usage-error" "GDA_DATA_PIVOT_USAGE_ERROR")
    '("overflow-error" "GDA_DATA_PIVOT_OVERFLOW_ERROR")
  )
)

(define-enum DataPivotAggregate
  (in-module "Gda")
  (c-name "GdaDataPivotAggregate")
  (gtype-id "GDA_TYPE_DATA_PIVOT_AGGREGATE")
  (values
    '("avg" "GDA_DATA_PIVOT_AVG")
    '("count" "GDA_DATA_PIVOT_COUNT")
    '("max" "GDA_DATA_PIVOT_MAX")
    '("min" "GDA_DATA_PIVOT_MIN")
    '("sum" "GDA_DATA_PIVOT_SUM")
  )
)

(define-enum DataPivotFieldType
  (in-module "Gda")
  (c-name "GdaDataPivotFieldType")
  (gtype-id "GDA_TYPE_DATA_PIVOT_FIELD_TYPE")
  (values
    '("row" "GDA_DATA_PIVOT_FIELD_ROW")
    '("column" "GDA_DATA_PIVOT_FIELD_COLUMN")
  )
)

(define-enum DataProxyError
  (in-module "Gda")
  (c-name "GdaDataProxyError")
  (gtype-id "GDA_TYPE_DATA_PROXY_ERROR")
  (values
    '("commit-error" "GDA_DATA_PROXY_COMMIT_ERROR")
    '("commit-cancelled" "GDA_DATA_PROXY_COMMIT_CANCELLED")
    '("read-only-value" "GDA_DATA_PROXY_READ_ONLY_VALUE")
    '("read-only-row" "GDA_DATA_PROXY_READ_ONLY_ROW")
    '("filter-error" "GDA_DATA_PROXY_FILTER_ERROR")
  )
)

(define-enum DataSelectError
  (in-module "Gda")
  (c-name "GdaDataSelectError")
  (gtype-id "GDA_TYPE_DATA_SELECT_ERROR")
  (values
    '("modification-statement-error" "GDA_DATA_SELECT_MODIFICATION_STATEMENT_ERROR")
    '("missing-modification-statement-error" "GDA_DATA_SELECT_MISSING_MODIFICATION_STATEMENT_ERROR")
    '("connection-error" "GDA_DATA_SELECT_CONNECTION_ERROR")
    '("access-error" "GDA_DATA_SELECT_ACCESS_ERROR")
    '("sql-error" "GDA_DATA_SELECT_SQL_ERROR")
    '("safety-locked-error" "GDA_DATA_SELECT_SAFETY_LOCKED_ERROR")
  )
)

(define-enum DataSelectConditionType
  (in-module "Gda")
  (c-name "GdaDataSelectConditionType")
  (gtype-id "GDA_TYPE_DATA_SELECT_CONDITION_TYPE")
  (values
    '("pk" "GDA_DATA_SELECT_COND_PK")
    '("all-columns" "GDA_DATA_SELECT_COND_ALL_COLUMNS")
  )
)

(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-flags ValueAttribute
  (in-module "Gda")
  (c-name "GdaValueAttribute")
  (gtype-id "GDA_TYPE_VALUE_ATTRIBUTE")
  (values
    '("none" "GDA_VALUE_ATTR_NONE")
    '("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")
    '("unused" "GDA_VALUE_ATTR_UNUSED")
  )
)

(define-flags SqlIdentifierStyle
  (in-module "Gda")
  (c-name "GdaSqlIdentifierStyle")
  (gtype-id "GDA_TYPE_SQL_IDENTIFIER_STYLE")
  (values
    '("lower-case" "GDA_SQL_IDENTIFIERS_LOWER_CASE")
    '("upper-case" "GDA_SQL_IDENTIFIERS_UPPER_CASE")
  )
)

(define-enum HolderError
  (in-module "Gda")
  (c-name "GdaHolderError")
  (gtype-id "GDA_TYPE_HOLDER_ERROR")
  (values
    '("string-conversion-error" "GDA_HOLDER_STRING_CONVERSION_ERROR")
    '("value-type-error" "GDA_HOLDER_VALUE_TYPE_ERROR")
    '("value-null-error" "GDA_HOLDER_VALUE_NULL_ERROR")
  )
)

(define-enum MetaStoreError
  (in-module "Gda")
  (c-name "GdaMetaStoreError")
  (gtype-id "GDA_TYPE_META_STORE_ERROR")
  (values
    '("incorrect-schema-error" "GDA_META_STORE_INCORRECT_SCHEMA_ERROR")
    '("unsupported-provider-error" "GDA_META_STORE_UNSUPPORTED_PROVIDER_ERROR")
    '("internal-error" "GDA_META_STORE_INTERNAL_ERROR")
    '("meta-context-error" "GDA_META_STORE_META_CONTEXT_ERROR")
    '("modify-contents-error" "GDA_META_STORE_MODIFY_CONTENTS_ERROR")
    '("extract-sql-error" "GDA_META_STORE_EXTRACT_SQL_ERROR")
    '("attribute-not-found-error" "GDA_META_STORE_ATTRIBUTE_NOT_FOUND_ERROR")
    '("attribute-error" "GDA_META_STORE_ATTRIBUTE_ERROR")
    '("schema-object-not-found-error" "GDA_META_STORE_SCHEMA_OBJECT_NOT_FOUND_ERROR")
    '("schema-object-conflict-error" "GDA_META_STORE_SCHEMA_OBJECT_CONFLICT_ERROR")
    '("schema-object-descr-error" "GDA_META_STORE_SCHEMA_OBJECT_DESCR_ERROR")
    '("transaction-already-started-error" "GDA_META_STORE_TRANSACTION_ALREADY_STARTED_ERROR")
  )
)

(define-enum MetaStoreChangeType
  (in-module "Gda")
  (c-name "GdaMetaStoreChangeType")
  (gtype-id "GDA_TYPE_META_STORE_CHANGE_TYPE")
  (values
    '("add" "GDA_META_STORE_ADD")
    '("remove" "GDA_META_STORE_REMOVE")
    '("modify" "GDA_META_STORE_MODIFY")
  )
)

(define-enum MetaStructError
  (in-module "Gda")
  (c-name "GdaMetaStructError")
  (gtype-id "GDA_TYPE_META_STRUCT_ERROR")
  (values
    '("unknown-object-error" "GDA_META_STRUCT_UNKNOWN_OBJECT_ERROR")
    '("duplicate-object-error" "GDA_META_STRUCT_DUPLICATE_OBJECT_ERROR")
    '("incoherence-error" "GDA_META_STRUCT_INCOHERENCE_ERROR")
    '("xml-error" "GDA_META_STRUCT_XML_ERROR")
  )
)

(define-enum MetaDbObjectType
  (in-module "Gda")
  (c-name "GdaMetaDbObjectType")
  (gtype-id "GDA_TYPE_META_DB_OBJECT_TYPE")
  (values
    '("unknown" "GDA_META_DB_UNKNOWN")
    '("table" "GDA_META_DB_TABLE")
    '("view" "GDA_META_DB_VIEW")
  )
)

(define-flags MetaStructFeature
  (in-module "Gda")
  (c-name "GdaMetaStructFeature")
  (gtype-id "GDA_TYPE_META_STRUCT_FEATURE")
  (values
    '("none" "GDA_META_STRUCT_FEATURE_NONE")
    '("foreign-keys" "GDA_META_STRUCT_FEATURE_FOREIGN_KEYS")
    '("view-dependencies" "GDA_META_STRUCT_FEATURE_VIEW_DEPENDENCIES")
    '("all" "GDA_META_STRUCT_FEATURE_ALL")
  )
)

(define-enum MetaSortType
  (in-module "Gda")
  (c-name "GdaMetaSortType")
  (gtype-id "GDA_TYPE_META_SORT_TYPE")
  (values
    '("alhapetical" "GDA_META_SORT_ALHAPETICAL")
    '("dependencies" "GDA_META_SORT_DEPENDENCIES")
  )
)

(define-enum MetaForeignKeyPolicy
  (in-module "Gda")
  (c-name "GdaMetaForeignKeyPolicy")
  (gtype-id "GDA_TYPE_META_FOREIGN_KEY_POLICY")
  (values
    '("unknown" "GDA_META_FOREIGN_KEY_UNKNOWN")
    '("none" "GDA_META_FOREIGN_KEY_NONE")
    '("no-action" "GDA_META_FOREIGN_KEY_NO_ACTION")
    '("restrict" "GDA_META_FOREIGN_KEY_RESTRICT")
    '("cascade" "GDA_META_FOREIGN_KEY_CASCADE")
    '("set-null" "GDA_META_FOREIGN_KEY_SET_NULL")
    '("set-default" "GDA_META_FOREIGN_KEY_SET_DEFAULT")
  )
)

(define-flags MetaGraphInfo
  (in-module "Gda")
  (c-name "GdaMetaGraphInfo")
  (gtype-id "GDA_TYPE_META_GRAPH_INFO")
  (values
    '("columns" "GDA_META_GRAPH_COLUMNS")
  )
)

(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")
    '("create-view" "GDA_SERVER_OPERATION_CREATE_VIEW")
    '("drop-view" "GDA_SERVER_OPERATION_DROP_VIEW")
    '("comment-table" "GDA_SERVER_OPERATION_COMMENT_TABLE")
    '("comment-column" "GDA_SERVER_OPERATION_COMMENT_COLUMN")
    '("create-user" "GDA_SERVER_OPERATION_CREATE_USER")
    '("alter-user" "GDA_SERVER_OPERATION_ALTER_USER")
    '("drop-user" "GDA_SERVER_OPERATION_DROP_USER")
    '("last" "GDA_SERVER_OPERATION_LAST")
  )
)

(define-enum ServerOperationError
  (in-module "Gda")
  (c-name "GdaServerOperationError")
  (gtype-id "GDA_TYPE_SERVER_OPERATION_ERROR")
  (values
    '("object-name-error" "GDA_SERVER_OPERATION_OBJECT_NAME_ERROR")
    '("incorrect-value-error" "GDA_SERVER_OPERATION_INCORRECT_VALUE_ERROR")
    '("xml-error" "GDA_SERVER_OPERATION_XML_ERROR")
  )
)

(define-flags ServerOperationCreateTableFlag
  (in-module "Gda")
  (c-name "GdaServerOperationCreateTableFlag")
  (gtype-id "GDA_TYPE_SERVER_OPERATION_CREATE_TABLE_FLAG")
  (values
    '("nothing-flag" "GDA_SERVER_OPERATION_CREATE_TABLE_NOTHING_FLAG")
    '("pkey-flag" "GDA_SERVER_OPERATION_CREATE_TABLE_PKEY_FLAG")
    '("not-null-flag" "GDA_SERVER_OPERATION_CREATE_TABLE_NOT_NULL_FLAG")
    '("unique-flag" "GDA_SERVER_OPERATION_CREATE_TABLE_UNIQUE_FLAG")
    '("autoinc-flag" "GDA_SERVER_OPERATION_CREATE_TABLE_AUTOINC_FLAG")
    '("fkey-flag" "GDA_SERVER_OPERATION_CREATE_TABLE_FKEY_FLAG")
    '("pkey-autoinc-flag" "GDA_SERVER_OPERATION_CREATE_TABLE_PKEY_AUTOINC_FLAG")
  )
)

(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 ServerProviderError
  (in-module "Gda")
  (c-name "GdaServerProviderError")
  (gtype-id "GDA_TYPE_SERVER_PROVIDER_ERROR")
  (values
    '("method-non-implemented-error" "GDA_SERVER_PROVIDER_METHOD_NON_IMPLEMENTED_ERROR")
    '("prepare-stmt-error" "GDA_SERVER_PROVIDER_PREPARE_STMT_ERROR")
    '("empty-stmt-error" "GDA_SERVER_PROVIDER_EMPTY_STMT_ERROR")
    '("missing-param-error" "GDA_SERVER_PROVIDER_MISSING_PARAM_ERROR")
    '("statement-exec-error" "GDA_SERVER_PROVIDER_STATEMENT_EXEC_ERROR")
    '("operation-error" "GDA_SERVER_PROVIDER_OPERATION_ERROR")
    '("internal-error" "GDA_SERVER_PROVIDER_INTERNAL_ERROR")
    '("busy-error" "GDA_SERVER_PROVIDER_BUSY_ERROR")
    '("non-supported-error" "GDA_SERVER_PROVIDER_NON_SUPPORTED_ERROR")
    '("server-version-error" "GDA_SERVER_PROVIDER_SERVER_VERSION_ERROR")
    '("data-error" "GDA_SERVER_PROVIDER_DATA_ERROR")
    '("default-value-handling-error" "GDA_SERVER_PROVIDER_DEFAULT_VALUE_HANDLING_ERROR")
    '("misuse-error" "GDA_SERVER_PROVIDER_MISUSE_ERROR")
    '("file-not-found-error" "GDA_SERVER_PROVIDER_FILE_NOT_FOUND_ERROR")
  )
)

(define-enum SetError
  (in-module "Gda")
  (c-name "GdaSetError")
  (gtype-id "GDA_TYPE_SET_ERROR")
  (values
    '("xml-spec-error" "GDA_SET_XML_SPEC_ERROR")
    '("holder-not-found-error" "GDA_SET_HOLDER_NOT_FOUND_ERROR")
    '("invalid-error" "GDA_SET_INVALID_ERROR")
    '("read-only-error" "GDA_SET_READ_ONLY_ERROR")
    '("implementation-error" "GDA_SET_IMPLEMENTATION_ERROR")
  )
)

(define-enum SqlBuilderError
  (in-module "Gda")
  (c-name "GdaSqlBuilderError")
  (gtype-id "GDA_TYPE_SQL_BUILDER_ERROR")
  (values
    '("wrong-type-error" "GDA_SQL_BUILDER_WRONG_TYPE_ERROR")
    '("misuse-error" "GDA_SQL_BUILDER_MISUSE_ERROR")
  )
)

(define-enum StatementError
  (in-module "Gda")
  (c-name "GdaStatementError")
  (gtype-id "GDA_TYPE_STATEMENT_ERROR")
  (values
    '("parse-error" "GDA_STATEMENT_PARSE_ERROR")
    '("syntax-error" "GDA_STATEMENT_SYNTAX_ERROR")
    '("no-cnc-error" "GDA_STATEMENT_NO_CNC_ERROR")
    '("cnc-closed-error" "GDA_STATEMENT_CNC_CLOSED_ERROR")
    '("exec-error" "GDA_STATEMENT_EXEC_ERROR")
    '("param-type-error" "GDA_STATEMENT_PARAM_TYPE_ERROR")
    '("param-error" "GDA_STATEMENT_PARAM_ERROR")
  )
)

(define-flags StatementModelUsage
  (in-module "Gda")
  (c-name "GdaStatementModelUsage")
  (gtype-id "GDA_TYPE_STATEMENT_MODEL_USAGE")
  (values
    '("random-access" "GDA_STATEMENT_MODEL_RANDOM_ACCESS")
    '("cursor-forward" "GDA_STATEMENT_MODEL_CURSOR_FORWARD")
    '("cursor-backward" "GDA_STATEMENT_MODEL_CURSOR_BACKWARD")
    '("cursor" "GDA_STATEMENT_MODEL_CURSOR")
    '("allow-noparam" "GDA_STATEMENT_MODEL_ALLOW_NOPARAM")
  )
)

(define-flags StatementSqlFlag
  (in-module "Gda")
  (c-name "GdaStatementSqlFlag")
  (gtype-id "GDA_TYPE_STATEMENT_SQL_FLAG")
  (values
    '("params-as-values" "GDA_STATEMENT_SQL_PARAMS_AS_VALUES")
    '("pretty" "GDA_STATEMENT_SQL_PRETTY")
    '("params-long" "GDA_STATEMENT_SQL_PARAMS_LONG")
    '("params-short" "GDA_STATEMENT_SQL_PARAMS_SHORT")
    '("params-as-colon" "GDA_STATEMENT_SQL_PARAMS_AS_COLON")
    '("params-as-dollar" "GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR")
    '("params-as-qmark" "GDA_STATEMENT_SQL_PARAMS_AS_QMARK")
    '("params-as-uqmark" "GDA_STATEMENT_SQL_PARAMS_AS_UQMARK")
  )
)

(define-enum TransactionStatusEventType
  (in-module "Gda")
  (c-name "GdaTransactionStatusEventType")
  (gtype-id "GDA_TYPE_TRANSACTION_STATUS_EVENT_TYPE")
  (values
    '("savepoint" "GDA_TRANSACTION_STATUS_EVENT_SAVEPOINT")
    '("sql" "GDA_TRANSACTION_STATUS_EVENT_SQL")
    '("sub-transaction" "GDA_TRANSACTION_STATUS_EVENT_SUB_TRANSACTION")
  )
)

(define-enum TransactionStatusState
  (in-module "Gda")
  (c-name "GdaTransactionStatusState")
  (gtype-id "GDA_TYPE_TRANSACTION_STATUS_STATE")
  (values
    '("ok" "GDA_TRANSACTION_STATUS_STATE_OK")
    '("failed" "GDA_TRANSACTION_STATUS_STATE_FAILED")
  )
)

(define-enum TreeError
  (in-module "Gda")
  (c-name "GdaTreeError")
  (gtype-id "GDA_TYPE_TREE_ERROR")
  (values
    '("error" "GDA_TREE_UNKNOWN_ERROR")
  )
)

(define-enum TreeManagerError
  (in-module "Gda")
  (c-name "GdaTreeManagerError")
  (gtype-id "GDA_TYPE_TREE_MANAGER_ERROR")
  (values
    '("error" "GDA_TREE_MANAGER_UNKNOWN_ERROR")
  )
)

(define-enum TreeNodeError
  (in-module "Gda")
  (c-name "GdaTreeNodeError")
  (gtype-id "GDA_TYPE_TREE_NODE_ERROR")
  (values
    '("error" "GDA_TREE_NODE_UNKNOWN_ERROR")
  )
)

(define-enum XaTransactionError
  (in-module "Gda")
  (c-name "GdaXaTransactionError")
  (gtype-id "GDA_TYPE_XA_TRANSACTION_ERROR")
  (values
    '("already-registered-error" "GDA_XA_TRANSACTION_ALREADY_REGISTERED_ERROR")
    '("dtp-not-supported-error" "GDA_XA_TRANSACTION_DTP_NOT_SUPPORTED_ERROR")
    '("connection-branch-length-error" "GDA_XA_TRANSACTION_CONNECTION_BRANCH_LENGTH_ERROR")
  )
)

(define-enum SqlParserError
  (in-module "Gda")
  (c-name "GdaSqlParserError")
  (gtype-id "GDA_TYPE_SQL_PARSER_ERROR")
  (values
    '("syntax-error" "GDA_SQL_PARSER_SYNTAX_ERROR")
    '("overflow-error" "GDA_SQL_PARSER_OVERFLOW_ERROR")
    '("empty-sql-error" "GDA_SQL_PARSER_EMPTY_SQL_ERROR")
  )
)

(define-enum SqlParserMode
  (in-module "Gda")
  (c-name "GdaSqlParserMode")
  (gtype-id "GDA_TYPE_SQL_PARSER_MODE")
  (values
    '("parse" "GDA_SQL_PARSER_MODE_PARSE")
    '("delimit" "GDA_SQL_PARSER_MODE_DELIMIT")
  )
)

(define-enum SqlParserFlavour
  (in-module "Gda")
  (c-name "GdaSqlParserFlavour")
  (gtype-id "GDA_TYPE_SQL_PARSER_FLAVOUR")
  (values
    '("standard" "GDA_SQL_PARSER_FLAVOUR_STANDARD")
    '("sqlite" "GDA_SQL_PARSER_FLAVOUR_SQLITE")
    '("mysql" "GDA_SQL_PARSER_FLAVOUR_MYSQL")
    '("oracle" "GDA_SQL_PARSER_FLAVOUR_ORACLE")
    '("postgresql" "GDA_SQL_PARSER_FLAVOUR_POSTGRESQL")
  )
)

(define-enum SqlStatementCompoundType
  (in-module "Gda")
  (c-name "GdaSqlStatementCompoundType")
  (gtype-id "GDA_TYPE_SQL_STATEMENT_COMPOUND_TYPE")
  (values
    '("union" "GDA_SQL_STATEMENT_COMPOUND_UNION")
    '("union-all" "GDA_SQL_STATEMENT_COMPOUND_UNION_ALL")
    '("intersect" "GDA_SQL_STATEMENT_COMPOUND_INTERSECT")
    '("intersect-all" "GDA_SQL_STATEMENT_COMPOUND_INTERSECT_ALL")
    '("except" "GDA_SQL_STATEMENT_COMPOUND_EXCEPT")
    '("except-all" "GDA_SQL_STATEMENT_COMPOUND_EXCEPT_ALL")
  )
)

(define-enum SqlError
  (in-module "Gda")
  (c-name "GdaSqlError")
  (gtype-id "GDA_TYPE_SQL_ERROR")
  (values
    '("structure-contents-error" "GDA_SQL_STRUCTURE_CONTENTS_ERROR")
    '("malformed-identifier-error" "GDA_SQL_MALFORMED_IDENTIFIER_ERROR")
    '("missing-identifier-error" "GDA_SQL_MISSING_IDENTIFIER_ERROR")
    '("validation-error" "GDA_SQL_VALIDATION_ERROR")
  )
)

(define-enum SqlStatementType
  (in-module "Gda")
  (c-name "GdaSqlStatementType")
  (gtype-id "GDA_TYPE_SQL_STATEMENT_TYPE")
  (values
    '("select" "GDA_SQL_STATEMENT_SELECT")
    '("insert" "GDA_SQL_STATEMENT_INSERT")
    '("update" "GDA_SQL_STATEMENT_UPDATE")
    '("delete" "GDA_SQL_STATEMENT_DELETE")
    '("compound" "GDA_SQL_STATEMENT_COMPOUND")
    '("begin" "GDA_SQL_STATEMENT_BEGIN")
    '("rollback" "GDA_SQL_STATEMENT_ROLLBACK")
    '("commit" "GDA_SQL_STATEMENT_COMMIT")
    '("savepoint" "GDA_SQL_STATEMENT_SAVEPOINT")
    '("rollback-savepoint" "GDA_SQL_STATEMENT_ROLLBACK_SAVEPOINT")
    '("delete-savepoint" "GDA_SQL_STATEMENT_DELETE_SAVEPOINT")
    '("unknown" "GDA_SQL_STATEMENT_UNKNOWN")
    '("none" "GDA_SQL_STATEMENT_NONE")
  )
)

(define-enum SqlAnyPartType
  (in-module "Gda")
  (c-name "GdaSqlAnyPartType")
  (gtype-id "GDA_TYPE_SQL_ANY_PART_TYPE")
  (values
    '("stmt-select" "GDA_SQL_ANY_STMT_SELECT")
    '("stmt-insert" "GDA_SQL_ANY_STMT_INSERT")
    '("stmt-update" "GDA_SQL_ANY_STMT_UPDATE")
    '("stmt-delete" "GDA_SQL_ANY_STMT_DELETE")
    '("stmt-compound" "GDA_SQL_ANY_STMT_COMPOUND")
    '("stmt-begin" "GDA_SQL_ANY_STMT_BEGIN")
    '("stmt-rollback" "GDA_SQL_ANY_STMT_ROLLBACK")
    '("stmt-commit" "GDA_SQL_ANY_STMT_COMMIT")
    '("stmt-savepoint" "GDA_SQL_ANY_STMT_SAVEPOINT")
    '("stmt-rollback-savepoint" "GDA_SQL_ANY_STMT_ROLLBACK_SAVEPOINT")
    '("stmt-delete-savepoint" "GDA_SQL_ANY_STMT_DELETE_SAVEPOINT")
    '("stmt-unknown" "GDA_SQL_ANY_STMT_UNKNOWN")
    '("expr" "GDA_SQL_ANY_EXPR")
    '("sql-field" "GDA_SQL_ANY_SQL_FIELD")
    '("sql-table" "GDA_SQL_ANY_SQL_TABLE")
    '("sql-function" "GDA_SQL_ANY_SQL_FUNCTION")
    '("sql-operation" "GDA_SQL_ANY_SQL_OPERATION")
    '("sql-case" "GDA_SQL_ANY_SQL_CASE")
    '("sql-select-field" "GDA_SQL_ANY_SQL_SELECT_FIELD")
    '("sql-select-target" "GDA_SQL_ANY_SQL_SELECT_TARGET")
    '("sql-select-join" "GDA_SQL_ANY_SQL_SELECT_JOIN")
    '("sql-select-from" "GDA_SQL_ANY_SQL_SELECT_FROM")
    '("sql-select-order" "GDA_SQL_ANY_SQL_SELECT_ORDER")
  )
)

(define-enum SqlOperatorType
  (in-module "Gda")
  (c-name "GdaSqlOperatorType")
  (gtype-id "GDA_TYPE_SQL_OPERATOR_TYPE")
  (values
    '("and" "GDA_SQL_OPERATOR_TYPE_AND")
    '("or" "GDA_SQL_OPERATOR_TYPE_OR")
    '("eq" "GDA_SQL_OPERATOR_TYPE_EQ")
    '("is" "GDA_SQL_OPERATOR_TYPE_IS")
    '("like" "GDA_SQL_OPERATOR_TYPE_LIKE")
    '("between" "GDA_SQL_OPERATOR_TYPE_BETWEEN")
    '("gt" "GDA_SQL_OPERATOR_TYPE_GT")
    '("lt" "GDA_SQL_OPERATOR_TYPE_LT")
    '("geq" "GDA_SQL_OPERATOR_TYPE_GEQ")
    '("leq" "GDA_SQL_OPERATOR_TYPE_LEQ")
    '("diff" "GDA_SQL_OPERATOR_TYPE_DIFF")
    '("regexp" "GDA_SQL_OPERATOR_TYPE_REGEXP")
    '("regexp-ci" "GDA_SQL_OPERATOR_TYPE_REGEXP_CI")
    '("not-regexp" "GDA_SQL_OPERATOR_TYPE_NOT_REGEXP")
    '("not-regexp-ci" "GDA_SQL_OPERATOR_TYPE_NOT_REGEXP_CI")
    '("similar" "GDA_SQL_OPERATOR_TYPE_SIMILAR")
    '("isnull" "GDA_SQL_OPERATOR_TYPE_ISNULL")
    '("isnotnull" "GDA_SQL_OPERATOR_TYPE_ISNOTNULL")
    '("not" "GDA_SQL_OPERATOR_TYPE_NOT")
    '("in" "GDA_SQL_OPERATOR_TYPE_IN")
    '("notin" "GDA_SQL_OPERATOR_TYPE_NOTIN")
    '("concat" "GDA_SQL_OPERATOR_TYPE_CONCAT")
    '("plus" "GDA_SQL_OPERATOR_TYPE_PLUS")
    '("minus" "GDA_SQL_OPERATOR_TYPE_MINUS")
    '("star" "GDA_SQL_OPERATOR_TYPE_STAR")
    '("div" "GDA_SQL_OPERATOR_TYPE_DIV")
    '("rem" "GDA_SQL_OPERATOR_TYPE_REM")
    '("bitand" "GDA_SQL_OPERATOR_TYPE_BITAND")
    '("bitor" "GDA_SQL_OPERATOR_TYPE_BITOR")
    '("bitnot" "GDA_SQL_OPERATOR_TYPE_BITNOT")
    '("ilike" "GDA_SQL_OPERATOR_TYPE_ILIKE")
  )
)

(define-enum SqlSelectJoinType
  (in-module "Gda")
  (c-name "GdaSqlSelectJoinType")
  (gtype-id "GDA_TYPE_SQL_SELECT_JOIN_TYPE")
  (values
    '("cross" "GDA_SQL_SELECT_JOIN_CROSS")
    '("natural" "GDA_SQL_SELECT_JOIN_NATURAL")
    '("inner" "GDA_SQL_SELECT_JOIN_INNER")
    '("left" "GDA_SQL_SELECT_JOIN_LEFT")
    '("right" "GDA_SQL_SELECT_JOIN_RIGHT")
    '("full" "GDA_SQL_SELECT_JOIN_FULL")
  )
)


;; From gda-attributes-manager.h

(define-function gda_attributes_manager_new
  (c-name "gda_attributes_manager_new")
  (is-constructor-of "GdaAttributesManager")
  (return-type "GdaAttributesManager*")
  (parameters
    '("gboolean" "for_objects")
    '("GdaAttributesManagerSignal" "signal_func")
    '("gpointer" "signal_data")
  )
)

(define-method free
  (of-object "GdaAttributesManager")
  (c-name "gda_attributes_manager_free")
  (return-type "none")
)

(define-method set
  (of-object "GdaAttributesManager")
  (c-name "gda_attributes_manager_set")
  (return-type "none")
  (parameters
    '("gpointer" "ptr")
    '("const-gchar*" "att_name")
    '("const-GValue*" "value")
  )
)

(define-method set_full
  (of-object "GdaAttributesManager")
  (c-name "gda_attributes_manager_set_full")
  (return-type "none")
  (parameters
    '("gpointer" "ptr")
    '("const-gchar*" "att_name")
    '("const-GValue*" "value")
    '("GDestroyNotify" "destroy")
  )
)

(define-method get
  (of-object "GdaAttributesManager")
  (c-name "gda_attributes_manager_get")
  (return-type "const-GValue*")
  (parameters
    '("gpointer" "ptr")
    '("const-gchar*" "att_name")
  )
)

(define-method copy
  (of-object "GdaAttributesManager")
  (c-name "gda_attributes_manager_copy")
  (return-type "none")
  (parameters
    '("gpointer*" "from")
    '("GdaAttributesManager*" "to_mgr")
    '("gpointer*" "to")
  )
)

(define-method clear
  (of-object "GdaAttributesManager")
  (c-name "gda_attributes_manager_clear")
  (return-type "none")
  (parameters
    '("gpointer" "ptr")
  )
)

(define-method foreach
  (of-object "GdaAttributesManager")
  (c-name "gda_attributes_manager_foreach")
  (return-type "none")
  (parameters
    '("gpointer" "ptr")
    '("GdaAttributesManagerFunc" "func")
    '("gpointer" "data")
  )
)



;; From gda-batch.h

(define-function gda_batch_get_type
  (c-name "gda_batch_get_type")
  (return-type "GType")
)

(define-function gda_batch_new
  (c-name "gda_batch_new")
  (is-constructor-of "GdaBatch")
  (return-type "GdaBatch*")
)

(define-method copy
  (of-object "GdaBatch")
  (c-name "gda_batch_copy")
  (return-type "GdaBatch*")
)

(define-method add_statement
  (of-object "GdaBatch")
  (c-name "gda_batch_add_statement")
  (return-type "none")
  (parameters
    '("GdaStatement*" "stmt")
  )
)

(define-method remove_statement
  (of-object "GdaBatch")
  (c-name "gda_batch_remove_statement")
  (return-type "none")
  (parameters
    '("GdaStatement*" "stmt")
  )
)

(define-method serialize
  (of-object "GdaBatch")
  (c-name "gda_batch_serialize")
  (return-type "gchar*")
)

(define-method get_statements
  (of-object "GdaBatch")
  (c-name "gda_batch_get_statements")
  (return-type "const-GSList*")
)

(define-method get_parameters
  (of-object "GdaBatch")
  (c-name "gda_batch_get_parameters")
  (return-type "gboolean")
  (parameters
    '("GdaSet**" "out_params")
    '("GError**" "error")
  )
)



;; From gda-binreloc.h

(define-function gda_gbr_init
  (c-name "gda_gbr_init")
  (return-type "none")
)

(define-function gda_gbr_get_file_path
  (c-name "gda_gbr_get_file_path")
  (return-type "gchar*")
  (parameters
    '("GdaPrefixDir" "where")
  )
  (varargs #t)
)



;; From gda-blob-op.h

(define-function gda_blob_op_get_type
  (c-name "gda_blob_op_get_type")
  (return-type "GType")
)

(define-method get_length
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_get_length")
  (return-type "glong")
)

(define-method read
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_read")
  (return-type "glong")
  (parameters
    '("GdaBlob*" "blob")
    '("glong" "offset")
    '("glong" "size")
  )
)

(define-method read_all
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_read_all")
  (return-type "gboolean")
  (parameters
    '("GdaBlob*" "blob")
  )
)

(define-method write
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_write")
  (return-type "glong")
  (parameters
    '("GdaBlob*" "blob")
    '("glong" "offset")
  )
)

(define-method write_all
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_write_all")
  (return-type "gboolean")
  (parameters
    '("GdaBlob*" "blob")
  )
)



;; 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_description
  (of-object "GdaColumn")
  (c-name "gda_column_get_description")
  (return-type "const-gchar*")
)

(define-method set_description
  (of-object "GdaColumn")
  (c-name "gda_column_set_description")
  (return-type "none")
  (parameters
    '("const-gchar*" "title")
  )
)

(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_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_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")
  )
)

(define-method get_attribute
  (of-object "GdaColumn")
  (c-name "gda_column_get_attribute")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "attribute")
  )
)

(define-method set_attribute
  (of-object "GdaColumn")
  (c-name "gda_column_set_attribute")
  (return-type "none")
  (parameters
    '("const-gchar*" "attribute")
    '("const-GValue*" "value")
    '("GDestroyNotify" "destroy")
  )
)



;; From gda-config.h

(define-function gda_config_get_type
  (c-name "gda_config_get_type")
  (return-type "GType")
)

(define-function gda_config_get
  (c-name "gda_config_get")
  (return-type "GdaConfig*")
)

(define-function gda_config_get_dsn_info
  (c-name "gda_config_get_dsn_info")
  (return-type "GdaDsnInfo*")
  (parameters
    '("const-gchar*" "dsn_name")
  )
)

(define-function gda_config_define_dsn
  (c-name "gda_config_define_dsn")
  (return-type "gboolean")
  (parameters
    '("const-GdaDsnInfo*" "info")
    '("GError**" "error")
  )
)

(define-function gda_config_remove_dsn
  (c-name "gda_config_remove_dsn")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "dsn_name")
    '("GError**" "error")
  )
)

(define-function gda_config_dsn_needs_authentication
  (c-name "gda_config_dsn_needs_authentication")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "dsn_name")
  )
)

(define-function gda_config_list_dsn
  (c-name "gda_config_list_dsn")
  (return-type "GdaDataModel*")
)

(define-function gda_config_can_modify_system_config
  (c-name "gda_config_can_modify_system_config")
  (return-type "gboolean")
)

(define-function gda_config_get_nb_dsn
  (c-name "gda_config_get_nb_dsn")
  (return-type "gint")
)

(define-function gda_config_get_dsn_info_index
  (c-name "gda_config_get_dsn_info_index")
  (return-type "gint")
  (parameters
    '("const-gchar*" "dsn_name")
  )
)

(define-function gda_config_get_dsn_info_at_index
  (c-name "gda_config_get_dsn_info_at_index")
  (return-type "GdaDsnInfo*")
  (parameters
    '("gint" "index")
  )
)

(define-function gda_config_get_provider_info
  (c-name "gda_config_get_provider_info")
  (return-type "GdaProviderInfo*")
  (parameters
    '("const-gchar*" "provider_name")
  )
)

(define-function gda_config_get_provider
  (c-name "gda_config_get_provider")
  (return-type "GdaServerProvider*")
  (parameters
    '("const-gchar*" "provider_name")
    '("GError**" "error")
  )
)

(define-function gda_config_list_providers
  (c-name "gda_config_list_providers")
  (return-type "GdaDataModel*")
)



;; From gda-connection-event.h

(define-function gda_connection_event_get_type
  (c-name "gda_connection_event_get_type")
  (return-type "GType")
)

(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_open_from_dsn
  (c-name "gda_connection_open_from_dsn")
  (return-type "GdaConnection*")
  (parameters
    '("const-gchar*" "dsn")
    '("const-gchar*" "auth_string")
    '("GdaConnectionOptions" "options")
    '("GError**" "error")
  )
)

(define-function gda_connection_open_from_string
  (c-name "gda_connection_open_from_string")
  (return-type "GdaConnection*")
  (parameters
    '("const-gchar*" "provider_name")
    '("const-gchar*" "cnc_string")
    '("const-gchar*" "auth_string")
    '("GdaConnectionOptions" "options")
    '("GError**" "error")
  )
)

(define-function gda_connection_new_from_dsn
  (c-name "gda_connection_new_from_dsn")
  (return-type "GdaConnection*")
  (parameters
    '("const-gchar*" "dsn")
    '("const-gchar*" "auth_string")
    '("GdaConnectionOptions" "options")
    '("GError**" "error")
  )
)

(define-function gda_connection_new_from_string
  (c-name "gda_connection_new_from_string")
  (return-type "GdaConnection*")
  (parameters
    '("const-gchar*" "provider_name")
    '("const-gchar*" "cnc_string")
    '("const-gchar*" "auth_string")
    '("GdaConnectionOptions" "options")
    '("GError**" "error")
  )
)

(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_options
  (of-object "GdaConnection")
  (c-name "gda_connection_get_options")
  (return-type "GdaConnectionOptions")
)

(define-method get_provider
  (of-object "GdaConnection")
  (c-name "gda_connection_get_provider")
  (return-type "GdaServerProvider*")
)

(define-method get_provider_name
  (of-object "GdaConnection")
  (c-name "gda_connection_get_provider_name")
  (return-type "const-gchar*")
)

(define-method create_operation
  (of-object "GdaConnection")
  (c-name "gda_connection_create_operation")
  (return-type "GdaServerOperation*")
  (parameters
    '("GdaServerOperationType" "type")
    '("GdaSet*" "options")
    '("GError**" "error")
  )
)

(define-method perform_operation
  (of-object "GdaConnection")
  (c-name "gda_connection_perform_operation")
  (return-type "gboolean")
  (parameters
    '("GdaServerOperation*" "op")
    '("GError**" "error")
  )
)

(define-method get_dsn
  (of-object "GdaConnection")
  (c-name "gda_connection_get_dsn")
  (return-type "const-gchar*")
)

(define-method get_cnc_string
  (of-object "GdaConnection")
  (c-name "gda_connection_get_cnc_string")
  (return-type "const-gchar*")
)

(define-method get_authentication
  (of-object "GdaConnection")
  (c-name "gda_connection_get_authentication")
  (return-type "const-gchar*")
)

(define-method parse_sql_string
  (of-object "GdaConnection")
  (c-name "gda_connection_parse_sql_string")
  (return-type "GdaStatement*")
  (parameters
    '("const-gchar*" "sql")
    '("GdaSet**" "params")
    '("GError**" "error")
  )
)

(define-method execute_select_command
  (of-object "GdaConnection")
  (c-name "gda_connection_execute_select_command")
  (return-type "GdaDataModel*")
  (parameters
    '("const-gchar*" "sql")
    '("GError**" "error")
  )
)

(define-method execute_non_select_command
  (of-object "GdaConnection")
  (c-name "gda_connection_execute_non_select_command")
  (return-type "gint")
  (parameters
    '("const-gchar*" "sql")
    '("GError**" "error")
  )
)

(define-method insert_row_into_table
  (of-object "GdaConnection")
  (c-name "gda_connection_insert_row_into_table")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "table")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-method insert_row_into_table_v
  (of-object "GdaConnection")
  (c-name "gda_connection_insert_row_into_table_v")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "table")
    '("GSList*" "col_names")
    '("GSList*" "values")
    '("GError**" "error")
  )
)

(define-method update_row_in_table
  (of-object "GdaConnection")
  (c-name "gda_connection_update_row_in_table")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "table")
    '("const-gchar*" "condition_column_name")
    '("GValue*" "condition_value")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-method update_row_in_table_v
  (of-object "GdaConnection")
  (c-name "gda_connection_update_row_in_table_v")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "table")
    '("const-gchar*" "condition_column_name")
    '("GValue*" "condition_value")
    '("GSList*" "col_names")
    '("GSList*" "values")
    '("GError**" "error")
  )
)

(define-method delete_row_from_table
  (of-object "GdaConnection")
  (c-name "gda_connection_delete_row_from_table")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "table")
    '("const-gchar*" "condition_column_name")
    '("GValue*" "condition_value")
    '("GError**" "error")
  )
)

(define-method get_events
  (of-object "GdaConnection")
  (c-name "gda_connection_get_events")
  (return-type "const-GList*")
)

(define-method create_parser
  (of-object "GdaConnection")
  (c-name "gda_connection_create_parser")
  (return-type "GdaSqlParser*")
)

(define-method batch_execute
  (of-object "GdaConnection")
  (c-name "gda_connection_batch_execute")
  (return-type "GSList*")
  (parameters
    '("GdaBatch*" "batch")
    '("GdaSet*" "params")
    '("GdaStatementModelUsage" "model_usage")
    '("GError**" "error")
  )
)

(define-method quote_sql_identifier
  (of-object "GdaConnection")
  (c-name "gda_connection_quote_sql_identifier")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "id")
  )
)

(define-method statement_to_sql
  (of-object "GdaConnection")
  (c-name "gda_connection_statement_to_sql")
  (return-type "gchar*")
  (parameters
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
    '("GdaStatementSqlFlag" "flags")
    '("GSList**" "params_used")
    '("GError**" "error")
  )
)

(define-method statement_prepare
  (of-object "GdaConnection")
  (c-name "gda_connection_statement_prepare")
  (return-type "gboolean")
  (parameters
    '("GdaStatement*" "stmt")
    '("GError**" "error")
  )
)

(define-method statement_execute
  (of-object "GdaConnection")
  (c-name "gda_connection_statement_execute")
  (return-type "GObject*")
  (parameters
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
    '("GdaStatementModelUsage" "model_usage")
    '("GdaSet**" "last_insert_row")
    '("GError**" "error")
  )
)

(define-method statement_execute_select
  (of-object "GdaConnection")
  (c-name "gda_connection_statement_execute_select")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
    '("GError**" "error")
  )
)

(define-method statement_execute_select_fullv
  (of-object "GdaConnection")
  (c-name "gda_connection_statement_execute_select_fullv")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
    '("GdaStatementModelUsage" "model_usage")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-method statement_execute_select_full
  (of-object "GdaConnection")
  (c-name "gda_connection_statement_execute_select_full")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
    '("GdaStatementModelUsage" "model_usage")
    '("GType*" "col_types")
    '("GError**" "error")
  )
)

(define-method statement_execute_non_select
  (of-object "GdaConnection")
  (c-name "gda_connection_statement_execute_non_select")
  (return-type "gint")
  (parameters
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
    '("GdaSet**" "last_insert_row")
    '("GError**" "error")
  )
)

(define-method async_statement_execute
  (of-object "GdaConnection")
  (c-name "gda_connection_async_statement_execute")
  (return-type "guint")
  (parameters
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
    '("GdaStatementModelUsage" "model_usage")
    '("GType*" "col_types")
    '("gboolean" "need_last_insert_row")
    '("GError**" "error")
  )
)

(define-method async_fetch_result
  (of-object "GdaConnection")
  (c-name "gda_connection_async_fetch_result")
  (return-type "GObject*")
  (parameters
    '("guint" "task_id")
    '("GdaSet**" "last_insert_row")
    '("GError**" "error")
  )
)

(define-method async_cancel
  (of-object "GdaConnection")
  (c-name "gda_connection_async_cancel")
  (return-type "gboolean")
  (parameters
    '("guint" "task_id")
    '("GError**" "error")
  )
)

(define-method repetitive_statement_execute
  (of-object "GdaConnection")
  (c-name "gda_connection_repetitive_statement_execute")
  (return-type "GSList*")
  (parameters
    '("GdaRepetitiveStatement*" "rstmt")
    '("GdaStatementModelUsage" "model_usage")
    '("GType*" "col_types")
    '("gboolean" "stop_on_error")
    '("GError**" "error")
  )
)

(define-method begin_transaction
  (of-object "GdaConnection")
  (c-name "gda_connection_begin_transaction")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GdaTransactionIsolation" "level")
    '("GError**" "error")
  )
)

(define-method commit_transaction
  (of-object "GdaConnection")
  (c-name "gda_connection_commit_transaction")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method rollback_transaction
  (of-object "GdaConnection")
  (c-name "gda_connection_rollback_transaction")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method add_savepoint
  (of-object "GdaConnection")
  (c-name "gda_connection_add_savepoint")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method rollback_savepoint
  (of-object "GdaConnection")
  (c-name "gda_connection_rollback_savepoint")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method delete_savepoint
  (of-object "GdaConnection")
  (c-name "gda_connection_delete_savepoint")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method get_transaction_status
  (of-object "GdaConnection")
  (c-name "gda_connection_get_transaction_status")
  (return-type "GdaTransactionStatus*")
)

(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_meta_store
  (of-object "GdaConnection")
  (c-name "gda_connection_get_meta_store")
  (return-type "GdaMetaStore*")
)

(define-method update_meta_store
  (of-object "GdaConnection")
  (c-name "gda_connection_update_meta_store")
  (return-type "gboolean")
  (parameters
    '("GdaMetaContext*" "context")
    '("GError**" "error")
  )
)

(define-method get_meta_store_data
  (of-object "GdaConnection")
  (c-name "gda_connection_get_meta_store_data")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaConnectionMetaType" "meta_type")
    '("GError**" "error")
    '("gint" "nb_filters")
  )
  (varargs #t)
)

(define-method get_meta_store_data_v
  (of-object "GdaConnection")
  (c-name "gda_connection_get_meta_store_data_v")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaConnectionMetaType" "meta_type")
    '("GList*" "filters")
    '("GError**" "error")
  )
)



;; From gda-connection-private.h

(define-method internal_set_provider_data
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_set_provider_data")
  (return-type "none")
  (parameters
    '("gpointer" "data")
    '("GDestroyNotify" "destroy_func")
  )
)

(define-method internal_get_provider_data
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_get_provider_data")
  (return-type "gpointer")
)

(define-method point_available_event
  (of-object "GdaConnection")
  (c-name "gda_connection_point_available_event")
  (return-type "GdaConnectionEvent*")
  (parameters
    '("GdaConnectionEventType" "type")
  )
)

(define-method add_event
  (of-object "GdaConnection")
  (c-name "gda_connection_add_event")
  (return-type "none")
  (parameters
    '("GdaConnectionEvent*" "event")
  )
)

(define-method add_event_string
  (of-object "GdaConnection")
  (c-name "gda_connection_add_event_string")
  (return-type "GdaConnectionEvent*")
  (parameters
    '("const-gchar*" "str")
  )
  (varargs #t)
)

(define-method clear_events_list
  (of-object "GdaConnection")
  (c-name "gda_connection_clear_events_list")
  (return-type "none")
)

(define-method internal_transaction_started
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_transaction_started")
  (return-type "none")
  (parameters
    '("const-gchar*" "parent_trans")
    '("const-gchar*" "trans_name")
    '("GdaTransactionIsolation" "isol_level")
  )
)

(define-method internal_transaction_rolledback
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_transaction_rolledback")
  (return-type "none")
  (parameters
    '("const-gchar*" "trans_name")
  )
)

(define-method internal_transaction_committed
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_transaction_committed")
  (return-type "none")
  (parameters
    '("const-gchar*" "trans_name")
  )
)

(define-method internal_statement_executed
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_statement_executed")
  (return-type "none")
  (parameters
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
    '("GdaConnectionEvent*" "error")
  )
)

(define-method internal_savepoint_added
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_savepoint_added")
  (return-type "none")
  (parameters
    '("const-gchar*" "parent_trans")
    '("const-gchar*" "svp_name")
  )
)

(define-method internal_savepoint_rolledback
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_savepoint_rolledback")
  (return-type "none")
  (parameters
    '("const-gchar*" "svp_name")
  )
)

(define-method internal_savepoint_removed
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_savepoint_removed")
  (return-type "none")
  (parameters
    '("const-gchar*" "svp_name")
  )
)

(define-method internal_change_transaction_state
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_change_transaction_state")
  (return-type "none")
  (parameters
    '("GdaTransactionStatusState" "newstate")
  )
)

(define-method internal_reset_transaction_status
  (of-object "GdaConnection")
  (c-name "gda_connection_internal_reset_transaction_status")
  (return-type "none")
)

(define-method add_prepared_statement
  (of-object "GdaConnection")
  (c-name "gda_connection_add_prepared_statement")
  (return-type "none")
  (parameters
    '("GdaStatement*" "gda_stmt")
    '("GdaPStmt*" "prepared_stmt")
  )
)

(define-method del_prepared_statement
  (of-object "GdaConnection")
  (c-name "gda_connection_del_prepared_statement")
  (return-type "none")
  (parameters
    '("GdaStatement*" "gda_stmt")
  )
)

(define-method get_prepared_statement
  (of-object "GdaConnection")
  (c-name "gda_connection_get_prepared_statement")
  (return-type "GdaPStmt*")
  (parameters
    '("GdaStatement*" "gda_stmt")
  )
)

(define-function gda_connection_open_sqlite
  (c-name "gda_connection_open_sqlite")
  (return-type "GdaConnection*")
  (parameters
    '("const-gchar*" "directory")
    '("const-gchar*" "filename")
    '("gboolean" "auto_unlink")
  )
)



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



;; From gda-data-comparator.h

(define-function gda_data_comparator_get_type
  (c-name "gda_data_comparator_get_type")
  (return-type "GType")
)

(define-function gda_data_comparator_new
  (c-name "gda_data_comparator_new")
  (is-constructor-of "GdaDataComparator")
  (return-type "GObject*")
  (parameters
    '("GdaDataModel*" "old_model")
    '("GdaDataModel*" "new_model")
  )
)

(define-method set_key_columns
  (of-object "GdaDataComparator")
  (c-name "gda_data_comparator_set_key_columns")
  (return-type "none")
  (parameters
    '("const-gint*" "col_numbers")
    '("gint" "nb_cols")
  )
)

(define-method compute_diff
  (of-object "GdaDataComparator")
  (c-name "gda_data_comparator_compute_diff")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method get_n_diffs
  (of-object "GdaDataComparator")
  (c-name "gda_data_comparator_get_n_diffs")
  (return-type "gint")
)

(define-method get_diff
  (of-object "GdaDataComparator")
  (c-name "gda_data_comparator_get_diff")
  (return-type "const-GdaDiff*")
  (parameters
    '("gint" "pos")
  )
)



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

(define-function gda_data_handler_get_default
  (c-name "gda_data_handler_get_default")
  (return-type "GdaDataHandler*")
  (parameters
    '("GType" "for_type")
  )
)



;; 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_with_g_types_v
  (c-name "gda_data_model_array_new_with_g_types_v")
  (return-type "GdaDataModel*")
  (parameters
    '("gint" "cols")
    '("GType*" "types")
  )
)

(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 "GdaDataModelArray*")
  (parameters
    '("GError**" "error")
  )
)

(define-method get_row
  (of-object "GdaDataModelArray")
  (c-name "gda_data_model_array_get_row")
  (return-type "GdaRow*")
  (parameters
    '("gint" "row")
    '("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-bdb.h

(define-function gda_data_model_bdb_get_type
  (c-name "gda_data_model_bdb_get_type")
  (return-type "GType")
)

(define-function gda_data_model_bdb_new
  (c-name "gda_data_model_bdb_new")
  (is-constructor-of "GdaDataModelBdb")
  (return-type "GdaDataModel*")
  (parameters
    '("const-gchar*" "filename")
    '("const-gchar*" "db_name")
  )
)

(define-method get_errors
  (of-object "GdaDataModelBdb")
  (c-name "gda_data_model_bdb_get_errors")
  (return-type "const-GSList*")
)

(define-method clean_errors
  (of-object "GdaDataModelBdb")
  (c-name "gda_data_model_bdb_clean_errors")
  (return-type "none")
)



;; From gda-data-model-dir.h

(define-function gda_data_model_dir_get_type
  (c-name "gda_data_model_dir_get_type")
  (return-type "GType")
)

(define-function gda_data_model_dir_new
  (c-name "gda_data_model_dir_new")
  (is-constructor-of "GdaDataModelDir")
  (return-type "GdaDataModel*")
  (parameters
    '("const-gchar*" "basedir")
  )
)

(define-method get_errors
  (of-object "GdaDataModelDir")
  (c-name "gda_data_model_dir_get_errors")
  (return-type "const-GSList*")
)

(define-method clean_errors
  (of-object "GdaDataModelDir")
  (c-name "gda_data_model_dir_clean_errors")
  (return-type "none")
)



;; From gda-data-model-extra.h

(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 reset
  (of-object "GdaDataModel")
  (c-name "gda_data_model_reset")
  (return-type "none")
)



;; From gda-data-model.h

(define-function gda_data_model_get_type
  (c-name "gda_data_model_get_type")
  (return-type "GType")
)

(define-method get_access_flags
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_access_flags")
  (return-type "GdaDataModelAccessFlags")
)

(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
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_column_index")
  (return-type "gint")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method get_column_name
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_column_name")
  (return-type "const-gchar*")
  (parameters
    '("gint" "col")
  )
)

(define-method set_column_name
  (of-object "GdaDataModel")
  (c-name "gda_data_model_set_column_name")
  (return-type "none")
  (parameters
    '("gint" "col")
    '("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")
    '("GError**" "error")
  )
)

(define-method get_typed_value_at
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_typed_value_at")
  (return-type "const-GValue*")
  (parameters
    '("gint" "col")
    '("gint" "row")
    '("GType" "expected_type")
    '("gboolean" "nullok")
    '("GError**" "error")
  )
)

(define-method get_attributes_at
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_attributes_at")
  (return-type "GdaValueAttribute")
  (parameters
    '("gint" "col")
    '("gint" "row")
  )
)

(define-method create_iter
  (of-object "GdaDataModel")
  (c-name "gda_data_model_create_iter")
  (return-type "GdaDataModelIter*")
)

(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 get_exceptions
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_exceptions")
  (return-type "GError**")
)

(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")
    '("GdaSet*" "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")
    '("GdaSet*" "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")
    '("gboolean" "overwrite")
    '("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")
    '("GdaSet*" "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")
    '("GdaSet*" "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-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")
    '("GdaSet*" "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")
    '("GdaSet*" "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-iter-extra.h

(define-method iter_move_to_row_default
  (of-object "GdaDataModel")
  (c-name "gda_data_model_iter_move_to_row_default")
  (return-type "gboolean")
  (parameters
    '("GdaDataModelIter*" "iter")
    '("gint" "row")
  )
)

(define-method iter_move_next_default
  (of-object "GdaDataModel")
  (c-name "gda_data_model_iter_move_next_default")
  (return-type "gboolean")
  (parameters
    '("GdaDataModelIter*" "iter")
  )
)

(define-method iter_move_prev_default
  (of-object "GdaDataModel")
  (c-name "gda_data_model_iter_move_prev_default")
  (return-type "gboolean")
  (parameters
    '("GdaDataModelIter*" "iter")
  )
)



;; 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 get_value_at
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_get_value_at")
  (return-type "const-GValue*")
  (parameters
    '("gint" "col")
  )
)

(define-method get_value_at_e
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_get_value_at_e")
  (return-type "const-GValue*")
  (parameters
    '("gint" "col")
    '("GError**" "error")
  )
)

(define-method get_value_for_field
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_get_value_for_field")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "field_name")
  )
)

(define-method set_value_at
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_set_value_at")
  (return-type "gboolean")
  (parameters
    '("gint" "col")
    '("const-GValue*" "value")
    '("GError**" "error")
  )
)

(define-method move_to_row
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_move_to_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_holder_for_field
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_get_holder_for_field")
  (return-type "GdaHolder*")
  (parameters
    '("gint" "col")
  )
)



;; From gda-data-model-ldap.h

(define-function gda_data_model_ldap_get_type
  (c-name "gda_data_model_ldap_get_type")
  (return-type "GType")
)

(define-function gda_data_model_ldap_new
  (c-name "gda_data_model_ldap_new")
  (is-constructor-of "GdaDataModelLdap")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "base_dn")
    '("const-gchar*" "filter")
    '("const-gchar*" "attributes")
    '("GdaLdapSearchScope" "scope")
  )
)

(define-function gda_data_model_ldap_compute_columns
  (c-name "gda_data_model_ldap_compute_columns")
  (return-type "GList*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "attributes")
  )
)



;; From gda-data-model-private.h

(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")
    '("GError**" "error")
  )
)



;; From gda-data-pivot.h

(define-function gda_data_pivot_get_type
  (c-name "gda_data_pivot_get_type")
  (return-type "GType")
)

(define-function gda_data_pivot_new
  (c-name "gda_data_pivot_new")
  (is-constructor-of "GdaDataPivot")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaDataModel*" "model")
  )
)

(define-method add_field
  (of-object "GdaDataPivot")
  (c-name "gda_data_pivot_add_field")
  (return-type "gboolean")
  (parameters
    '("GdaDataPivotFieldType" "field_type")
    '("const-gchar*" "field")
    '("const-gchar*" "alias")
    '("GError**" "error")
  )
)

(define-method add_data
  (of-object "GdaDataPivot")
  (c-name "gda_data_pivot_add_data")
  (return-type "gboolean")
  (parameters
    '("GdaDataPivotAggregate" "aggregate_type")
    '("const-gchar*" "field")
    '("const-gchar*" "alias")
    '("GError**" "error")
  )
)

(define-method populate
  (of-object "GdaDataPivot")
  (c-name "gda_data_pivot_populate")
  (return-type "gboolean")
  (parameters
    '("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 "GdaValueAttribute")
  (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")
    '("GdaValueAttribute" "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 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 get_n_modified_rows
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_n_modified_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")
)

(define-method set_filter_expr
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_set_filter_expr")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "filter_expr")
    '("GError**" "error")
  )
)

(define-method get_filter_expr
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_filter_expr")
  (return-type "const-gchar*")
)

(define-method set_ordering_column
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_set_ordering_column")
  (return-type "gboolean")
  (parameters
    '("gint" "col")
    '("GError**" "error")
  )
)

(define-method get_filtered_n_rows
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_filtered_n_rows")
  (return-type "gint")
)



;; From gda-data-select.h

(define-function gda_data_select_get_type
  (c-name "gda_data_select_get_type")
  (return-type "GType")
)

(define-method set_row_selection_condition
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_set_row_selection_condition")
  (return-type "gboolean")
  (parameters
    '("GdaSqlExpr*" "expr")
    '("GError**" "error")
  )
)

(define-method set_row_selection_condition_sql
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_set_row_selection_condition_sql")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "sql_where")
    '("GError**" "error")
  )
)

(define-method compute_row_selection_condition
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_compute_row_selection_condition")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method set_modification_statement
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_set_modification_statement")
  (return-type "gboolean")
  (parameters
    '("GdaStatement*" "mod_stmt")
    '("GError**" "error")
  )
)

(define-method set_modification_statement_sql
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_set_modification_statement_sql")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "sql")
    '("GError**" "error")
  )
)

(define-method compute_modification_statements
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_compute_modification_statements")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method compute_modification_statements_ext
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_compute_modification_statements_ext")
  (return-type "gboolean")
  (parameters
    '("GdaDataSelectConditionType" "cond_type")
    '("GError**" "error")
  )
)

(define-method compute_columns_attributes
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_compute_columns_attributes")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method get_connection
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_get_connection")
  (return-type "GdaConnection*")
)

(define-method rerun
  (of-object "GdaDataSelect")
  (c-name "gda_data_select_rerun")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)



;; From gda-debug-macros.h



;; From gda-decl.h



;; From gda-enums.h



;; From gda-enum-types.h

(define-function gda_batch_error_get_type
  (c-name "gda_batch_error_get_type")
  (return-type "GType")
)

(define-function gda_config_error_get_type
  (c-name "gda_config_error_get_type")
  (return-type "GType")
)

(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")
)

(define-function gda_connection_options_get_type
  (c-name "gda_connection_options_get_type")
  (return-type "GType")
)

(define-function gda_connection_feature_get_type
  (c-name "gda_connection_feature_get_type")
  (return-type "GType")
)

(define-function gda_connection_meta_type_get_type
  (c-name "gda_connection_meta_type_get_type")
  (return-type "GType")
)

(define-function gda_data_comparator_error_get_type
  (c-name "gda_data_comparator_error_get_type")
  (return-type "GType")
)

(define-function gda_diff_type_get_type
  (c-name "gda_diff_type_get_type")
  (return-type "GType")
)

(define-function gda_data_model_access_flags_get_type
  (c-name "gda_data_model_access_flags_get_type")
  (return-type "GType")
)

(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_error_get_type
  (c-name "gda_data_model_error_get_type")
  (return-type "GType")
)

(define-function gda_ldap_search_scope_get_type
  (c-name "gda_ldap_search_scope_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")
)

(define-function gda_data_proxy_error_get_type
  (c-name "gda_data_proxy_error_get_type")
  (return-type "GType")
)

(define-function gda_data_select_error_get_type
  (c-name "gda_data_select_error_get_type")
  (return-type "GType")
)

(define-function gda_data_select_condition_type_get_type
  (c-name "gda_data_select_condition_type_get_type")
  (return-type "GType")
)

(define-function gda_transaction_isolation_get_type
  (c-name "gda_transaction_isolation_get_type")
  (return-type "GType")
)

(define-function gda_value_attribute_get_type
  (c-name "gda_value_attribute_get_type")
  (return-type "GType")
)

(define-function gda_sql_identifier_style_get_type
  (c-name "gda_sql_identifier_style_get_type")
  (return-type "GType")
)

(define-function gda_holder_error_get_type
  (c-name "gda_holder_error_get_type")
  (return-type "GType")
)

(define-function gda_meta_store_error_get_type
  (c-name "gda_meta_store_error_get_type")
  (return-type "GType")
)

(define-function gda_meta_store_change_type_get_type
  (c-name "gda_meta_store_change_type_get_type")
  (return-type "GType")
)

(define-function gda_meta_struct_error_get_type
  (c-name "gda_meta_struct_error_get_type")
  (return-type "GType")
)

(define-function gda_meta_db_object_type_get_type
  (c-name "gda_meta_db_object_type_get_type")
  (return-type "GType")
)

(define-function gda_meta_struct_feature_get_type
  (c-name "gda_meta_struct_feature_get_type")
  (return-type "GType")
)

(define-function gda_meta_sort_type_get_type
  (c-name "gda_meta_sort_type_get_type")
  (return-type "GType")
)

(define-function gda_meta_foreign_key_policy_get_type
  (c-name "gda_meta_foreign_key_policy_get_type")
  (return-type "GType")
)

(define-function gda_meta_graph_info_get_type
  (c-name "gda_meta_graph_info_get_type")
  (return-type "GType")
)

(define-function gda_set_error_get_type
  (c-name "gda_set_error_get_type")
  (return-type "GType")
)

(define-function gda_server_operation_type_get_type
  (c-name "gda_server_operation_type_get_type")
  (return-type "GType")
)

(define-function gda_server_operation_error_get_type
  (c-name "gda_server_operation_error_get_type")
  (return-type "GType")
)

(define-function gda_server_operation_create_table_flag_get_type
  (c-name "gda_server_operation_create_table_flag_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-function gda_server_operation_node_status_get_type
  (c-name "gda_server_operation_node_status_get_type")
  (return-type "GType")
)

(define-function gda_server_provider_error_get_type
  (c-name "gda_server_provider_error_get_type")
  (return-type "GType")
)

(define-function gda_statement_error_get_type
  (c-name "gda_statement_error_get_type")
  (return-type "GType")
)

(define-function gda_statement_model_usage_get_type
  (c-name "gda_statement_model_usage_get_type")
  (return-type "GType")
)

(define-function gda_statement_sql_flag_get_type
  (c-name "gda_statement_sql_flag_get_type")
  (return-type "GType")
)

(define-function gda_sql_builder_error_get_type
  (c-name "gda_sql_builder_error_get_type")
  (return-type "GType")
)

(define-function gda_transaction_status_event_type_get_type
  (c-name "gda_transaction_status_event_type_get_type")
  (return-type "GType")
)

(define-function gda_transaction_status_state_get_type
  (c-name "gda_transaction_status_state_get_type")
  (return-type "GType")
)

(define-function gda_tree_error_get_type
  (c-name "gda_tree_error_get_type")
  (return-type "GType")
)

(define-function gda_tree_node_error_get_type
  (c-name "gda_tree_node_error_get_type")
  (return-type "GType")
)

(define-function gda_tree_manager_error_get_type
  (c-name "gda_tree_manager_error_get_type")
  (return-type "GType")
)

(define-function gda_xa_transaction_error_get_type
  (c-name "gda_xa_transaction_error_get_type")
  (return-type "GType")
)

(define-function gda_data_pivot_error_get_type
  (c-name "gda_data_pivot_error_get_type")
  (return-type "GType")
)

(define-function gda_data_pivot_aggregate_get_type
  (c-name "gda_data_pivot_aggregate_get_type")
  (return-type "GType")
)

(define-function gda_data_pivot_field_type_get_type
  (c-name "gda_data_pivot_field_type_get_type")
  (return-type "GType")
)



;; From gda-holder.h

(define-function gda_holder_get_type
  (c-name "gda_holder_get_type")
  (return-type "GType")
)

(define-function gda_holder_new
  (c-name "gda_holder_new")
  (is-constructor-of "GdaHolder")
  (return-type "GdaHolder*")
  (parameters
    '("GType" "type")
  )
)

(define-function gda_holder_new_inline
  (c-name "gda_holder_new_inline")
  (return-type "GdaHolder*")
  (parameters
    '("GType" "type")
    '("const-gchar*" "id")
  )
  (varargs #t)
)

(define-method copy
  (of-object "GdaHolder")
  (c-name "gda_holder_copy")
  (return-type "GdaHolder*")
)

(define-method get_g_type
  (of-object "GdaHolder")
  (c-name "gda_holder_get_g_type")
  (return-type "GType")
)

(define-method get_id
  (of-object "GdaHolder")
  (c-name "gda_holder_get_id")
  (return-type "const-gchar*")
)

(define-method get_value
  (of-object "GdaHolder")
  (c-name "gda_holder_get_value")
  (return-type "const-GValue*")
)

(define-method get_value_str
  (of-object "GdaHolder")
  (c-name "gda_holder_get_value_str")
  (return-type "gchar*")
  (parameters
    '("GdaDataHandler*" "dh")
  )
)

(define-method set_value
  (of-object "GdaHolder")
  (c-name "gda_holder_set_value")
  (return-type "gboolean")
  (parameters
    '("const-GValue*" "value")
    '("GError**" "error")
  )
)

(define-method take_value
  (of-object "GdaHolder")
  (c-name "gda_holder_take_value")
  (return-type "gboolean")
  (parameters
    '("GValue*" "value")
    '("GError**" "error")
  )
)

(define-method take_static_value
  (of-object "GdaHolder")
  (c-name "gda_holder_take_static_value")
  (return-type "GValue*")
  (parameters
    '("const-GValue*" "value")
    '("gboolean*" "value_changed")
    '("GError**" "error")
  )
)

(define-method set_value_str
  (of-object "GdaHolder")
  (c-name "gda_holder_set_value_str")
  (return-type "gboolean")
  (parameters
    '("GdaDataHandler*" "dh")
    '("const-gchar*" "value")
    '("GError**" "error")
  )
)

(define-method get_default_value
  (of-object "GdaHolder")
  (c-name "gda_holder_get_default_value")
  (return-type "const-GValue*")
)

(define-method set_default_value
  (of-object "GdaHolder")
  (c-name "gda_holder_set_default_value")
  (return-type "none")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-method set_value_to_default
  (of-object "GdaHolder")
  (c-name "gda_holder_set_value_to_default")
  (return-type "gboolean")
)

(define-method value_is_default
  (of-object "GdaHolder")
  (c-name "gda_holder_value_is_default")
  (return-type "gboolean")
)

(define-method force_invalid
  (of-object "GdaHolder")
  (c-name "gda_holder_force_invalid")
  (return-type "none")
)

(define-method force_invalid_e
  (of-object "GdaHolder")
  (c-name "gda_holder_force_invalid_e")
  (return-type "none")
  (parameters
    '("GError*" "error")
  )
)

(define-method is_valid
  (of-object "GdaHolder")
  (c-name "gda_holder_is_valid")
  (return-type "gboolean")
)

(define-method is_valid_e
  (of-object "GdaHolder")
  (c-name "gda_holder_is_valid_e")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method set_not_null
  (of-object "GdaHolder")
  (c-name "gda_holder_set_not_null")
  (return-type "none")
  (parameters
    '("gboolean" "not_null")
  )
)

(define-method get_not_null
  (of-object "GdaHolder")
  (c-name "gda_holder_get_not_null")
  (return-type "gboolean")
)

(define-method set_source_model
  (of-object "GdaHolder")
  (c-name "gda_holder_set_source_model")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "model")
    '("gint" "col")
    '("GError**" "error")
  )
)

(define-method get_source_model
  (of-object "GdaHolder")
  (c-name "gda_holder_get_source_model")
  (return-type "GdaDataModel*")
  (parameters
    '("gint*" "col")
  )
)

(define-method set_bind
  (of-object "GdaHolder")
  (c-name "gda_holder_set_bind")
  (return-type "gboolean")
  (parameters
    '("GdaHolder*" "bind_to")
    '("GError**" "error")
  )
)

(define-method get_bind
  (of-object "GdaHolder")
  (c-name "gda_holder_get_bind")
  (return-type "GdaHolder*")
)

(define-method get_attribute
  (of-object "GdaHolder")
  (c-name "gda_holder_get_attribute")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "attribute")
  )
)

(define-method set_attribute
  (of-object "GdaHolder")
  (c-name "gda_holder_set_attribute")
  (return-type "none")
  (parameters
    '("const-gchar*" "attribute")
    '("const-GValue*" "value")
    '("GDestroyNotify" "destroy")
  )
)



;; From gda-lockable.h

(define-function gda_lockable_get_type
  (c-name "gda_lockable_get_type")
  (return-type "GType")
)

(define-method lock
  (of-object "GdaLockable")
  (c-name "gda_lockable_lock")
  (return-type "none")
)

(define-method trylock
  (of-object "GdaLockable")
  (c-name "gda_lockable_trylock")
  (return-type "gboolean")
)

(define-method unlock
  (of-object "GdaLockable")
  (c-name "gda_lockable_unlock")
  (return-type "none")
)



;; From gda-log.h

(define-function gda_log_enable
  (c-name "gda_log_enable")
  (return-type "none")
)

(define-function gda_log_disable
  (c-name "gda_log_disable")
  (return-type "none")
)

(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
    '("const-gchar*" "format")
  )
  (varargs #t)
)

(define-function gda_log_error
  (c-name "gda_log_error")
  (return-type "none")
  (parameters
    '("const-gchar*" "format")
  )
  (varargs #t)
)



;; From gda-marshal.h



;; From gda-meta-store.h

(define-function gda_meta_store_get_type
  (c-name "gda_meta_store_get_type")
  (return-type "GType")
)

(define-function gda_meta_store_new_with_file
  (c-name "gda_meta_store_new_with_file")
  (return-type "GdaMetaStore*")
  (parameters
    '("const-gchar*" "file_name")
  )
)

(define-function gda_meta_store_new
  (c-name "gda_meta_store_new")
  (is-constructor-of "GdaMetaStore")
  (return-type "GdaMetaStore*")
  (parameters
    '("const-gchar*" "cnc_string")
  )
)

(define-method get_version
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_get_version")
  (return-type "gint")
)

(define-method get_internal_connection
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_get_internal_connection")
  (return-type "GdaConnection*")
)

(define-function gda_meta_store_sql_identifier_quote
  (c-name "gda_meta_store_sql_identifier_quote")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "id")
    '("GdaConnection*" "cnc")
  )
)

(define-method extract
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_extract")
  (return-type "GdaDataModel*")
  (parameters
    '("const-gchar*" "select_sql")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-method extract_v
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_extract_v")
  (return-type "GdaDataModel*")
  (parameters
    '("const-gchar*" "select_sql")
    '("GHashTable*" "vars")
    '("GError**" "error")
  )
)

(define-method modify
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_modify")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "table_name")
    '("GdaDataModel*" "new_data")
    '("const-gchar*" "condition")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-method modify_v
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_modify_v")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "table_name")
    '("GdaDataModel*" "new_data")
    '("const-gchar*" "condition")
    '("gint" "nvalues")
    '("const-gchar**" "value_names")
    '("const-GValue**" "values")
    '("GError**" "error")
  )
)

(define-method modify_with_context
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_modify_with_context")
  (return-type "gboolean")
  (parameters
    '("GdaMetaContext*" "context")
    '("GdaDataModel*" "new_data")
    '("GError**" "error")
  )
)

(define-method create_modify_data_model
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_create_modify_data_model")
  (return-type "GdaDataModel*")
  (parameters
    '("const-gchar*" "table_name")
  )
)

(define-method set_identifiers_style
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_set_identifiers_style")
  (return-type "none")
  (parameters
    '("GdaSqlIdentifierStyle" "style")
  )
)

(define-method set_reserved_keywords_func
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_set_reserved_keywords_func")
  (return-type "none")
  (parameters
    '("GdaSqlReservedKeywordsFunc" "func")
  )
)

(define-method get_attribute_value
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_get_attribute_value")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "att_name")
    '("gchar**" "att_value")
    '("GError**" "error")
  )
)

(define-method set_attribute_value
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_set_attribute_value")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "att_name")
    '("const-gchar*" "att_value")
    '("GError**" "error")
  )
)

(define-method schema_add_custom_object
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_schema_add_custom_object")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "xml_description")
    '("GError**" "error")
  )
)

(define-method schema_remove_custom_object
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_schema_remove_custom_object")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "obj_name")
    '("GError**" "error")
  )
)

(define-method schema_get_all_tables
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_schema_get_all_tables")
  (return-type "GSList*")
)

(define-method schema_get_depend_tables
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_schema_get_depend_tables")
  (return-type "GSList*")
  (parameters
    '("const-gchar*" "table_name")
  )
)

(define-method schema_get_structure
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_schema_get_structure")
  (return-type "GdaMetaStruct*")
  (parameters
    '("GError**" "error")
  )
)

(define-method declare_foreign_key
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_declare_foreign_key")
  (return-type "gboolean")
  (parameters
    '("GdaMetaStruct*" "mstruct")
    '("const-gchar*" "fk_name")
    '("const-gchar*" "catalog")
    '("const-gchar*" "schema")
    '("const-gchar*" "table")
    '("const-gchar*" "ref_catalog")
    '("const-gchar*" "ref_schema")
    '("const-gchar*" "ref_table")
    '("guint" "nb_cols")
    '("gchar**" "colnames")
    '("gchar**" "ref_colnames")
    '("GError**" "error")
  )
)

(define-method undeclare_foreign_key
  (of-object "GdaMetaStore")
  (c-name "gda_meta_store_undeclare_foreign_key")
  (return-type "gboolean")
  (parameters
    '("GdaMetaStruct*" "mstruct")
    '("const-gchar*" "fk_name")
    '("const-gchar*" "catalog")
    '("const-gchar*" "schema")
    '("const-gchar*" "table")
    '("const-gchar*" "ref_catalog")
    '("const-gchar*" "ref_schema")
    '("const-gchar*" "ref_table")
    '("GError**" "error")
  )
)



;; From gda-meta-struct.h

(define-method get_attribute
  (of-object "GdaMetaTableColumn")
  (c-name "gda_meta_table_column_get_attribute")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "attribute")
  )
)

(define-method set_attribute
  (of-object "GdaMetaTableColumn")
  (c-name "gda_meta_table_column_set_attribute")
  (return-type "none")
  (parameters
    '("const-gchar*" "attribute")
    '("const-GValue*" "value")
    '("GDestroyNotify" "destroy")
  )
)

(define-method foreach_attribute
  (of-object "GdaMetaTableColumn")
  (c-name "gda_meta_table_column_foreach_attribute")
  (return-type "none")
  (parameters
    '("GdaAttributesManagerFunc" "func")
    '("gpointer" "data")
  )
)

(define-function gda_meta_struct_get_type
  (c-name "gda_meta_struct_get_type")
  (return-type "GType")
)

(define-function gda_meta_struct_new
  (c-name "gda_meta_struct_new")
  (is-constructor-of "GdaMetaStruct")
  (return-type "GdaMetaStruct*")
  (parameters
    '("GdaMetaStore*" "store")
    '("GdaMetaStructFeature" "features")
  )
)

(define-method complement
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_complement")
  (return-type "GdaMetaDbObject*")
  (parameters
    '("GdaMetaDbObjectType" "type")
    '("const-GValue*" "catalog")
    '("const-GValue*" "schema")
    '("const-GValue*" "name")
    '("GError**" "error")
  )
)

(define-method complement_schema
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_complement_schema")
  (return-type "gboolean")
  (parameters
    '("const-GValue*" "catalog")
    '("const-GValue*" "schema")
    '("GError**" "error")
  )
)

(define-method complement_default
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_complement_default")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method complement_all
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_complement_all")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method complement_depend
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_complement_depend")
  (return-type "gboolean")
  (parameters
    '("GdaMetaDbObject*" "dbo")
    '("GError**" "error")
  )
)

(define-method sort_db_objects
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_sort_db_objects")
  (return-type "gboolean")
  (parameters
    '("GdaMetaSortType" "sort_type")
    '("GError**" "error")
  )
)

(define-method get_all_db_objects
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_get_all_db_objects")
  (return-type "GSList*")
)

(define-method get_db_object
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_get_db_object")
  (return-type "GdaMetaDbObject*")
  (parameters
    '("const-GValue*" "catalog")
    '("const-GValue*" "schema")
    '("const-GValue*" "name")
  )
)

(define-method get_table_column
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_get_table_column")
  (return-type "GdaMetaTableColumn*")
  (parameters
    '("GdaMetaTable*" "table")
    '("const-GValue*" "col_name")
  )
)

(define-method dump_as_graph
  (of-object "GdaMetaStruct")
  (c-name "gda_meta_struct_dump_as_graph")
  (return-type "gchar*")
  (parameters
    '("GdaMetaGraphInfo" "info")
    '("GError**" "error")
  )
)



;; From gda-mutex.h

(define-function gda_mutex_new
  (c-name "gda_mutex_new")
  (is-constructor-of "GdaMutex")
  (return-type "GdaMutex*")
)

(define-method lock
  (of-object "GdaMutex")
  (c-name "gda_mutex_lock")
  (return-type "none")
)

(define-method trylock
  (of-object "GdaMutex")
  (c-name "gda_mutex_trylock")
  (return-type "gboolean")
)

(define-method unlock
  (of-object "GdaMutex")
  (c-name "gda_mutex_unlock")
  (return-type "none")
)

(define-method free
  (of-object "GdaMutex")
  (c-name "gda_mutex_free")
  (return-type "none")
)

(define-method debug
  (of-object "GdaMutex")
  (c-name "gda_mutex_debug")
  (return-type "none")
  (parameters
    '("gboolean" "debug")
  )
)

(define-method dump_usage
  (of-object "GdaMutex")
  (c-name "gda_mutex_dump_usage")
  (return-type "none")
  (parameters
    '("FILE*" "stream")
  )
)



;; From gda-quark-list.h

(define-function gda_quark_list_get_type
  (c-name "gda_quark_list_get_type")
  (return-type "GType")
)

(define-function gda_quark_list_new
  (c-name "gda_quark_list_new")
  (is-constructor-of "GdaQuarkList")
  (return-type "GdaQuarkList*")
)

(define-function gda_quark_list_new_from_string
  (c-name "gda_quark_list_new_from_string")
  (return-type "GdaQuarkList*")
  (parameters
    '("const-gchar*" "string")
  )
)

(define-method copy
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_copy")
  (return-type "GdaQuarkList*")
)

(define-method free
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_free")
  (return-type "none")
)

(define-method add_from_string
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_add_from_string")
  (return-type "none")
  (parameters
    '("const-gchar*" "string")
    '("gboolean" "cleanup")
  )
)

(define-method find
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_find")
  (return-type "const-gchar*")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method remove
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_remove")
  (return-type "none")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method clear
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_clear")
  (return-type "none")
)

(define-method foreach
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_foreach")
  (return-type "none")
  (parameters
    '("GHFunc" "func")
    '("gpointer" "user_data")
  )
)



;; From gda-repetitive-statement.h

(define-function gda_repetitive_statement_get_type
  (c-name "gda_repetitive_statement_get_type")
  (return-type "GType")
)

(define-function gda_repetitive_statement_new
  (c-name "gda_repetitive_statement_new")
  (is-constructor-of "GdaRepetitiveStatement")
  (return-type "GdaRepetitiveStatement*")
  (parameters
    '("GdaStatement*" "stmt")
  )
)

(define-method get_template_set
  (of-object "GdaRepetitiveStatement")
  (c-name "gda_repetitive_statement_get_template_set")
  (return-type "gboolean")
  (parameters
    '("GdaSet**" "set")
    '("GError**" "error")
  )
)

(define-method get_all_sets
  (of-object "GdaRepetitiveStatement")
  (c-name "gda_repetitive_statement_get_all_sets")
  (return-type "GSList*")
)

(define-method append_set
  (of-object "GdaRepetitiveStatement")
  (c-name "gda_repetitive_statement_append_set")
  (return-type "gboolean")
  (parameters
    '("GdaSet*" "values")
    '("gboolean" "make_copy")
  )
)



;; 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
    '("gint" "count")
  )
)

(define-method get_length
  (of-object "GdaRow")
  (c-name "gda_row_get_length")
  (return-type "gint")
)

(define-method get_value
  (of-object "GdaRow")
  (c-name "gda_row_get_value")
  (return-type "GValue*")
  (parameters
    '("gint" "num")
  )
)

(define-method invalidate_value
  (of-object "GdaRow")
  (c-name "gda_row_invalidate_value")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method invalidate_value_e
  (of-object "GdaRow")
  (c-name "gda_row_invalidate_value_e")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("GError*" "error")
  )
)

(define-method value_is_valid
  (of-object "GdaRow")
  (c-name "gda_row_value_is_valid")
  (return-type "gboolean")
  (parameters
    '("GValue*" "value")
  )
)

(define-method value_is_valid_e
  (of-object "GdaRow")
  (c-name "gda_row_value_is_valid_e")
  (return-type "gboolean")
  (parameters
    '("GValue*" "value")
    '("GError**" "error")
  )
)



;; From gda-server-operation.h

(define-function gda_server_operation_get_type
  (c-name "gda_server_operation_get_type")
  (return-type "GType")
)

(define-function gda_server_operation_new
  (c-name "gda_server_operation_new")
  (is-constructor-of "GdaServerOperation")
  (return-type "GdaServerOperation*")
  (parameters
    '("GdaServerOperationType" "op_type")
    '("const-gchar*" "xml_file")
  )
)

(define-method get_op_type
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_op_type")
  (return-type "GdaServerOperationType")
)

(define-function gda_server_operation_op_type_to_string
  (c-name "gda_server_operation_op_type_to_string")
  (return-type "const-gchar*")
  (parameters
    '("GdaServerOperationType" "type")
  )
)

(define-function gda_server_operation_string_to_op_type
  (c-name "gda_server_operation_string_to_op_type")
  (return-type "GdaServerOperationType")
  (parameters
    '("const-gchar*" "str")
  )
)

(define-method get_node_info
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_node_info")
  (return-type "GdaServerOperationNode*")
  (parameters
    '("const-gchar*" "path_format")
  )
  (varargs #t)
)

(define-method get_value_at
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_value_at")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "path_format")
  )
  (varargs #t)
)

(define-method get_value_at_path
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_value_at_path")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method get_sql_identifier_at
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sql_identifier_at")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerProvider*" "prov")
    '("const-gchar*" "path_format")
  )
  (varargs #t)
)

(define-method get_sql_identifier_at_path
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sql_identifier_at_path")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerProvider*" "prov")
    '("const-gchar*" "path")
  )
)

(define-method set_value_at
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_set_value_at")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "value")
    '("GError**" "error")
    '("const-gchar*" "path_format")
  )
  (varargs #t)
)

(define-method set_value_at_path
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_set_value_at_path")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "value")
    '("const-gchar*" "path")
    '("GError**" "error")
  )
)

(define-method save_data_to_xml
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_save_data_to_xml")
  (return-type "xmlNodePtr")
  (parameters
    '("GError**" "error")
  )
)

(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-method get_root_nodes
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_root_nodes")
  (return-type "gchar**")
)

(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 get_node_parent
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_node_parent")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "path")
  )
)

(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 get_sequence_name
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sequence_name")
  (return-type "const-gchar*")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method get_sequence_size
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sequence_size")
  (return-type "guint")
  (parameters
    '("const-gchar*" "path")
  )
)

(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-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-method get_sequence_item_names
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sequence_item_names")
  (return-type "gchar**")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method add_item_to_sequence
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_add_item_to_sequence")
  (return-type "guint")
  (parameters
    '("const-gchar*" "seq_path")
  )
)

(define-method del_item_from_sequence
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_del_item_from_sequence")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "item_path")
  )
)

(define-method is_valid
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_is_valid")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "xml_file")
    '("GError**" "error")
  )
)

(define-function gda_server_operation_prepare_create_database
  (c-name "gda_server_operation_prepare_create_database")
  (return-type "GdaServerOperation*")
  (parameters
    '("const-gchar*" "provider")
    '("const-gchar*" "db_name")
    '("GError**" "error")
  )
)

(define-method perform_create_database
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_perform_create_database")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "provider")
    '("GError**" "error")
  )
)

(define-function gda_server_operation_prepare_drop_database
  (c-name "gda_server_operation_prepare_drop_database")
  (return-type "GdaServerOperation*")
  (parameters
    '("const-gchar*" "provider")
    '("const-gchar*" "db_name")
    '("GError**" "error")
  )
)

(define-method perform_drop_database
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_perform_drop_database")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "provider")
    '("GError**" "error")
  )
)

(define-function gda_server_operation_prepare_create_table
  (c-name "gda_server_operation_prepare_create_table")
  (return-type "GdaServerOperation*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "table_name")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-method perform_create_table
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_perform_create_table")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-function gda_server_operation_prepare_drop_table
  (c-name "gda_server_operation_prepare_drop_table")
  (return-type "GdaServerOperation*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "table_name")
    '("GError**" "error")
  )
)

(define-method perform_drop_table
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_perform_drop_table")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)



;; From gda-server-provider-extra.h

(define-method internal_get_parser
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_internal_get_parser")
  (return-type "GdaSqlParser*")
)

(define-method perform_operation_default
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_perform_operation_default")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerOperation*" "op")
    '("GError**" "error")
  )
)

(define-method get_data_handler_default
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_data_handler_default")
  (return-type "GdaDataHandler*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GType" "type")
    '("const-gchar*" "dbms_type")
  )
)

(define-function gda_select_alter_select_for_empty
  (c-name "gda_select_alter_select_for_empty")
  (return-type "GdaStatement*")
  (parameters
    '("GdaStatement*" "stmt")
    '("GError**" "error")
  )
)

(define-method handler_find
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_handler_find")
  (return-type "GdaDataHandler*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GType" "g_type")
    '("const-gchar*" "dbms_type")
  )
)

(define-method handler_declare
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_handler_declare")
  (return-type "none")
  (parameters
    '("GdaDataHandler*" "dh")
    '("GdaConnection*" "cnc")
    '("GType" "g_type")
    '("const-gchar*" "dbms_type")
  )
)

(define-method find_file
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_find_file")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "inst_dir")
    '("const-gchar*" "filename")
  )
)

(define-function gda_server_provider_load_file_contents
  (c-name "gda_server_provider_load_file_contents")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "inst_dir")
    '("const-gchar*" "data_dir")
    '("const-gchar*" "filename")
  )
)



;; 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_name
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_name")
  (return-type "const-gchar*")
)

(define-method get_version
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_version")
  (return-type "const-gchar*")
)

(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 supports_feature
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_supports_feature")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaConnectionFeature" "feature")
  )
)

(define-method get_data_handler_g_type
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_data_handler_g_type")
  (return-type "GdaDataHandler*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GType" "for_type")
  )
)

(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 string_to_value
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_string_to_value")
  (return-type "GValue*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "string")
    '("GType" "preferred_type")
    '("gchar**" "dbms_type")
  )
)

(define-method value_to_sql_string
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_value_to_sql_string")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GValue*" "from")
  )
)

(define-method get_default_dbms_type
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_default_dbms_type")
  (return-type "const-gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GType" "type")
  )
)

(define-method escape_string
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_escape_string")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "str")
  )
)

(define-method unescape_string
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_unescape_string")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "str")
  )
)

(define-method supports_operation
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_supports_operation")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerOperationType" "type")
    '("GdaSet*" "options")
  )
)

(define-method create_operation
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_create_operation")
  (return-type "GdaServerOperation*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerOperationType" "type")
    '("GdaSet*" "options")
    '("GError**" "error")
  )
)

(define-method render_operation
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_render_operation")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerOperation*" "op")
    '("GError**" "error")
  )
)

(define-method perform_operation
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_perform_operation")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerOperation*" "op")
    '("GError**" "error")
  )
)

(define-method create_parser
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_create_parser")
  (return-type "GdaSqlParser*")
  (parameters
    '("GdaConnection*" "cnc")
  )
)



;; From gda-server-provider-private.h



;; From gda-set.h

(define-function gda_set_get_type
  (c-name "gda_set_get_type")
  (return-type "GType")
)

(define-function gda_set_new
  (c-name "gda_set_new")
  (is-constructor-of "GdaSet")
  (return-type "GdaSet*")
  (parameters
    '("GSList*" "holders")
  )
)

(define-method copy
  (of-object "GdaSet")
  (c-name "gda_set_copy")
  (return-type "GdaSet*")
)

(define-function gda_set_new_inline
  (c-name "gda_set_new_inline")
  (return-type "GdaSet*")
  (parameters
    '("gint" "nb")
  )
  (varargs #t)
)

(define-function gda_set_new_from_spec_string
  (c-name "gda_set_new_from_spec_string")
  (return-type "GdaSet*")
  (parameters
    '("const-gchar*" "xml_spec")
    '("GError**" "error")
  )
)

(define-function gda_set_new_from_spec_node
  (c-name "gda_set_new_from_spec_node")
  (return-type "GdaSet*")
  (parameters
    '("xmlNodePtr" "xml_spec")
    '("GError**" "error")
  )
)

(define-method set_holder_value
  (of-object "GdaSet")
  (c-name "gda_set_set_holder_value")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
    '("const-gchar*" "holder_id")
  )
  (varargs #t)
)

(define-method get_holder_value
  (of-object "GdaSet")
  (c-name "gda_set_get_holder_value")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "holder_id")
  )
)

(define-method get_holder
  (of-object "GdaSet")
  (c-name "gda_set_get_holder")
  (return-type "GdaHolder*")
  (parameters
    '("const-gchar*" "holder_id")
  )
)

(define-method get_nth_holder
  (of-object "GdaSet")
  (c-name "gda_set_get_nth_holder")
  (return-type "GdaHolder*")
  (parameters
    '("gint" "pos")
  )
)

(define-method add_holder
  (of-object "GdaSet")
  (c-name "gda_set_add_holder")
  (return-type "gboolean")
  (parameters
    '("GdaHolder*" "holder")
  )
)

(define-method remove_holder
  (of-object "GdaSet")
  (c-name "gda_set_remove_holder")
  (return-type "none")
  (parameters
    '("GdaHolder*" "holder")
  )
)

(define-method merge_with_set
  (of-object "GdaSet")
  (c-name "gda_set_merge_with_set")
  (return-type "none")
  (parameters
    '("GdaSet*" "set_to_merge")
  )
)

(define-method is_valid
  (of-object "GdaSet")
  (c-name "gda_set_is_valid")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method replace_source_model
  (of-object "GdaSet")
  (c-name "gda_set_replace_source_model")
  (return-type "none")
  (parameters
    '("GdaSetSource*" "source")
    '("GdaDataModel*" "model")
  )
)

(define-method get_node
  (of-object "GdaSet")
  (c-name "gda_set_get_node")
  (return-type "GdaSetNode*")
  (parameters
    '("GdaHolder*" "holder")
  )
)

(define-method get_source_for_model
  (of-object "GdaSet")
  (c-name "gda_set_get_source_for_model")
  (return-type "GdaSetSource*")
  (parameters
    '("GdaDataModel*" "model")
  )
)

(define-method get_source
  (of-object "GdaSet")
  (c-name "gda_set_get_source")
  (return-type "GdaSetSource*")
  (parameters
    '("GdaHolder*" "holder")
  )
)

(define-method get_group
  (of-object "GdaSet")
  (c-name "gda_set_get_group")
  (return-type "GdaSetGroup*")
  (parameters
    '("GdaHolder*" "holder")
  )
)

(define-function gda_set_new_read_only
  (c-name "gda_set_new_read_only")
  (return-type "GdaSet*")
  (parameters
    '("GSList*" "holders")
  )
)



;; From gda-sql-builder.h

(define-function gda_sql_builder_get_type
  (c-name "gda_sql_builder_get_type")
  (return-type "GType")
)

(define-function gda_sql_builder_new
  (c-name "gda_sql_builder_new")
  (is-constructor-of "GdaSqlBuilder")
  (return-type "GdaSqlBuilder*")
  (parameters
    '("GdaSqlStatementType" "stmt_type")
  )
)

(define-method get_statement
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_get_statement")
  (return-type "GdaStatement*")
  (parameters
    '("GError**" "error")
  )
)

(define-method get_sql_statement
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_get_sql_statement")
  (return-type "GdaSqlStatement*")
)

(define-method add_id
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_id")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("const-gchar*" "str")
  )
)

(define-method add_field_id
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_field_id")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("const-gchar*" "field_name")
    '("const-gchar*" "table_name")
  )
)

(define-method add_expr
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_expr")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaDataHandler*" "dh")
    '("GType" "type")
  )
  (varargs #t)
)

(define-method add_expr_value
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_expr_value")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaDataHandler*" "dh")
    '("const-GValue*" "value")
  )
)

(define-method add_param
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_param")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("const-gchar*" "param_name")
    '("GType" "type")
    '("gboolean" "nullok")
  )
)

(define-method add_cond
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_cond")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaSqlOperatorType" "op")
    '("GdaSqlBuilderId" "op1")
    '("GdaSqlBuilderId" "op2")
    '("GdaSqlBuilderId" "op3")
  )
)

(define-method add_cond_v
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_cond_v")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaSqlOperatorType" "op")
    '("const-GdaSqlBuilderId*" "op_ids")
    '("gint" "op_ids_size")
  )
)

(define-method add_function
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_function")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("const-gchar*" "func_name")
  )
  (varargs #t)
)

(define-method add_function_v
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_function_v")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("const-gchar*" "func_name")
    '("const-GdaSqlBuilderId*" "args")
    '("gint" "args_size")
  )
)

(define-method add_sub_select
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_sub_select")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaSqlStatement*" "sqlst")
  )
)

(define-method add_case
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_case")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaSqlBuilderId" "test_expr")
    '("GdaSqlBuilderId" "else_expr")
  )
  (varargs #t)
)

(define-method add_case_v
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_case_v")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaSqlBuilderId" "test_expr")
    '("GdaSqlBuilderId" "else_expr")
    '("const-GdaSqlBuilderId*" "when_array")
    '("const-GdaSqlBuilderId*" "then_array")
    '("gint" "args_size")
  )
)

(define-method add_field_value
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_field_value")
  (return-type "none")
  (parameters
    '("const-gchar*" "field_name")
    '("GType" "type")
  )
  (varargs #t)
)

(define-method add_field_value_as_gvalue
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_field_value_as_gvalue")
  (return-type "none")
  (parameters
    '("const-gchar*" "field_name")
    '("const-GValue*" "value")
  )
)

(define-method add_field_value_id
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_add_field_value_id")
  (return-type "none")
  (parameters
    '("GdaSqlBuilderId" "field_id")
    '("GdaSqlBuilderId" "value_id")
  )
)

(define-method set_table
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_set_table")
  (return-type "none")
  (parameters
    '("const-gchar*" "table_name")
  )
)

(define-method set_where
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_set_where")
  (return-type "none")
  (parameters
    '("GdaSqlBuilderId" "cond_id")
  )
)

(define-method select_add_field
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_select_add_field")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("const-gchar*" "field_name")
    '("const-gchar*" "table_name")
    '("const-gchar*" "alias")
  )
)

(define-method select_add_target
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_select_add_target")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("const-gchar*" "table_name")
    '("const-gchar*" "alias")
  )
)

(define-method select_add_target_id
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_select_add_target_id")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaSqlBuilderId" "table_id")
    '("const-gchar*" "alias")
  )
)

(define-method select_join_targets
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_select_join_targets")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaSqlBuilderId" "left_target_id")
    '("GdaSqlBuilderId" "right_target_id")
    '("GdaSqlSelectJoinType" "join_type")
    '("GdaSqlBuilderId" "join_expr")
  )
)

(define-method join_add_field
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_join_add_field")
  (return-type "none")
  (parameters
    '("GdaSqlBuilderId" "join_id")
    '("const-gchar*" "field_name")
  )
)

(define-method select_order_by
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_select_order_by")
  (return-type "none")
  (parameters
    '("GdaSqlBuilderId" "expr_id")
    '("gboolean" "asc")
    '("const-gchar*" "collation_name")
  )
)

(define-method select_set_distinct
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_select_set_distinct")
  (return-type "none")
  (parameters
    '("gboolean" "distinct")
    '("GdaSqlBuilderId" "expr_id")
  )
)

(define-method select_set_limit
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_select_set_limit")
  (return-type "none")
  (parameters
    '("GdaSqlBuilderId" "limit_count_expr_id")
    '("GdaSqlBuilderId" "limit_offset_expr_id")
  )
)

(define-method select_set_having
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_select_set_having")
  (return-type "none")
  (parameters
    '("GdaSqlBuilderId" "cond_id")
  )
)

(define-method select_group_by
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_select_group_by")
  (return-type "none")
  (parameters
    '("GdaSqlBuilderId" "expr_id")
  )
)

(define-method compound_set_type
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_compound_set_type")
  (return-type "none")
  (parameters
    '("GdaSqlStatementCompoundType" "compound_type")
  )
)

(define-method compound_add_sub_select
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_compound_add_sub_select")
  (return-type "none")
  (parameters
    '("GdaSqlStatement*" "sqlst")
  )
)

(define-method compound_add_sub_select_from_builder
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_compound_add_sub_select_from_builder")
  (return-type "none")
  (parameters
    '("GdaSqlBuilder*" "subselect")
  )
)

(define-method export_expression
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_export_expression")
  (return-type "GdaSqlExpr*")
  (parameters
    '("GdaSqlBuilderId" "id")
  )
)

(define-method import_expression
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_import_expression")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaSqlExpr*" "expr")
  )
)

(define-method import_expression_from_builder
  (of-object "GdaSqlBuilder")
  (c-name "gda_sql_builder_import_expression_from_builder")
  (return-type "GdaSqlBuilderId")
  (parameters
    '("GdaSqlBuilder*" "query")
    '("GdaSqlBuilderId" "expr_id")
  )
)



;; From gda-statement-extra.h

(define-method to_sql_real
  (of-object "GdaStatement")
  (c-name "gda_statement_to_sql_real")
  (return-type "gchar*")
  (parameters
    '("GdaSqlRenderingContext*" "context")
    '("GError**" "error")
  )
)



;; From gda-statement.h

(define-function gda_statement_get_type
  (c-name "gda_statement_get_type")
  (return-type "GType")
)

(define-function gda_statement_new
  (c-name "gda_statement_new")
  (is-constructor-of "GdaStatement")
  (return-type "GdaStatement*")
)

(define-method copy
  (of-object "GdaStatement")
  (c-name "gda_statement_copy")
  (return-type "GdaStatement*")
)

(define-method serialize
  (of-object "GdaStatement")
  (c-name "gda_statement_serialize")
  (return-type "gchar*")
)

(define-method get_parameters
  (of-object "GdaStatement")
  (c-name "gda_statement_get_parameters")
  (return-type "gboolean")
  (parameters
    '("GdaSet**" "out_params")
    '("GError**" "error")
  )
)

(define-method to_sql_extended
  (of-object "GdaStatement")
  (c-name "gda_statement_to_sql_extended")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaSet*" "params")
    '("GdaStatementSqlFlag" "flags")
    '("GSList**" "params_used")
    '("GError**" "error")
  )
)

(define-method get_statement_type
  (of-object "GdaStatement")
  (c-name "gda_statement_get_statement_type")
  (return-type "GdaSqlStatementType")
)

(define-method is_useless
  (of-object "GdaStatement")
  (c-name "gda_statement_is_useless")
  (return-type "gboolean")
)

(define-method check_structure
  (of-object "GdaStatement")
  (c-name "gda_statement_check_structure")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method check_validity
  (of-object "GdaStatement")
  (c-name "gda_statement_check_validity")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GError**" "error")
  )
)

(define-method normalize
  (of-object "GdaStatement")
  (c-name "gda_statement_normalize")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GError**" "error")
  )
)



;; From gda-transaction-status.h

(define-function gda_transaction_status_get_type
  (c-name "gda_transaction_status_get_type")
  (return-type "GType")
)

(define-function gda_transaction_status_new
  (c-name "gda_transaction_status_new")
  (is-constructor-of "GdaTransactionStatus")
  (return-type "GdaTransactionStatus*")
  (parameters
    '("const-gchar*" "name")
  )
)



;; From gda-transaction-status-private.h

(define-method add_event_svp
  (of-object "GdaTransactionStatus")
  (c-name "gda_transaction_status_add_event_svp")
  (return-type "GdaTransactionStatusEvent*")
  (parameters
    '("const-gchar*" "svp_name")
  )
)

(define-method add_event_sql
  (of-object "GdaTransactionStatus")
  (c-name "gda_transaction_status_add_event_sql")
  (return-type "GdaTransactionStatusEvent*")
  (parameters
    '("const-gchar*" "sql")
    '("GdaConnectionEvent*" "conn_event")
  )
)

(define-method add_event_sub
  (of-object "GdaTransactionStatus")
  (c-name "gda_transaction_status_add_event_sub")
  (return-type "GdaTransactionStatusEvent*")
  (parameters
    '("GdaTransactionStatus*" "sub_trans")
  )
)

(define-method free_events
  (of-object "GdaTransactionStatus")
  (c-name "gda_transaction_status_free_events")
  (return-type "none")
  (parameters
    '("GdaTransactionStatusEvent*" "event")
    '("gboolean" "free_after")
  )
)

(define-method find
  (of-object "GdaTransactionStatus")
  (c-name "gda_transaction_status_find")
  (return-type "GdaTransactionStatus*")
  (parameters
    '("const-gchar*" "str")
    '("GdaTransactionStatusEvent**" "destev")
  )
)

(define-method find_current
  (of-object "GdaTransactionStatus")
  (c-name "gda_transaction_status_find_current")
  (return-type "GdaTransactionStatus*")
  (parameters
    '("GdaTransactionStatusEvent**" "destev")
    '("gboolean" "unnamed_only")
  )
)

(define-method dump
  (of-object "GdaTransactionStatus")
  (c-name "gda_transaction_status_dump")
  (return-type "none")
  (parameters
    '("guint" "offset")
  )
)



;; From gda-tree.h

(define-function gda_tree_get_type
  (c-name "gda_tree_get_type")
  (return-type "GType")
)

(define-function gda_tree_new
  (c-name "gda_tree_new")
  (is-constructor-of "GdaTree")
  (return-type "GdaTree*")
)

(define-method add_manager
  (of-object "GdaTree")
  (c-name "gda_tree_add_manager")
  (return-type "none")
  (parameters
    '("GdaTreeManager*" "manager")
  )
)

(define-method clean
  (of-object "GdaTree")
  (c-name "gda_tree_clean")
  (return-type "none")
)

(define-method update_all
  (of-object "GdaTree")
  (c-name "gda_tree_update_all")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method update_part
  (of-object "GdaTree")
  (c-name "gda_tree_update_part")
  (return-type "gboolean")
  (parameters
    '("GdaTreeNode*" "node")
    '("GError**" "error")
  )
)

(define-method update_children
  (of-object "GdaTree")
  (c-name "gda_tree_update_children")
  (return-type "gboolean")
  (parameters
    '("GdaTreeNode*" "node")
    '("GError**" "error")
  )
)

(define-method get_nodes_in_path
  (of-object "GdaTree")
  (c-name "gda_tree_get_nodes_in_path")
  (return-type "GSList*")
  (parameters
    '("const-gchar*" "tree_path")
    '("gboolean" "use_names")
  )
)

(define-method get_node
  (of-object "GdaTree")
  (c-name "gda_tree_get_node")
  (return-type "GdaTreeNode*")
  (parameters
    '("const-gchar*" "tree_path")
    '("gboolean" "use_names")
  )
)

(define-method get_node_path
  (of-object "GdaTree")
  (c-name "gda_tree_get_node_path")
  (return-type "gchar*")
  (parameters
    '("GdaTreeNode*" "node")
  )
)

(define-method get_node_manager
  (of-object "GdaTree")
  (c-name "gda_tree_get_node_manager")
  (return-type "GdaTreeManager*")
  (parameters
    '("GdaTreeNode*" "node")
  )
)

(define-method set_attribute
  (of-object "GdaTree")
  (c-name "gda_tree_set_attribute")
  (return-type "none")
  (parameters
    '("const-gchar*" "attribute")
    '("const-GValue*" "value")
    '("GDestroyNotify" "destroy")
  )
)

(define-method dump
  (of-object "GdaTree")
  (c-name "gda_tree_dump")
  (return-type "none")
  (parameters
    '("GdaTreeNode*" "node")
    '("FILE*" "stream")
  )
)



;; From gda-tree-manager.h

(define-function gda_tree_manager_get_type
  (c-name "gda_tree_manager_get_type")
  (return-type "GType")
)

(define-function gda_tree_manager_new_with_func
  (c-name "gda_tree_manager_new_with_func")
  (return-type "GdaTreeManager*")
  (parameters
    '("GdaTreeManagerNodesFunc" "update_func")
  )
)

(define-method add_manager
  (of-object "GdaTreeManager")
  (c-name "gda_tree_manager_add_manager")
  (return-type "none")
  (parameters
    '("GdaTreeManager*" "sub")
  )
)

(define-method get_managers
  (of-object "GdaTreeManager")
  (c-name "gda_tree_manager_get_managers")
  (return-type "const-GSList*")
)

(define-method set_node_create_func
  (of-object "GdaTreeManager")
  (c-name "gda_tree_manager_set_node_create_func")
  (return-type "none")
  (parameters
    '("GdaTreeManagerNodeFunc" "func")
  )
)

(define-method get_node_create_func
  (of-object "GdaTreeManager")
  (c-name "gda_tree_manager_get_node_create_func")
  (return-type "GdaTreeManagerNodeFunc")
)

(define-method add_new_node_attribute
  (of-object "GdaTreeManager")
  (c-name "gda_tree_manager_add_new_node_attribute")
  (return-type "none")
  (parameters
    '("const-gchar*" "attribute")
    '("const-GValue*" "value")
  )
)

(define-method create_node
  (of-object "GdaTreeManager")
  (c-name "gda_tree_manager_create_node")
  (return-type "GdaTreeNode*")
  (parameters
    '("GdaTreeNode*" "parent")
    '("const-gchar*" "name")
  )
)



;; From gda-tree-mgr-columns.h

(define-function gda_tree_mgr_columns_get_type
  (c-name "gda_tree_mgr_columns_get_type")
  (return-type "GType")
)

(define-function gda_tree_mgr_columns_new
  (c-name "gda_tree_mgr_columns_new")
  (is-constructor-of "GdaTreeMgrColumns")
  (return-type "GdaTreeManager*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "schema")
    '("const-gchar*" "table_name")
  )
)



;; From gda-tree-mgr-label.h

(define-function gda_tree_mgr_label_get_type
  (c-name "gda_tree_mgr_label_get_type")
  (return-type "GType")
)

(define-function gda_tree_mgr_label_new
  (c-name "gda_tree_mgr_label_new")
  (is-constructor-of "GdaTreeMgrLabel")
  (return-type "GdaTreeManager*")
  (parameters
    '("const-gchar*" "label")
  )
)



;; From gda-tree-mgr-ldap.h

(define-function gda_tree_mgr_ldap_get_type
  (c-name "gda_tree_mgr_ldap_get_type")
  (return-type "GType")
)

(define-function gda_tree_mgr_ldap_new
  (c-name "gda_tree_mgr_ldap_new")
  (is-constructor-of "GdaTreeMgrLdap")
  (return-type "GdaTreeManager*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "dn")
  )
)



;; From gda-tree-mgr-schemas.h

(define-function gda_tree_mgr_schemas_get_type
  (c-name "gda_tree_mgr_schemas_get_type")
  (return-type "GType")
)

(define-function gda_tree_mgr_schemas_new
  (c-name "gda_tree_mgr_schemas_new")
  (is-constructor-of "GdaTreeMgrSchemas")
  (return-type "GdaTreeManager*")
  (parameters
    '("GdaConnection*" "cnc")
  )
)



;; From gda-tree-mgr-select.h

(define-function gda_tree_mgr_select_get_type
  (c-name "gda_tree_mgr_select_get_type")
  (return-type "GType")
)

(define-function gda_tree_mgr_select_new
  (c-name "gda_tree_mgr_select_new")
  (is-constructor-of "GdaTreeMgrSelect")
  (return-type "GdaTreeManager*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
  )
)



;; From gda-tree-mgr-tables.h

(define-function gda_tree_mgr_tables_get_type
  (c-name "gda_tree_mgr_tables_get_type")
  (return-type "GType")
)

(define-function gda_tree_mgr_tables_new
  (c-name "gda_tree_mgr_tables_new")
  (is-constructor-of "GdaTreeMgrTables")
  (return-type "GdaTreeManager*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "schema")
  )
)



;; From gda-tree-node.h

(define-function gda_tree_node_get_type
  (c-name "gda_tree_node_get_type")
  (return-type "GType")
)

(define-function gda_tree_node_new
  (c-name "gda_tree_node_new")
  (is-constructor-of "GdaTreeNode")
  (return-type "GdaTreeNode*")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method get_parent
  (of-object "GdaTreeNode")
  (c-name "gda_tree_node_get_parent")
  (return-type "GdaTreeNode*")
)

(define-method get_children
  (of-object "GdaTreeNode")
  (c-name "gda_tree_node_get_children")
  (return-type "GSList*")
)

(define-method get_child_index
  (of-object "GdaTreeNode")
  (c-name "gda_tree_node_get_child_index")
  (return-type "GdaTreeNode*")
  (parameters
    '("gint" "index")
  )
)

(define-method get_child_name
  (of-object "GdaTreeNode")
  (c-name "gda_tree_node_get_child_name")
  (return-type "GdaTreeNode*")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method set_node_attribute
  (of-object "GdaTreeNode")
  (c-name "gda_tree_node_set_node_attribute")
  (return-type "none")
  (parameters
    '("const-gchar*" "attribute")
    '("const-GValue*" "value")
    '("GDestroyNotify" "destroy")
  )
)

(define-method get_node_attribute
  (of-object "GdaTreeNode")
  (c-name "gda_tree_node_get_node_attribute")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "attribute")
  )
)

(define-method fetch_attribute
  (of-object "GdaTreeNode")
  (c-name "gda_tree_node_fetch_attribute")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "attribute")
  )
)



;; From gda-util.h

(define-function gda_g_type_to_string
  (c-name "gda_g_type_to_string")
  (return-type "const-gchar*")
  (parameters
    '("GType" "type")
  )
)

(define-function gda_g_type_from_string
  (c-name "gda_g_type_from_string")
  (return-type "GType")
  (parameters
    '("const-gchar*" "str")
  )
)

(define-function gda_default_escape_string
  (c-name "gda_default_escape_string")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "string")
  )
)

(define-function gda_default_unescape_string
  (c-name "gda_default_unescape_string")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "string")
  )
)

(define-function gda_identifier_hash
  (c-name "gda_identifier_hash")
  (return-type "guint")
  (parameters
    '("const-gchar*" "id")
  )
)

(define-function gda_identifier_equal
  (c-name "gda_identifier_equal")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "id1")
    '("const-gchar*" "id2")
  )
)

(define-function gda_completion_list_get
  (c-name "gda_completion_list_get")
  (return-type "gchar**")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "sql")
    '("gint" "start")
    '("gint" "end")
  )
)

(define-function gda_sql_identifier_split
  (c-name "gda_sql_identifier_split")
  (return-type "gchar**")
  (parameters
    '("const-gchar*" "id")
  )
)

(define-function gda_sql_identifier_quote
  (c-name "gda_sql_identifier_quote")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "id")
    '("GdaConnection*" "cnc")
    '("GdaServerProvider*" "prov")
    '("gboolean" "meta_store_convention")
    '("gboolean" "force_quotes")
  )
)

(define-function gda_utility_check_data_model
  (c-name "gda_utility_check_data_model")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "model")
    '("gint" "nbcols")
  )
  (varargs #t)
)

(define-function gda_utility_check_data_model_v
  (c-name "gda_utility_check_data_model_v")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "model")
    '("gint" "nbcols")
    '("GType*" "types")
  )
)

(define-function gda_utility_data_model_dump_data_to_xml
  (c-name "gda_utility_data_model_dump_data_to_xml")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "model")
    '("xmlNodePtr" "parent")
    '("const-gint*" "cols")
    '("gint" "nb_cols")
    '("const-gint*" "rows")
    '("gint" "nb_rows")
    '("gboolean" "use_col_ids")
  )
)

(define-function gda_utility_data_model_find_column_description
  (c-name "gda_utility_data_model_find_column_description")
  (return-type "const-gchar*")
  (parameters
    '("GdaDataSelect*" "model")
    '("const-gchar*" "field_name")
  )
)

(define-function gda_utility_holder_load_attributes
  (c-name "gda_utility_holder_load_attributes")
  (return-type "gboolean")
  (parameters
    '("GdaHolder*" "holder")
    '("xmlNodePtr" "node")
    '("GSList*" "sources")
    '("GError**" "error")
  )
)

(define-method rewrite_for_default_values
  (of-object "GdaStatement")
  (c-name "gda_statement_rewrite_for_default_values")
  (return-type "GdaSqlStatement*")
  (parameters
    '("GdaSet*" "params")
    '("gboolean" "remove")
    '("GError**" "error")
  )
)

(define-function gda_text_to_alphanum
  (c-name "gda_text_to_alphanum")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "text")
  )
)

(define-function gda_alphanum_to_text
  (c-name "gda_alphanum_to_text")
  (return-type "gchar*")
  (parameters
    '("gchar*" "text")
  )
)

(define-function gda_compute_unique_table_row_condition
  (c-name "gda_compute_unique_table_row_condition")
  (return-type "GdaSqlExpr*")
  (parameters
    '("GdaSqlStatementSelect*" "stsel")
    '("GdaMetaTable*" "mtable")
    '("gboolean" "require_pk")
    '("GError**" "error")
  )
)

(define-function gda_compute_unique_table_row_condition_with_cnc
  (c-name "gda_compute_unique_table_row_condition_with_cnc")
  (return-type "GdaSqlExpr*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaSqlStatementSelect*" "stsel")
    '("GdaMetaTable*" "mtable")
    '("gboolean" "require_pk")
    '("GError**" "error")
  )
)

(define-function gda_compute_dml_statements
  (c-name "gda_compute_dml_statements")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaStatement*" "select_stmt")
    '("gboolean" "require_pk")
    '("GdaStatement**" "insert_stmt")
    '("GdaStatement**" "update_stmt")
    '("GdaStatement**" "delete_stmt")
    '("GError**" "error")
  )
)

(define-function gda_compute_select_statement_from_update
  (c-name "gda_compute_select_statement_from_update")
  (return-type "GdaSqlStatement*")
  (parameters
    '("GdaStatement*" "update_stmt")
    '("GError**" "error")
  )
)

(define-function gda_rewrite_sql_statement_for_null_parameters
  (c-name "gda_rewrite_sql_statement_for_null_parameters")
  (return-type "GdaSqlStatement*")
  (parameters
    '("GdaSqlStatement*" "sqlst")
    '("GdaSet*" "params")
    '("gboolean*" "out_modified")
    '("GError**" "error")
  )
)

(define-function gda_rewrite_statement_for_null_parameters
  (c-name "gda_rewrite_statement_for_null_parameters")
  (return-type "gboolean")
  (parameters
    '("GdaStatement*" "stmt")
    '("GdaSet*" "params")
    '("GdaStatement**" "out_stmt")
    '("GError**" "error")
  )
)

(define-function gda_rfc1738_encode
  (c-name "gda_rfc1738_encode")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "string")
  )
)

(define-function gda_rfc1738_decode
  (c-name "gda_rfc1738_decode")
  (return-type "gboolean")
  (parameters
    '("gchar*" "string")
  )
)

(define-function gda_dsn_split
  (c-name "gda_dsn_split")
  (return-type "none")
  (parameters
    '("const-gchar*" "string")
    '("gchar**" "out_dsn")
    '("gchar**" "out_username")
    '("gchar**" "out_password")
  )
)

(define-function gda_connection_string_split
  (c-name "gda_connection_string_split")
  (return-type "none")
  (parameters
    '("const-gchar*" "string")
    '("gchar**" "out_cnc_params")
    '("gchar**" "out_provider")
    '("gchar**" "out_username")
    '("gchar**" "out_password")
  )
)

(define-function gda_parse_iso8601_date
  (c-name "gda_parse_iso8601_date")
  (return-type "gboolean")
  (parameters
    '("GDate*" "gdate")
    '("const-gchar*" "value")
  )
)

(define-function gda_parse_iso8601_time
  (c-name "gda_parse_iso8601_time")
  (return-type "gboolean")
  (parameters
    '("GdaTime*" "timegda")
    '("const-gchar*" "value")
  )
)

(define-function gda_parse_iso8601_timestamp
  (c-name "gda_parse_iso8601_timestamp")
  (return-type "gboolean")
  (parameters
    '("GdaTimestamp*" "timestamp")
    '("const-gchar*" "value")
  )
)



;; From gda-value.h

(define-function gda_value_new
  (c-name "gda_value_new")
  (is-constructor-of "GdaValue")
  (return-type "GValue*")
  (parameters
    '("GType" "type")
  )
)

(define-function gda_value_new_null
  (c-name "gda_value_new_null")
  (return-type "GValue*")
)

(define-function gda_value_new_default
  (c-name "gda_value_new_default")
  (return-type "GValue*")
  (parameters
    '("const-gchar*" "default_val")
  )
)

(define-function gda_value_new_binary
  (c-name "gda_value_new_binary")
  (return-type "GValue*")
  (parameters
    '("const-guchar*" "val")
    '("glong" "size")
  )
)

(define-function gda_value_new_blob
  (c-name "gda_value_new_blob")
  (return-type "GValue*")
  (parameters
    '("const-guchar*" "val")
    '("glong" "size")
  )
)

(define-function gda_value_new_blob_from_file
  (c-name "gda_value_new_blob_from_file")
  (return-type "GValue*")
  (parameters
    '("const-gchar*" "filename")
  )
)

(define-function gda_value_new_timestamp_from_timet
  (c-name "gda_value_new_timestamp_from_timet")
  (return-type "GValue*")
  (parameters
    '("time_t" "val")
  )
)

(define-function gda_value_new_from_string
  (c-name "gda_value_new_from_string")
  (return-type "GValue*")
  (parameters
    '("const-gchar*" "as_string")
    '("GType" "type")
  )
)

(define-function gda_value_new_from_xml
  (c-name "gda_value_new_from_xml")
  (return-type "GValue*")
  (parameters
    '("const-xmlNodePtr" "node")
  )
)

(define-function gda_value_free
  (c-name "gda_value_free")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(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_value_is_null
  (c-name "gda_value_is_null")
  (return-type "gboolean")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_is_number
  (c-name "gda_value_is_number")
  (return-type "gboolean")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_copy
  (c-name "gda_value_copy")
  (return-type "GValue*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_get_binary
  (c-name "gda_value_get_binary")
  (return-type "const-GdaBinary*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_binary
  (c-name "gda_value_set_binary")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaBinary*" "binary")
  )
)

(define-function gda_value_take_binary
  (c-name "gda_value_take_binary")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("GdaBinary*" "binary")
  )
)

(define-function gda_value_get_blob
  (c-name "gda_value_get_blob")
  (return-type "const-GdaBlob*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_blob
  (c-name "gda_value_set_blob")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaBlob*" "blob")
  )
)

(define-function gda_value_take_blob
  (c-name "gda_value_take_blob")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("GdaBlob*" "blob")
  )
)

(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_value_set_geometric_point
  (c-name "gda_value_set_geometric_point")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaGeometricPoint*" "val")
  )
)

(define-function gda_value_set_null
  (c-name "gda_value_set_null")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-function gda_value_get_numeric
  (c-name "gda_value_get_numeric")
  (return-type "const-GdaNumeric*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_numeric
  (c-name "gda_value_set_numeric")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaNumeric*" "val")
  )
)

(define-function gda_value_get_short
  (c-name "gda_value_get_short")
  (return-type "gshort")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_short
  (c-name "gda_value_set_short")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-gshort" "val")
  )
)

(define-function gda_value_get_ushort
  (c-name "gda_value_get_ushort")
  (return-type "gushort")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_ushort
  (c-name "gda_value_set_ushort")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-gushort" "val")
  )
)

(define-function gda_value_get_time
  (c-name "gda_value_get_time")
  (return-type "const-GdaTime*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_time
  (c-name "gda_value_set_time")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaTime*" "val")
  )
)

(define-function gda_value_get_timestamp
  (c-name "gda_value_get_timestamp")
  (return-type "const-GdaTimestamp*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_timestamp
  (c-name "gda_value_set_timestamp")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaTimestamp*" "val")
  )
)

(define-function gda_value_set_from_string
  (c-name "gda_value_set_from_string")
  (return-type "gboolean")
  (parameters
    '("GValue*" "value")
    '("const-gchar*" "as_string")
    '("GType" "type")
  )
)

(define-function gda_value_set_from_value
  (c-name "gda_value_set_from_value")
  (return-type "gboolean")
  (parameters
    '("GValue*" "value")
    '("const-GValue*" "from")
  )
)

(define-function gda_value_differ
  (c-name "gda_value_differ")
  (return-type "gint")
  (parameters
    '("const-GValue*" "value1")
    '("const-GValue*" "value2")
  )
)

(define-function gda_value_compare
  (c-name "gda_value_compare")
  (return-type "gint")
  (parameters
    '("const-GValue*" "value1")
    '("const-GValue*" "value2")
  )
)

(define-function gda_value_stringify
  (c-name "gda_value_stringify")
  (return-type "gchar*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_to_xml
  (c-name "gda_value_to_xml")
  (return-type "xmlNodePtr")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-method to_string
  (of-object "GdaBinary")
  (c-name "gda_binary_to_string")
  (return-type "gchar*")
  (parameters
    '("guint" "maxlen")
  )
)

(define-function gda_string_to_binary
  (c-name "gda_string_to_binary")
  (return-type "GdaBinary*")
  (parameters
    '("const-gchar*" "str")
  )
)

(define-method to_string
  (of-object "GdaBlob")
  (c-name "gda_blob_to_string")
  (return-type "gchar*")
  (parameters
    '("guint" "maxlen")
  )
)

(define-function gda_string_to_blob
  (c-name "gda_string_to_blob")
  (return-type "GdaBlob*")
  (parameters
    '("const-gchar*" "str")
  )
)

(define-function gda_null_get_type
  (c-name "gda_null_get_type")
  (return-type "GType")
)

(define-function gda_default_get_type
  (c-name "gda_default_get_type")
  (return-type "GType")
)

(define-function gda_numeric_get_type
  (c-name "gda_numeric_get_type")
  (return-type "GType")
)

(define-function gda_numeric_new
  (c-name "gda_numeric_new")
  (is-constructor-of "GdaNumeric")
  (return-type "GdaNumeric*")
)

(define-function gda_numeric_copy
  (c-name "gda_numeric_copy")
  (return-type "GdaNumeric*")
  (parameters
    '("GdaNumeric*" "src")
  )
)

(define-method set_from_string
  (of-object "GdaNumeric")
  (c-name "gda_numeric_set_from_string")
  (return-type "none")
  (parameters
    '("const-gchar*" "str")
  )
)

(define-method set_double
  (of-object "GdaNumeric")
  (c-name "gda_numeric_set_double")
  (return-type "none")
  (parameters
    '("gdouble" "number")
  )
)

(define-method get_double
  (of-object "GdaNumeric")
  (c-name "gda_numeric_get_double")
  (return-type "gdouble")
)

(define-method set_precision
  (of-object "GdaNumeric")
  (c-name "gda_numeric_set_precision")
  (return-type "none")
  (parameters
    '("glong" "precision")
  )
)

(define-method get_precision
  (of-object "GdaNumeric")
  (c-name "gda_numeric_get_precision")
  (return-type "glong")
)

(define-method set_width
  (of-object "GdaNumeric")
  (c-name "gda_numeric_set_width")
  (return-type "none")
  (parameters
    '("glong" "width")
  )
)

(define-method get_width
  (of-object "GdaNumeric")
  (c-name "gda_numeric_get_width")
  (return-type "glong")
)

(define-method get_string
  (of-object "GdaNumeric")
  (c-name "gda_numeric_get_string")
  (return-type "gchar*")
)

(define-function gda_numeric_free
  (c-name "gda_numeric_free")
  (return-type "none")
  (parameters
    '("GdaNumeric*" "numeric")
  )
)

(define-function gda_time_get_type
  (c-name "gda_time_get_type")
  (return-type "GType")
)

(define-function gda_time_copy
  (c-name "gda_time_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_time_free
  (c-name "gda_time_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-method valid
  (of-object "GdaTime")
  (c-name "gda_time_valid")
  (return-type "gboolean")
)

(define-function gda_timestamp_get_type
  (c-name "gda_timestamp_get_type")
  (return-type "GType")
)

(define-function gda_timestamp_copy
  (c-name "gda_timestamp_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_timestamp_free
  (c-name "gda_timestamp_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-method valid
  (of-object "GdaTimestamp")
  (c-name "gda_timestamp_valid")
  (return-type "gboolean")
)

(define-function gda_geometricpoint_get_type
  (c-name "gda_geometricpoint_get_type")
  (return-type "GType")
)

(define-function gda_geometricpoint_copy
  (c-name "gda_geometricpoint_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_geometricpoint_free
  (c-name "gda_geometricpoint_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_binary_get_type
  (c-name "gda_binary_get_type")
  (return-type "GType")
)

(define-function gda_binary_copy
  (c-name "gda_binary_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_binary_free
  (c-name "gda_binary_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_blob_get_type
  (c-name "gda_blob_get_type")
  (return-type "GType")
)

(define-function gda_blob_copy
  (c-name "gda_blob_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_blob_free
  (c-name "gda_blob_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-method set_op
  (of-object "GdaBlob")
  (c-name "gda_blob_set_op")
  (return-type "none")
  (parameters
    '("GdaBlobOp*" "op")
  )
)

(define-function gda_short_get_type
  (c-name "gda_short_get_type")
  (return-type "GType")
)

(define-function gda_ushort_get_type
  (c-name "gda_ushort_get_type")
  (return-type "GType")
)



;; From gda-xa-transaction.h

(define-function gda_xa_transaction_get_type
  (c-name "gda_xa_transaction_get_type")
  (return-type "GType")
)

(define-function gda_xa_transaction_new
  (c-name "gda_xa_transaction_new")
  (is-constructor-of "GdaXaTransaction")
  (return-type "GdaXaTransaction*")
  (parameters
    '("guint32" "format")
    '("const-gchar*" "global_transaction_id")
  )
)

(define-method register_connection
  (of-object "GdaXaTransaction")
  (c-name "gda_xa_transaction_register_connection")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "branch")
    '("GError**" "error")
  )
)

(define-method unregister_connection
  (of-object "GdaXaTransaction")
  (c-name "gda_xa_transaction_unregister_connection")
  (return-type "none")
  (parameters
    '("GdaConnection*" "cnc")
  )
)

(define-method begin
  (of-object "GdaXaTransaction")
  (c-name "gda_xa_transaction_begin")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method commit
  (of-object "GdaXaTransaction")
  (c-name "gda_xa_transaction_commit")
  (return-type "gboolean")
  (parameters
    '("GSList**" "cnc_to_recover")
    '("GError**" "error")
  )
)

(define-method rollback
  (of-object "GdaXaTransaction")
  (c-name "gda_xa_transaction_rollback")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method commit_recovered
  (of-object "GdaXaTransaction")
  (c-name "gda_xa_transaction_commit_recovered")
  (return-type "gboolean")
  (parameters
    '("GSList**" "cnc_to_recover")
    '("GError**" "error")
  )
)

(define-method to_string
  (of-object "GdaXaTransactionId")
  (c-name "gda_xa_transaction_id_to_string")
  (return-type "gchar*")
)

(define-function gda_xa_transaction_string_to_id
  (c-name "gda_xa_transaction_string_to_id")
  (return-type "GdaXaTransactionId*")
  (parameters
    '("const-gchar*" "str")
  )
)



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

(define-function gda_sql_parser_error_get_type
  (c-name "gda_sql_parser_error_get_type")
  (return-type "GType")
)

(define-function gda_sql_parser_mode_get_type
  (c-name "gda_sql_parser_mode_get_type")
  (return-type "GType")
)

(define-function gda_sql_parser_flavour_get_type
  (c-name "gda_sql_parser_flavour_get_type")
  (return-type "GType")
)

(define-function gda_sql_error_get_type
  (c-name "gda_sql_error_get_type")
  (return-type "GType")
)

(define-function gda_sql_statement_type_get_type
  (c-name "gda_sql_statement_type_get_type")
  (return-type "GType")
)

(define-function gda_sql_any_part_type_get_type
  (c-name "gda_sql_any_part_type_get_type")
  (return-type "GType")
)

(define-function gda_sql_statement_compound_type_get_type
  (c-name "gda_sql_statement_compound_type_get_type")
  (return-type "GType")
)

(define-function gda_sql_operator_type_get_type
  (c-name "gda_sql_operator_type_get_type")
  (return-type "GType")
)

(define-function gda_sql_select_join_type_get_type
  (c-name "gda_sql_select_join_type_get_type")
  (return-type "GType")
)



;; From gda-sql-parser.h

(define-function gda_sql_parser_get_type
  (c-name "gda_sql_parser_get_type")
  (return-type "GType")
)

(define-function gda_sql_parser_new
  (c-name "gda_sql_parser_new")
  (is-constructor-of "GdaSqlParser")
  (return-type "GdaSqlParser*")
)

(define-method parse_string
  (of-object "GdaSqlParser")
  (c-name "gda_sql_parser_parse_string")
  (return-type "GdaStatement*")
  (parameters
    '("const-gchar*" "sql")
    '("const-gchar**" "remain")
    '("GError**" "error")
  )
)

(define-method parse_string_as_batch
  (of-object "GdaSqlParser")
  (c-name "gda_sql_parser_parse_string_as_batch")
  (return-type "GdaBatch*")
  (parameters
    '("const-gchar*" "sql")
    '("const-gchar**" "remain")
    '("GError**" "error")
  )
)

(define-method parse_file_as_batch
  (of-object "GdaSqlParser")
  (c-name "gda_sql_parser_parse_file_as_batch")
  (return-type "GdaBatch*")
  (parameters
    '("const-gchar*" "filename")
    '("GError**" "error")
  )
)

(define-method set_syntax_error
  (of-object "GdaSqlParser")
  (c-name "gda_sql_parser_set_syntax_error")
  (return-type "none")
)

(define-method set_overflow_error
  (of-object "GdaSqlParser")
  (c-name "gda_sql_parser_set_overflow_error")
  (return-type "none")
)



;; From gda-sql-statement.h



;; From gda-statement-struct-compound.h

(define-method compound_set_type
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_compound_set_type")
  (return-type "none")
  (parameters
    '("GdaSqlStatementCompoundType" "type")
  )
)

(define-method compound_take_stmt
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_compound_take_stmt")
  (return-type "none")
  (parameters
    '("GdaSqlStatement*" "s")
  )
)



;; From gda-statement-struct-decl.h

(define-method foreach
  (of-object "GdaSqlAnyPart")
  (c-name "gda_sql_any_part_foreach")
  (return-type "gboolean")
  (parameters
    '("GdaSqlForeachFunc" "func")
    '("gpointer" "data")
    '("GError**" "error")
  )
)

(define-method check_structure
  (of-object "GdaSqlAnyPart")
  (c-name "gda_sql_any_part_check_structure")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)



;; From gda-statement-struct-delete.h

(define-method delete_take_table_name
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_delete_take_table_name")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method delete_take_condition
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_delete_take_condition")
  (return-type "none")
  (parameters
    '("GdaSqlExpr*" "cond")
  )
)



;; From gda-statement-struct.h

(define-function gda_sql_statement_get_type
  (c-name "gda_sql_statement_get_type")
  (return-type "GType")
)

(define-function gda_sql_statement_new
  (c-name "gda_sql_statement_new")
  (is-constructor-of "GdaSqlStatement")
  (return-type "GdaSqlStatement*")
  (parameters
    '("GdaSqlStatementType" "type")
  )
)

(define-method copy
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_copy")
  (return-type "GdaSqlStatement*")
)

(define-method free
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_free")
  (return-type "none")
)

(define-method serialize
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_serialize")
  (return-type "gchar*")
)

(define-method to_string
  (of-object "GdaSqlStatementType")
  (c-name "gda_sql_statement_type_to_string")
  (return-type "const-gchar*")
)

(define-function gda_sql_statement_string_to_type
  (c-name "gda_sql_statement_string_to_type")
  (return-type "GdaSqlStatementType")
  (parameters
    '("const-gchar*" "type")
  )
)

(define-method check_structure
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_check_structure")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method check_validity
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_check_validity")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GError**" "error")
  )
)

(define-method check_validity_m
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_check_validity_m")
  (return-type "gboolean")
  (parameters
    '("GdaMetaStruct*" "mstruct")
    '("GError**" "error")
  )
)

(define-method check_clean
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_check_clean")
  (return-type "none")
)

(define-method normalize
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_normalize")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GError**" "error")
  )
)

(define-function gda_sql_statement_get_contents_infos
  (c-name "gda_sql_statement_get_contents_infos")
  (return-type "GdaSqlStatementContentsInfo*")
  (parameters
    '("GdaSqlStatementType" "type")
  )
)



;; From gda-statement-struct-insert.h

(define-method insert_take_table_name
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_insert_take_table_name")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method insert_take_on_conflict
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_insert_take_on_conflict")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method insert_take_fields_list
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_insert_take_fields_list")
  (return-type "none")
  (parameters
    '("GSList*" "list")
  )
)

(define-method insert_take_1_values_list
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_insert_take_1_values_list")
  (return-type "none")
  (parameters
    '("GSList*" "list")
  )
)

(define-method insert_take_extra_values_list
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_insert_take_extra_values_list")
  (return-type "none")
  (parameters
    '("GSList*" "list")
  )
)

(define-method insert_take_select
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_insert_take_select")
  (return-type "none")
  (parameters
    '("GdaSqlStatement*" "select")
  )
)



;; From gda-statement-struct-parts.h

(define-function gda_sql_expr_get_type
  (c-name "gda_sql_expr_get_type")
  (return-type "GType")
)

(define-function gda_sql_expr_new
  (c-name "gda_sql_expr_new")
  (is-constructor-of "GdaSqlExpr")
  (return-type "GdaSqlExpr*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlExpr")
  (c-name "gda_sql_expr_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlExpr")
  (c-name "gda_sql_expr_copy")
  (return-type "GdaSqlExpr*")
)

(define-method serialize
  (of-object "GdaSqlExpr")
  (c-name "gda_sql_expr_serialize")
  (return-type "gchar*")
)

(define-method take_select
  (of-object "GdaSqlExpr")
  (c-name "gda_sql_expr_take_select")
  (return-type "none")
  (parameters
    '("GdaSqlStatement*" "stmt")
  )
)

(define-function gda_sql_field_new
  (c-name "gda_sql_field_new")
  (is-constructor-of "GdaSqlField")
  (return-type "GdaSqlField*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlField")
  (c-name "gda_sql_field_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlField")
  (c-name "gda_sql_field_copy")
  (return-type "GdaSqlField*")
)

(define-method serialize
  (of-object "GdaSqlField")
  (c-name "gda_sql_field_serialize")
  (return-type "gchar*")
)

(define-method take_name
  (of-object "GdaSqlField")
  (c-name "gda_sql_field_take_name")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-function gda_sql_table_new
  (c-name "gda_sql_table_new")
  (is-constructor-of "GdaSqlTable")
  (return-type "GdaSqlTable*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlTable")
  (c-name "gda_sql_table_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlTable")
  (c-name "gda_sql_table_copy")
  (return-type "GdaSqlTable*")
)

(define-method serialize
  (of-object "GdaSqlTable")
  (c-name "gda_sql_table_serialize")
  (return-type "gchar*")
)

(define-method take_name
  (of-object "GdaSqlTable")
  (c-name "gda_sql_table_take_name")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-function gda_sql_function_new
  (c-name "gda_sql_function_new")
  (is-constructor-of "GdaSqlFunction")
  (return-type "GdaSqlFunction*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlFunction")
  (c-name "gda_sql_function_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlFunction")
  (c-name "gda_sql_function_copy")
  (return-type "GdaSqlFunction*")
)

(define-method serialize
  (of-object "GdaSqlFunction")
  (c-name "gda_sql_function_serialize")
  (return-type "gchar*")
)

(define-method check_clean
  (of-object "GdaSqlFunction")
  (c-name "gda_sql_function_check_clean")
  (return-type "none")
)

(define-method take_name
  (of-object "GdaSqlFunction")
  (c-name "gda_sql_function_take_name")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method take_args_list
  (of-object "GdaSqlFunction")
  (c-name "gda_sql_function_take_args_list")
  (return-type "none")
  (parameters
    '("GSList*" "args")
  )
)

(define-function gda_sql_operation_new
  (c-name "gda_sql_operation_new")
  (is-constructor-of "GdaSqlOperation")
  (return-type "GdaSqlOperation*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlOperation")
  (c-name "gda_sql_operation_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlOperation")
  (c-name "gda_sql_operation_copy")
  (return-type "GdaSqlOperation*")
)

(define-method serialize
  (of-object "GdaSqlOperation")
  (c-name "gda_sql_operation_serialize")
  (return-type "gchar*")
)

(define-function gda_sql_operation_operator_to_string
  (c-name "gda_sql_operation_operator_to_string")
  (return-type "const-gchar*")
  (parameters
    '("GdaSqlOperatorType" "op")
  )
)

(define-function gda_sql_operation_operator_from_string
  (c-name "gda_sql_operation_operator_from_string")
  (return-type "GdaSqlOperatorType")
  (parameters
    '("const-gchar*" "op")
  )
)

(define-function gda_sql_case_new
  (c-name "gda_sql_case_new")
  (is-constructor-of "GdaSqlCase")
  (return-type "GdaSqlCase*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlCase")
  (c-name "gda_sql_case_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlCase")
  (c-name "gda_sql_case_copy")
  (return-type "GdaSqlCase*")
)

(define-method serialize
  (of-object "GdaSqlCase")
  (c-name "gda_sql_case_serialize")
  (return-type "gchar*")
)

(define-function gda_sql_select_field_new
  (c-name "gda_sql_select_field_new")
  (is-constructor-of "GdaSqlSelectField")
  (return-type "GdaSqlSelectField*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlSelectField")
  (c-name "gda_sql_select_field_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlSelectField")
  (c-name "gda_sql_select_field_copy")
  (return-type "GdaSqlSelectField*")
)

(define-method serialize
  (of-object "GdaSqlSelectField")
  (c-name "gda_sql_select_field_serialize")
  (return-type "gchar*")
)

(define-method take_star_value
  (of-object "GdaSqlSelectField")
  (c-name "gda_sql_select_field_take_star_value")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method take_expr
  (of-object "GdaSqlSelectField")
  (c-name "gda_sql_select_field_take_expr")
  (return-type "none")
  (parameters
    '("GdaSqlExpr*" "expr")
  )
)

(define-method take_alias
  (of-object "GdaSqlSelectField")
  (c-name "gda_sql_select_field_take_alias")
  (return-type "none")
  (parameters
    '("GValue*" "alias")
  )
)

(define-function gda_sql_select_target_new
  (c-name "gda_sql_select_target_new")
  (is-constructor-of "GdaSqlSelectTarget")
  (return-type "GdaSqlSelectTarget*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlSelectTarget")
  (c-name "gda_sql_select_target_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlSelectTarget")
  (c-name "gda_sql_select_target_copy")
  (return-type "GdaSqlSelectTarget*")
)

(define-method serialize
  (of-object "GdaSqlSelectTarget")
  (c-name "gda_sql_select_target_serialize")
  (return-type "gchar*")
)

(define-method take_table_name
  (of-object "GdaSqlSelectTarget")
  (c-name "gda_sql_select_target_take_table_name")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method take_select
  (of-object "GdaSqlSelectTarget")
  (c-name "gda_sql_select_target_take_select")
  (return-type "none")
  (parameters
    '("GdaSqlStatement*" "stmt")
  )
)

(define-method take_alias
  (of-object "GdaSqlSelectTarget")
  (c-name "gda_sql_select_target_take_alias")
  (return-type "none")
  (parameters
    '("GValue*" "alias")
  )
)

(define-function gda_sql_select_join_new
  (c-name "gda_sql_select_join_new")
  (is-constructor-of "GdaSqlSelectJoin")
  (return-type "GdaSqlSelectJoin*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlSelectJoin")
  (c-name "gda_sql_select_join_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlSelectJoin")
  (c-name "gda_sql_select_join_copy")
  (return-type "GdaSqlSelectJoin*")
)

(define-method serialize
  (of-object "GdaSqlSelectJoin")
  (c-name "gda_sql_select_join_serialize")
  (return-type "gchar*")
)

(define-method to_string
  (of-object "GdaSqlSelectJoinType")
  (c-name "gda_sql_select_join_type_to_string")
  (return-type "const-gchar*")
)

(define-function gda_sql_select_from_new
  (c-name "gda_sql_select_from_new")
  (is-constructor-of "GdaSqlSelectFrom")
  (return-type "GdaSqlSelectFrom*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlSelectFrom")
  (c-name "gda_sql_select_from_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlSelectFrom")
  (c-name "gda_sql_select_from_copy")
  (return-type "GdaSqlSelectFrom*")
)

(define-method serialize
  (of-object "GdaSqlSelectFrom")
  (c-name "gda_sql_select_from_serialize")
  (return-type "gchar*")
)

(define-method take_new_target
  (of-object "GdaSqlSelectFrom")
  (c-name "gda_sql_select_from_take_new_target")
  (return-type "none")
  (parameters
    '("GdaSqlSelectTarget*" "target")
  )
)

(define-method take_new_join
  (of-object "GdaSqlSelectFrom")
  (c-name "gda_sql_select_from_take_new_join")
  (return-type "none")
  (parameters
    '("GdaSqlSelectJoin*" "join")
  )
)

(define-function gda_sql_select_order_new
  (c-name "gda_sql_select_order_new")
  (is-constructor-of "GdaSqlSelectOrder")
  (return-type "GdaSqlSelectOrder*")
  (parameters
    '("GdaSqlAnyPart*" "parent")
  )
)

(define-method free
  (of-object "GdaSqlSelectOrder")
  (c-name "gda_sql_select_order_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaSqlSelectOrder")
  (c-name "gda_sql_select_order_copy")
  (return-type "GdaSqlSelectOrder*")
)

(define-method serialize
  (of-object "GdaSqlSelectOrder")
  (c-name "gda_sql_select_order_serialize")
  (return-type "gchar*")
)



;; From gda-statement-struct-pspec.h

(define-function gda_sql_param_spec_new
  (c-name "gda_sql_param_spec_new")
  (is-constructor-of "GdaSqlParamSpec")
  (return-type "GdaSqlParamSpec*")
  (parameters
    '("GValue*" "simple_spec")
  )
)

(define-method copy
  (of-object "GdaSqlParamSpec")
  (c-name "gda_sql_param_spec_copy")
  (return-type "GdaSqlParamSpec*")
)

(define-method take_name
  (of-object "GdaSqlParamSpec")
  (c-name "gda_sql_param_spec_take_name")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method take_type
  (of-object "GdaSqlParamSpec")
  (c-name "gda_sql_param_spec_take_type")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method take_descr
  (of-object "GdaSqlParamSpec")
  (c-name "gda_sql_param_spec_take_descr")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method take_nullok
  (of-object "GdaSqlParamSpec")
  (c-name "gda_sql_param_spec_take_nullok")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method free
  (of-object "GdaSqlParamSpec")
  (c-name "gda_sql_param_spec_free")
  (return-type "none")
)

(define-method serialize
  (of-object "GdaSqlParamSpec")
  (c-name "gda_sql_param_spec_serialize")
  (return-type "gchar*")
)



;; From gda-statement-struct-select.h

(define-method select_take_distinct
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_select_take_distinct")
  (return-type "none")
  (parameters
    '("gboolean" "distinct")
    '("GdaSqlExpr*" "distinct_expr")
  )
)

(define-method select_take_expr_list
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_select_take_expr_list")
  (return-type "none")
  (parameters
    '("GSList*" "expr_list")
  )
)

(define-method select_take_from
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_select_take_from")
  (return-type "none")
  (parameters
    '("GdaSqlSelectFrom*" "from")
  )
)

(define-method select_take_where_cond
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_select_take_where_cond")
  (return-type "none")
  (parameters
    '("GdaSqlExpr*" "expr")
  )
)

(define-method select_take_group_by
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_select_take_group_by")
  (return-type "none")
  (parameters
    '("GSList*" "group_by")
  )
)

(define-method select_take_having_cond
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_select_take_having_cond")
  (return-type "none")
  (parameters
    '("GdaSqlExpr*" "expr")
  )
)

(define-method select_take_order_by
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_select_take_order_by")
  (return-type "none")
  (parameters
    '("GSList*" "order_by")
  )
)

(define-method select_take_limits
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_select_take_limits")
  (return-type "none")
  (parameters
    '("GdaSqlExpr*" "count")
    '("GdaSqlExpr*" "offset")
  )
)



;; From gda-statement-struct-trans.h

(define-method trans_take_mode
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_trans_take_mode")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method trans_set_isol_level
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_trans_set_isol_level")
  (return-type "none")
  (parameters
    '("GdaTransactionIsolation" "level")
  )
)

(define-method trans_take_name
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_trans_take_name")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)



;; From gda-statement-struct-unknown.h

(define-method unknown_take_expressions
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_unknown_take_expressions")
  (return-type "none")
  (parameters
    '("GSList*" "expressions")
  )
)



;; From gda-statement-struct-update.h

(define-method update_take_table_name
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_update_take_table_name")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method update_take_on_conflict
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_update_take_on_conflict")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-method update_take_condition
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_update_take_condition")
  (return-type "none")
  (parameters
    '("GdaSqlExpr*" "cond")
  )
)

(define-method update_take_set_value
  (of-object "GdaSqlStatement")
  (c-name "gda_sql_statement_update_take_set_value")
  (return-type "none")
  (parameters
    '("GValue*" "fname")
    '("GdaSqlExpr*" "expr")
  )
)



;; From gda-statement-struct-util.h

(define-function gda_sql_identifier_force_quotes
  (c-name "gda_sql_identifier_force_quotes")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "str")
  )
)

(define-function gda_sql_identifier_prepare_for_compare
  (c-name "gda_sql_identifier_prepare_for_compare")
  (return-type "gchar*")
  (parameters
    '("gchar*" "str")
  )
)

(define-function gda_sql_value_stringify
  (c-name "gda_sql_value_stringify")
  (return-type "gchar*")
  (parameters
    '("const-GValue*" "value")
  )
)



;; From gda-report-docbook-document.h

(define-function gda_report_docbook_document_get_type
  (c-name "gda_report_docbook_document_get_type")
  (return-type "GType")
)

(define-function gda_report_docbook_document_new
  (c-name "gda_report_docbook_document_new")
  (is-constructor-of "GdaReportDocbookDocument")
  (return-type "GdaReportDocument*")
  (parameters
    '("GdaReportEngine*" "engine")
  )
)



;; From gda-report-document.h

(define-function gda_report_document_get_type
  (c-name "gda_report_document_get_type")
  (return-type "GType")
)

(define-method set_template
  (of-object "GdaReportDocument")
  (c-name "gda_report_document_set_template")
  (return-type "none")
  (parameters
    '("const-gchar*" "file")
  )
)

(define-method run_as_html
  (of-object "GdaReportDocument")
  (c-name "gda_report_document_run_as_html")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "filename")
    '("GError**" "error")
  )
)

(define-method run_as_pdf
  (of-object "GdaReportDocument")
  (c-name "gda_report_document_run_as_pdf")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "filename")
    '("GError**" "error")
  )
)



;; From gda-report-engine.h

(define-function gda_report_engine_get_type
  (c-name "gda_report_engine_get_type")
  (return-type "GType")
)

(define-function gda_report_engine_new
  (c-name "gda_report_engine_new")
  (is-constructor-of "GdaReportEngine")
  (return-type "GdaReportEngine*")
  (parameters
    '("xmlNodePtr" "spec_node")
  )
)

(define-function gda_report_engine_new_from_string
  (c-name "gda_report_engine_new_from_string")
  (return-type "GdaReportEngine*")
  (parameters
    '("const-gchar*" "spec_string")
  )
)

(define-function gda_report_engine_new_from_file
  (c-name "gda_report_engine_new_from_file")
  (return-type "GdaReportEngine*")
  (parameters
    '("const-gchar*" "spec_file_name")
  )
)

(define-method declare_object
  (of-object "GdaReportEngine")
  (c-name "gda_report_engine_declare_object")
  (return-type "none")
  (parameters
    '("GObject*" "object")
    '("const-gchar*" "obj_name")
  )
)

(define-method find_declared_object
  (of-object "GdaReportEngine")
  (c-name "gda_report_engine_find_declared_object")
  (return-type "GObject*")
  (parameters
    '("GType" "obj_type")
    '("const-gchar*" "obj_name")
  )
)

(define-method run_as_node
  (of-object "GdaReportEngine")
  (c-name "gda_report_engine_run_as_node")
  (return-type "xmlNodePtr")
  (parameters
    '("GError**" "error")
  )
)

(define-method run_as_doc
  (of-object "GdaReportEngine")
  (c-name "gda_report_engine_run_as_doc")
  (return-type "xmlDocPtr")
  (parameters
    '("GError**" "error")
  )
)



;; From gda-report-rml-document.h

(define-function gda_report_rml_document_get_type
  (c-name "gda_report_rml_document_get_type")
  (return-type "GType")
)

(define-function gda_report_rml_document_new
  (c-name "gda_report_rml_document_new")
  (is-constructor-of "GdaReportRmlDocument")
  (return-type "GdaReportDocument*")
  (parameters
    '("GdaReportEngine*" "engine")
  )
)



;; From libgda-report.h