GNOME.org
 

[gnome-python-extras] Gda: Updated

commit 9301bcf09ee10affcc3c9fe53cf668d71b073dea
Author: Murray Cumming <murrayc murrayc com>
Date:   Sun May 2 01:06:43 2010 +0200

    Gda: Updated
    
    * gda/gda.defs: Regenerated with small corrections, against libgda-4.0 (not 4.2)
    * gda/gda.override: Added gda-sql-parser headers, though the API does not
    seem to be generated yet.

 ChangeLog        |    8 +
 gda/gda.defs     | 1314 ++++++++++++++++++++++++++++++++++++++++++++++++++----
 gda/gda.override |    2 +
 3 files changed, 1233 insertions(+), 91 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 9a1b18c..ad8e6fa 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2010-05-02  Murray Cumming  <murrayc murrayc com>
+
+	Gda: Updated
+	
+	* gda/gda.defs: Regenerated with small corrections, against libgda-4.0 (not 4.2)
+	* gda/gda.override: Added gda-sql-parser headers, though the API does not 
+	seem to be generated yet.
+
 2009-06-24  Armin Burgmeier  <armin openismus com>
 
 	* gda/gda.override: Added an override for
diff --git a/gda/gda.defs b/gda/gda.defs
index 70537c2..5809d40 100644
--- a/gda/gda.defs
+++ b/gda/gda.defs
@@ -56,7 +56,7 @@
   (gtype-id "GDA_TYPE_DATA_COMPARATOR")
 )
 
-(define-interface DataHandler
+(define-inferface DataHandler
   (in-module "Gda")
   (c-name "GdaDataHandler")
   (gtype-id "GDA_TYPE_DATA_HANDLER")
@@ -165,6 +165,13 @@
   (gtype-id "GDA_TYPE_DATA_MODEL_ITER")
 )
 
+(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")
@@ -728,6 +735,170 @@
   )
 )
 
+(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")
+  )
+)
+
+(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
 
@@ -2006,6 +2177,7 @@
 
 
 
+
 ;; From gda-data-model-dir.h
 
 (define-function gda_data_model_dir_get_type
@@ -2034,17 +2206,6 @@
   (return-type "none")
 )
 
-
-
-;; From gda-data-model-dsn-list.h
-
-(define-function gda_data_model_dsn_list_get_type
-  (c-name "gda_data_model_dsn_list_get_type")
-  (return-type "GType")
-)
-
-
-
 ;; From gda-data-model-extra.h
 
 (define-method row_inserted
@@ -3270,15 +3431,6 @@
 
 
 
-;; From gda-error.h
-
-(define-function gda_error_get_type
-  (c-name "gda_error_get_type")
-  (return-type "GType")
-)
-
-
-
 ;; From gda-holder.h
 
 (define-function gda_holder_get_type
@@ -3859,6 +4011,7 @@
 )
 
 
+
 ;; From gda-mutex.h
 
 (define-function gda_mutex_new
@@ -4003,6 +4156,24 @@
   )
 )
 
+(define-method invalidate_value
+  (of-object "GdaRow")
+  (c-name "gda_row_invalidate_value")
+  (return-type "none")
+  (parameters
+    '("GValue*" "value")
+  )
+)
+
+(define-method value_is_valid
+  (of-object "GdaRow")
+  (c-name "gda_row_value_is_valid")
+  (return-type "gboolean")
+  (parameters
+    '("GValue*" "value")
+  )
+)
+
 
 
 ;; From gda-server-operation.h
@@ -4691,12 +4862,6 @@
   )
 )
 
-(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")
@@ -4751,66 +4916,9 @@
 )
 
 
+;; From gda-types.h
 
-;; 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")
-  )
-)
 
 ;; From gda-util.h
 
@@ -4874,6 +4982,14 @@
   )
 )
 
+(define-function gda_sql_identifier_split
+  (c-name "gda_sql_identifier_split")
+  (return-type "gchar**")
+  (parameters
+    '("const-gchar*" "id")
+  )
+)
+
 (define-function gda_utility_check_data_model
   (c-name "gda_utility_check_data_model")
   (return-type "gboolean")
@@ -5161,7 +5277,7 @@
   (return-type "none")
   (parameters
     '("GValue*" "value")
-    '("const-GdaBinary*" "binary")
+    '("GdaBinary*" "binary")
   )
 )
 
@@ -5187,7 +5303,7 @@
   (return-type "none")
   (parameters
     '("GValue*" "value")
-    '("const-GdaBlob*" "blob")
+    '("GdaBlob*" "blob")
   )
 )
 
@@ -5382,10 +5498,9 @@
 
 (define-function gda_string_to_binary
   (c-name "gda_string_to_binary")
-  (return-type "gboolean")
+  (return-type "GdaBinary*")
   (parameters
     '("const-gchar*" "str")
-    '("GdaBinary*" "bin")
   )
 )
 
@@ -5400,10 +5515,9 @@
 
 (define-function gda_string_to_blob
   (c-name "gda_string_to_blob")
-  (return-type "gboolean")
+  (return-type "GdaBlob*")
   (parameters
     '("const-gchar*" "str")
-    '("GdaBlob*" "blob")
   )
 )
 
@@ -5649,3 +5763,1021 @@
 )
 
 
+
+;; 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_type_get_type
+  (c-name "gda_sql_error_type_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-parser-private.h
+
+
+
+;; 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_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-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_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_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_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_add_quotes
+  (c-name "gda_sql_identifier_add_quotes")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "str")
+  )
+)
+
+(define-function gda_sql_identifier_needs_quotes
+  (c-name "gda_sql_identifier_needs_quotes")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "str")
+  )
+)
+
+(define-function gda_sql_identifier_remove_quotes
+  (c-name "gda_sql_identifier_remove_quotes")
+  (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")
+  )
+)
+
+
diff --git a/gda/gda.override b/gda/gda.override
index 442529f..b14ccc7 100644
--- a/gda/gda.override
+++ b/gda/gda.override
@@ -7,6 +7,8 @@ headers
 #include <libgda/gda-data-model-extra.h>
 #include <libgda/gda-data-model-iter.h>
 #include <libgda/gda-data-model-iter-extra.h>
+#include <libgda/sql-parser/gda-sql-parser.h>
+#include <libgda/sql-parser/gda-sql-parser-enum-types.h>
 #include <libgda/gda-server-provider-extra.h>
 #include <libgda/gda-transaction-status-private.h> //TODO: Or can we just make the generator ignore this without removing it from the .defs by hand?
 #include <libgda/gda-enum-types.h>
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]