← Back to branch summary

~ubuntu-branches/debian/sid/sqlheavy/sid

« back to all changes in this revision

Viewing changes to sqlheavy/sqlheavy-row.c

  • Committer: Package Import Robot
  • Author(s): Devid Antonio Filoni
  • Date: 2011-10-23 15:43:22 UTC
  • Revision ID: package-import@ubuntu.com-20111023154322-unzj3fz2aj4g6cl8
Tags: upstream-0.1.0
Import upstream version 0.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
sqlheavy/sqlheavy-row.c
 
1
/* sqlheavy-row.c generated by valac 0.12.1, the Vala compiler
 
2
 * generated from sqlheavy-row.vala, do not modify */
 
3
 
 
4
 
 
5
#include <glib.h>
 
6
#include <glib-object.h>
 
7
#include "SQLHeavy.h"
 
8
#include <stdlib.h>
 
9
#include <string.h>
 
10
 
 
11
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
12
#define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
 
13
#define _g_free0(var) (var = (g_free (var), NULL))
 
14
#define __vala_GValue_free0(var) ((var == NULL) ? NULL : (var = (_vala_GValue_free (var), NULL)))
 
15
#define _g_value_array_free0(var) ((var == NULL) ? NULL : (var = (g_value_array_free (var), NULL)))
 
16
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
17
 
 
18
struct _SQLHeavyRowPrivate {
 
19
        SQLHeavyTable* _table;
 
20
        gboolean _auto_save;
 
21
        gint64 _id;
 
22
        GValue** values;
 
23
        gint values_length1;
 
24
        gint _values_size_;
 
25
        GStaticRecMutex __lock_values;
 
26
        GValue** cache;
 
27
        gint cache_length1;
 
28
        gint _cache_size_;
 
29
        GStaticRecMutex __lock_cache;
 
30
        gboolean _enable_cache;
 
31
};
 
32
 
 
33
 
 
34
static gpointer sql_heavy_row_parent_class = NULL;
 
35
static SQLHeavyRecordIface* sql_heavy_row_sql_heavy_record_parent_iface = NULL;
 
36
static SQLHeavyMutableRecordIface* sql_heavy_row_sql_heavy_mutable_record_parent_iface = NULL;
 
37
 
 
38
#define SQL_HEAVY_ROW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SQL_HEAVY_TYPE_ROW, SQLHeavyRowPrivate))
 
39
enum  {
 
40
        SQL_HEAVY_ROW_DUMMY_PROPERTY,
 
41
        SQL_HEAVY_ROW_TABLE,
 
42
        SQL_HEAVY_ROW_AUTO_SAVE,
 
43
        SQL_HEAVY_ROW_ID,
 
44
        SQL_HEAVY_ROW_FIELD_COUNT,
 
45
        SQL_HEAVY_ROW_ENABLE_CACHE
 
46
};
 
47
void sql_heavy_table_unregister_row (SQLHeavyTable* self, SQLHeavyRow* row);
 
48
static void _vala_GValue_free (GValue* self);
 
49
static void sql_heavy_row_real_save (SQLHeavyMutableRecord* base, GError** error);
 
50
void sql_heavy_table_register_row (SQLHeavyTable* self, SQLHeavyRow* row);
 
51
void sql_heavy_row_update_cache (SQLHeavyRow* self, GError** error);
 
52
static gint sql_heavy_row_real_field_index (SQLHeavyRecord* base, const gchar* field, GError** error);
 
53
static gchar* sql_heavy_row_real_field_name (SQLHeavyRecord* base, gint field, GError** error);
 
54
static GType sql_heavy_row_real_field_type (SQLHeavyRecord* base, gint field, GError** error);
 
55
static void sql_heavy_row_real_put (SQLHeavyMutableRecord* base, gint field, GValue* value, GError** error);
 
56
static GValue* _g_value_dup (GValue* self);
 
57
void sql_heavy_row_on_delete (SQLHeavyRow* self);
 
58
static void sql_heavy_row_real_delete (SQLHeavyMutableRecord* base, GError** error);
 
59
static void sql_heavy_row_real_fetch (SQLHeavyRecord* base, gint field, GValue* result, GError** error);
 
60
static SQLHeavyRow* sql_heavy_row_real_fetch_foreign_row (SQLHeavyRecord* base, gint field, GError** error);
 
61
static SQLHeavyRow* sql_heavy_row_real_get_foreign_row (SQLHeavyRecord* base, const gchar* field, GError** error);
 
62
SQLHeavyQueryResult* sql_heavy_query_result_new_no_lock (SQLHeavyQuery* query, GError** error);
 
63
SQLHeavyQueryResult* sql_heavy_query_result_construct_no_lock (GType object_type, SQLHeavyQuery* query, GError** error);
 
64
gboolean sql_heavy_value_equal (GValue* a, GValue* b);
 
65
gint sql_heavy_row_direct_compare (SQLHeavyRow* a, SQLHeavyRow* b);
 
66
static GObject * sql_heavy_row_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
 
67
static void _lambda2_ (SQLHeavyRow* self);
 
68
void sql_heavy_database_add_step_unlock_notify_row (SQLHeavyDatabase* self, SQLHeavyRow* row);
 
69
static void __lambda2__sql_heavy_row_changed (SQLHeavyRow* _sender, gpointer self);
 
70
static void _lambda3_ (GParamSpec* pspec, SQLHeavyRow* self);
 
71
static void __lambda3__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 
72
static void sql_heavy_row_finalize (GObject* obj);
 
73
static void _vala_sql_heavy_row_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
74
static void _vala_sql_heavy_row_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
75
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
76
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
77
 
 
78
 
 
79
static void _vala_GValue_free (GValue* self) {
 
80
        g_value_unset (self);
 
81
        g_free (self);
 
82
}
 
83
 
 
84
 
 
85
/**
 
86
     * {@inheritDoc}
 
87
     */
 
88
static const gchar* string_to_string (const gchar* self) {
 
89
        const gchar* result = NULL;
 
90
        g_return_val_if_fail (self != NULL, NULL);
 
91
        result = self;
 
92
        return result;
 
93
}
 
94
 
 
95
 
 
96
static void sql_heavy_row_real_save (SQLHeavyMutableRecord* base, GError** error) {
 
97
        SQLHeavyRow * self;
 
98
        GError * _inner_error_ = NULL;
 
99
        self = (SQLHeavyRow*) base;
 
100
        {
 
101
                gint field;
 
102
                gint _tmp0_;
 
103
                gint field_count;
 
104
                GString* _tmp1_ = NULL;
 
105
                GString* sql;
 
106
                gboolean first_field;
 
107
                SQLHeavyQueryable* _tmp19_ = NULL;
 
108
                SQLHeavyQuery* _tmp20_ = NULL;
 
109
                SQLHeavyQuery* query;
 
110
                g_static_rec_mutex_lock (&self->priv->__lock_values);
 
111
                if (self->priv->values == NULL) {
 
112
                        g_static_rec_mutex_unlock (&self->priv->__lock_values);
 
113
                        return;
 
114
                }
 
115
                field = 0;
 
116
                _tmp0_ = sql_heavy_table_get_field_count (self->priv->_table);
 
117
                field_count = _tmp0_;
 
118
                _tmp1_ = g_string_new ("");
 
119
                sql = _tmp1_;
 
120
                first_field = TRUE;
 
121
                if (self->priv->_id > 0) {
 
122
                        const gchar* _tmp2_ = NULL;
 
123
                        _tmp2_ = sql_heavy_table_get_name (self->priv->_table);
 
124
                        g_string_printf (sql, "UPDATE `%s` SET ", _tmp2_);
 
125
                        {
 
126
                                gboolean _tmp3_;
 
127
                                field = 0;
 
128
                                _tmp3_ = TRUE;
 
129
                                while (TRUE) {
 
130
                                        if (!_tmp3_) {
 
131
                                                field++;
 
132
                                        }
 
133
                                        _tmp3_ = FALSE;
 
134
                                        if (!(field < field_count)) {
 
135
                                                break;
 
136
                                        }
 
137
                                        if (self->priv->values[field] != NULL) {
 
138
                                                gchar* _tmp4_ = NULL;
 
139
                                                gchar* field_name;
 
140
                                                const gchar* _tmp5_ = NULL;
 
141
                                                const gchar* _tmp6_ = NULL;
 
142
                                                gchar* _tmp7_ = NULL;
 
143
                                                gchar* _tmp8_;
 
144
                                                if (!first_field) {
 
145
                                                        g_string_append (sql, ", ");
 
146
                                                }
 
147
                                                _tmp4_ = sql_heavy_table_field_name (self->priv->_table, field, &_inner_error_);
 
148
                                                field_name = _tmp4_;
 
149
                                                if (_inner_error_ != NULL) {
 
150
                                                        _g_string_free0 (sql);
 
151
                                                        goto __finally28;
 
152
                                                }
 
153
                                                _tmp5_ = string_to_string (field_name);
 
154
                                                _tmp6_ = string_to_string (field_name);
 
155
                                                _tmp7_ = g_strconcat ("`", _tmp5_, "` = :", _tmp6_, NULL);
 
156
                                                _tmp8_ = _tmp7_;
 
157
                                                g_string_append (sql, _tmp8_);
 
158
                                                _g_free0 (_tmp8_);
 
159
                                                first_field = FALSE;
 
160
                                                _g_free0 (field_name);
 
161
                                        }
 
162
                                }
 
163
                        }
 
164
                        g_string_append (sql, " WHERE `ROWID` = :ROWID;");
 
165
                } else {
 
166
                        const gchar* _tmp9_ = NULL;
 
167
                        GString* _tmp10_ = NULL;
 
168
                        GString* qvalues;
 
169
                        _tmp9_ = sql_heavy_table_get_name (self->priv->_table);
 
170
                        g_string_printf (sql, "INSERT INTO `%s` (", _tmp9_);
 
171
                        _tmp10_ = g_string_new ("");
 
172
                        qvalues = _tmp10_;
 
173
                        {
 
174
                                gboolean _tmp11_;
 
175
                                field = 0;
 
176
                                _tmp11_ = TRUE;
 
177
                                while (TRUE) {
 
178
                                        if (!_tmp11_) {
 
179
                                                field++;
 
180
                                        }
 
181
                                        _tmp11_ = FALSE;
 
182
                                        if (!(field < field_count)) {
 
183
                                                break;
 
184
                                        }
 
185
                                        if (self->priv->values[field] != NULL) {
 
186
                                                gchar* _tmp12_ = NULL;
 
187
                                                gchar* field_name;
 
188
                                                const gchar* _tmp13_ = NULL;
 
189
                                                gchar* _tmp14_ = NULL;
 
190
                                                gchar* _tmp15_;
 
191
                                                const gchar* _tmp16_ = NULL;
 
192
                                                gchar* _tmp17_ = NULL;
 
193
                                                gchar* _tmp18_;
 
194
                                                if (!first_field) {
 
195
                                                        g_string_append (sql, ", ");
 
196
                                                        g_string_append (qvalues, ", ");
 
197
                                                }
 
198
                                                _tmp12_ = sql_heavy_table_field_name (self->priv->_table, field, &_inner_error_);
 
199
                                                field_name = _tmp12_;
 
200
                                                if (_inner_error_ != NULL) {
 
201
                                                        _g_string_free0 (qvalues);
 
202
                                                        _g_string_free0 (sql);
 
203
                                                        goto __finally28;
 
204
                                                }
 
205
                                                _tmp13_ = string_to_string (field_name);
 
206
                                                _tmp14_ = g_strconcat ("`", _tmp13_, "`", NULL);
 
207
                                                _tmp15_ = _tmp14_;
 
208
                                                g_string_append (sql, _tmp15_);
 
209
                                                _g_free0 (_tmp15_);
 
210
                                                _tmp16_ = string_to_string (field_name);
 
211
                                                _tmp17_ = g_strconcat (":", _tmp16_, NULL);
 
212
                                                _tmp18_ = _tmp17_;
 
213
                                                g_string_append (qvalues, _tmp18_);
 
214
                                                _g_free0 (_tmp18_);
 
215
                                                first_field = FALSE;
 
216
                                                _g_free0 (field_name);
 
217
                                        }
 
218
                                }
 
219
                        }
 
220
                        g_string_append (sql, ") VALUES (");
 
221
                        g_string_append (sql, qvalues->str);
 
222
                        g_string_append (sql, ");");
 
223
                        _g_string_free0 (qvalues);
 
224
                }
 
225
                _tmp19_ = sql_heavy_table_get_queryable (self->priv->_table);
 
226
                _tmp20_ = sql_heavy_query_new (_tmp19_, sql->str, &_inner_error_);
 
227
                query = _tmp20_;
 
228
                if (_inner_error_ != NULL) {
 
229
                        _g_string_free0 (sql);
 
230
                        goto __finally28;
 
231
                }
 
232
                {
 
233
                        gboolean _tmp21_;
 
234
                        field = 0;
 
235
                        _tmp21_ = TRUE;
 
236
                        while (TRUE) {
 
237
                                if (!_tmp21_) {
 
238
                                        field++;
 
239
                                }
 
240
                                _tmp21_ = FALSE;
 
241
                                if (!(field < field_count)) {
 
242
                                        break;
 
243
                                }
 
244
                                if (self->priv->values[field] != NULL) {
 
245
                                        gchar* _tmp22_ = NULL;
 
246
                                        gchar* field_name;
 
247
                                        const gchar* _tmp23_ = NULL;
 
248
                                        gchar* _tmp24_ = NULL;
 
249
                                        gchar* _tmp25_;
 
250
                                        _tmp22_ = sql_heavy_table_field_name (self->priv->_table, field, &_inner_error_);
 
251
                                        field_name = _tmp22_;
 
252
                                        if (_inner_error_ != NULL) {
 
253
                                                _g_object_unref0 (query);
 
254
                                                _g_string_free0 (sql);
 
255
                                                goto __finally28;
 
256
                                        }
 
257
                                        _tmp23_ = string_to_string (field_name);
 
258
                                        _tmp24_ = g_strconcat (":", _tmp23_, NULL);
 
259
                                        _tmp25_ = _tmp24_;
 
260
                                        sql_heavy_query_set (query, _tmp25_, self->priv->values[field], &_inner_error_);
 
261
                                        _g_free0 (_tmp25_);
 
262
                                        if (_inner_error_ != NULL) {
 
263
                                                _g_free0 (field_name);
 
264
                                                _g_object_unref0 (query);
 
265
                                                _g_string_free0 (sql);
 
266
                                                goto __finally28;
 
267
                                        }
 
268
                                        _g_free0 (field_name);
 
269
                                }
 
270
                        }
 
271
                }
 
272
                if (self->priv->_id > 0) {
 
273
                        SQLHeavyQueryResult* _tmp26_ = NULL;
 
274
                        SQLHeavyQueryResult* _tmp27_;
 
275
                        sql_heavy_query_set_int64 (query, ":ROWID", self->priv->_id, &_inner_error_);
 
276
                        if (_inner_error_ != NULL) {
 
277
                                _g_object_unref0 (query);
 
278
                                _g_string_free0 (sql);
 
279
                                goto __finally28;
 
280
                        }
 
281
                        _tmp26_ = sql_heavy_query_execute (query, NULL, &_inner_error_, NULL);
 
282
                        _tmp27_ = _tmp26_;
 
283
                        _g_object_unref0 (_tmp27_);
 
284
                        if (_inner_error_ != NULL) {
 
285
                                _g_object_unref0 (query);
 
286
                                _g_string_free0 (sql);
 
287
                                goto __finally28;
 
288
                        }
 
289
                } else {
 
290
                        gint64 _tmp28_;
 
291
                        gint64 _tmp29_;
 
292
                        _tmp28_ = sql_heavy_query_execute_insert (query, NULL, &_inner_error_, NULL);
 
293
                        _tmp29_ = _tmp28_;
 
294
                        if (_inner_error_ != NULL) {
 
295
                                _g_object_unref0 (query);
 
296
                                _g_string_free0 (sql);
 
297
                                goto __finally28;
 
298
                        }
 
299
                        self->priv->_id = _tmp29_;
 
300
                        sql_heavy_table_register_row (self->priv->_table, self);
 
301
                        sql_heavy_row_update_cache (self, &_inner_error_);
 
302
                        if (_inner_error_ != NULL) {
 
303
                                _g_object_unref0 (query);
 
304
                                _g_string_free0 (sql);
 
305
                                goto __finally28;
 
306
                        }
 
307
                }
 
308
                self->priv->values = (_vala_array_free (self->priv->values, self->priv->values_length1, (GDestroyNotify) _vala_GValue_free), NULL);
 
309
                self->priv->values = NULL;
 
310
                self->priv->values_length1 = 0;
 
311
                self->priv->_values_size_ = 0;
 
312
                _g_object_unref0 (query);
 
313
                _g_string_free0 (sql);
 
314
                __finally28:
 
315
                g_static_rec_mutex_unlock (&self->priv->__lock_values);
 
316
                if (_inner_error_ != NULL) {
 
317
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
318
                                g_propagate_error (error, _inner_error_);
 
319
                                return;
 
320
                        } else {
 
321
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
322
                                g_clear_error (&_inner_error_);
 
323
                                return;
 
324
                        }
 
325
                }
 
326
        }
 
327
}
 
328
 
 
329
 
 
330
/**
 
331
     * {@inheritDoc}
 
332
     */
 
333
static gint sql_heavy_row_real_field_index (SQLHeavyRecord* base, const gchar* field, GError** error) {
 
334
        SQLHeavyRow * self;
 
335
        gint result = 0;
 
336
        gint _tmp0_;
 
337
        gint _tmp1_;
 
338
        GError * _inner_error_ = NULL;
 
339
        self = (SQLHeavyRow*) base;
 
340
        g_return_val_if_fail (field != NULL, 0);
 
341
        _tmp0_ = sql_heavy_table_field_index (self->priv->_table, field, &_inner_error_);
 
342
        _tmp1_ = _tmp0_;
 
343
        if (_inner_error_ != NULL) {
 
344
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
345
                        g_propagate_error (error, _inner_error_);
 
346
                        return 0;
 
347
                } else {
 
348
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
349
                        g_clear_error (&_inner_error_);
 
350
                        return 0;
 
351
                }
 
352
        }
 
353
        result = _tmp1_;
 
354
        return result;
 
355
}
 
356
 
 
357
 
 
358
/**
 
359
     * {@inheritDoc}
 
360
     */
 
361
static gchar* sql_heavy_row_real_field_name (SQLHeavyRecord* base, gint field, GError** error) {
 
362
        SQLHeavyRow * self;
 
363
        gchar* result = NULL;
 
364
        gchar* _tmp0_ = NULL;
 
365
        gchar* _tmp1_;
 
366
        GError * _inner_error_ = NULL;
 
367
        self = (SQLHeavyRow*) base;
 
368
        _tmp0_ = sql_heavy_table_field_name (self->priv->_table, field, &_inner_error_);
 
369
        _tmp1_ = _tmp0_;
 
370
        if (_inner_error_ != NULL) {
 
371
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
372
                        g_propagate_error (error, _inner_error_);
 
373
                        return NULL;
 
374
                } else {
 
375
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
376
                        g_clear_error (&_inner_error_);
 
377
                        return NULL;
 
378
                }
 
379
        }
 
380
        result = _tmp1_;
 
381
        return result;
 
382
}
 
383
 
 
384
 
 
385
/**
 
386
     * {@inheritDoc}
 
387
     */
 
388
static GType sql_heavy_row_real_field_type (SQLHeavyRecord* base, gint field, GError** error) {
 
389
        SQLHeavyRow * self;
 
390
        GType result = 0UL;
 
391
        GValue _tmp0_ = {0};
 
392
        GValue _tmp1_ = {0};
 
393
        GValue _tmp2_;
 
394
        GValue _tmp3_;
 
395
        GType _tmp4_;
 
396
        GType _tmp5_;
 
397
        GError * _inner_error_ = NULL;
 
398
        self = (SQLHeavyRow*) base;
 
399
        sql_heavy_record_fetch ((SQLHeavyRecord*) self, field, &_tmp0_, &_inner_error_);
 
400
        _tmp1_ = _tmp0_;
 
401
        _tmp2_ = _tmp1_;
 
402
        if (_inner_error_ != NULL) {
 
403
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
404
                        g_propagate_error (error, _inner_error_);
 
405
                        return 0UL;
 
406
                } else {
 
407
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
408
                        g_clear_error (&_inner_error_);
 
409
                        return 0UL;
 
410
                }
 
411
        }
 
412
        _tmp3_ = _tmp2_;
 
413
        _tmp4_ = G_VALUE_TYPE (&_tmp3_);
 
414
        _tmp5_ = _tmp4_;
 
415
        G_IS_VALUE (&_tmp3_) ? (g_value_unset (&_tmp3_), NULL) : NULL;
 
416
        result = _tmp5_;
 
417
        return result;
 
418
}
 
419
 
 
420
 
 
421
/**
 
422
     * {@inheritDoc}
 
423
     */
 
424
static GValue* _g_value_dup (GValue* self) {
 
425
        return g_boxed_copy (G_TYPE_VALUE, self);
 
426
}
 
427
 
 
428
 
 
429
static gpointer __g_value_dup0 (gpointer self) {
 
430
        return self ? _g_value_dup (self) : NULL;
 
431
}
 
432
 
 
433
 
 
434
static void sql_heavy_row_real_put (SQLHeavyMutableRecord* base, gint field, GValue* value, GError** error) {
 
435
        SQLHeavyRow * self;
 
436
        gint _tmp0_;
 
437
        gint field_count;
 
438
        gboolean _tmp1_ = FALSE;
 
439
        GError * _inner_error_ = NULL;
 
440
        self = (SQLHeavyRow*) base;
 
441
        _tmp0_ = sql_heavy_table_get_field_count (self->priv->_table);
 
442
        field_count = _tmp0_;
 
443
        if (field < 0) {
 
444
                _tmp1_ = TRUE;
 
445
        } else {
 
446
                _tmp1_ = field >= field_count;
 
447
        }
 
448
        if (_tmp1_) {
 
449
                GError* _tmp2_ = NULL;
 
450
                _tmp2_ = g_error_new (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_RANGE, "Invalid field index (%d)", field);
 
451
                _inner_error_ = _tmp2_;
 
452
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
453
                        g_propagate_error (error, _inner_error_);
 
454
                        return;
 
455
                } else {
 
456
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
457
                        g_clear_error (&_inner_error_);
 
458
                        return;
 
459
                }
 
460
        }
 
461
        {
 
462
                GValue* _tmp4_;
 
463
                GValue* _tmp5_;
 
464
                g_static_rec_mutex_lock (&self->priv->__lock_values);
 
465
                if (self->priv->values == NULL) {
 
466
                        GValue* _tmp3_ = NULL;
 
467
                        _tmp3_ = g_new0 (GValue, field_count);
 
468
                        self->priv->values = (_vala_array_free (self->priv->values, self->priv->values_length1, (GDestroyNotify) _vala_GValue_free), NULL);
 
469
                        self->priv->values = _tmp3_;
 
470
                        self->priv->values_length1 = field_count;
 
471
                        self->priv->_values_size_ = field_count;
 
472
                }
 
473
                _tmp4_ = __g_value_dup0 (value);
 
474
                _tmp5_ = _tmp4_;
 
475
                __vala_GValue_free0 (self->priv->values[field]);
 
476
                self->priv->values[field] = _tmp5_;
 
477
                __finally29:
 
478
                g_static_rec_mutex_unlock (&self->priv->__lock_values);
 
479
                if (_inner_error_ != NULL) {
 
480
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
481
                                g_propagate_error (error, _inner_error_);
 
482
                                return;
 
483
                        } else {
 
484
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
485
                                g_clear_error (&_inner_error_);
 
486
                                return;
 
487
                        }
 
488
                }
 
489
        }
 
490
}
 
491
 
 
492
 
 
493
void sql_heavy_row_on_delete (SQLHeavyRow* self) {
 
494
        g_return_if_fail (self != NULL);
 
495
        self->priv->_id = (gint64) 0;
 
496
        g_signal_emit_by_name (self, "deleted");
 
497
}
 
498
 
 
499
 
 
500
/**
 
501
     * {@inheritDoc}
 
502
     *
 
503
     * @see deleted
 
504
     */
 
505
static void sql_heavy_row_real_delete (SQLHeavyMutableRecord* base, GError** error) {
 
506
        SQLHeavyRow * self;
 
507
        GError * _inner_error_ = NULL;
 
508
        self = (SQLHeavyRow*) base;
 
509
        if (self->priv->_id > 0) {
 
510
                SQLHeavyQueryable* _tmp0_ = NULL;
 
511
                const gchar* _tmp1_ = NULL;
 
512
                const gchar* _tmp2_ = NULL;
 
513
                gchar* _tmp3_ = NULL;
 
514
                gchar* _tmp4_;
 
515
                SQLHeavyQuery* _tmp5_ = NULL;
 
516
                SQLHeavyQuery* _tmp6_;
 
517
                SQLHeavyQuery* query;
 
518
                SQLHeavyQueryResult* _tmp7_ = NULL;
 
519
                SQLHeavyQueryResult* _tmp8_;
 
520
                _tmp0_ = sql_heavy_table_get_queryable (self->priv->_table);
 
521
                _tmp1_ = sql_heavy_table_get_name (self->priv->_table);
 
522
                _tmp2_ = string_to_string (_tmp1_);
 
523
                _tmp3_ = g_strconcat ("DELETE FROM `", _tmp2_, "` WHERE `ROWID` = :id;", NULL);
 
524
                _tmp4_ = _tmp3_;
 
525
                _tmp5_ = sql_heavy_queryable_prepare (_tmp0_, _tmp4_, &_inner_error_);
 
526
                _tmp6_ = _tmp5_;
 
527
                _g_free0 (_tmp4_);
 
528
                query = _tmp6_;
 
529
                if (_inner_error_ != NULL) {
 
530
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
531
                                g_propagate_error (error, _inner_error_);
 
532
                                return;
 
533
                        } else {
 
534
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
535
                                g_clear_error (&_inner_error_);
 
536
                                return;
 
537
                        }
 
538
                }
 
539
                sql_heavy_query_set_int64 (query, ":id", self->priv->_id, &_inner_error_);
 
540
                if (_inner_error_ != NULL) {
 
541
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
542
                                g_propagate_error (error, _inner_error_);
 
543
                                _g_object_unref0 (query);
 
544
                                return;
 
545
                        } else {
 
546
                                _g_object_unref0 (query);
 
547
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
548
                                g_clear_error (&_inner_error_);
 
549
                                return;
 
550
                        }
 
551
                }
 
552
                _tmp7_ = sql_heavy_query_execute (query, NULL, &_inner_error_, NULL);
 
553
                _tmp8_ = _tmp7_;
 
554
                _g_object_unref0 (_tmp8_);
 
555
                if (_inner_error_ != NULL) {
 
556
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
557
                                g_propagate_error (error, _inner_error_);
 
558
                                _g_object_unref0 (query);
 
559
                                return;
 
560
                        } else {
 
561
                                _g_object_unref0 (query);
 
562
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
563
                                g_clear_error (&_inner_error_);
 
564
                                return;
 
565
                        }
 
566
                }
 
567
                _g_object_unref0 (query);
 
568
        }
 
569
}
 
570
 
 
571
 
 
572
/**
 
573
     * {@inheritDoc}
 
574
     */
 
575
static void sql_heavy_row_real_fetch (SQLHeavyRecord* base, gint field, GValue* result, GError** error) {
 
576
        SQLHeavyRow * self;
 
577
        gboolean _tmp0_ = FALSE;
 
578
        gboolean _tmp3_ = FALSE;
 
579
        gchar* _tmp6_ = NULL;
 
580
        gchar* field_name;
 
581
        SQLHeavyQueryable* _tmp8_ = NULL;
 
582
        const gchar* _tmp9_ = NULL;
 
583
        const gchar* _tmp10_ = NULL;
 
584
        const gchar* _tmp11_ = NULL;
 
585
        gchar* _tmp12_ = NULL;
 
586
        gchar* _tmp13_;
 
587
        SQLHeavyQuery* _tmp14_ = NULL;
 
588
        SQLHeavyQuery* _tmp15_;
 
589
        SQLHeavyQuery* query;
 
590
        SQLHeavyQueryResult* _tmp16_ = NULL;
 
591
        SQLHeavyQueryResult* _tmp17_;
 
592
        SQLHeavyQueryResult* _tmp18_;
 
593
        GValue _tmp19_ = {0};
 
594
        GValue _tmp20_ = {0};
 
595
        GValue _tmp21_;
 
596
        GValue _tmp22_;
 
597
        GError * _inner_error_ = NULL;
 
598
        self = (SQLHeavyRow*) base;
 
599
        if (self->priv->values != NULL) {
 
600
                _tmp0_ = self->priv->values[field] != NULL;
 
601
        } else {
 
602
                _tmp0_ = FALSE;
 
603
        }
 
604
        if (_tmp0_) {
 
605
                GValue _tmp1_;
 
606
                GValue _tmp2_ = {0};
 
607
                if (G_IS_VALUE (self->priv->values[field])) {
 
608
                        g_value_init (&_tmp2_, G_VALUE_TYPE (self->priv->values[field]));
 
609
                        g_value_copy (self->priv->values[field], &_tmp2_);
 
610
                } else {
 
611
                        _tmp2_ = *self->priv->values[field];
 
612
                }
 
613
                _tmp1_ = _tmp2_;
 
614
                *result = _tmp1_;
 
615
                return;
 
616
        }
 
617
        if (self->priv->_enable_cache) {
 
618
                _tmp3_ = self->priv->cache[field] != NULL;
 
619
        } else {
 
620
                _tmp3_ = FALSE;
 
621
        }
 
622
        if (_tmp3_) {
 
623
                GValue _tmp4_;
 
624
                GValue _tmp5_ = {0};
 
625
                if (G_IS_VALUE (self->priv->cache[field])) {
 
626
                        g_value_init (&_tmp5_, G_VALUE_TYPE (self->priv->cache[field]));
 
627
                        g_value_copy (self->priv->cache[field], &_tmp5_);
 
628
                } else {
 
629
                        _tmp5_ = *self->priv->cache[field];
 
630
                }
 
631
                _tmp4_ = _tmp5_;
 
632
                *result = _tmp4_;
 
633
                return;
 
634
        }
 
635
        _tmp6_ = sql_heavy_table_field_name (self->priv->_table, field, &_inner_error_);
 
636
        field_name = _tmp6_;
 
637
        if (_inner_error_ != NULL) {
 
638
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
639
                        g_propagate_error (error, _inner_error_);
 
640
                        return;
 
641
                } else {
 
642
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
643
                        g_clear_error (&_inner_error_);
 
644
                        return;
 
645
                }
 
646
        }
 
647
        if (self->priv->_id <= 0) {
 
648
                GError* _tmp7_ = NULL;
 
649
                _tmp7_ = g_error_new (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_MISUSE, "Cannot read field `%s` from row not persisted to database.", field_name);
 
650
                _inner_error_ = _tmp7_;
 
651
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
652
                        g_propagate_error (error, _inner_error_);
 
653
                        _g_free0 (field_name);
 
654
                        return;
 
655
                } else {
 
656
                        _g_free0 (field_name);
 
657
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
658
                        g_clear_error (&_inner_error_);
 
659
                        return;
 
660
                }
 
661
        }
 
662
        _tmp8_ = sql_heavy_table_get_queryable (self->priv->_table);
 
663
        _tmp9_ = string_to_string (field_name);
 
664
        _tmp10_ = sql_heavy_table_get_name (self->priv->_table);
 
665
        _tmp11_ = string_to_string (_tmp10_);
 
666
        _tmp12_ = g_strconcat ("SELECT `", _tmp9_, "` FROM `", _tmp11_, "` WHERE `ROWID` = :id;", NULL);
 
667
        _tmp13_ = _tmp12_;
 
668
        _tmp14_ = sql_heavy_query_new (_tmp8_, _tmp13_, &_inner_error_);
 
669
        _tmp15_ = _tmp14_;
 
670
        _g_free0 (_tmp13_);
 
671
        query = _tmp15_;
 
672
        if (_inner_error_ != NULL) {
 
673
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
674
                        g_propagate_error (error, _inner_error_);
 
675
                        _g_free0 (field_name);
 
676
                        return;
 
677
                } else {
 
678
                        _g_free0 (field_name);
 
679
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
680
                        g_clear_error (&_inner_error_);
 
681
                        return;
 
682
                }
 
683
        }
 
684
        sql_heavy_query_set_int64 (query, ":id", self->priv->_id, &_inner_error_);
 
685
        if (_inner_error_ != NULL) {
 
686
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
687
                        g_propagate_error (error, _inner_error_);
 
688
                        _g_object_unref0 (query);
 
689
                        _g_free0 (field_name);
 
690
                        return;
 
691
                } else {
 
692
                        _g_object_unref0 (query);
 
693
                        _g_free0 (field_name);
 
694
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
695
                        g_clear_error (&_inner_error_);
 
696
                        return;
 
697
                }
 
698
        }
 
699
        _tmp16_ = sql_heavy_query_execute (query, NULL, &_inner_error_, NULL);
 
700
        _tmp17_ = _tmp16_;
 
701
        if (_inner_error_ != NULL) {
 
702
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
703
                        g_propagate_error (error, _inner_error_);
 
704
                        _g_object_unref0 (query);
 
705
                        _g_free0 (field_name);
 
706
                        return;
 
707
                } else {
 
708
                        _g_object_unref0 (query);
 
709
                        _g_free0 (field_name);
 
710
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
711
                        g_clear_error (&_inner_error_);
 
712
                        return;
 
713
                }
 
714
        }
 
715
        _tmp18_ = _tmp17_;
 
716
        sql_heavy_record_fetch ((SQLHeavyRecord*) _tmp18_, 0, &_tmp19_, &_inner_error_);
 
717
        _tmp20_ = _tmp19_;
 
718
        _tmp21_ = _tmp20_;
 
719
        _g_object_unref0 (_tmp18_);
 
720
        _tmp22_ = _tmp21_;
 
721
        if (_inner_error_ != NULL) {
 
722
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
723
                        g_propagate_error (error, _inner_error_);
 
724
                        _g_object_unref0 (query);
 
725
                        _g_free0 (field_name);
 
726
                        return;
 
727
                } else {
 
728
                        _g_object_unref0 (query);
 
729
                        _g_free0 (field_name);
 
730
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
731
                        g_clear_error (&_inner_error_);
 
732
                        return;
 
733
                }
 
734
        }
 
735
        *result = _tmp22_;
 
736
        _g_object_unref0 (query);
 
737
        _g_free0 (field_name);
 
738
        return;
 
739
}
 
740
 
 
741
 
 
742
/**
 
743
     * {@inheritDoc}
 
744
     */
 
745
static SQLHeavyRow* sql_heavy_row_real_fetch_foreign_row (SQLHeavyRecord* base, gint field, GError** error) {
 
746
        SQLHeavyRow * self;
 
747
        SQLHeavyRow* result = NULL;
 
748
        gchar* _tmp0_ = NULL;
 
749
        gchar* _tmp1_;
 
750
        gchar* _tmp2_;
 
751
        SQLHeavyRow* _tmp3_ = NULL;
 
752
        SQLHeavyRow* _tmp4_;
 
753
        SQLHeavyRow* _tmp5_;
 
754
        GError * _inner_error_ = NULL;
 
755
        self = (SQLHeavyRow*) base;
 
756
        _tmp0_ = sql_heavy_record_field_name ((SQLHeavyRecord*) self, field, &_inner_error_);
 
757
        _tmp1_ = _tmp0_;
 
758
        if (_inner_error_ != NULL) {
 
759
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
760
                        g_propagate_error (error, _inner_error_);
 
761
                        return NULL;
 
762
                } else {
 
763
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
764
                        g_clear_error (&_inner_error_);
 
765
                        return NULL;
 
766
                }
 
767
        }
 
768
        _tmp2_ = _tmp1_;
 
769
        _tmp3_ = sql_heavy_record_get_foreign_row ((SQLHeavyRecord*) self, _tmp2_, &_inner_error_);
 
770
        _tmp4_ = _tmp3_;
 
771
        _g_free0 (_tmp2_);
 
772
        _tmp5_ = _tmp4_;
 
773
        if (_inner_error_ != NULL) {
 
774
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
775
                        g_propagate_error (error, _inner_error_);
 
776
                        return NULL;
 
777
                } else {
 
778
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
779
                        g_clear_error (&_inner_error_);
 
780
                        return NULL;
 
781
                }
 
782
        }
 
783
        result = _tmp5_;
 
784
        return result;
 
785
}
 
786
 
 
787
 
 
788
/**
 
789
     * {@inheritDoc}
 
790
     */
 
791
static SQLHeavyRow* sql_heavy_row_real_get_foreign_row (SQLHeavyRecord* base, const gchar* field, GError** error) {
 
792
        SQLHeavyRow * self;
 
793
        SQLHeavyRow* result = NULL;
 
794
        gint _tmp0_;
 
795
        gint foreign_key_idx;
 
796
        SQLHeavyTable* _tmp1_ = NULL;
 
797
        SQLHeavyTable* foreign_table;
 
798
        gint64 _tmp2_;
 
799
        gint64 _tmp3_;
 
800
        SQLHeavyRow* _tmp4_ = NULL;
 
801
        GError * _inner_error_ = NULL;
 
802
        self = (SQLHeavyRow*) base;
 
803
        g_return_val_if_fail (field != NULL, NULL);
 
804
        _tmp0_ = sql_heavy_table_foreign_key_index (self->priv->_table, field, &_inner_error_);
 
805
        foreign_key_idx = _tmp0_;
 
806
        if (_inner_error_ != NULL) {
 
807
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
808
                        g_propagate_error (error, _inner_error_);
 
809
                        return NULL;
 
810
                } else {
 
811
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
812
                        g_clear_error (&_inner_error_);
 
813
                        return NULL;
 
814
                }
 
815
        }
 
816
        _tmp1_ = sql_heavy_table_foreign_key_table (self->priv->_table, foreign_key_idx, &_inner_error_);
 
817
        foreign_table = _tmp1_;
 
818
        if (_inner_error_ != NULL) {
 
819
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
820
                        g_propagate_error (error, _inner_error_);
 
821
                        return NULL;
 
822
                } else {
 
823
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
824
                        g_clear_error (&_inner_error_);
 
825
                        return NULL;
 
826
                }
 
827
        }
 
828
        _tmp2_ = sql_heavy_record_get_int64 ((SQLHeavyRecord*) self, field, &_inner_error_);
 
829
        _tmp3_ = _tmp2_;
 
830
        if (_inner_error_ != NULL) {
 
831
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
832
                        g_propagate_error (error, _inner_error_);
 
833
                        _g_object_unref0 (foreign_table);
 
834
                        return NULL;
 
835
                } else {
 
836
                        _g_object_unref0 (foreign_table);
 
837
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
838
                        g_clear_error (&_inner_error_);
 
839
                        return NULL;
 
840
                }
 
841
        }
 
842
        _tmp4_ = sql_heavy_row_new (foreign_table, _tmp3_);
 
843
        result = _tmp4_;
 
844
        _g_object_unref0 (foreign_table);
 
845
        return result;
 
846
}
 
847
 
 
848
 
 
849
/**
 
850
     * Updates the cache of the row
 
851
     */
 
852
void sql_heavy_row_update_cache (SQLHeavyRow* self, GError** error) {
 
853
        GError * _inner_error_ = NULL;
 
854
        g_return_if_fail (self != NULL);
 
855
        {
 
856
                gint fc = 0;
 
857
                SQLHeavyQueryable* _tmp2_ = NULL;
 
858
                const gchar* _tmp3_ = NULL;
 
859
                const gchar* _tmp4_ = NULL;
 
860
                gchar* _tmp5_ = NULL;
 
861
                gchar* _tmp6_;
 
862
                SQLHeavyQuery* _tmp7_ = NULL;
 
863
                SQLHeavyQuery* _tmp8_;
 
864
                SQLHeavyQuery* query;
 
865
                SQLHeavyQueryResult* _tmp9_ = NULL;
 
866
                SQLHeavyQueryResult* _tmp10_;
 
867
                SQLHeavyQueryResult* _tmp11_;
 
868
                GValueArray* _tmp12_ = NULL;
 
869
                GValueArray* _tmp13_;
 
870
                GValueArray* res;
 
871
                gboolean* _tmp14_ = NULL;
 
872
                gboolean* fields_changed;
 
873
                gint fields_changed_length1;
 
874
                gint _fields_changed_size_;
 
875
                gint f;
 
876
                g_static_rec_mutex_lock (&self->priv->__lock_cache);
 
877
                if (self->priv->_id == 0) {
 
878
                        g_static_rec_mutex_unlock (&self->priv->__lock_cache);
 
879
                        return;
 
880
                }
 
881
                if (!self->priv->_enable_cache) {
 
882
                        self->priv->cache = (_vala_array_free (self->priv->cache, self->priv->cache_length1, (GDestroyNotify) _vala_GValue_free), NULL);
 
883
                        self->priv->cache = NULL;
 
884
                        self->priv->cache_length1 = 0;
 
885
                        self->priv->_cache_size_ = 0;
 
886
                        g_static_rec_mutex_unlock (&self->priv->__lock_cache);
 
887
                        return;
 
888
                } else {
 
889
                        gint _tmp0_;
 
890
                        _tmp0_ = sql_heavy_record_get_field_count ((SQLHeavyRecord*) self);
 
891
                        fc = _tmp0_;
 
892
                        if (self->priv->cache == NULL) {
 
893
                                GValue* _tmp1_ = NULL;
 
894
                                _tmp1_ = g_new0 (GValue, fc);
 
895
                                self->priv->cache = (_vala_array_free (self->priv->cache, self->priv->cache_length1, (GDestroyNotify) _vala_GValue_free), NULL);
 
896
                                self->priv->cache = _tmp1_;
 
897
                                self->priv->cache_length1 = fc;
 
898
                                self->priv->_cache_size_ = fc;
 
899
                        }
 
900
                }
 
901
                _tmp2_ = sql_heavy_table_get_queryable (self->priv->_table);
 
902
                _tmp3_ = sql_heavy_table_get_name (self->priv->_table);
 
903
                _tmp4_ = string_to_string (_tmp3_);
 
904
                _tmp5_ = g_strconcat ("SELECT * FROM `", _tmp4_, "` WHERE `ROWID` = :id;", NULL);
 
905
                _tmp6_ = _tmp5_;
 
906
                _tmp7_ = sql_heavy_query_new (_tmp2_, _tmp6_, &_inner_error_);
 
907
                _tmp8_ = _tmp7_;
 
908
                _g_free0 (_tmp6_);
 
909
                query = _tmp8_;
 
910
                if (_inner_error_ != NULL) {
 
911
                        goto __finally30;
 
912
                }
 
913
                sql_heavy_query_set_int64 (query, ":id", self->priv->_id, &_inner_error_);
 
914
                if (_inner_error_ != NULL) {
 
915
                        _g_object_unref0 (query);
 
916
                        goto __finally30;
 
917
                }
 
918
                _tmp9_ = sql_heavy_query_result_new_no_lock (query, &_inner_error_);
 
919
                _tmp10_ = _tmp9_;
 
920
                if (_inner_error_ != NULL) {
 
921
                        _g_object_unref0 (query);
 
922
                        goto __finally30;
 
923
                }
 
924
                _tmp11_ = _tmp10_;
 
925
                _tmp12_ = sql_heavy_record_fetch_row ((SQLHeavyRecord*) _tmp11_, &_inner_error_);
 
926
                _tmp13_ = _tmp12_;
 
927
                _g_object_unref0 (_tmp11_);
 
928
                res = _tmp13_;
 
929
                if (_inner_error_ != NULL) {
 
930
                        _g_object_unref0 (query);
 
931
                        goto __finally30;
 
932
                }
 
933
                _tmp14_ = g_new0 (gboolean, fc);
 
934
                fields_changed = _tmp14_;
 
935
                fields_changed_length1 = fc;
 
936
                _fields_changed_size_ = fc;
 
937
                f = 0;
 
938
                {
 
939
                        gboolean _tmp15_;
 
940
                        f = 0;
 
941
                        _tmp15_ = TRUE;
 
942
                        while (TRUE) {
 
943
                                gboolean _tmp16_ = FALSE;
 
944
                                if (!_tmp15_) {
 
945
                                        f++;
 
946
                                }
 
947
                                _tmp15_ = FALSE;
 
948
                                if (!(f < fc)) {
 
949
                                        break;
 
950
                                }
 
951
                                if (self->priv->cache[f] == NULL) {
 
952
                                        _tmp16_ = TRUE;
 
953
                                } else {
 
954
                                        GValue _tmp17_;
 
955
                                        gboolean _tmp18_;
 
956
                                        _tmp17_ = res->values[f];
 
957
                                        _tmp18_ = sql_heavy_value_equal (self->priv->cache[f], &_tmp17_);
 
958
                                        _tmp16_ = !_tmp18_;
 
959
                                }
 
960
                                if (_tmp16_) {
 
961
                                        GValue _tmp19_;
 
962
                                        GValue* _tmp20_;
 
963
                                        GValue* _tmp21_;
 
964
                                        fields_changed[f] = self->priv->cache[f] != NULL;
 
965
                                        _tmp19_ = res->values[f];
 
966
                                        _tmp20_ = __g_value_dup0 (&_tmp19_);
 
967
                                        _tmp21_ = _tmp20_;
 
968
                                        __vala_GValue_free0 (self->priv->cache[f]);
 
969
                                        self->priv->cache[f] = _tmp21_;
 
970
                                } else {
 
971
                                        fields_changed[f] = FALSE;
 
972
                                }
 
973
                        }
 
974
                }
 
975
                {
 
976
                        gboolean _tmp22_;
 
977
                        f = 0;
 
978
                        _tmp22_ = TRUE;
 
979
                        while (TRUE) {
 
980
                                if (!_tmp22_) {
 
981
                                        f++;
 
982
                                }
 
983
                                _tmp22_ = FALSE;
 
984
                                if (!(f < fc)) {
 
985
                                        break;
 
986
                                }
 
987
                                if (fields_changed[f]) {
 
988
                                        g_signal_emit_by_name (self, "field-changed", f);
 
989
                                }
 
990
                        }
 
991
                }
 
992
                fields_changed = (g_free (fields_changed), NULL);
 
993
                _g_value_array_free0 (res);
 
994
                _g_object_unref0 (query);
 
995
                __finally30:
 
996
                g_static_rec_mutex_unlock (&self->priv->__lock_cache);
 
997
                if (_inner_error_ != NULL) {
 
998
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
999
                                g_propagate_error (error, _inner_error_);
 
1000
                                return;
 
1001
                        } else {
 
1002
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
1003
                                g_clear_error (&_inner_error_);
 
1004
                                return;
 
1005
                        }
 
1006
                }
 
1007
        }
 
1008
}
 
1009
 
 
1010
 
 
1011
/**
 
1012
     * Compare two rows
 
1013
     *
 
1014
     * @param a the first row
 
1015
     * @param b the second row
 
1016
     * @return less than, equal to, or greater than 0 depending on a's relationship to b
 
1017
     */
 
1018
gint sql_heavy_row_compare (SQLHeavyRow* a, SQLHeavyRow* b) {
 
1019
        gint result = 0;
 
1020
        gint r;
 
1021
        gint _tmp0_;
 
1022
        gint64 _tmp1_;
 
1023
        gint64 _tmp2_;
 
1024
        gint64 _tmp3_;
 
1025
        gint _tmp4_;
 
1026
        r = 0;
 
1027
        if (a == b) {
 
1028
                result = 0;
 
1029
                return result;
 
1030
        }
 
1031
        if (a == NULL) {
 
1032
                result = -1;
 
1033
                return result;
 
1034
        }
 
1035
        if (b == NULL) {
 
1036
                result = 1;
 
1037
                return result;
 
1038
        }
 
1039
        _tmp0_ = sql_heavy_table_compare (a->priv->_table, b->priv->_table);
 
1040
        r = _tmp0_;
 
1041
        if (r != 0) {
 
1042
                result = r;
 
1043
                return result;
 
1044
        }
 
1045
        _tmp1_ = sql_heavy_row_get_id (a);
 
1046
        _tmp2_ = sql_heavy_row_get_id (b);
 
1047
        _tmp3_ = CLAMP (_tmp1_ - _tmp2_, (gint64) G_MININT, (gint64) G_MAXINT);
 
1048
        r = (gint) _tmp3_;
 
1049
        if (r != 0) {
 
1050
                result = r;
 
1051
                return result;
 
1052
        }
 
1053
        _tmp4_ = sql_heavy_row_direct_compare (a, b);
 
1054
        result = _tmp4_;
 
1055
        return result;
 
1056
}
 
1057
 
 
1058
 
 
1059
/**
 
1060
     * Compare row pointers directly
 
1061
     *
 
1062
     * @param a the first row
 
1063
     * @param b the second row
 
1064
     * @return less than, equal to, or greater than 0 depending on a's relationship to b
 
1065
     */
 
1066
gint sql_heavy_row_direct_compare (SQLHeavyRow* a, SQLHeavyRow* b) {
 
1067
        gint result = 0;
 
1068
        result = (gint) (((gulong) a) - ((gulong) b));
 
1069
        return result;
 
1070
}
 
1071
 
 
1072
 
 
1073
/**
 
1074
     * Create or load a row from a table
 
1075
     *
 
1076
     * Note that you must call {@link save} in order for a new row
 
1077
     * to be written to the queryable
 
1078
     *
 
1079
     * @param table the table to load the row from
 
1080
     * @param id row ID, or 0 to create a new row
 
1081
     */
 
1082
SQLHeavyRow* sql_heavy_row_construct (GType object_type, SQLHeavyTable* table, gint64 id) {
 
1083
        SQLHeavyRow * self = NULL;
 
1084
        g_return_val_if_fail (table != NULL, NULL);
 
1085
        self = (SQLHeavyRow*) g_object_new (object_type, "table", table, "id", id, NULL);
 
1086
        return self;
 
1087
}
 
1088
 
 
1089
 
 
1090
SQLHeavyRow* sql_heavy_row_new (SQLHeavyTable* table, gint64 id) {
 
1091
        return sql_heavy_row_construct (SQL_HEAVY_TYPE_ROW, table, id);
 
1092
}
 
1093
 
 
1094
 
 
1095
SQLHeavyTable* sql_heavy_row_get_table (SQLHeavyRow* self) {
 
1096
        SQLHeavyTable* result;
 
1097
        g_return_val_if_fail (self != NULL, NULL);
 
1098
        result = self->priv->_table;
 
1099
        return result;
 
1100
}
 
1101
 
 
1102
 
 
1103
static gpointer _g_object_ref0 (gpointer self) {
 
1104
        return self ? g_object_ref (self) : NULL;
 
1105
}
 
1106
 
 
1107
 
 
1108
static void sql_heavy_row_set_table (SQLHeavyRow* self, SQLHeavyTable* value) {
 
1109
        SQLHeavyTable* _tmp0_;
 
1110
        g_return_if_fail (self != NULL);
 
1111
        _tmp0_ = _g_object_ref0 (value);
 
1112
        _g_object_unref0 (self->priv->_table);
 
1113
        self->priv->_table = _tmp0_;
 
1114
        g_object_notify ((GObject *) self, "table");
 
1115
}
 
1116
 
 
1117
 
 
1118
gboolean sql_heavy_row_get_auto_save (SQLHeavyRow* self) {
 
1119
        gboolean result;
 
1120
        g_return_val_if_fail (self != NULL, FALSE);
 
1121
        result = self->priv->_auto_save;
 
1122
        return result;
 
1123
}
 
1124
 
 
1125
 
 
1126
void sql_heavy_row_set_auto_save (SQLHeavyRow* self, gboolean value) {
 
1127
        g_return_if_fail (self != NULL);
 
1128
        self->priv->_auto_save = value;
 
1129
        g_object_notify ((GObject *) self, "auto-save");
 
1130
}
 
1131
 
 
1132
 
 
1133
gint64 sql_heavy_row_get_id (SQLHeavyRow* self) {
 
1134
        gint64 result;
 
1135
        g_return_val_if_fail (self != NULL, 0LL);
 
1136
        result = self->priv->_id;
 
1137
        return result;
 
1138
}
 
1139
 
 
1140
 
 
1141
static void sql_heavy_row_set_id (SQLHeavyRow* self, gint64 value) {
 
1142
        g_return_if_fail (self != NULL);
 
1143
        self->priv->_id = value;
 
1144
        g_object_notify ((GObject *) self, "id");
 
1145
}
 
1146
 
 
1147
 
 
1148
static gint sql_heavy_row_real_get_field_count (SQLHeavyRecord* base) {
 
1149
        gint result;
 
1150
        SQLHeavyRow* self;
 
1151
        gint _tmp0_;
 
1152
        self = (SQLHeavyRow*) base;
 
1153
        _tmp0_ = sql_heavy_table_get_field_count (self->priv->_table);
 
1154
        result = _tmp0_;
 
1155
        return result;
 
1156
}
 
1157
 
 
1158
 
 
1159
gboolean sql_heavy_row_get_enable_cache (SQLHeavyRow* self) {
 
1160
        gboolean result;
 
1161
        g_return_val_if_fail (self != NULL, FALSE);
 
1162
        result = self->priv->_enable_cache;
 
1163
        return result;
 
1164
}
 
1165
 
 
1166
 
 
1167
void sql_heavy_row_set_enable_cache (SQLHeavyRow* self, gboolean value) {
 
1168
        g_return_if_fail (self != NULL);
 
1169
        self->priv->_enable_cache = value;
 
1170
        g_object_notify ((GObject *) self, "enable-cache");
 
1171
}
 
1172
 
 
1173
 
 
1174
static void _lambda2_ (SQLHeavyRow* self) {
 
1175
        SQLHeavyQueryable* _tmp0_ = NULL;
 
1176
        SQLHeavyDatabase* _tmp1_ = NULL;
 
1177
        SQLHeavyDatabase* _tmp2_;
 
1178
        _tmp0_ = sql_heavy_table_get_queryable (self->priv->_table);
 
1179
        _tmp1_ = sql_heavy_queryable_get_database (_tmp0_);
 
1180
        _tmp2_ = _tmp1_;
 
1181
        sql_heavy_database_add_step_unlock_notify_row (_tmp2_, self);
 
1182
        _g_object_unref0 (_tmp2_);
 
1183
}
 
1184
 
 
1185
 
 
1186
static void __lambda2__sql_heavy_row_changed (SQLHeavyRow* _sender, gpointer self) {
 
1187
        _lambda2_ (self);
 
1188
}
 
1189
 
 
1190
 
 
1191
static void _lambda3_ (GParamSpec* pspec, SQLHeavyRow* self) {
 
1192
        GError * _inner_error_ = NULL;
 
1193
        g_return_if_fail (pspec != NULL);
 
1194
        sql_heavy_row_update_cache (self, &_inner_error_);
 
1195
        if (_inner_error_ != NULL) {
 
1196
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
1197
                        goto __catch32_sql_heavy_error;
 
1198
                }
 
1199
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
1200
                g_clear_error (&_inner_error_);
 
1201
                return;
 
1202
        }
 
1203
        goto __finally32;
 
1204
        __catch32_sql_heavy_error:
 
1205
        {
 
1206
                GError * e;
 
1207
                const gchar* _tmp0_ = NULL;
 
1208
                e = _inner_error_;
 
1209
                _inner_error_ = NULL;
 
1210
                if (self->priv->_enable_cache) {
 
1211
                        _tmp0_ = "enable";
 
1212
                } else {
 
1213
                        _tmp0_ = "disable";
 
1214
                }
 
1215
                g_warning ("sqlheavy-row.vala:336: Unable to %s cache: %s", _tmp0_, e->message);
 
1216
                _g_error_free0 (e);
 
1217
        }
 
1218
        __finally32:
 
1219
        if (_inner_error_ != NULL) {
 
1220
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
1221
                g_clear_error (&_inner_error_);
 
1222
                return;
 
1223
        }
 
1224
}
 
1225
 
 
1226
 
 
1227
static void __lambda3__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
 
1228
        _lambda3_ (pspec, self);
 
1229
}
 
1230
 
 
1231
 
 
1232
static GObject * sql_heavy_row_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
 
1233
        GObject * obj;
 
1234
        GObjectClass * parent_class;
 
1235
        SQLHeavyRow * self;
 
1236
        GError * _inner_error_ = NULL;
 
1237
        parent_class = G_OBJECT_CLASS (sql_heavy_row_parent_class);
 
1238
        obj = parent_class->constructor (type, n_construct_properties, construct_properties);
 
1239
        self = SQL_HEAVY_ROW (obj);
 
1240
        if (self->priv->_id != 0) {
 
1241
                sql_heavy_table_register_row (self->priv->_table, self);
 
1242
        }
 
1243
        if (self->priv->_enable_cache) {
 
1244
                sql_heavy_row_update_cache (self, &_inner_error_);
 
1245
                if (_inner_error_ != NULL) {
 
1246
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
1247
                                goto __catch31_sql_heavy_error;
 
1248
                        }
 
1249
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
1250
                        g_clear_error (&_inner_error_);
 
1251
                }
 
1252
                goto __finally31;
 
1253
                __catch31_sql_heavy_error:
 
1254
                {
 
1255
                        GError * e;
 
1256
                        e = _inner_error_;
 
1257
                        _inner_error_ = NULL;
 
1258
                        g_warning ("sqlheavy-row.vala:324: Unable to initialize cache: %s", e->message);
 
1259
                        _g_error_free0 (e);
 
1260
                }
 
1261
                __finally31:
 
1262
                if (_inner_error_ != NULL) {
 
1263
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
1264
                        g_clear_error (&_inner_error_);
 
1265
                }
 
1266
        }
 
1267
        g_signal_connect_object (self, "changed", (GCallback) __lambda2__sql_heavy_row_changed, self, 0);
 
1268
        g_signal_connect_object ((GObject*) self, "notify::enable-cache", (GCallback) __lambda3__g_object_notify, self, 0);
 
1269
        return obj;
 
1270
}
 
1271
 
 
1272
 
 
1273
static void sql_heavy_row_class_init (SQLHeavyRowClass * klass) {
 
1274
        sql_heavy_row_parent_class = g_type_class_peek_parent (klass);
 
1275
        g_type_class_add_private (klass, sizeof (SQLHeavyRowPrivate));
 
1276
        G_OBJECT_CLASS (klass)->get_property = _vala_sql_heavy_row_get_property;
 
1277
        G_OBJECT_CLASS (klass)->set_property = _vala_sql_heavy_row_set_property;
 
1278
        G_OBJECT_CLASS (klass)->constructor = sql_heavy_row_constructor;
 
1279
        G_OBJECT_CLASS (klass)->finalize = sql_heavy_row_finalize;
 
1280
        /**
 
1281
             * The table that this row is a record of
 
1282
             */
 
1283
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_ROW_TABLE, g_param_spec_object ("table", "table", "table", SQL_HEAVY_TYPE_TABLE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 
1284
        /**
 
1285
             * Whether the row should automatically save itself when destroyed
 
1286
             */
 
1287
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_ROW_AUTO_SAVE, g_param_spec_boolean ("auto-save", "auto-save", "auto-save", TRUE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 
1288
        /**
 
1289
             * The row ID of this row, or 0 if it has not yet been inserted
 
1290
             */
 
1291
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_ROW_ID, g_param_spec_int64 ("id", "id", "id", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 
1292
        /**
 
1293
             * {@inheritDoc}
 
1294
             */
 
1295
        g_object_class_override_property (G_OBJECT_CLASS (klass), SQL_HEAVY_ROW_FIELD_COUNT, "field-count");
 
1296
        /**
 
1297
             * Whether or not to enable caching for this row
 
1298
             *
 
1299
             * Caching is required for field-level change notifications.
 
1300
             */
 
1301
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_ROW_ENABLE_CACHE, g_param_spec_boolean ("enable-cache", "enable-cache", "enable-cache", TRUE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
 
1302
        /**
 
1303
             * One or more field in this row has changed in the database
 
1304
             *
 
1305
             * @see put
 
1306
             */
 
1307
        g_signal_new ("changed", SQL_HEAVY_TYPE_ROW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
1308
        /**
 
1309
             * The row was deleted from the database
 
1310
             *
 
1311
             * @see delete
 
1312
             */
 
1313
        g_signal_new ("deleted", SQL_HEAVY_TYPE_ROW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
1314
        /**
 
1315
             * The specified field changed in the database
 
1316
             *
 
1317
             * @param field the index of the field which was modified
 
1318
             */
 
1319
        g_signal_new ("field_changed", SQL_HEAVY_TYPE_ROW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
 
1320
}
 
1321
 
 
1322
 
 
1323
static void sql_heavy_row_sql_heavy_record_interface_init (SQLHeavyRecordIface * iface) {
 
1324
        sql_heavy_row_sql_heavy_record_parent_iface = g_type_interface_peek_parent (iface);
 
1325
        iface->field_index = (gint (*)(SQLHeavyRecord* ,const gchar* ,GError**)) sql_heavy_row_real_field_index;
 
1326
        iface->field_name = (gchar* (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_row_real_field_name;
 
1327
        iface->field_type = (GType (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_row_real_field_type;
 
1328
        iface->fetch = (GValue (*)(SQLHeavyRecord* ,gint ,GValue* ,GError**)) sql_heavy_row_real_fetch;
 
1329
        iface->fetch_foreign_row = (SQLHeavyRow* (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_row_real_fetch_foreign_row;
 
1330
        iface->get_foreign_row = (SQLHeavyRow* (*)(SQLHeavyRecord* ,const gchar* ,GError**)) sql_heavy_row_real_get_foreign_row;
 
1331
        iface->get_field_count = sql_heavy_row_real_get_field_count;
 
1332
}
 
1333
 
 
1334
 
 
1335
static void sql_heavy_row_sql_heavy_mutable_record_interface_init (SQLHeavyMutableRecordIface * iface) {
 
1336
        sql_heavy_row_sql_heavy_mutable_record_parent_iface = g_type_interface_peek_parent (iface);
 
1337
        iface->save = (void (*)(SQLHeavyMutableRecord* ,GError**)) sql_heavy_row_real_save;
 
1338
        iface->put = (void (*)(SQLHeavyMutableRecord* ,gint ,GValue* ,GError**)) sql_heavy_row_real_put;
 
1339
        iface->delete = (void (*)(SQLHeavyMutableRecord* ,GError**)) sql_heavy_row_real_delete;
 
1340
}
 
1341
 
 
1342
 
 
1343
static void sql_heavy_row_instance_init (SQLHeavyRow * self) {
 
1344
        self->priv = SQL_HEAVY_ROW_GET_PRIVATE (self);
 
1345
        self->priv->_auto_save = TRUE;
 
1346
        self->priv->_id = (gint64) 0;
 
1347
        g_static_rec_mutex_init (&self->priv->__lock_values);
 
1348
        self->priv->values = NULL;
 
1349
        g_static_rec_mutex_init (&self->priv->__lock_cache);
 
1350
        self->priv->cache = NULL;
 
1351
        self->priv->_enable_cache = TRUE;
 
1352
}
 
1353
 
 
1354
 
 
1355
static void sql_heavy_row_finalize (GObject* obj) {
 
1356
        SQLHeavyRow * self;
 
1357
        GError * _inner_error_ = NULL;
 
1358
        self = SQL_HEAVY_ROW (obj);
 
1359
        if (self->priv->_auto_save) {
 
1360
                sql_heavy_mutable_record_save ((SQLHeavyMutableRecord*) self, &_inner_error_);
 
1361
                if (_inner_error_ != NULL) {
 
1362
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
1363
                        g_clear_error (&_inner_error_);
 
1364
                }
 
1365
        }
 
1366
        sql_heavy_table_unregister_row (self->priv->_table, self);
 
1367
        _g_object_unref0 (self->priv->_table);
 
1368
        g_static_rec_mutex_free (&self->priv->__lock_values);
 
1369
        self->priv->values = (_vala_array_free (self->priv->values, self->priv->values_length1, (GDestroyNotify) _vala_GValue_free), NULL);
 
1370
        g_static_rec_mutex_free (&self->priv->__lock_cache);
 
1371
        self->priv->cache = (_vala_array_free (self->priv->cache, self->priv->cache_length1, (GDestroyNotify) _vala_GValue_free), NULL);
 
1372
        G_OBJECT_CLASS (sql_heavy_row_parent_class)->finalize (obj);
 
1373
}
 
1374
 
 
1375
 
 
1376
/**
 
1377
   * A table row
 
1378
   */
 
1379
GType sql_heavy_row_get_type (void) {
 
1380
        static volatile gsize sql_heavy_row_type_id__volatile = 0;
 
1381
        if (g_once_init_enter (&sql_heavy_row_type_id__volatile)) {
 
1382
                static const GTypeInfo g_define_type_info = { sizeof (SQLHeavyRowClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) sql_heavy_row_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SQLHeavyRow), 0, (GInstanceInitFunc) sql_heavy_row_instance_init, NULL };
 
1383
                static const GInterfaceInfo sql_heavy_record_info = { (GInterfaceInitFunc) sql_heavy_row_sql_heavy_record_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 
1384
                static const GInterfaceInfo sql_heavy_mutable_record_info = { (GInterfaceInitFunc) sql_heavy_row_sql_heavy_mutable_record_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 
1385
                GType sql_heavy_row_type_id;
 
1386
                sql_heavy_row_type_id = g_type_register_static (G_TYPE_OBJECT, "SQLHeavyRow", &g_define_type_info, 0);
 
1387
                g_type_add_interface_static (sql_heavy_row_type_id, SQL_HEAVY_TYPE_RECORD, &sql_heavy_record_info);
 
1388
                g_type_add_interface_static (sql_heavy_row_type_id, SQL_HEAVY_TYPE_MUTABLE_RECORD, &sql_heavy_mutable_record_info);
 
1389
                g_once_init_leave (&sql_heavy_row_type_id__volatile, sql_heavy_row_type_id);
 
1390
        }
 
1391
        return sql_heavy_row_type_id__volatile;
 
1392
}
 
1393
 
 
1394
 
 
1395
static void _vala_sql_heavy_row_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
1396
        SQLHeavyRow * self;
 
1397
        self = SQL_HEAVY_ROW (object);
 
1398
        switch (property_id) {
 
1399
                case SQL_HEAVY_ROW_TABLE:
 
1400
                g_value_set_object (value, sql_heavy_row_get_table (self));
 
1401
                break;
 
1402
                case SQL_HEAVY_ROW_AUTO_SAVE:
 
1403
                g_value_set_boolean (value, sql_heavy_row_get_auto_save (self));
 
1404
                break;
 
1405
                case SQL_HEAVY_ROW_ID:
 
1406
                g_value_set_int64 (value, sql_heavy_row_get_id (self));
 
1407
                break;
 
1408
                case SQL_HEAVY_ROW_FIELD_COUNT:
 
1409
                g_value_set_int (value, sql_heavy_record_get_field_count ((SQLHeavyRecord*) self));
 
1410
                break;
 
1411
                case SQL_HEAVY_ROW_ENABLE_CACHE:
 
1412
                g_value_set_boolean (value, sql_heavy_row_get_enable_cache (self));
 
1413
                break;
 
1414
                default:
 
1415
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
1416
                break;
 
1417
        }
 
1418
}
 
1419
 
 
1420
 
 
1421
static void _vala_sql_heavy_row_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
1422
        SQLHeavyRow * self;
 
1423
        self = SQL_HEAVY_ROW (object);
 
1424
        switch (property_id) {
 
1425
                case SQL_HEAVY_ROW_TABLE:
 
1426
                sql_heavy_row_set_table (self, g_value_get_object (value));
 
1427
                break;
 
1428
                case SQL_HEAVY_ROW_AUTO_SAVE:
 
1429
                sql_heavy_row_set_auto_save (self, g_value_get_boolean (value));
 
1430
                break;
 
1431
                case SQL_HEAVY_ROW_ID:
 
1432
                sql_heavy_row_set_id (self, g_value_get_int64 (value));
 
1433
                break;
 
1434
                case SQL_HEAVY_ROW_ENABLE_CACHE:
 
1435
                sql_heavy_row_set_enable_cache (self, g_value_get_boolean (value));
 
1436
                break;
 
1437
                default:
 
1438
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
1439
                break;
 
1440
        }
 
1441
}
 
1442
 
 
1443
 
 
1444
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
1445
        if ((array != NULL) && (destroy_func != NULL)) {
 
1446
                int i;
 
1447
                for (i = 0; i < array_length; i = i + 1) {
 
1448
                        if (((gpointer*) array)[i] != NULL) {
 
1449
                                destroy_func (((gpointer*) array)[i]);
 
1450
                        }
 
1451
                }
 
1452
        }
 
1453
}
 
1454
 
 
1455
 
 
1456
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
1457
        _vala_array_destroy (array, array_length, destroy_func);
 
1458
        g_free (array);
 
1459
}
 
1460
 
 
1461
 
 
1462