vapi/libgda-4.0.vapi

   1 /* libgda-4.0.vapi generated by vapigen, do not modify. */
   2
   3 [Version (deprecated_since = "4.2.13", replacement = "bindings distributed with libgda-4.0")]
   4 namespace Gda {
   5         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_attributes_manager_copy")]
   6         [Compact]
   7         public class AttributesManager {
   8                 [CCode (has_construct_function = false)]
   9                 public AttributesManager (bool for_objects, Gda.AttributesManagerSignal signal_func, void* signal_data);
  10                 public void clear (void* ptr);
  11                 public void copy (void* from, Gda.AttributesManager to_mgr, void* to);
  12                 public void @foreach (void* ptr, Gda.AttributesManagerFunc func, void* data);
  13                 public GLib.Value @get (void* ptr, string att_name);
  14                 public void @set (void* ptr, string att_name, GLib.Value value);
  15                 public void set_full (void* ptr, string att_name, GLib.Value value, GLib.DestroyNotify destroy);
  16         }
  17         [CCode (cheader_filename = "libgda/libgda.h")]
  18         public class Batch : GLib.Object {
  19                 [CCode (has_construct_function = false)]
  20                 public Batch ();
  21                 public void add_statement (Gda.Statement stmt);
  22                 public unowned Gda.Batch copy ();
  23                 public static GLib.Quark error_quark ();
  24                 public bool get_parameters (out unowned Gda.Set out_params) throws GLib.Error;
  25                 public unowned GLib.SList<Gda.Statement> get_statements ();
  26                 public void remove_statement (Gda.Statement stmt);
  27                 public unowned string serialize ();
  28                 public virtual signal void changed (GLib.Object changed_stmt);
  29         }
  30         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_binary_copy", type_id = "gda_binary_get_type ()")]
  31         [Compact]
  32         public class Binary {
  33                 public long binary_length;
  34                 [CCode (array_length = false)]
  35                 public weak uchar[] data;
  36                 public static void* copy (void* boxed);
  37                 public unowned string to_string (uint maxlen);
  38         }
  39         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_blob_copy", type_id = "gda_blob_get_type ()")]
  40         [Compact]
  41         public class Blob {
  42                 public weak Gda.Binary data;
  43                 public weak Gda.BlobOp op;
  44                 public static void* copy (void* boxed);
  45                 public void set_op (Gda.BlobOp op);
  46                 public unowned string to_string (uint maxlen);
  47         }
  48         [CCode (cheader_filename = "libgda/libgda.h")]
  49         public class BlobOp : GLib.Object {
  50                 [CCode (has_construct_function = false)]
  51                 protected BlobOp ();
  52                 public virtual long get_length ();
  53                 public virtual long read (Gda.Blob blob, long offset, long size);
  54                 public bool read_all (Gda.Blob blob);
  55                 public virtual long write (Gda.Blob blob, long offset);
  56                 public virtual bool write_all (Gda.Blob blob);
  57         }
  58         [CCode (cheader_filename = "libgda/libgda.h")]
  59         public class Column : GLib.Object {
  60                 [CCode (has_construct_function = false)]
  61                 public Column ();
  62                 public unowned Gda.Column copy ();
  63                 public bool get_allow_null ();
  64                 public GLib.Value get_attribute (string attribute);
  65                 public bool get_auto_increment ();
  66                 public unowned string get_dbms_type ();
  67                 public GLib.Value get_default_value ();
  68                 public unowned string get_description ();
  69                 public GLib.Type get_g_type ();
  70                 public unowned string get_name ();
  71                 public int get_position ();
  72                 public void set_allow_null (bool allow);
  73                 public void set_attribute (string attribute, GLib.Value value, GLib.DestroyNotify destroy);
  74                 public void set_auto_increment (bool is_auto);
  75                 public void set_dbms_type (string dbms_type);
  76                 public void set_default_value (GLib.Value default_value);
  77                 public void set_description (string title);
  78                 public void set_g_type (GLib.Type type);
  79                 public void set_name (string name);
  80                 public void set_position (int position);
  81                 [NoAccessorMethod]
  82                 public string id { owned get; set; }
  83                 public virtual signal void g_type_changed (GLib.Type old_type, GLib.Type new_type);
  84                 public virtual signal void name_changed (string old_name);
  85         }
  86         [CCode (cheader_filename = "libgda/libgda.h")]
  87         public class Config : GLib.Object {
  88                 [CCode (has_construct_function = false)]
  89                 protected Config ();
  90                 public static bool can_modify_system_config ();
  91                 public static bool define_dsn (Gda.DsnInfo info) throws GLib.Error;
  92                 public static bool dsn_needs_authentication (string dsn_name);
  93                 public static GLib.Quark error_quark ();
  94                 public static unowned Gda.Config @get ();
  95                 public static Gda.DsnInfo get_dsn_info (string dsn_name);
  96                 public static Gda.DsnInfo get_dsn_info_at_index (int index);
  97                 public static int get_dsn_info_index (string dsn_name);
  98                 public static int get_nb_dsn ();
  99                 public static unowned Gda.ServerProvider get_provider (string provider_name) throws GLib.Error;
 100                 public static unowned Gda.ProviderInfo get_provider_info (string provider_name);
 101                 public static unowned Gda.DataModel list_dsn ();
 102                 public static unowned Gda.DataModel list_providers ();
 103                 public static bool remove_dsn (string dsn_name) throws GLib.Error;
 104                 [NoAccessorMethod]
 105                 public string system_filename { owned get; set; }
 106                 [NoAccessorMethod]
 107                 public string user_filename { owned get; set; }
 108                 public virtual signal void dsn_added (void* new_dsn);
 109                 public virtual signal void dsn_changed (void* dsn);
 110                 public virtual signal void dsn_removed (void* old_dsn);
 111                 public virtual signal void dsn_to_be_removed (void* old_dsn);
 112         }
 113         [CCode (cheader_filename = "libgda/libgda.h")]
 114         public class Connection : GLib.Object, Gda.Lockable {
 115                 [CCode (has_construct_function = false)]
 116                 protected Connection ();
 117                 public bool add_savepoint (string name) throws GLib.Error;
 118                 public bool async_cancel (uint task_id) throws GLib.Error;
 119                 public unowned GLib.Object async_fetch_result (uint task_id, out unowned Gda.Set last_insert_row) throws GLib.Error;
 120                 public uint async_statement_execute (Gda.Statement stmt, Gda.Set @params, Gda.StatementModelUsage model_usage, GLib.Type[] col_types, bool need_last_insert_row) throws GLib.Error;
 121                 public unowned GLib.SList<GLib.Object> batch_execute (Gda.Batch batch, Gda.Set @params, Gda.StatementModelUsage model_usage) throws GLib.Error;
 122                 public bool begin_transaction (string name, Gda.TransactionIsolation level) throws GLib.Error;
 123                 public void close ();
 124                 public void close_no_warning ();
 125                 public bool commit_transaction (string name) throws GLib.Error;
 126                 public unowned Gda.ServerOperation create_operation (Gda.ServerOperationType type, Gda.Set options) throws GLib.Error;
 127                 public unowned Gda.SqlParser create_parser ();
 128                 public bool delete_row_from_table (string table, string condition_column_name, GLib.Value condition_value) throws GLib.Error;
 129                 public bool delete_savepoint (string name) throws GLib.Error;
 130                 public static GLib.Quark error_quark ();
 131                 public int execute_non_select_command (string sql) throws GLib.Error;
 132                 public unowned Gda.DataModel execute_select_command (string sql) throws GLib.Error;
 133                 public unowned string get_authentication ();
 134                 public unowned string get_cnc_string ();
 135                 public unowned string get_dsn ();
 136                 public unowned GLib.List<Gda.ConnectionEvent> get_events ();
 137                 public unowned Gda.MetaStore get_meta_store ();
 138                 public unowned Gda.DataModel get_meta_store_data (Gda.ConnectionMetaType meta_type, int nb_filters) throws GLib.Error;
 139                 public Gda.DataModel get_meta_store_data_v (Gda.ConnectionMetaType meta_type, GLib.List<Gda.Holder> filters) throws GLib.Error;
 140                 public Gda.ConnectionOptions get_options ();
 141                 public unowned Gda.ServerProvider get_provider ();
 142                 public unowned string get_provider_name ();
 143                 public unowned Gda.TransactionStatus get_transaction_status ();
 144                 public bool insert_row_into_table (string table) throws GLib.Error;
 145                 public bool insert_row_into_table_v (string table, GLib.SList col_names, GLib.SList values) throws GLib.Error;
 146                 public bool is_opened ();
 147                 public bool open () throws GLib.Error;
 148                 public static unowned Gda.Connection open_from_dsn (string dsn, string? auth_string, Gda.ConnectionOptions options) throws GLib.Error;
 149                 public static unowned Gda.Connection open_from_string (string provider_name, string? cnc_string, string? auth_string, Gda.ConnectionOptions options) throws GLib.Error;
 150                 public unowned Gda.Statement parse_sql_string (string sql, out unowned Gda.Set @params) throws GLib.Error;
 151                 public bool perform_operation (Gda.ServerOperation op) throws GLib.Error;
 152                 public unowned string quote_sql_identifier (string id);
 153                 public unowned GLib.SList repetitive_statement_execute (Gda.RepetitiveStatement rstmt, Gda.StatementModelUsage model_usage, GLib.Type[] col_types, bool stop_on_error) throws GLib.Error;
 154                 public bool rollback_savepoint (string name) throws GLib.Error;
 155                 public bool rollback_transaction (string name) throws GLib.Error;
 156                 public unowned GLib.Object statement_execute (Gda.Statement stmt, Gda.Set @params, Gda.StatementModelUsage model_usage, out unowned Gda.Set last_insert_row) throws GLib.Error;
 157                 public int statement_execute_non_select (Gda.Statement stmt, Gda.Set? @params, out unowned Gda.Set? last_insert_row) throws GLib.Error;
 158                 public unowned Gda.DataModel statement_execute_select (Gda.Statement stmt, Gda.Set @params) throws GLib.Error;
 159                 public unowned Gda.DataModel statement_execute_select_full (Gda.Statement stmt, Gda.Set @params, Gda.StatementModelUsage model_usage, GLib.Type[] col_types) throws GLib.Error;
 160                 public unowned Gda.DataModel statement_execute_select_fullv (Gda.Statement stmt, Gda.Set @params, Gda.StatementModelUsage model_usage) throws GLib.Error;
 161                 public bool statement_prepare (Gda.Statement stmt) throws GLib.Error;
 162                 public unowned string statement_to_sql (Gda.Statement stmt, Gda.Set @params, Gda.StatementSqlFlag flags, GLib.SList<Gda.Holder> params_used) throws GLib.Error;
 163                 public static void string_split (string str, string out_cnc_params, string out_provider, string out_username, string out_password);
 164                 public bool supports_feature (Gda.ConnectionFeature feature);
 165                 public bool update_meta_store (Gda.MetaContext context) throws GLib.Error;
 166                 public bool update_row_in_table (string table, string condition_column_name, GLib.Value condition_value) throws GLib.Error;
 167                 public bool update_row_in_table_v (string table, string condition_column_name, GLib.Value condition_value, GLib.SList col_names, GLib.SList values) throws GLib.Error;
 168                 public unowned string value_to_sql_string (GLib.Value from);
 169                 [NoAccessorMethod]
 170                 public string auth_string { owned get; set; }
 171                 [NoAccessorMethod]
 172                 public string cnc_string { owned get; set; }
 173                 [NoAccessorMethod]
 174                 public string dsn { owned get; set; }
 175                 [NoAccessorMethod]
 176                 public int events_history_size { get; set; }
 177                 [NoAccessorMethod]
 178                 public bool is_wrapper { get; construct; }
 179                 [NoAccessorMethod]
 180                 public Gda.MetaStore meta_store { owned get; set; }
 181                 [NoAccessorMethod]
 182                 public bool monitor_wrapped_in_mainloop { get; set; }
 183                 [NoAccessorMethod]
 184                 public Gda.ConnectionOptions options { get; set; }
 185                 [NoAccessorMethod]
 186                 public Gda.ServerProvider provider { owned get; set; }
 187                 [NoAccessorMethod]
 188                 public void* thread_owner { get; set; }
 189                 public virtual signal void conn_closed ();
 190                 public virtual signal void conn_opened ();
 191                 public virtual signal void conn_to_close ();
 192                 public virtual signal void dsn_changed ();
 193                 public virtual signal void error (Gda.ConnectionEvent error);
 194                 public virtual signal void transaction_status_changed ();
 195         }
 196         [CCode (cheader_filename = "libgda/libgda.h")]
 197         public class ConnectionEvent : GLib.Object {
 198                 [CCode (has_construct_function = false)]
 199                 public ConnectionEvent (Gda.ConnectionEventType type);
 200                 public long get_code ();
 201                 public unowned string get_description ();
 202                 public Gda.ConnectionEventType get_event_type ();
 203                 public Gda.ConnectionEventCode get_gda_code ();
 204                 public unowned string get_source ();
 205                 public unowned string get_sqlstate ();
 206                 public void set_code (long code);
 207                 public void set_description (string description);
 208                 public void set_event_type (Gda.ConnectionEventType type);
 209                 public void set_gda_code (Gda.ConnectionEventCode code);
 210                 public void set_source (string source);
 211                 public void set_sqlstate (string sqlstate);
 212                 [NoAccessorMethod]
 213                 public int type { get; set; }
 214         }
 215         [CCode (cheader_filename = "libgda/libgda.h")]
 216         public class DataAccessWrapper : GLib.Object, Gda.DataModel {
 217                 [CCode (has_construct_function = false, type = "GdaDataModel*")]
 218                 public DataAccessWrapper (Gda.DataModel model);
 219                 [NoAccessorMethod]
 220                 public Gda.DataModel model { owned get; construct; }
 221         }
 222         [CCode (cheader_filename = "libgda/libgda.h")]
 223         public class DataComparator : GLib.Object {
 224                 [CCode (has_construct_function = false, type = "GObject*")]
 225                 public DataComparator (Gda.DataModel old_model, Gda.DataModel new_model);
 226                 public bool compute_diff () throws GLib.Error;
 227                 public static GLib.Quark error_quark ();
 228                 public unowned Gda.Diff get_diff (int pos);
 229                 public int get_n_diffs ();
 230                 public void set_key_columns (int col_numbers, int nb_cols);
 231                 [NoAccessorMethod]
 232                 public Gda.DataModel new_model { owned get; set; }
 233                 [NoAccessorMethod]
 234                 public Gda.DataModel old_model { owned get; set; }
 235                 public virtual signal bool diff_computed (void* diff);
 236         }
 237         [CCode (cheader_filename = "libgda/libgda.h")]
 238         public class DataModelArray : GLib.Object, Gda.DataModel {
 239                 [CCode (has_construct_function = false, type = "GdaDataModel*")]
 240                 public DataModelArray (int cols);
 241                 public void clear ();
 242                 public static unowned Gda.DataModelArray copy_model (Gda.DataModel src) throws GLib.Error;
 243                 public unowned Gda.Row get_row (int row) throws GLib.Error;
 244                 public void set_n_columns (int cols);
 245                 [CCode (has_construct_function = false, sentinel = "", type = "GdaDataModel*")]
 246                 public DataModelArray.with_g_types (int cols, ...);
 247                 [NoAccessorMethod]
 248                 public uint n_columns { get; set; }
 249                 [NoAccessorMethod]
 250                 public bool read_only { get; set; }
 251         }
 252         [CCode (cheader_filename = "libgda/libgda.h")]
 253         public class DataModelDir : GLib.Object, Gda.DataModel {
 254                 [CCode (has_construct_function = false, type = "GdaDataModel*")]
 255                 public DataModelDir (string basedir);
 256                 public void clean_errors ();
 257                 public unowned GLib.SList<GLib.Error> get_errors ();
 258                 [NoAccessorMethod]
 259                 public string basedir { owned get; construct; }
 260         }
 261         [CCode (cheader_filename = "libgda/libgda.h")]
 262         public class DataModelImport : GLib.Object, Gda.DataModel {
 263                 [CCode (has_construct_function = false)]
 264                 protected DataModelImport ();
 265                 public void clean_errors ();
 266                 [CCode (has_construct_function = false, type = "GdaDataModel*")]
 267                 public DataModelImport.file (string filename, bool random_access, Gda.Set options);
 268                 public static bool from_file (Gda.DataModel model, string file, GLib.HashTable cols_trans, Gda.Set options) throws GLib.Error;
 269                 public static bool from_model (Gda.DataModel to, Gda.DataModel from, bool overwrite, GLib.HashTable cols_trans) throws GLib.Error;
 270                 public static bool from_string (Gda.DataModel model, string str, GLib.HashTable cols_trans, Gda.Set options) throws GLib.Error;
 271                 [CCode (cname = "gda_data_model_import_new_xml_node", has_construct_function = false, type = "GdaDataModel*")]
 272                 public DataModelImport.from_xml_node (Xml.Node node);
 273                 public unowned GLib.SList<GLib.Error> get_errors ();
 274                 [CCode (has_construct_function = false, type = "GdaDataModel*")]
 275                 public DataModelImport.mem (string data, bool random_access, Gda.Set options);
 276                 [NoAccessorMethod]
 277                 public string data_string { owned get; construct; }
 278                 [NoAccessorMethod]
 279                 public string filename { owned get; construct; }
 280                 [NoAccessorMethod]
 281                 public Gda.Set options { owned get; construct; }
 282                 [NoAccessorMethod]
 283                 public bool random_access { get; construct; }
 284                 [NoAccessorMethod]
 285                 public bool strict { get; set construct; }
 286                 [NoAccessorMethod]
 287                 public void* xml_node { get; construct; }
 288         }
 289         [CCode (cheader_filename = "libgda/libgda.h")]
 290         public class DataModelIter : Gda.Set {
 291                 [CCode (has_construct_function = false)]
 292                 protected DataModelIter ();
 293                 public static GLib.Quark error_quark ();
 294                 public unowned Gda.Holder get_holder_for_field (int col);
 295                 public int get_row ();
 296                 public unowned GLib.Value? get_value_at (int col);
 297                 public unowned GLib.Value? get_value_for_field (string field_name);
 298                 public void invalidate_contents ();
 299                 public bool is_valid ();
 300                 public bool move_next ();
 301                 public static bool move_next_default (Gda.DataModel model, Gda.DataModelIter iter);
 302                 public bool move_prev ();
 303                 public static bool move_prev_default (Gda.DataModel model, Gda.DataModelIter iter);
 304                 public bool move_to_row (int row);
 305                 public static bool move_to_row_default (Gda.DataModel model, Gda.DataModelIter iter, int row);
 306                 public bool set_value_at (int col, GLib.Value value) throws GLib.Error;
 307                 [NoAccessorMethod]
 308                 public int current_row { get; set; }
 309                 [NoAccessorMethod]
 310                 public Gda.DataModel data_model { owned get; construct; }
 311                 [NoAccessorMethod]
 312                 public Gda.DataModel forced_model { owned get; set; }
 313                 [NoAccessorMethod]
 314                 public bool update_model { get; set; }
 315                 public virtual signal void end_of_data ();
 316                 public virtual signal void row_changed (int row);
 317         }
 318         [CCode (cheader_filename = "libgda/libgda.h")]
 319         public class DataProxy : GLib.Object, Gda.DataModel {
 320                 [CCode (has_construct_function = false, type = "GObject*")]
 321                 public DataProxy (Gda.DataModel model);
 322                 public void alter_value_attributes (int proxy_row, int col, Gda.ValueAttribute alter_flags);
 323                 public bool apply_all_changes () throws GLib.Error;
 324                 public bool apply_row_changes (int proxy_row) throws GLib.Error;
 325                 public bool cancel_all_changes ();
 326                 public void cancel_row_changes (int proxy_row, int col);
 327                 public void @delete (int proxy_row);
 328                 public static GLib.Quark error_quark ();
 329                 public unowned string get_filter_expr ();
 330                 public int get_filtered_n_rows ();
 331                 public int get_n_modified_rows ();
 332                 public int get_n_new_rows ();
 333                 public unowned Gda.DataModel get_proxied_model ();
 334                 public int get_proxied_model_n_cols ();
 335                 public int get_proxied_model_n_rows ();
 336                 public int get_proxied_model_row (int proxy_row);
 337                 public int get_sample_end ();
 338                 public int get_sample_size ();
 339                 public int get_sample_start ();
 340                 public Gda.ValueAttribute get_value_attributes (int proxy_row, int col);
 341                 public unowned GLib.SList<GLib.Value> get_values (int proxy_row, int cols_index, int n_cols);
 342                 public bool has_changed ();
 343                 public bool is_read_only ();
 344                 public bool row_has_changed (int proxy_row);
 345                 public bool row_is_deleted (int proxy_row);
 346                 public bool row_is_inserted (int proxy_row);
 347                 public bool set_filter_expr (string filter_expr) throws GLib.Error;
 348                 public bool set_ordering_column (int col) throws GLib.Error;
 349                 public void set_sample_size (int sample_size);
 350                 public void set_sample_start (int sample_start);
 351                 public void undelete (int proxy_row);
 352                 [NoAccessorMethod]
 353                 public bool defer_sync { get; set; }
 354                 [NoAccessorMethod]
 355                 public Gda.DataModel model { owned get; set construct; }
 356                 [NoAccessorMethod]
 357                 public bool prepend_null_entry { get; set; }
 358                 public int sample_size { get; set construct; }
 359                 public virtual signal void filter_changed ();
 360                 public virtual signal void row_changes_applied (int row, int proxied_row);
 361                 public virtual signal void row_delete_changed (int row, bool to_be_deleted);
 362                 public virtual signal void sample_changed (int sample_start, int sample_end);
 363                 public virtual signal void sample_size_changed (int sample_size);
 364                 public virtual signal unowned GLib.Error validate_row_changes (int row, int proxied_row);
 365         }
 366         [CCode (cheader_filename = "libgda/libgda.h")]
 367         public class DataSelect : GLib.Object, Gda.DataModel {
 368                 public int advertized_nrows;
 369                 public int nb_stored_rows;
 370                 public weak Gda.PStmt prep_stmt;
 371                 [CCode (has_construct_function = false)]
 372                 protected DataSelect ();
 373                 public bool compute_columns_attributes () throws GLib.Error;
 374                 public bool compute_modification_statements () throws GLib.Error;
 375                 public bool compute_row_selection_condition () throws GLib.Error;
 376                 public static GLib.Quark error_quark ();
 377                 [NoWrapper]
 378                 public virtual bool fetch_at (out unowned Gda.Row prow, int rownum) throws GLib.Error;
 379                 [NoWrapper]
 380                 public virtual int fetch_nb_rows ();
 381                 [NoWrapper]
 382                 public virtual bool fetch_next (out unowned Gda.Row prow, int rownum) throws GLib.Error;
 383                 [NoWrapper]
 384                 public virtual bool fetch_prev (out unowned Gda.Row prow, int rownum) throws GLib.Error;
 385                 [NoWrapper]
 386                 public virtual bool fetch_random (out unowned Gda.Row prow, int rownum) throws GLib.Error;
 387                 public unowned Gda.Connection get_connection ();
 388                 public unowned Gda.Row get_stored_row (int rownum);
 389                 public bool rerun () throws GLib.Error;
 390                 public void set_columns (GLib.SList columns);
 391                 public bool set_modification_statement (Gda.Statement mod_stmt) throws GLib.Error;
 392                 public bool set_modification_statement_sql (string sql) throws GLib.Error;
 393                 public bool set_row_selection_condition (Gda.SqlExpr expr) throws GLib.Error;
 394                 public bool set_row_selection_condition_sql (string sql_where) throws GLib.Error;
 395                 [NoWrapper]
 396                 public virtual bool store_all () throws GLib.Error;
 397                 public void take_row (Gda.Row row, int rownum);
 398                 [NoAccessorMethod]
 399                 public bool auto_reset { get; set; }
 400                 public Gda.Connection connection { get; construct; }
 401                 [NoAccessorMethod]
 402                 public Gda.Statement delete_stmt { owned get; set; }
 403                 [NoAccessorMethod]
 404                 public Gda.Set exec_params { owned get; construct; }
 405                 [NoAccessorMethod]
 406                 public Gda.Statement insert_stmt { owned get; set; }
 407                 [NoAccessorMethod]
 408                 public uint model_usage { get; construct; }
 409                 [NoAccessorMethod]
 410                 public Gda.PStmt prepared_stmt { owned get; set; }
 411                 [NoAccessorMethod]
 412                 public Gda.Statement select_stmt { owned get; }
 413                 [NoAccessorMethod]
 414                 public bool store_all_rows { get; set; }
 415                 [NoAccessorMethod]
 416                 public Gda.Statement update_stmt { owned get; set; }
 417         }
 418         [CCode (cheader_filename = "libgda/libgda.h")]
 419         [Compact]
 420         public class Diff {
 421                 public int new_row;
 422                 public int old_row;
 423                 public Gda.DiffType type;
 424                 public weak GLib.HashTable values;
 425         }
 426         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_geometricpoint_copy", free_function = "gda_geometricpoint_free", type_id = "gda_geometricpoint_get_type ()")]
 427         [Compact]
 428         public class GeometricPoint {
 429                 public double x;
 430                 public double y;
 431                 [CCode (cname = "gda_geometricpoint_copy")]
 432                 public static void* copy (void* boxed);
 433         }
 434         [CCode (cheader_filename = "libgda/libgda.h")]
 435         public class HandlerBin : GLib.Object, Gda.DataHandler {
 436                 [CCode (has_construct_function = false, type = "GdaDataHandler*")]
 437                 public HandlerBin ();
 438         }
 439         [CCode (cheader_filename = "libgda/libgda.h")]
 440         [Compact]
 441         public class HandlerBinPriv {
 442         }
 443         [CCode (cheader_filename = "libgda/libgda.h")]
 444         public class HandlerBoolean : GLib.Object, Gda.DataHandler {
 445                 [CCode (has_construct_function = false, type = "GdaDataHandler*")]
 446                 public HandlerBoolean ();
 447         }
 448         [CCode (cheader_filename = "libgda/libgda.h")]
 449         [Compact]
 450         public class HandlerBooleanPriv {
 451         }
 452         [CCode (cheader_filename = "libgda/libgda.h")]
 453         public class HandlerNumerical : GLib.Object, Gda.DataHandler {
 454                 [CCode (has_construct_function = false, type = "GdaDataHandler*")]
 455                 public HandlerNumerical ();
 456         }
 457         [CCode (cheader_filename = "libgda/libgda.h")]
 458         [Compact]
 459         public class HandlerNumericalPriv {
 460         }
 461         [CCode (cheader_filename = "libgda/libgda.h")]
 462         public class HandlerString : GLib.Object, Gda.DataHandler {
 463                 [CCode (has_construct_function = false, type = "GdaDataHandler*")]
 464                 public HandlerString ();
 465                 [CCode (has_construct_function = false, type = "GdaDataHandler*")]
 466                 public HandlerString.with_provider (Gda.ServerProvider prov, Gda.Connection cnc);
 467         }
 468         [CCode (cheader_filename = "libgda/libgda.h")]
 469         [Compact]
 470         public class HandlerStringPriv {
 471         }
 472         [CCode (cheader_filename = "libgda/libgda.h")]
 473         public class HandlerTime : GLib.Object, Gda.DataHandler {
 474                 [CCode (has_construct_function = false, type = "GdaDataHandler*")]
 475                 public HandlerTime ();
 476                 public unowned string get_format (GLib.Type type);
 477                 public unowned string get_no_locale_str_from_value (GLib.Value value);
 478                 [CCode (has_construct_function = false, type = "GdaDataHandler*")]
 479                 public HandlerTime.no_locale ();
 480                 public void set_sql_spec (GLib.DateDMY first, GLib.DateDMY sec, GLib.DateDMY third, char separator, bool twodigits_years);
 481         }
 482         [CCode (cheader_filename = "libgda/libgda.h")]
 483         [Compact]
 484         public class HandlerTimePriv {
 485         }
 486         [CCode (cheader_filename = "libgda/libgda.h")]
 487         public class HandlerType : GLib.Object, Gda.DataHandler {
 488                 [CCode (has_construct_function = false, type = "GdaDataHandler*")]
 489                 public HandlerType ();
 490         }
 491         [CCode (cheader_filename = "libgda/libgda.h")]
 492         [Compact]
 493         public class HandlerTypePriv {
 494         }
 495         [CCode (cheader_filename = "libgda/libgda.h")]
 496         public class Holder : GLib.Object {
 497                 [CCode (has_construct_function = false)]
 498                 public Holder (GLib.Type type);
 499                 [NoWrapper]
 500                 public virtual void att_changed (string att_name, GLib.Value att_value);
 501                 public unowned Gda.Holder copy ();
 502                 public static GLib.Quark error_quark ();
 503                 public void force_invalid ();
 504                 public GLib.Value get_attribute (string attribute);
 505                 public unowned Gda.Holder get_bind ();
 506                 public GLib.Value get_default_value ();
 507                 public GLib.Type get_g_type ();
 508                 public unowned string get_id ();
 509                 public bool get_not_null ();
 510                 public unowned Gda.DataModel get_source_model (int col);
 511                 public GLib.Value get_value ();
 512                 public unowned string get_value_str (Gda.DataHandler dh);
 513                 [CCode (has_construct_function = false)]
 514                 public Holder.@inline (GLib.Type type, string id);
 515                 public bool is_valid ();
 516                 public void set_attribute (string attribute, GLib.Value value, GLib.DestroyNotify destroy);
 517                 public bool set_bind (Gda.Holder bind_to) throws GLib.Error;
 518                 public void set_default_value (GLib.Value value);
 519                 public void set_not_null (bool not_null);
 520                 public bool set_source_model (Gda.DataModel model, int col) throws GLib.Error;
 521                 public bool set_value (GLib.Value value) throws GLib.Error;
 522                 public bool set_value_str (Gda.DataHandler dh, string value) throws GLib.Error;
 523                 public bool set_value_to_default ();
 524                 public GLib.Value take_static_value (GLib.Value value, bool value_changed) throws GLib.Error;
 525                 public bool take_value (GLib.Value value) throws GLib.Error;
 526                 public bool value_is_default ();
 527                 [NoAccessorMethod]
 528                 public string description { owned get; set; }
 529                 [NoAccessorMethod]
 530                 public Gda.Holder full_bind { owned get; set; }
 531                 [NoAccessorMethod]
 532                 public GLib.Type g_type { get; set construct; }
 533                 [NoAccessorMethod]
 534                 public string id { owned get; set; }
 535                 [NoAccessorMethod]
 536                 public string name { owned get; set; }
 537                 public bool not_null { get; set; }
 538                 [NoAccessorMethod]
 539                 public Gda.Holder simple_bind { owned get; set; }
 540                 [NoAccessorMethod]
 541                 public int source_column { get; set; }
 542                 public Gda.DataModel source_model { get; set; }
 543                 public virtual signal void attribute_changed (string p0, GLib.Value p1);
 544                 public virtual signal void changed ();
 545                 public virtual signal void source_changed ();
 546                 public virtual signal unowned GLib.Error validate_change (GLib.Value new_value);
 547         }
 548         [CCode (cheader_filename = "libgda/libgda.h")]
 549         [Compact]
 550         public class MetaContext {
 551                 public weak string column_names;
 552                 public GLib.Value column_values;
 553                 public int size;
 554                 public weak string table_name;
 555         }
 556         [CCode (cheader_filename = "libgda/libgda.h")]
 557         [Compact]
 558         public class MetaDbObject {
 559                 public weak GLib.SList depend_list;
 560                 public void* extra;
 561                 public weak string obj_catalog;
 562                 public weak string obj_full_name;
 563                 public weak string obj_name;
 564                 public weak string obj_owner;
 565                 public weak string obj_schema;
 566                 public weak string obj_short_name;
 567                 public Gda.MetaDbObjectType obj_type;
 568                 public bool outdated;
 569         }
 570         [CCode (cheader_filename = "libgda/libgda.h")]
 571         public class MetaStore : GLib.Object {
 572                 [CCode (has_construct_function = false)]
 573                 public MetaStore (string cnc_string);
 574                 public unowned Gda.DataModel create_modify_data_model (string table_name);
 575                 public bool declare_foreign_key (Gda.MetaStruct mstruct, string fk_name, string catalog, string schema, string table, string ref_catalog, string ref_schema, string ref_table, uint nb_cols, string colnames, string ref_colnames) throws GLib.Error;
 576                 public static GLib.Quark error_quark ();
 577                 public unowned Gda.DataModel extract (string select_sql) throws GLib.Error;
 578                 public bool get_attribute_value (string att_name, string att_value) throws GLib.Error;
 579                 public unowned Gda.Connection get_internal_connection ();
 580                 public int get_version ();
 581                 public bool modify (string table_name, Gda.DataModel new_data, string condition) throws GLib.Error;
 582                 public bool modify_with_context (Gda.MetaContext context, Gda.DataModel new_data) throws GLib.Error;
 583                 public bool schema_add_custom_object (string xml_description) throws GLib.Error;
 584                 public unowned GLib.SList schema_get_all_tables ();
 585                 public unowned GLib.SList schema_get_depend_tables (string table_name);
 586                 public unowned Gda.MetaStruct schema_get_structure () throws GLib.Error;
 587                 public bool schema_remove_custom_object (string obj_name) throws GLib.Error;
 588                 public bool set_attribute_value (string att_name, string att_value) throws GLib.Error;
 589                 public void set_identifiers_style (Gda.SqlIdentifierStyle style);
 590                 public void set_reserved_keywords_func (Gda.SqlReservedKeywordsFunc func);
 591                 public static unowned string sql_identifier_quote (string id, Gda.Connection cnc);
 592                 public bool undeclare_foreign_key (Gda.MetaStruct mstruct, string fk_name, string catalog, string schema, string table, string ref_catalog, string ref_schema, string ref_table) throws GLib.Error;
 593                 [CCode (has_construct_function = false)]
 594                 public MetaStore.with_file (string file_name);
 595                 public string catalog { construct; }
 596                 [NoAccessorMethod]
 597                 public Gda.Connection cnc { owned get; construct; }
 598                 public string cnc_string { construct; }
 599                 public string schema { construct; }
 600                 public virtual signal void meta_changed (GLib.SList<Gda.MetaStoreChange> changes);
 601                 public virtual signal void meta_reset ();
 602                 public virtual signal unowned GLib.Error suggest_update (Gda.MetaContext suggest);
 603         }
 604         [CCode (cheader_filename = "libgda/libgda.h")]
 605         [Compact]
 606         public class MetaStoreChange {
 607                 public Gda.MetaStoreChangeType c_type;
 608                 public weak GLib.HashTable keys;
 609                 public weak string table_name;
 610         }
 611         [CCode (cheader_filename = "libgda/libgda.h")]
 612         public class MetaStruct : GLib.Object {
 613                 [CCode (has_construct_function = false)]
 614                 public MetaStruct (Gda.MetaStore store, Gda.MetaStructFeature features);
 615                 public unowned Gda.MetaDbObject complement (Gda.MetaDbObjectType type, GLib.Value catalog, GLib.Value schema, GLib.Value name) throws GLib.Error;
 616                 public bool complement_all () throws GLib.Error;
 617                 public bool complement_default () throws GLib.Error;
 618                 public bool complement_depend (Gda.MetaDbObject dbo) throws GLib.Error;
 619                 public bool complement_schema (GLib.Value catalog, GLib.Value schema) throws GLib.Error;
 620                 public unowned string dump_as_graph (Gda.MetaGraphInfo info) throws GLib.Error;
 621                 public static GLib.Quark error_quark ();
 622                 public GLib.SList<Gda.MetaDbObject> get_all_db_objects ();
 623                 public unowned Gda.MetaDbObject get_db_object (GLib.Value catalog, GLib.Value schema, GLib.Value name);
 624                 public unowned Gda.MetaTableColumn get_table_column (Gda.MetaTable table, GLib.Value col_name);
 625                 public bool sort_db_objects (Gda.MetaSortType sort_type) throws GLib.Error;
 626                 [NoAccessorMethod]
 627                 public uint features { get; construct; }
 628                 [NoAccessorMethod]
 629                 public Gda.MetaStore meta_store { owned get; construct; }
 630         }
 631         [CCode (cheader_filename = "libgda/libgda.h")]
 632         [Compact]
 633         public class MetaTable {
 634                 public weak GLib.SList columns;
 635                 public weak GLib.SList fk_list;
 636                 public int pk_cols_array;
 637                 public int pk_cols_nb;
 638                 public weak GLib.SList reverse_fk_list;
 639         }
 640         [CCode (cheader_filename = "libgda/libgda.h")]
 641         [Compact]
 642         public class MetaTableColumn {
 643                 public weak string column_name;
 644                 public weak string column_type;
 645                 public weak string default_value;
 646                 public GLib.Type gtype;
 647                 public bool nullok;
 648                 public bool pkey;
 649                 public void foreach_attribute (Gda.AttributesManagerFunc func, void* data);
 650                 public GLib.Value get_attribute (string attribute);
 651                 public void set_attribute (string attribute, GLib.Value value, GLib.DestroyNotify destroy);
 652         }
 653         [CCode (cheader_filename = "libgda/libgda.h")]
 654         [Compact]
 655         public class MetaTableForeignKey {
 656                 public int cols_nb;
 657                 public void* declared;
 658                 public weak Gda.MetaDbObject depend_on;
 659                 public int fk_cols_array;
 660                 public weak string fk_name;
 661                 public weak string fk_names_array;
 662                 public weak Gda.MetaDbObject meta_table;
 663                 public void* on_delete_policy;
 664                 public void* on_update_policy;
 665                 public int ref_pk_cols_array;
 666                 public weak string ref_pk_names_array;
 667         }
 668         [CCode (cheader_filename = "libgda/libgda.h")]
 669         [Compact]
 670         public class MetaView {
 671                 public bool is_updatable;
 672                 public weak Gda.MetaTable table;
 673                 public weak string view_def;
 674         }
 675         [CCode (cheader_filename = "libgda/libgda.h")]
 676         [Compact]
 677         public class Mutex {
 678                 [CCode (has_construct_function = false)]
 679                 public Mutex ();
 680                 public void @lock ();
 681                 public bool trylock ();
 682                 public void @unlock ();
 683         }
 684         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_numeric_copy", type_id = "gda_numeric_get_type ()")]
 685         [Compact]
 686         public class Numeric {
 687                 public weak string number;
 688                 public long precision;
 689                 public void* reserved;
 690                 public long width;
 691                 public static void* copy (void* boxed);
 692         }
 693         [CCode (cheader_filename = "libgda/libgda.h")]
 694         public class PStmt : GLib.Object {
 695                 public int ncols;
 696                 public weak GLib.SList param_ids;
 697                 public weak string sql;
 698                 public weak GLib.SList tmpl_columns;
 699                 [CCode (array_length = false)]
 700                 public weak GLib.Type[] types;
 701                 [CCode (has_construct_function = false)]
 702                 protected PStmt ();
 703                 public void copy_contents (Gda.PStmt dest);
 704                 public unowned Gda.Statement get_gda_statement ();
 705                 public void set_gda_statement (Gda.Statement stmt);
 706         }
 707         [CCode (cheader_filename = "libgda/libgda.h")]
 708         [Compact]
 709         public class ProviderInfo {
 710                 public weak Gda.Set auth_params;
 711                 public weak string description;
 712                 public weak Gda.Set dsn_params;
 713                 public weak string id;
 714                 public weak string location;
 715         }
 716         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_quark_list_copy", type_id = "gda_quark_list_get_type ()")]
 717         [Compact]
 718         public class QuarkList {
 719                 [CCode (has_construct_function = false)]
 720                 public QuarkList ();
 721                 public void add_from_string (string str, bool cleanup);
 722                 public void clear ();
 723                 public unowned Gda.QuarkList copy ();
 724                 public unowned string find (string name);
 725                 public void @foreach (GLib.HFunc<string,string> func);
 726                 [CCode (has_construct_function = false)]
 727                 public QuarkList.from_string (string str);
 728                 public void remove (string name);
 729         }
 730         [CCode (cheader_filename = "libgda/libgda.h")]
 731         public class RepetitiveStatement : GLib.Object {
 732                 [CCode (has_construct_function = false)]
 733                 public RepetitiveStatement (Gda.Statement stmt);
 734                 public bool append_set (Gda.Set values, bool make_copy);
 735                 public unowned GLib.SList get_all_sets ();
 736                 public bool get_template_set (out unowned Gda.Set @set) throws GLib.Error;
 737                 [NoAccessorMethod]
 738                 public Gda.Statement statement { owned get; construct; }
 739         }
 740         [CCode (cheader_filename = "libgda/libgda.h")]
 741         public class Row : GLib.Object {
 742                 [CCode (has_construct_function = false)]
 743                 public Row (int count);
 744                 public int get_length ();
 745                 public GLib.Value get_value (int num);
 746                 public void invalidate_value (GLib.Value value);
 747                 public bool value_is_valid (GLib.Value value);
 748                 [NoAccessorMethod]
 749                 public int nb_values { set; }
 750         }
 751         [CCode (cheader_filename = "libgda/libgda.h")]
 752         public class ServerOperation : GLib.Object {
 753                 [CCode (has_construct_function = false)]
 754                 public ServerOperation (Gda.ServerOperationType op_type, string xml_file);
 755                 public uint add_item_to_sequence (string seq_path);
 756                 public bool del_item_from_sequence (string item_path);
 757                 public static GLib.Quark error_quark ();
 758                 public unowned Gda.ServerOperationNode get_node_info (string path_format);
 759                 public unowned string get_node_parent (string path);
 760                 public unowned string get_node_path_portion (string path);
 761                 public Gda.ServerOperationNodeType get_node_type (string path, Gda.ServerOperationNodeStatus status);
 762                 public Gda.ServerOperationType get_op_type ();
 763                 public unowned string get_root_nodes ();
 764                 public unowned string get_sequence_item_names (string path);
 765                 public uint get_sequence_max_size (string path);
 766                 public uint get_sequence_min_size (string path);
 767                 public unowned string get_sequence_name (string path);
 768                 public uint get_sequence_size (string path);
 769                 public unowned string get_sql_identifier_at (Gda.Connection cnc, Gda.ServerProvider prov, string path_format);
 770                 public GLib.Value get_value_at (string path_format);
 771                 public bool is_valid (string xml_file) throws GLib.Error;
 772                 public bool load_data_from_xml (Xml.Node node) throws GLib.Error;
 773                 public static unowned string op_type_to_string (Gda.ServerOperationType type);
 774                 public bool perform_create_database (string provider) throws GLib.Error;
 775                 public bool perform_create_table () throws GLib.Error;
 776                 public bool perform_drop_database (string provider) throws GLib.Error;
 777                 public bool perform_drop_table () throws GLib.Error;
 778                 public static unowned Gda.ServerOperation prepare_create_database (string provider, string db_name) throws GLib.Error;
 779                 public static unowned Gda.ServerOperation prepare_create_table (Gda.Connection cnc, string table_name) throws GLib.Error;
 780                 public static unowned Gda.ServerOperation prepare_drop_database (string provider, string db_name) throws GLib.Error;
 781                 public static unowned Gda.ServerOperation prepare_drop_table (Gda.Connection cnc, string table_name) throws GLib.Error;
 782                 public unowned Xml.Node save_data_to_xml () throws GLib.Error;
 783                 [NoWrapper]
 784                 public virtual void seq_item_added (string seq_path, int item_index);
 785                 [NoWrapper]
 786                 public virtual void seq_item_remove (string seq_path, int item_index);
 787                 public bool set_value_at (string value, string path_format) throws GLib.Error;
 788                 public static Gda.ServerOperationType string_to_op_type (string str);
 789                 [NoAccessorMethod]
 790                 public Gda.Connection connection { owned get; construct; }
 791                 public int op_type { get; construct; }
 792                 [NoAccessorMethod]
 793                 public Gda.ServerProvider provider { owned get; construct; }
 794                 public string spec_filename { construct; }
 795                 public virtual signal void sequence_item_added (string p0, int p1);
 796                 public virtual signal void sequence_item_remove (string p0, int p1);
 797         }
 798         [CCode (cheader_filename = "libgda/libgda.h")]
 799         [Compact]
 800         public class ServerOperationNode {
 801                 public weak Gda.Column column;
 802                 public weak Gda.DataModel model;
 803                 public weak Gda.Holder param;
 804                 public weak Gda.Set plist;
 805                 public void* priv;
 806                 public Gda.ServerOperationNodeStatus status;
 807                 public Gda.ServerOperationNodeType type;
 808         }
 809         [CCode (cheader_filename = "libgda/libgda.h")]
 810         public class ServerProvider : GLib.Object {
 811                 [CCode (has_construct_function = false)]
 812                 protected ServerProvider ();
 813                 [NoWrapper]
 814                 public virtual bool add_savepoint (Gda.Connection cnc, string name) throws GLib.Error;
 815                 [NoWrapper]
 816                 public virtual bool begin_transaction (Gda.Connection cnc, string name, Gda.TransactionIsolation level) throws GLib.Error;
 817                 [NoWrapper]
 818                 public virtual bool cancel (Gda.Connection cnc, uint task_id) throws GLib.Error;
 819                 [NoWrapper]
 820                 public virtual bool close_connection (Gda.Connection cnc);
 821                 [NoWrapper]
 822                 public virtual bool commit_transaction (Gda.Connection cnc, string name) throws GLib.Error;
 823                 [NoWrapper]
 824                 public virtual unowned Gda.Connection create_connection ();
 825                 public virtual unowned Gda.ServerOperation create_operation (Gda.Connection cnc, Gda.ServerOperationType type, Gda.Set options) throws GLib.Error;
 826                 public virtual unowned Gda.SqlParser create_parser (Gda.Connection cnc);
 827                 [NoWrapper]
 828                 public virtual bool delete_savepoint (Gda.Connection cnc, string name) throws GLib.Error;
 829                 public static GLib.Quark error_quark ();
 830                 public virtual unowned string escape_string (Gda.Connection cnc, string str);
 831                 public unowned string find_file (string inst_dir, string filename);
 832                 [NoWrapper]
 833                 public virtual unowned Gda.DataHandler get_data_handler (Gda.Connection cnc, GLib.Type g_type, string dbms_type);
 834                 public unowned Gda.DataHandler get_data_handler_dbms (Gda.Connection cnc, string for_type);
 835                 public unowned Gda.DataHandler get_data_handler_default (Gda.Connection cnc, GLib.Type type, string dbms_type);
 836                 public unowned Gda.DataHandler get_data_handler_g_type (Gda.Connection cnc, GLib.Type for_type);
 837                 [NoWrapper]
 838                 public virtual unowned string get_database (Gda.Connection cnc);
 839                 [NoWrapper]
 840                 public virtual unowned string get_def_dbms_type (Gda.Connection cnc, GLib.Type g_type);
 841                 public unowned string get_default_dbms_type (Gda.Connection cnc, GLib.Type type);
 842                 public virtual unowned string get_name ();
 843                 public static int get_schema_nb_columns (Gda.ConnectionSchema schema);
 844                 public virtual unowned string get_server_version (Gda.Connection cnc);
 845                 public virtual unowned string get_version ();
 846                 [NoWrapper]
 847                 public virtual bool handle_async (Gda.Connection cnc) throws GLib.Error;
 848                 public void handler_declare (Gda.DataHandler dh, Gda.Connection cnc, GLib.Type g_type, string dbms_type);
 849                 public unowned Gda.DataHandler handler_find (Gda.Connection cnc, GLib.Type g_type, string dbms_type);
 850                 [NoWrapper]
 851                 public virtual unowned string identifier_quote (Gda.Connection cnc, string id, bool for_meta_store, bool force_quotes);
 852                 public static bool init_schema_model (Gda.DataModel model, Gda.ConnectionSchema schema);
 853                 public unowned Gda.SqlParser internal_get_parser ();
 854                 [NoWrapper]
 855                 public virtual bool is_busy (Gda.Connection cnc) throws GLib.Error;
 856                 public static unowned string load_file_contents (string inst_dir, string data_dir, string filename);
 857                 [NoWrapper]
 858                 public virtual bool open_connection (Gda.Connection cnc, Gda.QuarkList @params, Gda.QuarkList auth, uint task_id, Gda.ServerProviderAsyncCallback async_cb, void* cb_data);
 859                 public virtual bool perform_operation (Gda.Connection cnc, Gda.ServerOperation op) throws GLib.Error;
 860                 public bool perform_operation_default (Gda.Connection cnc, Gda.ServerOperation op) throws GLib.Error;
 861                 public virtual unowned string render_operation (Gda.Connection cnc, Gda.ServerOperation op) throws GLib.Error;
 862                 [NoWrapper]
 863                 public virtual bool rollback_savepoint (Gda.Connection cnc, string name) throws GLib.Error;
 864                 [NoWrapper]
 865                 public virtual bool rollback_transaction (Gda.Connection cnc, string name) throws GLib.Error;
 866                 [NoWrapper]
 867                 public virtual unowned GLib.Object statement_execute (Gda.Connection cnc, Gda.Statement stmt, Gda.Set @params, Gda.StatementModelUsage model_usage, GLib.Type[] col_types, out unowned Gda.Set last_inserted_row, uint task_id, Gda.ServerProviderExecCallback exec_cb, void* cb_data) throws GLib.Error;
 868                 [NoWrapper]
 869                 public virtual bool statement_prepare (Gda.Connection cnc, Gda.Statement stmt) throws GLib.Error;
 870                 [NoWrapper]
 871                 public virtual unowned Gda.SqlStatement statement_rewrite (Gda.Connection cnc, Gda.Statement stmt, Gda.Set @params) throws GLib.Error;
 872                 [NoWrapper]
 873                 public virtual unowned string statement_to_sql (Gda.Connection cnc, Gda.Statement stmt, Gda.Set @params, Gda.StatementSqlFlag flags, GLib.SList params_used) throws GLib.Error;
 874                 public GLib.Value string_to_value (Gda.Connection cnc, string str, GLib.Type preferred_type, string dbms_type);
 875                 public virtual bool supports_feature (Gda.Connection cnc, Gda.ConnectionFeature feature);
 876                 public virtual bool supports_operation (Gda.Connection cnc, Gda.ServerOperationType type, Gda.Set options);
 877                 public static bool test_schema_model (Gda.DataModel model, Gda.ConnectionSchema schema) throws GLib.Error;
 878                 public virtual unowned string unescape_string (Gda.Connection cnc, string str);
 879                 public unowned string value_to_sql_string (Gda.Connection cnc, GLib.Value from);
 880         }
 881         [CCode (cheader_filename = "libgda/libgda.h")]
 882         [Compact]
 883         public class ServerProviderHandlerInfo {
 884                 public weak Gda.Connection cnc;
 885                 public weak string dbms_type;
 886                 public GLib.Type g_type;
 887         }
 888         [CCode (cheader_filename = "libgda/libgda.h")]
 889         [Compact]
 890         public class ServerProviderInfo {
 891         }
 892         [CCode (cheader_filename = "libgda/libgda.h")]
 893         [Compact]
 894         public class ServerProviderMeta {
 895                 public weak GLib.Callback character_sets;
 896                 public weak GLib.Callback check_columns;
 897                 public weak GLib.Callback collations;
 898                 public weak GLib.Callback columns;
 899                 public weak GLib.Callback constraints_dom;
 900                 public weak GLib.Callback constraints_ref;
 901                 public weak GLib.Callback constraints_tab;
 902                 public weak GLib.Callback domains;
 903                 public weak GLib.Callback el_types;
 904                 public weak GLib.Callback enums;
 905                 public weak GLib.Callback index_cols;
 906                 public weak GLib.Callback indexes_tab;
 907                 public weak GLib.Callback key_columns;
 908                 public weak GLib.Callback routine_col;
 909                 public weak GLib.Callback routine_par;
 910                 public weak GLib.Callback routines;
 911                 public weak GLib.Callback schemata;
 912                 public weak GLib.Callback tables_views;
 913                 public weak GLib.Callback triggers;
 914                 public weak GLib.Callback udt;
 915                 public weak GLib.Callback udt_cols;
 916                 public weak GLib.Callback view_cols;
 917         }
 918         [CCode (cheader_filename = "libgda/libgda.h")]
 919         [Compact]
 920         public class ServerProviderXa {
 921                 public weak GLib.Callback xa_commit;
 922                 public weak GLib.Callback xa_end;
 923                 public weak GLib.Callback xa_prepare;
 924                 public weak GLib.Callback xa_recover;
 925                 public weak GLib.Callback xa_rollback;
 926                 public weak GLib.Callback xa_start;
 927         }
 928         [CCode (cheader_filename = "libgda/libgda.h")]
 929         public class Set : GLib.Object {
 930                 public weak GLib.SList groups_list;
 931                 public weak GLib.SList nodes_list;
 932                 public weak GLib.SList sources_list;
 933                 [CCode (has_construct_function = false)]
 934                 public Set (GLib.SList<Gda.Holder> holders);
 935                 public bool add_holder (Gda.Holder holder);
 936                 public unowned Gda.Set copy ();
 937                 public static GLib.Quark error_quark ();
 938                 [CCode (has_construct_function = false)]
 939                 public Set.from_spec_node (Xml.Node xml_spec) throws GLib.Error;
 940                 [CCode (has_construct_function = false)]
 941                 public Set.from_spec_string (string xml_spec) throws GLib.Error;
 942                 public unowned Gda.SetGroup get_group (Gda.Holder holder);
 943                 public unowned Gda.Holder get_holder (string holder_id);
 944                 public GLib.Value get_holder_value (string holder_id);
 945                 public unowned Gda.SetNode get_node (Gda.Holder holder);
 946                 public unowned Gda.Holder get_nth_holder (int pos);
 947                 public unowned Gda.SetSource get_source (Gda.Holder holder);
 948                 public unowned Gda.SetSource get_source_for_model (Gda.DataModel model);
 949                 [CCode (has_construct_function = false)]
 950                 public Set.@inline (int nb);
 951                 public bool is_valid () throws GLib.Error;
 952                 public void merge_with_set (Gda.Set set_to_merge);
 953                 [CCode (has_construct_function = false)]
 954                 public Set.read_only (GLib.SList holders);
 955                 public void remove_holder (Gda.Holder holder);
 956                 public void replace_source_model (Gda.SetSource source, Gda.DataModel model);
 957                 public bool set_holder_value (string holder_id) throws GLib.Error;
 958                 [NoAccessorMethod]
 959                 public string description { owned get; set; }
 960                 public void* holders { construct; }
 961                 [NoAccessorMethod]
 962                 public string id { owned get; set; }
 963                 [NoAccessorMethod]
 964                 public string name { owned get; set; }
 965                 public virtual signal void holder_attr_changed (Gda.Holder holder, string attr_name, GLib.Value attr_value);
 966                 public virtual signal void holder_changed (Gda.Holder holder);
 967                 public virtual signal void holder_type_set (Gda.Holder holder);
 968                 public virtual signal void public_data_changed ();
 969                 public virtual signal void source_model_changed (void* source);
 970                 public virtual signal unowned GLib.Error validate_holder_change (Gda.Holder holder, GLib.Value new_value);
 971                 public virtual signal unowned GLib.Error validate_set ();
 972         }
 973         [CCode (cheader_filename = "libgda/libgda.h")]
 974         [Compact]
 975         public class SetGroup {
 976                 public weak GLib.SList nodes;
 977                 public weak Gda.SetSource nodes_source;
 978         }
 979         [CCode (cheader_filename = "libgda/libgda.h")]
 980         [Compact]
 981         public class SetNode {
 982                 public weak Gda.Holder holder;
 983                 public int source_column;
 984                 public weak Gda.DataModel source_model;
 985         }
 986         [CCode (cheader_filename = "libgda/libgda.h")]
 987         [Compact]
 988         public class SetSource {
 989                 public weak Gda.DataModel data_model;
 990                 public weak GLib.SList nodes;
 991         }
 992         [CCode (cheader_filename = "libgda/libgda.h")]
 993         [Compact]
 994         public class SqlAnyPart {
 995                 public weak Gda.SqlAnyPart parent;
 996                 public Gda.SqlAnyPartType type;
 997                 public bool check_structure () throws GLib.Error;
 998                 public bool @foreach (Gda.SqlForeachFunc func, void* data) throws GLib.Error;
 999         }
1000         [CCode (cheader_filename = "libgda/libgda.h")]
1001         public class SqlBuilder : GLib.Object {
1002                 [CCode (has_construct_function = false)]
1003                 public SqlBuilder (Gda.SqlStatementType stmt_type);
1004                 [CCode (sentinel = "")]
1005                 public Gda.SqlBuilderId add_case (Gda.SqlBuilderId test_expr, Gda.SqlBuilderId else_expr, ...);
1006                 public Gda.SqlBuilderId add_case_v (Gda.SqlBuilderId test_expr, Gda.SqlBuilderId else_expr, Gda.SqlBuilderId when_array, Gda.SqlBuilderId then_array, int args_size);
1007                 public Gda.SqlBuilderId add_cond (Gda.SqlOperatorType op, Gda.SqlBuilderId op1, Gda.SqlBuilderId op2, Gda.SqlBuilderId op3);
1008                 public Gda.SqlBuilderId add_cond_v (Gda.SqlOperatorType op, Gda.SqlBuilderId op_ids, int op_ids_size);
1009                 [CCode (sentinel = "")]
1010                 public Gda.SqlBuilderId add_expr (Gda.DataHandler dh, GLib.Type type, ...);
1011                 public Gda.SqlBuilderId add_expr_value (Gda.DataHandler dh, GLib.Value value);
1012                 public Gda.SqlBuilderId add_field_id (string field_name, string table_name);
1013                 [CCode (sentinel = "")]
1014                 public void add_field_value (string field_name, GLib.Type type, ...);
1015                 public void add_field_value_as_gvalue (string field_name, GLib.Value value);
1016                 public void add_field_value_id (Gda.SqlBuilderId field_id, Gda.SqlBuilderId value_id);
1017                 [CCode (sentinel = "")]
1018                 public Gda.SqlBuilderId add_function (string func_name, ...);
1019                 public Gda.SqlBuilderId add_function_v (string func_name, Gda.SqlBuilderId args, int args_size);
1020                 public Gda.SqlBuilderId add_id (string str);
1021                 public Gda.SqlBuilderId add_param (string param_name, GLib.Type type, bool nullok);
1022                 public Gda.SqlBuilderId add_sub_select (Gda.SqlStatement sqlst);
1023                 public void compound_add_sub_select (Gda.SqlStatement sqlst);
1024                 public void compound_set_type (Gda.SqlStatementCompoundType compound_type);
1025                 public static GLib.Quark error_quark ();
1026                 public unowned Gda.SqlExpr export_expression (Gda.SqlBuilderId id);
1027                 public unowned Gda.SqlStatement get_sql_statement ();
1028                 public unowned Gda.Statement get_statement () throws GLib.Error;
1029                 public Gda.SqlBuilderId import_expression (Gda.SqlExpr expr);
1030                 public void join_add_field (Gda.SqlBuilderId join_id, string field_name);
1031                 public Gda.SqlBuilderId select_add_field (string field_name, string table_name, string alias);
1032                 public Gda.SqlBuilderId select_add_target (string table_name, string alias);
1033                 public Gda.SqlBuilderId select_add_target_id (Gda.SqlBuilderId table_id, string alias);
1034                 public void select_group_by (Gda.SqlBuilderId expr_id);
1035                 public Gda.SqlBuilderId select_join_targets (Gda.SqlBuilderId left_target_id, Gda.SqlBuilderId right_target_id, Gda.SqlSelectJoinType join_type, Gda.SqlBuilderId join_expr);
1036                 public void select_order_by (Gda.SqlBuilderId expr_id, bool asc, string collation_name);
1037                 public void select_set_distinct (bool distinct, Gda.SqlBuilderId expr_id);
1038                 public void select_set_having (Gda.SqlBuilderId cond_id);
1039                 public void select_set_limit (Gda.SqlBuilderId limit_count_expr_id, Gda.SqlBuilderId limit_offset_expr_id);
1040                 public void set_table (string table_name);
1041                 public void set_where (Gda.SqlBuilderId cond_id);
1042                 public Gda.SqlStatementType stmt_type { construct; }
1043         }
1044         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_case_copy")]
1045         [Compact]
1046         public class SqlCase {
1047                 public weak Gda.SqlAnyPart any;
1048                 public weak Gda.SqlExpr base_expr;
1049                 public weak Gda.SqlExpr else_expr;
1050                 public weak GLib.SList then_expr_list;
1051                 public weak GLib.SList when_expr_list;
1052                 [CCode (has_construct_function = false)]
1053                 public SqlCase (Gda.SqlAnyPart parent);
1054                 public unowned Gda.SqlCase copy ();
1055                 public unowned string serialize ();
1056         }
1057         [CCode (cheader_filename = "libgda/libgda.h")]
1058         [Compact]
1059         public class SqlErrorType {
1060         }
1061         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_expr_copy", type_id = "gda_sql_expr_get_type ()")]
1062         [Compact]
1063         public class SqlExpr {
1064                 public weak Gda.SqlAnyPart any;
1065                 public weak Gda.SqlCase case_s;
1066                 public weak string cast_as;
1067                 public weak Gda.SqlOperation cond;
1068                 public weak Gda.SqlFunction func;
1069                 public weak Gda.SqlParamSpec param_spec;
1070                 public weak Gda.SqlAnyPart select;
1071                 public GLib.Value value;
1072                 public void* value_is_ident;
1073                 [CCode (has_construct_function = false)]
1074                 public SqlExpr (Gda.SqlAnyPart parent);
1075                 public unowned Gda.SqlExpr copy ();
1076                 public unowned string serialize ();
1077                 public void take_select (Gda.SqlStatement stmt);
1078         }
1079         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_field_copy")]
1080         [Compact]
1081         public class SqlField {
1082                 public weak Gda.SqlAnyPart any;
1083                 public weak string field_name;
1084                 public weak Gda.MetaTableColumn validity_meta_table_column;
1085                 [CCode (has_construct_function = false)]
1086                 public SqlField (Gda.SqlAnyPart parent);
1087                 public unowned Gda.SqlField copy ();
1088                 public unowned string serialize ();
1089                 public void take_name (GLib.Value value);
1090         }
1091         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_function_copy")]
1092         [Compact]
1093         public class SqlFunction {
1094                 public weak Gda.SqlAnyPart any;
1095                 public weak GLib.SList args_list;
1096                 public weak string function_name;
1097                 [CCode (has_construct_function = false)]
1098                 public SqlFunction (Gda.SqlAnyPart parent);
1099                 public void check_clean ();
1100                 public unowned Gda.SqlFunction copy ();
1101                 public unowned string serialize ();
1102                 public void take_args_list (owned GLib.SList args);
1103                 public void take_name (GLib.Value value);
1104         }
1105         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_operation_copy")]
1106         [Compact]
1107         public class SqlOperation {
1108                 public weak Gda.SqlAnyPart any;
1109                 public weak GLib.SList operands;
1110                 public Gda.SqlOperatorType operator_type;
1111                 [CCode (has_construct_function = false)]
1112                 public SqlOperation (Gda.SqlAnyPart parent);
1113                 public unowned Gda.SqlOperation copy ();
1114                 public static Gda.SqlOperatorType operator_from_string (string op);
1115                 public static unowned string operator_to_string (Gda.SqlOperatorType op);
1116                 public unowned string serialize ();
1117         }
1118         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_param_spec_copy")]
1119         [Compact]
1120         public class SqlParamSpec {
1121                 public weak string descr;
1122                 public GLib.Type g_type;
1123                 public bool is_param;
1124                 public weak string name;
1125                 public bool nullok;
1126                 public void* validity_meta_dict;
1127                 [CCode (has_construct_function = false)]
1128                 public SqlParamSpec (GLib.Value simple_spec);
1129                 public unowned Gda.SqlParamSpec copy ();
1130                 public unowned string serialize ();
1131                 public void take_descr (GLib.Value value);
1132                 public void take_name (GLib.Value value);
1133                 public void take_nullok (GLib.Value value);
1134                 public void take_type (GLib.Value value);
1135         }
1136         [CCode (cheader_filename = "libgda/libgda.h")]
1137         public class SqlParser : GLib.Object, Gda.Lockable {
1138                 [CCode (has_construct_function = false)]
1139                 public SqlParser ();
1140                 [NoWrapper]
1141                 public virtual void* delim_alloc (GLib.Callback p1);
1142                 [NoWrapper]
1143                 public virtual void delim_free (void* p1, GLib.Callback p2);
1144                 [NoWrapper]
1145                 public virtual void delim_parse (void* p1, int p2, GLib.Value p3, Gda.SqlParserIface p4);
1146                 [NoWrapper]
1147                 public virtual void delim_trace (void* p1, string p2);
1148                 public static GLib.Quark error_quark ();
1149                 public unowned Gda.Batch parse_file_as_batch (string filename) throws GLib.Error;
1150                 public unowned Gda.Statement parse_string (string sql, out unowned string remain) throws GLib.Error;
1151                 public unowned Gda.Batch parse_string_as_batch (string sql, string remain) throws GLib.Error;
1152                 [NoWrapper]
1153                 public virtual void* parser_alloc (GLib.Callback p1);
1154                 [NoWrapper]
1155                 public virtual void parser_free (void* p1, GLib.Callback p2);
1156                 [NoWrapper]
1157                 public virtual void parser_parse (void* p1, int p2, GLib.Value p3, Gda.SqlParserIface p4);
1158                 [NoWrapper]
1159                 public virtual void parser_trace (void* p1, string p2);
1160                 public void set_overflow_error ();
1161                 public void set_syntax_error ();
1162                 [NoAccessorMethod]
1163                 public int column_error { get; }
1164                 [NoAccessorMethod]
1165                 public int line_error { get; }
1166                 [NoAccessorMethod]
1167                 public int mode { get; set; }
1168                 [NoAccessorMethod]
1169                 public int tokenizer_flavour { get; set; }
1170         }
1171         [CCode (cheader_filename = "libgda/libgda.h")]
1172         [Compact]
1173         public class SqlRenderingContext {
1174                 public weak Gda.Connection cnc;
1175                 public Gda.StatementSqlFlag flags;
1176                 public weak Gda.Set @params;
1177                 public weak GLib.SList params_used;
1178                 public weak Gda.ServerProvider provider;
1179                 public weak Gda.SqlRenderingFunc render_begin;
1180                 public weak Gda.SqlRenderingFunc render_case;
1181                 public weak Gda.SqlRenderingFunc render_commit;
1182                 public weak Gda.SqlRenderingFunc render_compound;
1183                 public weak Gda.SqlRenderingFunc render_delete;
1184                 public weak Gda.SqlRenderingFunc render_delete_savepoint;
1185                 public weak Gda.SqlRenderingExpr render_expr;
1186                 public weak Gda.SqlRenderingFunc render_field;
1187                 public weak Gda.SqlRenderingFunc render_function;
1188                 public weak Gda.SqlRenderingFunc render_insert;
1189                 public weak Gda.SqlRenderingFunc render_operation;
1190                 public weak Gda.SqlRenderingPSpecFunc render_param_spec;
1191                 public weak Gda.SqlRenderingFunc render_rollback;
1192                 public weak Gda.SqlRenderingFunc render_rollback_savepoint;
1193                 public weak Gda.SqlRenderingFunc render_savepoint;
1194                 public weak Gda.SqlRenderingFunc render_select;
1195                 public weak Gda.SqlRenderingFunc render_select_field;
1196                 public weak Gda.SqlRenderingFunc render_select_from;
1197                 public weak Gda.SqlRenderingFunc render_select_join;
1198                 public weak Gda.SqlRenderingFunc render_select_order;
1199                 public weak Gda.SqlRenderingFunc render_select_target;
1200                 public weak Gda.SqlRenderingFunc render_table;
1201                 public weak Gda.SqlRenderingFunc render_unknown;
1202                 public weak Gda.SqlRenderingFunc render_update;
1203                 public weak Gda.SqlRenderingValue render_value;
1204         }
1205         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_select_field_copy")]
1206         [Compact]
1207         public class SqlSelectField {
1208                 public weak Gda.SqlAnyPart any;
1209                 public weak string @as;
1210                 public weak Gda.SqlExpr expr;
1211                 public weak string field_name;
1212                 public weak string table_name;
1213                 public weak Gda.MetaDbObject validity_meta_object;
1214                 public weak Gda.MetaTableColumn validity_meta_table_column;
1215                 [CCode (has_construct_function = false)]
1216                 public SqlSelectField (Gda.SqlAnyPart parent);
1217                 public unowned Gda.SqlSelectField copy ();
1218                 public unowned string serialize ();
1219                 public void take_alias (GLib.Value alias);
1220                 public void take_expr (Gda.SqlExpr expr);
1221                 public void take_star_value (GLib.Value value);
1222         }
1223         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_select_from_copy")]
1224         [Compact]
1225         public class SqlSelectFrom {
1226                 public weak Gda.SqlAnyPart any;
1227                 public weak GLib.SList joins;
1228                 public weak GLib.SList targets;
1229                 [CCode (has_construct_function = false)]
1230                 public SqlSelectFrom (Gda.SqlAnyPart parent);
1231                 public unowned Gda.SqlSelectFrom copy ();
1232                 public unowned string serialize ();
1233                 public void take_new_join (Gda.SqlSelectJoin join);
1234                 public void take_new_target (Gda.SqlSelectTarget target);
1235         }
1236         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_select_join_copy")]
1237         [Compact]
1238         public class SqlSelectJoin {
1239                 public weak Gda.SqlAnyPart any;
1240                 public weak Gda.SqlExpr expr;
1241                 public int position;
1242                 public Gda.SqlSelectJoinType type;
1243                 public weak GLib.SList use;
1244                 [CCode (has_construct_function = false)]
1245                 public SqlSelectJoin (Gda.SqlAnyPart parent);
1246                 public unowned Gda.SqlSelectJoin copy ();
1247                 public unowned string serialize ();
1248                 public static unowned string type_to_string (Gda.SqlSelectJoinType type);
1249         }
1250         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_select_order_copy")]
1251         [Compact]
1252         public class SqlSelectOrder {
1253                 public weak Gda.SqlAnyPart any;
1254                 public bool asc;
1255                 public weak string collation_name;
1256                 public weak Gda.SqlExpr expr;
1257                 [CCode (has_construct_function = false)]
1258                 public SqlSelectOrder (Gda.SqlAnyPart parent);
1259                 public unowned Gda.SqlSelectOrder copy ();
1260                 public unowned string serialize ();
1261         }
1262         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_select_target_copy")]
1263         [Compact]
1264         public class SqlSelectTarget {
1265                 public weak Gda.SqlAnyPart any;
1266                 public weak string @as;
1267                 public weak Gda.SqlExpr expr;
1268                 public weak string table_name;
1269                 public weak Gda.MetaDbObject validity_meta_object;
1270                 [CCode (has_construct_function = false)]
1271                 public SqlSelectTarget (Gda.SqlAnyPart parent);
1272                 public unowned Gda.SqlSelectTarget copy ();
1273                 public unowned string serialize ();
1274                 public void take_alias (GLib.Value alias);
1275                 public void take_select (Gda.SqlStatement stmt);
1276                 public void take_table_name (GLib.Value value);
1277         }
1278         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_statement_copy", type_id = "gda_sql_statement_get_type ()")]
1279         [Compact]
1280         public class SqlStatement {
1281                 public void* contents;
1282                 public weak string sql;
1283                 public Gda.SqlStatementType stmt_type;
1284                 public weak Gda.MetaStruct validity_meta_struct;
1285                 [CCode (has_construct_function = false)]
1286                 public SqlStatement (Gda.SqlStatementType type);
1287                 public void check_clean ();
1288                 public bool check_structure () throws GLib.Error;
1289                 public bool check_validity (Gda.Connection cnc) throws GLib.Error;
1290                 public bool check_validity_m (Gda.MetaStruct mstruct) throws GLib.Error;
1291                 public unowned Gda.SqlStatement copy ();
1292                 public static unowned Gda.SqlStatementContentsInfo get_contents_infos (Gda.SqlStatementType type);
1293                 public bool normalize (Gda.Connection cnc) throws GLib.Error;
1294                 public unowned string serialize ();
1295                 public static Gda.SqlStatementType string_to_type (string type);
1296                 public void trans_set_isol_level (Gda.TransactionIsolation level);
1297                 public void trans_take_mode (GLib.Value value);
1298                 public void trans_take_name (GLib.Value value);
1299                 public static unowned string type_to_string (Gda.SqlStatementType type);
1300         }
1301         [CCode (cheader_filename = "libgda/libgda.h")]
1302         [Compact]
1303         public class SqlStatementCheckValidityData {
1304                 public weak Gda.Connection cnc;
1305                 public weak Gda.MetaStruct mstruct;
1306                 public weak Gda.MetaStore store;
1307         }
1308         [CCode (cheader_filename = "libgda/libgda.h")]
1309         [Compact]
1310         public class SqlStatementCompound {
1311                 public weak Gda.SqlAnyPart any;
1312                 public Gda.SqlStatementCompoundType compound_type;
1313                 public weak GLib.SList stmt_list;
1314                 public static void set_type (Gda.SqlStatement stmt, Gda.SqlStatementCompoundType type);
1315                 public static void take_stmt (Gda.SqlStatement stmt, Gda.SqlStatement s);
1316         }
1317         [CCode (cheader_filename = "libgda/libgda.h")]
1318         [Compact]
1319         public class SqlStatementContentsInfo {
1320                 public weak Gda.SqlForeachFunc check_structure_func;
1321                 public weak Gda.SqlForeachFunc check_validity_func;
1322                 public weak GLib.Callback @construct;
1323                 public weak GLib.Callback copy;
1324                 public weak GLib.Callback free;
1325                 public weak string name;
1326                 public weak GLib.Callback serialize;
1327                 public Gda.SqlStatementType type;
1328         }
1329         [CCode (cheader_filename = "libgda/libgda.h")]
1330         [Compact]
1331         public class SqlStatementDelete {
1332                 public weak Gda.SqlAnyPart any;
1333                 public weak Gda.SqlExpr cond;
1334                 public weak Gda.SqlTable table;
1335                 public static void take_condition (Gda.SqlStatement stmt, Gda.SqlExpr cond);
1336                 public static void take_table_name (Gda.SqlStatement stmt, GLib.Value value);
1337         }
1338         [CCode (cheader_filename = "libgda/libgda.h")]
1339         [Compact]
1340         public class SqlStatementInsert {
1341                 public weak Gda.SqlAnyPart any;
1342                 public weak GLib.SList fields_list;
1343                 public weak string on_conflict;
1344                 public weak Gda.SqlAnyPart select;
1345                 public weak Gda.SqlTable table;
1346                 public weak GLib.SList values_list;
1347                 public static void take_1_values_list (Gda.SqlStatement stmt, owned GLib.SList<Gda.SqlExpr> list);
1348                 public static void take_extra_values_list (Gda.SqlStatement stmt, GLib.SList list);
1349                 public static void take_fields_list (Gda.SqlStatement stmt, owned GLib.SList<Gda.SqlField> list);
1350                 public static void take_on_conflict (Gda.SqlStatement stmt, GLib.Value value);
1351                 public static void take_select (Gda.SqlStatement stmt, Gda.SqlStatement select);
1352                 public static void take_table_name (Gda.SqlStatement stmt, GLib.Value value);
1353         }
1354         [CCode (cheader_filename = "libgda/libgda.h")]
1355         [Compact]
1356         public class SqlStatementSelect {
1357                 public weak Gda.SqlAnyPart any;
1358                 public bool distinct;
1359                 public weak Gda.SqlExpr distinct_expr;
1360                 public weak GLib.SList expr_list;
1361                 public weak Gda.SqlSelectFrom from;
1362                 public weak GLib.SList group_by;
1363                 public weak Gda.SqlExpr having_cond;
1364                 public weak Gda.SqlExpr limit_count;
1365                 public weak Gda.SqlExpr limit_offset;
1366                 public weak GLib.SList order_by;
1367                 public weak Gda.SqlExpr where_cond;
1368                 public static void take_distinct (Gda.SqlStatement stmt, bool distinct, Gda.SqlExpr distinct_expr);
1369                 public static void take_expr_list (Gda.SqlStatement stmt, owned GLib.SList<Gda.SqlSelectField> expr_list);
1370                 public static void take_from (Gda.SqlStatement stmt, Gda.SqlSelectFrom from);
1371                 public static void take_group_by (Gda.SqlStatement stmt, owned GLib.SList<Gda.SqlExpr> group_by);
1372                 public static void take_having_cond (Gda.SqlStatement stmt, Gda.SqlExpr expr);
1373                 public static void take_limits (Gda.SqlStatement stmt, Gda.SqlExpr count, Gda.SqlExpr offset);
1374                 public static void take_order_by (Gda.SqlStatement stmt, owned GLib.SList<Gda.SqlSelectOrder> order_by);
1375                 public static void take_where_cond (Gda.SqlStatement stmt, owned Gda.SqlExpr expr);
1376         }
1377         [CCode (cheader_filename = "libgda/libgda.h")]
1378         [Compact]
1379         public class SqlStatementTransaction {
1380                 public weak Gda.SqlAnyPart any;
1381                 public Gda.TransactionIsolation isolation_level;
1382                 public weak string trans_mode;
1383                 public weak string trans_name;
1384         }
1385         [CCode (cheader_filename = "libgda/libgda.h")]
1386         [Compact]
1387         public class SqlStatementUnknown {
1388                 public weak Gda.SqlAnyPart any;
1389                 public weak GLib.SList expressions;
1390                 public static void take_expressions (Gda.SqlStatement stmt, owned GLib.SList<Gda.SqlExpr> expressions);
1391         }
1392         [CCode (cheader_filename = "libgda/libgda.h")]
1393         [Compact]
1394         public class SqlStatementUpdate {
1395                 public weak Gda.SqlAnyPart any;
1396                 public weak Gda.SqlExpr cond;
1397                 public weak GLib.SList expr_list;
1398                 public weak GLib.SList fields_list;
1399                 public weak string on_conflict;
1400                 public weak Gda.SqlTable table;
1401                 public static void take_condition (Gda.SqlStatement stmt, Gda.SqlExpr cond);
1402                 public static void take_on_conflict (Gda.SqlStatement stmt, GLib.Value value);
1403                 public static void take_set_value (Gda.SqlStatement stmt, GLib.Value fname, Gda.SqlExpr expr);
1404                 public static void take_table_name (Gda.SqlStatement stmt, GLib.Value value);
1405         }
1406         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_sql_table_copy")]
1407         [Compact]
1408         public class SqlTable {
1409                 public weak Gda.SqlAnyPart any;
1410                 public weak string table_name;
1411                 public weak Gda.MetaDbObject validity_meta_object;
1412                 [CCode (has_construct_function = false)]
1413                 public SqlTable (Gda.SqlAnyPart parent);
1414                 public unowned Gda.SqlTable copy ();
1415                 public unowned string serialize ();
1416                 public void take_name (GLib.Value value);
1417         }
1418         [CCode (cheader_filename = "libgda/libgda.h")]
1419         public class SqliteProvider : Gda.ServerProvider {
1420                 [CCode (has_construct_function = false)]
1421                 protected SqliteProvider ();
1422         }
1423         [CCode (cheader_filename = "libgda/libgda.h")]
1424         public class Statement : GLib.Object {
1425                 [CCode (has_construct_function = false)]
1426                 public Statement ();
1427                 public bool check_structure () throws GLib.Error;
1428                 public bool check_validity (Gda.Connection cnc) throws GLib.Error;
1429                 public unowned Gda.Statement copy ();
1430                 public static GLib.Quark error_quark ();
1431                 public bool get_parameters (out unowned Gda.Set out_params) throws GLib.Error;
1432                 public Gda.SqlStatementType get_statement_type ();
1433                 public bool is_useless ();
1434                 public bool normalize (Gda.Connection cnc) throws GLib.Error;
1435                 public unowned Gda.SqlStatement rewrite_for_default_values (Gda.Set @params, bool remove) throws GLib.Error;
1436                 public unowned string serialize ();
1437                 public string to_sql_extended (Gda.Connection? cnc, Gda.Set? @params, Gda.StatementSqlFlag flags, GLib.SList<Gda.Holder>? params_used) throws GLib.Error;
1438                 public unowned string to_sql_real (Gda.SqlRenderingContext context) throws GLib.Error;
1439                 [NoAccessorMethod]
1440                 public void* structure { get; set; }
1441                 public virtual signal void checked (Gda.Connection cnc, bool checked);
1442                 public virtual signal void reset ();
1443         }
1444         [CCode (cheader_filename = "libgda/libgda.h")]
1445         public class ThreadWrapper : GLib.Object {
1446                 [CCode (has_construct_function = false)]
1447                 public ThreadWrapper ();
1448                 public bool cancel (uint id);
1449                 public ulong connect_raw (void* instance, string sig_name, bool private_thread, bool private_job, Gda.ThreadWrapperCallback callback, void* data);
1450                 public void disconnect (ulong id);
1451                 public static GLib.Quark error_quark ();
1452                 public uint execute (Gda.ThreadWrapperFunc func, void* arg, GLib.DestroyNotify arg_destroy_func) throws GLib.Error;
1453                 public uint execute_void (Gda.ThreadWrapperVoidFunc func, void* arg, GLib.DestroyNotify arg_destroy_func) throws GLib.Error;
1454                 public void* fetch_result (bool may_lock, uint exp_id) throws GLib.Error;
1455                 public int get_waiting_size ();
1456                 public void iterate (bool may_block);
1457                 public void steal_signal (ulong id);
1458         }
1459         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_time_copy", type_id = "gda_time_get_type ()")]
1460         [Compact]
1461         public class Time {
1462                 public ulong fraction;
1463                 public ushort hour;
1464                 public ushort minute;
1465                 public ushort second;
1466                 public long timezone;
1467                 public static void* copy (void* boxed);
1468                 public bool valid ();
1469         }
1470         [CCode (cheader_filename = "libgda/libgda.h", copy_function = "gda_timestamp_copy", type_id = "gda_timestamp_get_type ()")]
1471         [Compact]
1472         public class Timestamp {
1473                 public ushort day;
1474                 public ulong fraction;
1475                 public ushort hour;
1476                 public ushort minute;
1477                 public ushort month;
1478                 public ushort second;
1479                 public long timezone;
1480                 public short year;
1481                 public static void* copy (void* boxed);
1482                 public bool valid ();
1483         }
1484         [CCode (cheader_filename = "libgda/libgda.h")]
1485         public class TransactionStatus : GLib.Object {
1486                 public weak GLib.List events;
1487                 public Gda.TransactionIsolation isolation_level;
1488                 public weak string name;
1489                 public Gda.TransactionStatusState state;
1490                 [CCode (has_construct_function = false)]
1491                 public TransactionStatus (string name);
1492         }
1493         [CCode (cheader_filename = "libgda/libgda.h")]
1494         [Compact]
1495         public class TransactionStatusEvent {
1496                 public weak Gda.ConnectionEvent conn_event;
1497                 public void* pl;
1498                 public weak Gda.TransactionStatus trans;
1499                 public Gda.TransactionStatusEventType type;
1500         }
1501         [CCode (cheader_filename = "libgda/libgda.h")]
1502         public class Tree : GLib.Object {
1503                 [CCode (has_construct_function = false)]
1504                 public Tree ();
1505                 public void add_manager (Gda.TreeManager manager);
1506                 public void clean ();
1507                 public void dump (Gda.TreeNode node, GLib.FileStream stream);
1508                 public static GLib.Quark error_quark ();
1509                 public unowned Gda.TreeNode get_node (string tree_path, bool use_names);
1510                 public unowned Gda.TreeManager get_node_manager (Gda.TreeNode node);
1511                 public unowned string get_node_path (Gda.TreeNode node);
1512                 public unowned GLib.SList get_nodes_in_path (string tree_path, bool use_names);
1513                 public void set_attribute (string attribute, GLib.Value value, GLib.DestroyNotify destroy);
1514                 public bool update_all () throws GLib.Error;
1515                 public bool update_part (Gda.TreeNode node) throws GLib.Error;
1516                 [NoAccessorMethod]
1517                 public bool is_list { get; }
1518                 public virtual signal void node_changed (Gda.TreeNode node);
1519                 public virtual signal void node_deleted (string node_path);
1520                 public virtual signal void node_has_child_toggled (Gda.TreeNode node);
1521                 public virtual signal void node_inserted (Gda.TreeNode node);
1522         }
1523         [CCode (cheader_filename = "libgda/libgda.h")]
1524         public class TreeManager : GLib.Object {
1525                 [CCode (has_construct_function = false)]
1526                 protected TreeManager ();
1527                 public void add_manager (Gda.TreeManager sub);
1528                 public void add_new_node_attribute (string attribute, GLib.Value value);
1529                 public unowned Gda.TreeNode create_node (Gda.TreeNode parent, string name);
1530                 public static GLib.Quark error_quark ();
1531                 public unowned GLib.SList get_managers ();
1532                 public unowned Gda.TreeManagerNodeFunc get_node_create_func ();
1533                 public void set_node_create_func (Gda.TreeManagerNodeFunc func);
1534                 [NoWrapper]
1535                 public virtual unowned GLib.SList update_children (Gda.TreeNode node, GLib.SList children_nodes, bool out_error) throws GLib.Error;
1536                 [CCode (has_construct_function = false)]
1537                 public TreeManager.with_func (Gda.TreeManagerNodesFunc update_func);
1538                 [NoAccessorMethod]
1539                 public void* func { get; set construct; }
1540                 [NoAccessorMethod]
1541                 public bool recursive { get; set construct; }
1542         }
1543         [CCode (cheader_filename = "libgda/libgda.h")]
1544         public class TreeMgrColumns : Gda.TreeManager {
1545                 [CCode (has_construct_function = false, type = "GdaTreeManager*")]
1546                 public TreeMgrColumns (Gda.Connection cnc, string schema, string table_name);
1547                 [NoAccessorMethod]
1548                 public Gda.Connection connection { owned get; construct; }
1549                 [NoAccessorMethod]
1550                 public Gda.MetaStore meta_store { owned get; construct; }
1551                 public string schema { construct; }
1552                 public string table_name { construct; }
1553         }
1554         [CCode (cheader_filename = "libgda/libgda.h")]
1555         [Compact]
1556         public class TreeMgrColumnsPriv {
1557         }
1558         [CCode (cheader_filename = "libgda/libgda.h")]
1559         public class TreeMgrLabel : Gda.TreeManager {
1560                 [CCode (has_construct_function = false, type = "GdaTreeManager*")]
1561                 public TreeMgrLabel (string label);
1562                 public string label { construct; }
1563         }
1564         [CCode (cheader_filename = "libgda/libgda.h")]
1565         [Compact]
1566         public class TreeMgrLabelPriv {
1567         }
1568         [CCode (cheader_filename = "libgda/libgda.h")]
1569         public class TreeMgrSchemas : Gda.TreeManager {
1570                 [CCode (has_construct_function = false, type = "GdaTreeManager*")]
1571                 public TreeMgrSchemas (Gda.Connection cnc);
1572                 [NoAccessorMethod]
1573                 public Gda.Connection connection { owned get; construct; }
1574                 [NoAccessorMethod]
1575                 public Gda.MetaStore meta_store { owned get; construct; }
1576         }
1577         [CCode (cheader_filename = "libgda/libgda.h")]
1578         [Compact]
1579         public class TreeMgrSchemasPriv {
1580         }
1581         [CCode (cheader_filename = "libgda/libgda.h")]
1582         public class TreeMgrSelect : Gda.TreeManager {
1583                 [CCode (has_construct_function = false, type = "GdaTreeManager*")]
1584                 public TreeMgrSelect (Gda.Connection cnc, Gda.Statement stmt, Gda.Set @params);
1585                 [NoAccessorMethod]
1586                 public Gda.Connection connection { owned get; construct; }
1587                 [NoAccessorMethod]
1588                 public Gda.Set @params { owned get; construct; }
1589                 [NoAccessorMethod]
1590                 public Gda.Statement statement { owned get; construct; }
1591         }
1592         [CCode (cheader_filename = "libgda/libgda.h")]
1593         [Compact]
1594         public class TreeMgrSelectPriv {
1595         }
1596         [CCode (cheader_filename = "libgda/libgda.h")]
1597         public class TreeMgrTables : Gda.TreeManager {
1598                 [CCode (has_construct_function = false, type = "GdaTreeManager*")]
1599                 public TreeMgrTables (Gda.Connection cnc, string schema);
1600                 [NoAccessorMethod]
1601                 public Gda.Connection connection { owned get; construct; }
1602                 [NoAccessorMethod]
1603                 public Gda.MetaStore meta_store { owned get; construct; }
1604                 public string schema { construct; }
1605         }
1606         [CCode (cheader_filename = "libgda/libgda.h")]
1607         [Compact]
1608         public class TreeMgrTablesPriv {
1609         }
1610         [CCode (cheader_filename = "libgda/libgda.h")]
1611         public class TreeNode : GLib.Object {
1612                 [CCode (has_construct_function = false)]
1613                 public TreeNode (string name);
1614                 [NoWrapper]
1615                 public virtual void dump_children (string prefix, GLib.StringBuilder in_string);
1616                 [NoWrapper]
1617                 public virtual unowned string dump_header ();
1618                 public static GLib.Quark error_quark ();
1619                 public GLib.Value fetch_attribute (string attribute);
1620                 public unowned Gda.TreeNode get_child_index (int index);
1621                 public unowned Gda.TreeNode get_child_name (string name);
1622                 public unowned GLib.SList get_children ();
1623                 public GLib.Value get_node_attribute (string attribute);
1624                 public unowned Gda.TreeNode get_parent ();
1625                 public void set_node_attribute (string attribute, GLib.Value value, GLib.DestroyNotify destroy);
1626                 [NoAccessorMethod]
1627                 public string name { owned get; set; }
1628                 public virtual signal void node_changed (Gda.TreeNode node);
1629                 public virtual signal void node_deleted (string relative_path);
1630                 public virtual signal void node_has_child_toggled (Gda.TreeNode node);
1631                 public virtual signal void node_inserted (Gda.TreeNode node);
1632         }
1633         [CCode (cheader_filename = "libgda/libgda.h")]
1634         [Compact]
1635         public class ValueList {
1636         }
1637         [CCode (cheader_filename = "libgda/libgda.h")]
1638         public class VconnectionDataModel : Gda.VirtualConnection, Gda.Lockable {
1639                 [CCode (has_construct_function = false)]
1640                 protected VconnectionDataModel ();
1641                 public bool add (Gda.VconnectionDataModelSpec spec, GLib.DestroyNotify spec_free_func, string table_name) throws GLib.Error;
1642                 public bool add_model (Gda.DataModel model, string table_name) throws GLib.Error;
1643                 public void @foreach (Gda.VconnectionDataModelFunc func, void* data);
1644                 public unowned Gda.DataModel get_model (string table_name);
1645                 public unowned string get_table_name (Gda.DataModel model);
1646                 public bool remove (string table_name) throws GLib.Error;
1647         }
1648         [CCode (cheader_filename = "libgda/libgda.h")]
1649         [Compact]
1650         public class VconnectionDataModelFilter {
1651                 public void* aConstraint;
1652                 public void* aConstraintUsage;
1653                 public void* aOrderBy;
1654                 public double estimatedCost;
1655                 public int idxNum;
1656                 public void* idxPointer;
1657                 public int nConstraint;
1658                 public int nOrderBy;
1659                 public bool orderByConsumed;
1660         }
1661         [CCode (cheader_filename = "libgda/libgda.h")]
1662         [Compact]
1663         public class VconnectionDataModelSpec {
1664                 public weak Gda.VconnectionDataModelCreateColumnsFunc create_columns_func;
1665                 public weak Gda.VconnectionDataModelParseFilterFunc create_filter_func;
1666                 public weak Gda.VconnectionDataModelCreateFModelFunc create_filtered_model_func;
1667                 public weak Gda.VconnectionDataModelCreateModelFunc create_model_func;
1668                 public weak Gda.DataModel data_model;
1669         }
1670         [CCode (cheader_filename = "libgda/libgda.h")]
1671         public class VconnectionHub : Gda.VconnectionDataModel, Gda.Lockable {
1672                 [CCode (has_construct_function = false)]
1673                 protected VconnectionHub ();
1674                 public bool add (Gda.Connection cnc, string ns) throws GLib.Error;
1675                 public void @foreach (Gda.VConnectionHubFunc func, void* data);
1676                 public unowned Gda.Connection get_connection (string ns);
1677                 public bool remove (Gda.Connection cnc) throws GLib.Error;
1678         }
1679         [CCode (cheader_filename = "libgda/libgda.h")]
1680         public class VirtualConnection : Gda.Connection, Gda.Lockable {
1681                 [CCode (has_construct_function = false)]
1682                 protected VirtualConnection ();
1683                 public void* internal_get_provider_data ();
1684                 public void internal_set_provider_data (void* data, GLib.DestroyNotify destroy_func);
1685                 public static unowned Gda.Connection open (Gda.VirtualProvider virtual_provider) throws GLib.Error;
1686                 public static unowned Gda.Connection open_extended (Gda.VirtualProvider virtual_provider, Gda.ConnectionOptions options) throws GLib.Error;
1687         }
1688         [CCode (cheader_filename = "libgda/libgda.h")]
1689         public class VirtualProvider : Gda.SqliteProvider {
1690                 [CCode (has_construct_function = false)]
1691                 protected VirtualProvider ();
1692         }
1693         [CCode (cheader_filename = "libgda/libgda.h")]
1694         public class VproviderDataModel : Gda.VirtualProvider {
1695                 [CCode (has_construct_function = false, type = "GdaVirtualProvider*")]
1696                 public VproviderDataModel ();
1697         }
1698         [CCode (cheader_filename = "libgda/libgda.h")]
1699         public class VproviderHub : Gda.VproviderDataModel {
1700                 [CCode (has_construct_function = false, type = "GdaVirtualProvider*")]
1701                 public VproviderHub ();
1702         }
1703         [CCode (cheader_filename = "libgda/libgda.h")]
1704         public class XaTransaction : GLib.Object {
1705                 [CCode (has_construct_function = false)]
1706                 public XaTransaction (uint32 format, string global_transaction_id);
1707                 public bool begin () throws GLib.Error;
1708                 public bool commit (out GLib.SList<Gda.Connection> cnc_to_recover) throws GLib.Error;
1709                 public bool commit_recovered (out GLib.SList<Gda.Connection> cnc_to_recover) throws GLib.Error;
1710                 public static GLib.Quark error_quark ();
1711                 public bool register_connection (Gda.Connection cnc, string branch) throws GLib.Error;
1712                 public bool rollback () throws GLib.Error;
1713                 public static unowned Gda.XaTransactionId string_to_id (string str);
1714                 public void unregister_connection (Gda.Connection cnc);
1715                 [NoAccessorMethod]
1716                 public uint format_id { get; construct; }
1717                 [NoAccessorMethod]
1718                 public string transaction_id { owned get; construct; }
1719         }
1720         [CCode (cheader_filename = "libgda/libgda.h")]
1721         [Compact]
1722         public class XaTransactionId {
1723                 public ushort bqual_length;
1724                 [CCode (array_length = false)]
1725                 public uint8[] data;
1726                 public uint32 format;
1727                 public ushort gtrid_length;
1728                 public unowned string to_string ();
1729         }
1730         [CCode (cheader_filename = "libgda/libgda.h")]
1731         public interface DataHandler : GLib.Object {
1732                 public abstract bool accepts_g_type (GLib.Type type);
1733                 public static unowned Gda.DataHandler get_default (GLib.Type for_type);
1734                 public abstract unowned string get_descr ();
1735                 public abstract GLib.Value get_sane_init_value (GLib.Type type);
1736                 public abstract unowned string get_sql_from_value (GLib.Value value);
1737                 public abstract unowned string get_str_from_value (GLib.Value value);
1738                 public abstract GLib.Value get_value_from_sql (string sql, GLib.Type type);
1739                 public abstract GLib.Value get_value_from_str (string str, GLib.Type type);
1740         }
1741         [CCode (cheader_filename = "libgda/libgda.h")]
1742         public interface DataModel : GLib.Object {
1743                 [CCode (vfunc_name = "i_append_row")]
1744                 public virtual int append_row () throws GLib.Error;
1745                 [CCode (vfunc_name = "i_append_values")]
1746                 public virtual int append_values (GLib.List<GLib.Value> values) throws GLib.Error;
1747                 [CCode (vfunc_name = "i_create_iter")]
1748                 public virtual unowned Gda.DataModelIter create_iter ();
1749                 [CCode (vfunc_name = "i_describe_column")]
1750                 public virtual unowned Gda.Column describe_column (int col);
1751                 public void dump (GLib.FileStream to_stream);
1752                 public unowned string dump_as_string ();
1753                 public static GLib.Quark error_quark ();
1754                 public bool export_to_file (Gda.DataModelIOFormat format, string file, int cols, int nb_cols, int rows, int nb_rows, Gda.Set options) throws GLib.Error;
1755                 public unowned string export_to_string (Gda.DataModelIOFormat format, int cols, int nb_cols, int rows, int nb_rows, Gda.Set options);
1756                 public void freeze ();
1757                 [CCode (vfunc_name = "i_get_access_flags")]
1758                 public virtual Gda.DataModelAccessFlags get_access_flags ();
1759                 [CCode (vfunc_name = "i_get_attributes_at")]
1760                 public virtual Gda.ValueAttribute get_attributes_at (int col, int row);
1761                 public int get_column_index (string name);
1762                 public unowned string get_column_name (int col);
1763                 public unowned string get_column_title (int col);
1764                 [CCode (vfunc_name = "i_get_n_columns")]
1765                 public virtual int get_n_columns ();
1766                 [CCode (vfunc_name = "i_get_n_rows")]
1767                 public virtual int get_n_rows ();
1768                 public int get_row_from_values (GLib.SList<GLib.Value> values, int[] cols_index);
1769                 public unowned GLib.Value? get_typed_value_at (int col, int row, GLib.Type expected_type, bool nullok) throws GLib.Error;
1770                 public unowned GLib.Value? get_value_at (int col, int row) throws GLib.Error;
1771                 [CCode (vfunc_name = "i_remove_row")]
1772                 public virtual bool remove_row (int row) throws GLib.Error;
1773                 [CCode (vfunc_name = "i_send_hint")]
1774                 public virtual void send_hint (Gda.DataModelHint hint, GLib.Value hint_value);
1775                 public void set_column_name (int col, string name);
1776                 public void set_column_title (int col, string title);
1777                 [CCode (vfunc_name = "i_set_value_at")]
1778                 public virtual bool set_value_at (int col, int row, GLib.Value value) throws GLib.Error;
1779                 [CCode (vfunc_name = "i_set_values")]
1780                 public virtual bool set_values (int row, GLib.List<GLib.Value> values) throws GLib.Error;
1781                 public void thaw ();
1782                 public signal void changed ();
1783                 public signal void reset ();
1784                 public signal void row_inserted (int row);
1785                 public signal void row_removed (int row);
1786                 public signal void row_updated (int row);
1787         }
1788         [CCode (cheader_filename = "libgda/libgda.h")]
1789         public interface Lockable : GLib.Object {
1790                 [CCode (vfunc_name = "i_lock")]
1791                 public virtual void @lock ();
1792                 [CCode (vfunc_name = "i_trylock")]
1793                 public virtual bool trylock ();
1794                 [CCode (vfunc_name = "i_unlock")]
1795                 public virtual void @unlock ();
1796         }
1797         [CCode (cheader_filename = "libgda/libgda.h")]
1798         public struct DsnInfo {
1799                 public weak string name;
1800                 public weak string provider;
1801                 public weak string description;
1802                 public weak string cnc_string;
1803                 public weak string auth_string;
1804                 public bool is_system;
1805         }
1806         [CCode (cheader_filename = "libgda/libgda.h")]
1807         [SimpleType]
1808         public struct SqlBuilderId : uint {
1809         }
1810         [CCode (cheader_filename = "libgda/libgda.h")]
1811         protected struct SqlParserIface {
1812                 public Gda.SqlParser parser;
1813                 public Gda.SqlStatement parsed_statement;
1814         }
1815         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_BATCH_CONFLICTING_PARAMETER_")]
1816         public enum BatchError {
1817                 ERROR
1818         }
1819         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_CONFIG_")]
1820         public enum ConfigError {
1821                 DSN_NOT_FOUND_ERROR,
1822                 PERMISSION_ERROR,
1823                 PROVIDER_NOT_FOUND_ERROR,
1824                 PROVIDER_CREATION_ERROR
1825         }
1826         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_CONNECTION_")]
1827         public enum ConnectionError {
1828                 DSN_NOT_FOUND_ERROR,
1829                 PROVIDER_NOT_FOUND_ERROR,
1830                 PROVIDER_ERROR,
1831                 NO_CNC_SPEC_ERROR,
1832                 NO_PROVIDER_SPEC_ERROR,
1833                 OPEN_ERROR,
1834                 STATEMENT_TYPE_ERROR,
1835                 CANT_LOCK_ERROR,
1836                 TASK_NOT_FOUND_ERROR,
1837                 UNSUPPORTED_THREADS_ERROR,
1838                 CLOSED_ERROR
1839         }
1840         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_CONNECTION_EVENT_CODE_")]
1841         public enum ConnectionEventCode {
1842                 CONSTRAINT_VIOLATION,
1843                 RESTRICT_VIOLATION,
1844                 NOT_NULL_VIOLATION,
1845                 FOREIGN_KEY_VIOLATION,
1846                 UNIQUE_VIOLATION,
1847                 CHECK_VIOLATION,
1848                 INSUFFICIENT_PRIVILEGES,
1849                 UNDEFINED_COLUMN,
1850                 UNDEFINED_FUNCTION,
1851                 UNDEFINED_TABLE,
1852                 DUPLICATE_COLUMN,
1853                 DUPLICATE_DATABASE,
1854                 DUPLICATE_FUNCTION,
1855                 DUPLICATE_SCHEMA,
1856                 DUPLICATE_TABLE,
1857                 DUPLICATE_ALIAS,
1858                 DUPLICATE_OBJECT,
1859                 SYNTAX_ERROR,
1860                 UNKNOWN
1861         }
1862         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_CONNECTION_EVENT_")]
1863         public enum ConnectionEventType {
1864                 NOTICE,
1865                 WARNING,
1866                 ERROR,
1867                 COMMAND
1868         }
1869         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_CONNECTION_FEATURE_")]
1870         public enum ConnectionFeature {
1871                 AGGREGATES,
1872                 BLOBS,
1873                 INDEXES,
1874                 INHERITANCE,
1875                 NAMESPACES,
1876                 PROCEDURES,
1877                 SEQUENCES,
1878                 SQL,
1879                 TRANSACTIONS,
1880                 SAVEPOINTS,
1881                 SAVEPOINTS_REMOVE,
1882                 TRIGGERS,
1883                 UPDATABLE_CURSOR,
1884                 USERS,
1885                 VIEWS,
1886                 XA_TRANSACTIONS,
1887                 MULTI_THREADING,
1888                 LAST
1889         }
1890         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_CONNECTION_META_")]
1891         public enum ConnectionMetaType {
1892                 NAMESPACES,
1893                 TYPES,
1894                 TABLES,
1895                 VIEWS,
1896                 FIELDS,
1897                 INDEXES
1898         }
1899         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_CONNECTION_OPTIONS_")]
1900         [Flags]
1901         public enum ConnectionOptions {
1902                 NONE,
1903                 READ_ONLY,
1904                 SQL_IDENTIFIERS_CASE_SENSITIVE,
1905                 THREAD_SAFE,
1906                 THREAD_ISOLATED,
1907                 AUTO_META_DATA
1908         }
1909         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_CONNECTION_SCHEMA_")]
1910         public enum ConnectionSchema {
1911                 AGGREGATES,
1912                 DATABASES,
1913                 FIELDS,
1914                 INDEXES,
1915                 LANGUAGES,
1916                 NAMESPACES,
1917                 PARENT_TABLES,
1918                 PROCEDURES,
1919                 SEQUENCES,
1920                 TABLES,
1921                 TRIGGERS,
1922                 TYPES,
1923                 USERS,
1924                 VIEWS,
1925                 CONSTRAINTS,
1926                 TABLE_CONTENTS
1927         }
1928         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_DATA_COMPARATOR_")]
1929         public enum DataComparatorError {
1930                 MISSING_DATA_MODEL_ERROR,
1931                 COLUMN_TYPES_MISMATCH_ERROR,
1932                 MODEL_ACCESS_ERROR,
1933                 USER_CANCELLED_ERROR
1934         }
1935         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_DATA_MODEL_ACCESS_")]
1936         [Flags]
1937         public enum DataModelAccessFlags {
1938                 RANDOM,
1939                 CURSOR_FORWARD,
1940                 CURSOR_BACKWARD,
1941                 CURSOR,
1942                 INSERT,
1943                 UPDATE,
1944                 DELETE,
1945                 WRITE
1946         }
1947         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_DATA_MODEL_")]
1948         public enum DataModelError {
1949                 ROW_OUT_OF_RANGE_ERROR,
1950                 COLUMN_OUT_OF_RANGE_ERROR,
1951                 VALUES_LIST_ERROR,
1952                 VALUE_TYPE_ERROR,
1953                 ROW_NOT_FOUND_ERROR,
1954                 ACCESS_ERROR,
1955                 FEATURE_NON_SUPPORTED_ERROR,
1956                 FILE_EXIST_ERROR,
1957                 XML_FORMAT_ERROR
1958         }
1959         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_DATA_MODEL_HINT_")]
1960         public enum DataModelHint {
1961                 START_BATCH_UPDATE,
1962                 END_BATCH_UPDATE,
1963                 REFRESH
1964         }
1965         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_DATA_MODEL_IO_")]
1966         public enum DataModelIOFormat {
1967                 DATA_ARRAY_XML,
1968                 TEXT_SEPARATED
1969         }
1970         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_DATA_MODEL_ITER_COLUMN_OUT_OF_RANGE_")]
1971         public enum DataModelIterError {
1972                 ERROR
1973         }
1974         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_DATA_PROXY_")]
1975         public enum DataProxyError {
1976                 COMMIT_ERROR,
1977                 COMMIT_CANCELLED,
1978                 READ_ONLY_VALUE,
1979                 READ_ONLY_ROW,
1980                 FILTER_ERROR
1981         }
1982         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_DATA_SELECT_")]
1983         public enum DataSelectError {
1984                 MODIFICATION_STATEMENT_ERROR,
1985                 MISSING_MODIFICATION_STATEMENT_ERROR,
1986                 CONNECTION_ERROR,
1987                 ACCESS_ERROR,
1988                 SQL_ERROR,
1989                 SAFETY_LOCKED_ERROR
1990         }
1991         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_DIFF_")]
1992         public enum DiffType {
1993                 ADD_ROW,
1994                 REMOVE_ROW,
1995                 MODIFY_ROW
1996         }
1997         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_EASY_CREATE_TABLE_")]
1998         public enum EasyCreateTableFlag {
1999                 NOTHING_FLAG,
2000                 PKEY_FLAG,
2001                 NOT_NULL_FLAG,
2002                 UNIQUE_FLAG,
2003                 AUTOINC_FLAG,
2004                 FKEY_FLAG,
2005                 PKEY_AUTOINC_FLAG
2006         }
2007         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_EASY_")]
2008         public enum EasyError {
2009                 OBJECT_NAME_ERROR,
2010                 INCORRECT_VALUE_ERROR,
2011                 OPERATION_ERROR
2012         }
2013         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_HOLDER_")]
2014         public enum HolderError {
2015                 STRING_CONVERSION_ERROR,
2016                 VALUE_TYPE_ERROR,
2017                 VALUE_NULL_ERROR
2018         }
2019         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_META_DB_")]
2020         public enum MetaDbObjectType {
2021                 UNKNOWN,
2022                 TABLE,
2023                 VIEW
2024         }
2025         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_META_FOREIGN_KEY_")]
2026         public enum MetaForeignKeyPolicy {
2027                 UNKNOWN,
2028                 NONE,
2029                 NO_ACTION,
2030                 RESTRICT,
2031                 CASCADE,
2032                 SET_NULL,
2033                 SET_DEFAULT
2034         }
2035         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_META_GRAPH_")]
2036         [Flags]
2037         public enum MetaGraphInfo {
2038                 COLUMNS
2039         }
2040         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_META_SORT_")]
2041         public enum MetaSortType {
2042                 ALHAPETICAL,
2043                 DEPENDENCIES
2044         }
2045         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_META_STORE_")]
2046         public enum MetaStoreChangeType {
2047                 ADD,
2048                 REMOVE,
2049                 MODIFY
2050         }
2051         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_META_STORE_")]
2052         public enum MetaStoreError {
2053                 INCORRECT_SCHEMA_ERROR,
2054                 UNSUPPORTED_PROVIDER_ERROR,
2055                 INTERNAL_ERROR,
2056                 META_CONTEXT_ERROR,
2057                 MODIFY_CONTENTS_ERROR,
2058                 EXTRACT_SQL_ERROR,
2059                 ATTRIBUTE_NOT_FOUND_ERROR,
2060                 ATTRIBUTE_ERROR,
2061                 SCHEMA_OBJECT_NOT_FOUND_ERROR,
2062                 SCHEMA_OBJECT_CONFLICT_ERROR,
2063                 SCHEMA_OBJECT_DESCR_ERROR,
2064                 TRANSACTION_ALREADY_STARTED_ERROR
2065         }
2066         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_META_STRUCT_")]
2067         public enum MetaStructError {
2068                 UNKNOWN_OBJECT_ERROR,
2069                 DUPLICATE_OBJECT_ERROR,
2070                 INCOHERENCE_ERROR
2071         }
2072         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_META_STRUCT_FEATURE_")]
2073         [Flags]
2074         public enum MetaStructFeature {
2075                 NONE,
2076                 FOREIGN_KEYS,
2077                 VIEW_DEPENDENCIES,
2078                 ALL
2079         }
2080         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_", has_type_id = false)]
2081         public enum PrefixDir {
2082                 NO_DIR,
2083                 BIN_DIR,
2084                 SBIN_DIR,
2085                 DATA_DIR,
2086                 LOCALE_DIR,
2087                 LIB_DIR,
2088                 LIBEXEC_DIR,
2089                 ETC_DIR
2090         }
2091         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SERVER_OPERATION_CREATE_TABLE_")]
2092         [Flags]
2093         public enum ServerOperationCreateTableFlag {
2094                 NOTHING_FLAG,
2095                 PKEY_FLAG,
2096                 NOT_NULL_FLAG,
2097                 UNIQUE_FLAG,
2098                 AUTOINC_FLAG,
2099                 FKEY_FLAG,
2100                 PKEY_AUTOINC_FLAG
2101         }
2102         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SERVER_OPERATION_")]
2103         public enum ServerOperationError {
2104                 OBJECT_NAME_ERROR,
2105                 INCORRECT_VALUE_ERROR
2106         }
2107         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SERVER_OPERATION_STATUS_")]
2108         public enum ServerOperationNodeStatus {
2109                 OPTIONAL,
2110                 REQUIRED,
2111                 UNKNOWN
2112         }
2113         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SERVER_OPERATION_NODE_")]
2114         public enum ServerOperationNodeType {
2115                 PARAMLIST,
2116                 DATA_MODEL,
2117                 PARAM,
2118                 SEQUENCE,
2119                 SEQUENCE_ITEM,
2120                 DATA_MODEL_COLUMN,
2121                 UNKNOWN
2122         }
2123         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SERVER_OPERATION_")]
2124         public enum ServerOperationType {
2125                 CREATE_DB,
2126                 DROP_DB,
2127                 CREATE_TABLE,
2128                 DROP_TABLE,
2129                 RENAME_TABLE,
2130                 ADD_COLUMN,
2131                 DROP_COLUMN,
2132                 CREATE_INDEX,
2133                 DROP_INDEX,
2134                 CREATE_VIEW,
2135                 DROP_VIEW,
2136                 COMMENT_TABLE,
2137                 COMMENT_COLUMN,
2138                 CREATE_USER,
2139                 ALTER_USER,
2140                 DROP_USER,
2141                 LAST
2142         }
2143         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SERVER_PROVIDER_")]
2144         public enum ServerProviderError {
2145                 METHOD_NON_IMPLEMENTED_ERROR,
2146                 PREPARE_STMT_ERROR,
2147                 EMPTY_STMT_ERROR,
2148                 MISSING_PARAM_ERROR,
2149                 STATEMENT_EXEC_ERROR,
2150                 OPERATION_ERROR,
2151                 INTERNAL_ERROR,
2152                 BUSY_ERROR,
2153                 NON_SUPPORTED_ERROR,
2154                 SERVER_VERSION_ERROR,
2155                 DATA_ERROR,
2156                 DEFAULT_VALUE_HANDLING_ERROR
2157         }
2158         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SET_")]
2159         public enum SetError {
2160                 XML_SPEC_ERROR,
2161                 HOLDER_NOT_FOUND_ERROR,
2162                 INVALID_ERROR,
2163                 READ_ONLY_ERROR
2164         }
2165         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_ANY_")]
2166         public enum SqlAnyPartType {
2167                 STMT_SELECT,
2168                 STMT_INSERT,
2169                 STMT_UPDATE,
2170                 STMT_DELETE,
2171                 STMT_COMPOUND,
2172                 STMT_BEGIN,
2173                 STMT_ROLLBACK,
2174                 STMT_COMMIT,
2175                 STMT_SAVEPOINT,
2176                 STMT_ROLLBACK_SAVEPOINT,
2177                 STMT_DELETE_SAVEPOINT,
2178                 STMT_UNKNOWN,
2179                 EXPR,
2180                 SQL_FIELD,
2181                 SQL_TABLE,
2182                 SQL_FUNCTION,
2183                 SQL_OPERATION,
2184                 SQL_CASE,
2185                 SQL_SELECT_FIELD,
2186                 SQL_SELECT_TARGET,
2187                 SQL_SELECT_JOIN,
2188                 SQL_SELECT_FROM,
2189                 SQL_SELECT_ORDER
2190         }
2191         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_BUILDER_")]
2192         public enum SqlBuilderError {
2193                 WRONG_TYPE_ERROR,
2194                 MISUSE_ERROR
2195         }
2196         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_IDENTIFIERS_")]
2197         [Flags]
2198         public enum SqlIdentifierStyle {
2199                 LOWER_CASE,
2200                 UPPER_CASE
2201         }
2202         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_OPERATOR_TYPE_")]
2203         public enum SqlOperatorType {
2204                 AND,
2205                 OR,
2206                 EQ,
2207                 IS,
2208                 LIKE,
2209                 BETWEEN,
2210                 GT,
2211                 LT,
2212                 GEQ,
2213                 LEQ,
2214                 DIFF,
2215                 REGEXP,
2216                 REGEXP_CI,
2217                 NOT_REGEXP,
2218                 NOT_REGEXP_CI,
2219                 SIMILAR,
2220                 ISNULL,
2221                 ISNOTNULL,
2222                 NOT,
2223                 IN,
2224                 NOTIN,
2225                 CONCAT,
2226                 PLUS,
2227                 MINUS,
2228                 STAR,
2229                 DIV,
2230                 REM,
2231                 BITAND,
2232                 BITOR,
2233                 BITNOT
2234         }
2235         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_PARSER_")]
2236         public enum SqlParserError {
2237                 SYNTAX_ERROR,
2238                 OVERFLOW_ERROR,
2239                 EMPTY_SQL_ERROR
2240         }
2241         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_PARSER_FLAVOUR_")]
2242         public enum SqlParserFlavour {
2243                 STANDARD,
2244                 SQLITE,
2245                 MYSQL,
2246                 ORACLE,
2247                 POSTGRESQL
2248         }
2249         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_PARSER_MODE_")]
2250         public enum SqlParserMode {
2251                 PARSE,
2252                 DELIMIT
2253         }
2254         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_SELECT_JOIN_")]
2255         public enum SqlSelectJoinType {
2256                 CROSS,
2257                 NATURAL,
2258                 INNER,
2259                 LEFT,
2260                 RIGHT,
2261                 FULL
2262         }
2263         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_STATEMENT_COMPOUND_")]
2264         public enum SqlStatementCompoundType {
2265                 UNION,
2266                 UNION_ALL,
2267                 INTERSECT,
2268                 INTERSECT_ALL,
2269                 EXCEPT,
2270                 EXCEPT_ALL
2271         }
2272         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_SQL_STATEMENT_")]
2273         public enum SqlStatementType {
2274                 SELECT,
2275                 INSERT,
2276                 UPDATE,
2277                 DELETE,
2278                 COMPOUND,
2279                 BEGIN,
2280                 ROLLBACK,
2281                 COMMIT,
2282                 SAVEPOINT,
2283                 ROLLBACK_SAVEPOINT,
2284                 DELETE_SAVEPOINT,
2285                 UNKNOWN,
2286                 NONE
2287         }
2288         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_STATEMENT_")]
2289         public enum StatementError {
2290                 PARSE_ERROR,
2291                 SYNTAX_ERROR,
2292                 NO_CNC_ERROR,
2293                 CNC_CLOSED_ERROR,
2294                 EXEC_ERROR,
2295                 PARAM_TYPE_ERROR,
2296                 PARAM_ERROR
2297         }
2298         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_STATEMENT_MODEL_")]
2299         [Flags]
2300         public enum StatementModelUsage {
2301                 RANDOM_ACCESS,
2302                 CURSOR_FORWARD,
2303                 CURSOR_BACKWARD,
2304                 CURSOR,
2305                 ALLOW_NOPARAM
2306         }
2307         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_STATEMENT_SQL_")]
2308         [Flags]
2309         public enum StatementSqlFlag {
2310                 PARAMS_AS_VALUES,
2311                 PRETTY,
2312                 PARAMS_LONG,
2313                 PARAMS_SHORT,
2314                 PARAMS_AS_COLON,
2315                 PARAMS_AS_DOLLAR,
2316                 PARAMS_AS_QMARK,
2317                 PARAMS_AS_UQMARK
2318         }
2319         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_THREAD_WRAPPER_UNKNOWN_", has_type_id = false)]
2320         public enum ThreadWrapperError {
2321                 ERROR
2322         }
2323         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_TRANSACTION_ISOLATION_")]
2324         public enum TransactionIsolation {
2325                 UNKNOWN,
2326                 READ_COMMITTED,
2327                 READ_UNCOMMITTED,
2328                 REPEATABLE_READ,
2329                 SERIALIZABLE
2330         }
2331         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_TRANSACTION_STATUS_EVENT_")]
2332         public enum TransactionStatusEventType {
2333                 SAVEPOINT,
2334                 SQL,
2335                 SUB_TRANSACTION
2336         }
2337         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_TRANSACTION_STATUS_STATE_")]
2338         public enum TransactionStatusState {
2339                 OK,
2340                 FAILED
2341         }
2342         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_TREE_UNKNOWN_")]
2343         public enum TreeError {
2344                 ERROR
2345         }
2346         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_TREE_MANAGER_UNKNOWN_")]
2347         public enum TreeManagerError {
2348                 ERROR
2349         }
2350         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_TREE_NODE_UNKNOWN_")]
2351         public enum TreeNodeError {
2352                 ERROR
2353         }
2354         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_VALUE_ATTR_")]
2355         [Flags]
2356         public enum ValueAttribute {
2357                 NONE,
2358                 IS_NULL,
2359                 CAN_BE_NULL,
2360                 IS_DEFAULT,
2361                 CAN_BE_DEFAULT,
2362                 IS_UNCHANGED,
2363                 ACTIONS_SHOWN,
2364                 DATA_NON_VALID,
2365                 HAS_VALUE_ORIG,
2366                 NO_MODIF,
2367                 UNUSED
2368         }
2369         [CCode (cheader_filename = "libgda/libgda.h", cprefix = "GDA_XA_TRANSACTION_")]
2370         public enum XaTransactionError {
2371                 ALREADY_REGISTERED_ERROR,
2372                 DTP_NOT_SUPPORTED_ERROR,
2373                 CONNECTION_BRANCH_LENGTH_ERROR
2374         }
2375         [CCode (cheader_filename = "libgda/libgda.h")]
2376         public errordomain SqlError {
2377                 STRUCTURE_CONTENTS_ERROR,
2378                 MALFORMED_IDENTIFIER_ERROR,
2379                 MISSING_IDENTIFIER_ERROR,
2380                 VALIDATION_ERROR
2381         }
2382         [CCode (cheader_filename = "libgda/libgda.h")]
2383         public delegate void AttributesManagerFunc (string att_name, GLib.Value value);
2384         [CCode (cheader_filename = "libgda/libgda.h")]
2385         public delegate void AttributesManagerSignal (GLib.Object obj, string att_name, GLib.Value value);
2386         [CCode (cheader_filename = "libgda/libgda.h")]
2387         public delegate void ServerProviderAsyncCallback (Gda.ServerProvider provider, Gda.Connection cnc, uint task_id, bool result_status, GLib.Error error);
2388         [CCode (cheader_filename = "libgda/libgda.h")]
2389         public delegate void ServerProviderExecCallback (Gda.ServerProvider provider, Gda.Connection cnc, uint task_id, GLib.Object result_obj, GLib.Error error);
2390         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2391         public delegate bool SqlForeachFunc (Gda.SqlAnyPart p1, void* p2) throws GLib.Error;
2392         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2393         public delegate unowned string SqlRenderingExpr (Gda.SqlExpr expr, Gda.SqlRenderingContext context, bool is_default, bool is_null) throws GLib.Error;
2394         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2395         public delegate unowned string SqlRenderingFunc (Gda.SqlAnyPart node, Gda.SqlRenderingContext context) throws GLib.Error;
2396         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2397         public delegate unowned string SqlRenderingPSpecFunc (Gda.SqlParamSpec pspec, Gda.SqlExpr expr, Gda.SqlRenderingContext context, bool is_default, bool is_null) throws GLib.Error;
2398         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2399         public delegate unowned string SqlRenderingValue (GLib.Value value, Gda.SqlRenderingContext context) throws GLib.Error;
2400         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2401         public delegate bool SqlReservedKeywordsFunc (string word);
2402         [CCode (cheader_filename = "libgda/libgda.h")]
2403         public delegate void ThreadWrapperCallback (Gda.ThreadWrapper wrapper, void* instance, string signame, int n_param_values, GLib.Value param_values, void* gda_reserved);
2404         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2405         public delegate void* ThreadWrapperFunc (void* arg) throws GLib.Error;
2406         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2407         public delegate void ThreadWrapperVoidFunc (void* arg) throws GLib.Error;
2408         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2409         public delegate unowned Gda.TreeNode TreeManagerNodeFunc (Gda.TreeManager manager, Gda.TreeNode parent, string name);
2410         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2411         public delegate unowned GLib.SList TreeManagerNodesFunc (Gda.TreeManager manager, Gda.TreeNode node, GLib.SList children_nodes, bool out_error) throws GLib.Error;
2412         [CCode (cheader_filename = "libgda/libgda.h")]
2413         public delegate void VConnectionHubFunc (Gda.Connection cnc, string ns);
2414         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2415         public delegate unowned GLib.List VconnectionDataModelCreateColumnsFunc (Gda.VconnectionDataModelSpec p1) throws GLib.Error;
2416         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2417         public delegate unowned Gda.DataModel VconnectionDataModelCreateFModelFunc (Gda.VconnectionDataModelSpec p1, int p2, string p3, int p4, out GLib.Value p5);
2418         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2419         public delegate unowned Gda.DataModel VconnectionDataModelCreateModelFunc (Gda.VconnectionDataModelSpec p1);
2420         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2421         public delegate void VconnectionDataModelFunc (Gda.DataModel p1, string p2, void* p3);
2422         [CCode (cheader_filename = "libgda/libgda.h", has_target = false)]
2423         public delegate void VconnectionDataModelParseFilterFunc (Gda.VconnectionDataModelSpec p1, Gda.VconnectionDataModelFilter p2);
2424         [CCode (cheader_filename = "libgda/libgda.h")]
2425         public const string ATTRIBUTE_AUTO_INCREMENT;
2426         [CCode (cheader_filename = "libgda/libgda.h")]
2427         public const string ATTRIBUTE_DESCRIPTION;
2428         [CCode (cheader_filename = "libgda/libgda.h")]
2429         public const string ATTRIBUTE_IS_DEFAULT;
2430         [CCode (cheader_filename = "libgda/libgda.h")]
2431         public const string ATTRIBUTE_NAME;
2432         [CCode (cheader_filename = "libgda/libgda.h")]
2433         public const string ATTRIBUTE_NUMERIC_PRECISION;
2434         [CCode (cheader_filename = "libgda/libgda.h")]
2435         public const string ATTRIBUTE_NUMERIC_SCALE;
2436         [CCode (cheader_filename = "libgda/libgda.h")]
2437         public const string EXTRA_AUTO_INCREMENT;
2438         [CCode (cheader_filename = "libgda/libgda.h")]
2439         public const string SQLSTATE_GENERAL_ERROR;
2440         [CCode (cheader_filename = "libgda/libgda.h")]
2441         public const string SQLSTATE_NO_ERROR;
2442         [CCode (cheader_filename = "libgda/libgda.h")]
2443         public const int TIMEZONE_INVALID;
2444         [CCode (cheader_filename = "libgda/libgda.h")]
2445         public const int TYPE_NULL;
2446         [CCode (cheader_filename = "libgda/libgda.h")]
2447         public static unowned string alphanum_to_text (string text);
2448         [CCode (cheader_filename = "libgda/libgda.h")]
2449         public static unowned string completion_list_get (Gda.Connection cnc, string sql, int start, int end);
2450         [CCode (cheader_filename = "libgda/libgda.h")]
2451         public static bool compute_dml_statements (Gda.Connection cnc, Gda.Statement select_stmt, bool require_pk, out unowned Gda.Statement insert_stmt, out unowned Gda.Statement update_stmt, out unowned Gda.Statement delete_stmt) throws GLib.Error;
2452         [CCode (cheader_filename = "libgda/libgda.h")]
2453         public static unowned Gda.SqlStatement compute_select_statement_from_update (Gda.Statement update_stmt) throws GLib.Error;
2454         [CCode (cheader_filename = "libgda/libgda.h")]
2455         public static unowned Gda.SqlExpr compute_unique_table_row_condition (Gda.SqlStatementSelect stsel, Gda.MetaTable mtable, bool require_pk) throws GLib.Error;
2456         [CCode (cheader_filename = "libgda/libgda.h")]
2457         public static unowned Gda.SqlExpr compute_unique_table_row_condition_with_cnc (Gda.Connection cnc, Gda.SqlStatementSelect stsel, Gda.MetaTable mtable, bool require_pk) throws GLib.Error;
2458         [CCode (cheader_filename = "libgda/libgda.h")]
2459         public static unowned string default_escape_string (string str);
2460         [CCode (cheader_filename = "libgda/libgda.h")]
2461         public static unowned string default_unescape_string (string str);
2462         [CCode (cheader_filename = "libgda/libgda.h")]
2463         public static bool delete_row_from_table (Gda.Connection cnc, string table, string condition_column_name, GLib.Value condition_value) throws GLib.Error;
2464         [CCode (cheader_filename = "libgda/libgda.h")]
2465         public static void dsn_split (string str, string out_dsn, string out_username, string out_password);
2466         [CCode (cheader_filename = "libgda/libgda.h")]
2467         public static GLib.Quark easy_error_quark ();
2468         [CCode (cheader_filename = "libgda/libgda.h")]
2469         public static int execute_non_select_command (Gda.Connection cnc, string sql) throws GLib.Error;
2470         [CCode (cheader_filename = "libgda/libgda.h")]
2471         public static unowned Gda.DataModel execute_select_command (Gda.Connection cnc, string sql) throws GLib.Error;
2472         [CCode (cheader_filename = "libgda/libgda.h")]
2473         public static GLib.Type g_type_from_string (string str);
2474         [CCode (cheader_filename = "libgda/libgda.h")]
2475         public static unowned string g_type_to_string (GLib.Type type);
2476         [CCode (cheader_filename = "libgda/libgda.h")]
2477         public static unowned string gbr_get_file_path (Gda.PrefixDir where);
2478         [CCode (cheader_filename = "libgda/libgda.h")]
2479         public static void gbr_init ();
2480         [CCode (cheader_filename = "libgda/libgda.h")]
2481         public static unowned string get_application_exec_path (string app_name);
2482         [CCode (cheader_filename = "libgda/libgda.h")]
2483         public static unowned Gda.DataHandler get_default_handler (GLib.Type for_type);
2484         [CCode (cheader_filename = "libgda/libgda.h")]
2485         public static bool identifier_equal (string id1, string id2);
2486         [CCode (cheader_filename = "libgda/libgda.h")]
2487         public static uint identifier_hash (string id);
2488         [CCode (cheader_filename = "libgda/libgda.h")]
2489         public static void init ();
2490         [CCode (cheader_filename = "libgda/libgda.h")]
2491         public static bool insert_row_into_table (Gda.Connection cnc, string table) throws GLib.Error;
2492         [CCode (cheader_filename = "libgda/libgda.h")]
2493         public static bool insert_row_into_table_v (Gda.Connection cnc, string table, GLib.SList col_names, GLib.SList values) throws GLib.Error;
2494         [CCode (cheader_filename = "libgda/libgda.h")]
2495         public static void locale_changed ();
2496         [CCode (cheader_filename = "libgda/libgda.h")]
2497         public static void log_disable ();
2498         [CCode (cheader_filename = "libgda/libgda.h")]
2499         public static void log_enable ();
2500         [CCode (cheader_filename = "libgda/libgda.h")]
2501         public static void log_error (string format);
2502         [CCode (cheader_filename = "libgda/libgda.h")]
2503         public static bool log_is_enabled ();
2504         [CCode (cheader_filename = "libgda/libgda.h")]
2505         public static void log_message (string format);
2506         [CCode (cheader_filename = "libgda/libgda.h")]
2507         public static bool parse_iso8601_date (GLib.Date gdate, string value);
2508         [CCode (cheader_filename = "libgda/libgda.h")]
2509         public static bool parse_iso8601_time (Gda.Time timegda, string value);
2510         [CCode (cheader_filename = "libgda/libgda.h")]
2511         public static bool parse_iso8601_timestamp (Gda.Timestamp timestamp, string value);
2512         [CCode (cheader_filename = "libgda/libgda.h")]
2513         public static unowned Gda.Statement parse_sql_string (Gda.Connection cnc, string sql, out unowned Gda.Set @params) throws GLib.Error;
2514         [CCode (cheader_filename = "libgda/libgda.h")]
2515         public static bool perform_create_database (string provider, Gda.ServerOperation op) throws GLib.Error;
2516         [CCode (cheader_filename = "libgda/libgda.h")]
2517         public static bool perform_create_table (Gda.ServerOperation op) throws GLib.Error;
2518         [CCode (cheader_filename = "libgda/libgda.h")]
2519         public static bool perform_drop_database (string provider, Gda.ServerOperation op) throws GLib.Error;
2520         [CCode (cheader_filename = "libgda/libgda.h")]
2521         public static bool perform_drop_table (Gda.ServerOperation op) throws GLib.Error;
2522         [CCode (cheader_filename = "libgda/libgda.h")]
2523         public static unowned Gda.ServerOperation prepare_create_database (string provider, string db_name) throws GLib.Error;
2524         [CCode (cheader_filename = "libgda/libgda.h")]
2525         public static unowned Gda.ServerOperation prepare_create_table (Gda.Connection cnc, string table_name) throws GLib.Error;
2526         [CCode (cheader_filename = "libgda/libgda.h")]
2527         public static unowned Gda.ServerOperation prepare_drop_database (string provider, string db_name) throws GLib.Error;
2528         [CCode (cheader_filename = "libgda/libgda.h")]
2529         public static unowned Gda.ServerOperation prepare_drop_table (Gda.Connection cnc, string table_name) throws GLib.Error;
2530         [CCode (cheader_filename = "libgda/libgda.h")]
2531         public static bool rfc1738_decode (string str);
2532         [CCode (cheader_filename = "libgda/libgda.h")]
2533         public static unowned string rfc1738_encode (string str);
2534         [CCode (cheader_filename = "libgda/libgda.h")]
2535         public static unowned Gda.Statement select_alter_select_for_empty (Gda.Statement stmt) throws GLib.Error;
2536         [CCode (cheader_filename = "libgda/libgda.h")]
2537         public static GLib.Type short_get_type ();
2538         [CCode (cheader_filename = "libgda/libgda.h")]
2539         public static GLib.Quark sql_error_quark ();
2540         [CCode (cheader_filename = "libgda/libgda.h")]
2541         public static unowned string sql_identifier_add_quotes (string str);
2542         [CCode (cheader_filename = "libgda/libgda.h")]
2543         public static bool sql_identifier_needs_quotes (string str);
2544         [CCode (cheader_filename = "libgda/libgda.h")]
2545         public static unowned string sql_identifier_quote (string id, Gda.Connection cnc, Gda.ServerProvider prov, bool meta_store_convention, bool force_quotes);
2546         [CCode (cheader_filename = "libgda/libgda.h")]
2547         public static unowned string sql_identifier_remove_quotes (string str);
2548         [CCode (cheader_filename = "libgda/libgda.h")]
2549         public static unowned string sql_identifier_split (string id);
2550         [CCode (cheader_filename = "libgda/libgda.h")]
2551         public static unowned string sql_value_stringify (GLib.Value value);
2552         [CCode (cheader_filename = "libgda/libgda.h")]
2553         public static unowned Gda.Binary string_to_binary (string str);
2554         [CCode (cheader_filename = "libgda/libgda.h")]
2555         public static unowned Gda.Blob string_to_blob (string str);
2556         [CCode (cheader_filename = "libgda/libgda.h")]
2557         public static unowned string text_to_alphanum (string text);
2558         [CCode (cheader_filename = "libgda/libgda.h")]
2559         public static bool update_row_in_table (Gda.Connection cnc, string table, string condition_column_name, GLib.Value condition_value) throws GLib.Error;
2560         [CCode (cheader_filename = "libgda/libgda.h")]
2561         public static bool update_row_in_table_v (Gda.Connection cnc, string table, string condition_column_name, GLib.Value condition_value, GLib.SList col_names, GLib.SList values) throws GLib.Error;
2562         [CCode (cheader_filename = "libgda/libgda.h")]
2563         public static GLib.Type ushort_get_type ();
2564         [CCode (cheader_filename = "libgda/libgda.h")]
2565         public static bool utility_check_data_model (Gda.DataModel model, int nbcols);
2566         [CCode (cheader_filename = "libgda/libgda.h")]
2567         public static bool utility_data_model_dump_data_to_xml (Gda.DataModel model, Xml.Node parent, int cols, int nb_cols, int rows, int nb_rows, bool use_col_ids);
2568         [CCode (cheader_filename = "libgda/libgda.h")]
2569         public static unowned string utility_data_model_find_column_description (Gda.DataSelect model, string field_name);
2570         [CCode (cheader_filename = "libgda/libgda.h")]
2571         public static bool utility_holder_load_attributes (Gda.Holder holder, Xml.Node node, GLib.SList sources) throws GLib.Error;
2572         [CCode (cheader_filename = "libgda/libgda.h")]
2573         public static int value_compare (GLib.Value value1, GLib.Value value2);
2574         [CCode (cheader_filename = "libgda/libgda.h")]
2575         public static GLib.Value value_copy (GLib.Value value);
2576         [CCode (cheader_filename = "libgda/libgda.h")]
2577         public static int value_differ (GLib.Value value1, GLib.Value value2);
2578         [CCode (cheader_filename = "libgda/libgda.h")]
2579         public static void value_free (GLib.Value value);
2580         [CCode (cheader_filename = "libgda/libgda.h")]
2581         public static unowned Gda.Binary value_get_binary (GLib.Value value);
2582         [CCode (cheader_filename = "libgda/libgda.h")]
2583         public static unowned Gda.Blob value_get_blob (GLib.Value value);
2584         [CCode (cheader_filename = "libgda/libgda.h")]
2585         public static unowned Gda.GeometricPoint value_get_geometric_point (GLib.Value value);
2586         [CCode (cheader_filename = "libgda/libgda.h")]
2587         public static unowned Gda.ValueList value_get_list (GLib.Value value);
2588         [CCode (cheader_filename = "libgda/libgda.h")]
2589         public static unowned Gda.Numeric value_get_numeric (GLib.Value value);
2590         [CCode (cheader_filename = "libgda/libgda.h")]
2591         public static short value_get_short (GLib.Value value);
2592         [CCode (cheader_filename = "libgda/libgda.h")]
2593         public static unowned Gda.Time value_get_time (GLib.Value value);
2594         [CCode (cheader_filename = "libgda/libgda.h")]
2595         public static unowned Gda.Timestamp value_get_timestamp (GLib.Value value);
2596         [CCode (cheader_filename = "libgda/libgda.h")]
2597         public static ushort value_get_ushort (GLib.Value value);
2598         [CCode (cheader_filename = "libgda/libgda.h")]
2599         public static bool value_is_null (GLib.Value value);
2600         [CCode (cheader_filename = "libgda/libgda.h")]
2601         public static bool value_is_number (GLib.Value value);
2602         [CCode (cheader_filename = "libgda/libgda.h")]
2603         public static GLib.Value value_new (GLib.Type type);
2604         [CCode (cheader_filename = "libgda/libgda.h")]
2605         public static GLib.Value value_new_binary (uchar[] val, long size);
2606         [CCode (cheader_filename = "libgda/libgda.h")]
2607         public static GLib.Value value_new_blob (uchar[] val, long size);
2608         [CCode (cheader_filename = "libgda/libgda.h")]
2609         public static GLib.Value value_new_blob_from_file (string filename);
2610         [CCode (cheader_filename = "libgda/libgda.h")]
2611         public static GLib.Value value_new_from_string (string as_string, GLib.Type type);
2612         [CCode (cheader_filename = "libgda/libgda.h")]
2613         public static GLib.Value value_new_from_xml (Xml.Node node);
2614         [CCode (cheader_filename = "libgda/libgda.h")]
2615         public static GLib.Value value_new_timestamp_from_timet (time_t val);
2616         [CCode (cheader_filename = "libgda/libgda.h")]
2617         public static void value_reset_with_type (GLib.Value value, GLib.Type type);
2618         [CCode (cheader_filename = "libgda/libgda.h")]
2619         public static void value_set_binary (GLib.Value value, Gda.Binary binary);
2620         [CCode (cheader_filename = "libgda/libgda.h")]
2621         public static void value_set_blob (GLib.Value value, Gda.Blob blob);
2622         [CCode (cheader_filename = "libgda/libgda.h")]
2623         public static bool value_set_from_string (GLib.Value value, string as_string, GLib.Type type);
2624         [CCode (cheader_filename = "libgda/libgda.h")]
2625         public static bool value_set_from_value (GLib.Value value, GLib.Value from);
2626         [CCode (cheader_filename = "libgda/libgda.h")]
2627         public static void value_set_geometric_point (GLib.Value value, Gda.GeometricPoint val);
2628         [CCode (cheader_filename = "libgda/libgda.h")]
2629         public static void value_set_list (GLib.Value value, Gda.ValueList val);
2630         [CCode (cheader_filename = "libgda/libgda.h")]
2631         public static void value_set_null (GLib.Value value);
2632         [CCode (cheader_filename = "libgda/libgda.h")]
2633         public static void value_set_numeric (GLib.Value value, Gda.Numeric val);
2634         [CCode (cheader_filename = "libgda/libgda.h")]
2635         public static void value_set_short (GLib.Value value, short val);
2636         [CCode (cheader_filename = "libgda/libgda.h")]
2637         public static void value_set_time (GLib.Value value, Gda.Time val);
2638         [CCode (cheader_filename = "libgda/libgda.h")]
2639         public static void value_set_timestamp (GLib.Value value, Gda.Timestamp val);
2640         [CCode (cheader_filename = "libgda/libgda.h")]
2641         public static void value_set_ushort (GLib.Value value, ushort val);
2642         [CCode (cheader_filename = "libgda/libgda.h")]
2643         public static unowned string value_stringify (GLib.Value value);
2644         [CCode (cheader_filename = "libgda/libgda.h")]
2645         public static void value_take_binary (GLib.Value value, Gda.Binary binary);
2646         [CCode (cheader_filename = "libgda/libgda.h")]
2647         public static void value_take_blob (GLib.Value value, Gda.Blob blob);
2648         [CCode (cheader_filename = "libgda/libgda.h")]
2649         public static unowned Xml.Node value_to_xml (GLib.Value value);
2650 }