← Back to branch summary

~ubuntu-branches/debian/jessie/sqlheavy/jessie

« back to all changes in this revision

Viewing changes to sqlheavy/sqlheavy-record.c

  • Committer: Package Import Robot
  • Author(s): Devid Antonio Filoni
  • Date: 2012-05-17 09:47:17 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120517094717-ue17pqaud5tywjj5
Tags: 0.1.1-1
http://bugs.debian.org/663320
* New upstream release (Closes: #663320).
* Fix debug-package-should-be-priority-extra lintian warning.
* debian/control: switch to vala-0.16 in Build-Depends field.
* debian/libsqlheavy-dev.install, debian/libsqlheavygtk-dev.install:
  install files in vala-0.16 dir.
* Update libsqlheavy0.1-0.symbols.amd64 file.
* debian/rules: update override_dh_makeshlibs target.
* Bump Standards-Version to 3.9.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sqlheavy/sqlheavy-record.c
1
 
/* sqlheavy-record.c generated by valac 0.12.1, the Vala compiler
 
1
/* sqlheavy-record.c generated by valac 0.16.0, the Vala compiler
2
2
 * generated from sqlheavy-record.vala, do not modify */
3
3
 
4
4
 
49
49
     * @see field_names
50
50
     */
51
51
gchar* sql_heavy_record_field_name (SQLHeavyRecord* self, gint field, GError** error) {
 
52
        g_return_val_if_fail (self != NULL, NULL);
52
53
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->field_name (self, field, error);
53
54
}
54
55
 
61
62
     * @see field_name
62
63
     */
63
64
gint sql_heavy_record_field_index (SQLHeavyRecord* self, const gchar* field, GError** error) {
 
65
        g_return_val_if_fail (self != NULL, 0);
64
66
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->field_index (self, field, error);
65
67
}
66
68
 
73
75
     */
74
76
static gchar** sql_heavy_record_real_field_names (SQLHeavyRecord* self, int* result_length1) {
75
77
        gchar** result = NULL;
76
 
        gint _tmp0_;
77
 
        gchar** _tmp1_ = NULL;
78
 
        gchar** fields;
79
 
        gint fields_length1;
80
 
        gint _fields_size_;
81
 
        gchar** _tmp6_;
82
78
        GError * _inner_error_ = NULL;
83
 
        _tmp0_ = sql_heavy_record_get_field_count (self);
84
 
        _tmp1_ = g_new0 (gchar*, _tmp0_ + 1);
85
 
        fields = _tmp1_;
86
 
        fields_length1 = _tmp0_;
87
 
        _fields_size_ = _tmp0_;
88
79
        {
89
 
                gint i;
90
 
                i = 0;
 
80
                gint _tmp0_;
 
81
                gint _tmp1_;
 
82
                gchar** _tmp2_ = NULL;
 
83
                gchar** fields;
 
84
                gint fields_length1;
 
85
                gint _fields_size_;
 
86
                gchar** _tmp14_;
 
87
                gint _tmp14__length1;
 
88
                _tmp0_ = sql_heavy_record_get_field_count (self);
 
89
                _tmp1_ = _tmp0_;
 
90
                _tmp2_ = g_new0 (gchar*, _tmp1_ + 1);
 
91
                fields = _tmp2_;
 
92
                fields_length1 = _tmp1_;
 
93
                _fields_size_ = fields_length1;
91
94
                {
92
 
                        gboolean _tmp2_;
93
 
                        _tmp2_ = TRUE;
94
 
                        while (TRUE) {
95
 
                                gchar* _tmp3_ = NULL;
96
 
                                gchar* _tmp4_;
97
 
                                gchar* _tmp5_;
98
 
                                if (!_tmp2_) {
99
 
                                        i++;
100
 
                                }
101
 
                                _tmp2_ = FALSE;
102
 
                                if (!(i < fields_length1)) {
103
 
                                        break;
104
 
                                }
105
 
                                _tmp3_ = sql_heavy_record_field_name (self, i, &_inner_error_);
106
 
                                _tmp4_ = _tmp3_;
107
 
                                if (_inner_error_ != NULL) {
108
 
                                        fields = (_vala_array_free (fields, fields_length1, (GDestroyNotify) g_free), NULL);
109
 
                                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
110
 
                                                goto __catch27_sql_heavy_error;
111
 
                                        }
112
 
                                        fields = (_vala_array_free (fields, fields_length1, (GDestroyNotify) g_free), NULL);
113
 
                                        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);
114
 
                                        g_clear_error (&_inner_error_);
115
 
                                        return NULL;
116
 
                                }
117
 
                                _tmp5_ = _tmp4_;
118
 
                                _g_free0 (fields[i]);
119
 
                                fields[i] = _tmp5_;
 
95
                        gint i;
 
96
                        i = 0;
 
97
                        {
 
98
                                gboolean _tmp3_;
 
99
                                _tmp3_ = TRUE;
 
100
                                while (TRUE) {
 
101
                                        gboolean _tmp4_;
 
102
                                        gint _tmp6_;
 
103
                                        gchar** _tmp7_;
 
104
                                        gint _tmp7__length1;
 
105
                                        gint _tmp8_;
 
106
                                        gchar* _tmp9_ = NULL;
 
107
                                        gchar* _tmp10_;
 
108
                                        gchar** _tmp11_;
 
109
                                        gint _tmp11__length1;
 
110
                                        gint _tmp12_;
 
111
                                        gchar* _tmp13_;
 
112
                                        _tmp4_ = _tmp3_;
 
113
                                        if (!_tmp4_) {
 
114
                                                gint _tmp5_;
 
115
                                                _tmp5_ = i;
 
116
                                                i = _tmp5_ + 1;
 
117
                                        }
 
118
                                        _tmp3_ = FALSE;
 
119
                                        _tmp6_ = i;
 
120
                                        _tmp7_ = fields;
 
121
                                        _tmp7__length1 = fields_length1;
 
122
                                        if (!(_tmp6_ < _tmp7__length1)) {
 
123
                                                break;
 
124
                                        }
 
125
                                        _tmp8_ = i;
 
126
                                        _tmp9_ = sql_heavy_record_field_name (self, _tmp8_, &_inner_error_);
 
127
                                        _tmp10_ = _tmp9_;
 
128
                                        if (_inner_error_ != NULL) {
 
129
                                                fields = (_vala_array_free (fields, fields_length1, (GDestroyNotify) g_free), NULL);
 
130
                                                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
131
                                                        goto __catch27_sql_heavy_error;
 
132
                                                }
 
133
                                                fields = (_vala_array_free (fields, fields_length1, (GDestroyNotify) g_free), NULL);
 
134
                                                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);
 
135
                                                g_clear_error (&_inner_error_);
 
136
                                                return NULL;
 
137
                                        }
 
138
                                        _tmp11_ = fields;
 
139
                                        _tmp11__length1 = fields_length1;
 
140
                                        _tmp12_ = i;
 
141
                                        _g_free0 (_tmp11_[_tmp12_]);
 
142
                                        _tmp11_[_tmp12_] = _tmp10_;
 
143
                                        _tmp13_ = _tmp11_[_tmp12_];
 
144
                                }
120
145
                        }
121
146
                }
122
 
        }
123
 
        _tmp6_ = fields;
124
 
        if (result_length1) {
125
 
                *result_length1 = fields_length1;
126
 
        }
127
 
        result = _tmp6_;
128
 
        return result;
129
 
        fields = (_vala_array_free (fields, fields_length1, (GDestroyNotify) g_free), NULL);
 
147
                _tmp14_ = fields;
 
148
                _tmp14__length1 = fields_length1;
 
149
                if (result_length1) {
 
150
                        *result_length1 = _tmp14__length1;
 
151
                }
 
152
                result = _tmp14_;
 
153
                return result;
 
154
        }
130
155
        goto __finally27;
131
156
        __catch27_sql_heavy_error:
132
157
        {
133
 
                GError * e;
 
158
                GError* e = NULL;
134
159
                e = _inner_error_;
135
160
                _inner_error_ = NULL;
136
161
                g_assert_not_reached ();
144
169
 
145
170
 
146
171
gchar** sql_heavy_record_field_names (SQLHeavyRecord* self, int* result_length1) {
 
172
        g_return_val_if_fail (self != NULL, NULL);
147
173
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->field_names (self, result_length1);
148
174
}
149
175
 
155
181
     * @return the datatype of the field
156
182
     */
157
183
GType sql_heavy_record_field_type (SQLHeavyRecord* self, gint field, GError** error) {
 
184
        g_return_val_if_fail (self != NULL, 0UL);
158
185
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->field_type (self, field, error);
159
186
}
160
187
 
168
195
     * @see fetch_row
169
196
     */
170
197
void sql_heavy_record_fetch (SQLHeavyRecord* self, gint field, GValue* result, GError** error) {
 
198
        g_return_if_fail (self != NULL);
171
199
        SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch (self, field, result, error);
172
200
}
173
201
 
191
219
 
192
220
static GValue* sql_heavy_record_real_get (SQLHeavyRecord* self, const gchar* field, GError** error) {
193
221
        GValue* result = NULL;
194
 
        gint _tmp0_;
195
 
        gint _tmp1_;
196
 
        GValue _tmp2_ = {0};
 
222
        const gchar* _tmp0_;
 
223
        gint _tmp1_ = 0;
 
224
        gint _tmp2_;
197
225
        GValue _tmp3_ = {0};
198
226
        GValue _tmp4_;
199
227
        GValue _tmp5_;
201
229
        GValue* _tmp7_;
202
230
        GError * _inner_error_ = NULL;
203
231
        g_return_val_if_fail (field != NULL, NULL);
204
 
        _tmp0_ = sql_heavy_record_field_index (self, field, &_inner_error_);
205
 
        _tmp1_ = _tmp0_;
 
232
        _tmp0_ = field;
 
233
        _tmp1_ = sql_heavy_record_field_index (self, _tmp0_, &_inner_error_);
 
234
        _tmp2_ = _tmp1_;
206
235
        if (_inner_error_ != NULL) {
207
236
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
208
237
                        g_propagate_error (error, _inner_error_);
213
242
                        return NULL;
214
243
                }
215
244
        }
216
 
        sql_heavy_record_fetch (self, _tmp1_, &_tmp2_, &_inner_error_);
217
 
        _tmp3_ = _tmp2_;
 
245
        sql_heavy_record_fetch (self, _tmp2_, &_tmp3_, &_inner_error_);
218
246
        _tmp4_ = _tmp3_;
219
247
        if (_inner_error_ != NULL) {
220
248
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
236
264
 
237
265
 
238
266
GValue* sql_heavy_record_get (SQLHeavyRecord* self, const gchar* field, GError** error) {
 
267
        g_return_val_if_fail (self != NULL, NULL);
239
268
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->get (self, field, error);
240
269
}
241
270
 
248
277
     * @see get_foreign_row
249
278
     */
250
279
SQLHeavyRow* sql_heavy_record_fetch_foreign_row (SQLHeavyRecord* self, gint field, GError** error) {
 
280
        g_return_val_if_fail (self != NULL, NULL);
251
281
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch_foreign_row (self, field, error);
252
282
}
253
283
 
261
291
     */
262
292
static SQLHeavyRow* sql_heavy_record_real_get_foreign_row (SQLHeavyRecord* self, const gchar* field, GError** error) {
263
293
        SQLHeavyRow* result = NULL;
264
 
        gint _tmp0_;
265
 
        gint _tmp1_;
266
 
        SQLHeavyRow* _tmp2_ = NULL;
267
 
        SQLHeavyRow* _tmp3_;
 
294
        const gchar* _tmp0_;
 
295
        gint _tmp1_ = 0;
 
296
        gint _tmp2_;
 
297
        SQLHeavyRow* _tmp3_ = NULL;
 
298
        SQLHeavyRow* _tmp4_;
268
299
        GError * _inner_error_ = NULL;
269
300
        g_return_val_if_fail (field != NULL, NULL);
270
 
        _tmp0_ = sql_heavy_record_field_index (self, field, &_inner_error_);
271
 
        _tmp1_ = _tmp0_;
272
 
        if (_inner_error_ != NULL) {
273
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
274
 
                        g_propagate_error (error, _inner_error_);
275
 
                        return NULL;
276
 
                } else {
277
 
                        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);
278
 
                        g_clear_error (&_inner_error_);
279
 
                        return NULL;
280
 
                }
281
 
        }
282
 
        _tmp2_ = sql_heavy_record_fetch_foreign_row (self, _tmp1_, &_inner_error_);
283
 
        _tmp3_ = _tmp2_;
284
 
        if (_inner_error_ != NULL) {
285
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
286
 
                        g_propagate_error (error, _inner_error_);
287
 
                        return NULL;
288
 
                } else {
289
 
                        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);
290
 
                        g_clear_error (&_inner_error_);
291
 
                        return NULL;
292
 
                }
293
 
        }
294
 
        result = _tmp3_;
 
301
        _tmp0_ = field;
 
302
        _tmp1_ = sql_heavy_record_field_index (self, _tmp0_, &_inner_error_);
 
303
        _tmp2_ = _tmp1_;
 
304
        if (_inner_error_ != NULL) {
 
305
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
306
                        g_propagate_error (error, _inner_error_);
 
307
                        return NULL;
 
308
                } else {
 
309
                        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);
 
310
                        g_clear_error (&_inner_error_);
 
311
                        return NULL;
 
312
                }
 
313
        }
 
314
        _tmp3_ = sql_heavy_record_fetch_foreign_row (self, _tmp2_, &_inner_error_);
 
315
        _tmp4_ = _tmp3_;
 
316
        if (_inner_error_ != NULL) {
 
317
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
318
                        g_propagate_error (error, _inner_error_);
 
319
                        return NULL;
 
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 NULL;
 
324
                }
 
325
        }
 
326
        result = _tmp4_;
295
327
        return result;
296
328
}
297
329
 
298
330
 
299
331
SQLHeavyRow* sql_heavy_record_get_foreign_row (SQLHeavyRecord* self, const gchar* field, GError** error) {
 
332
        g_return_val_if_fail (self != NULL, NULL);
300
333
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->get_foreign_row (self, field, error);
301
334
}
302
335
 
310
343
static GValueArray* sql_heavy_record_real_fetch_row (SQLHeavyRecord* self, GError** error) {
311
344
        GValueArray* result = NULL;
312
345
        gint _tmp0_;
 
346
        gint _tmp1_;
313
347
        gint fields;
314
 
        GValueArray* _tmp1_ = NULL;
 
348
        gint _tmp2_;
 
349
        GValueArray* _tmp3_;
315
350
        GValueArray* data;
316
351
        GError * _inner_error_ = NULL;
317
352
        _tmp0_ = sql_heavy_record_get_field_count (self);
318
 
        fields = _tmp0_;
319
 
        _tmp1_ = g_value_array_new ((guint) fields);
320
 
        data = _tmp1_;
 
353
        _tmp1_ = _tmp0_;
 
354
        fields = _tmp1_;
 
355
        _tmp2_ = fields;
 
356
        _tmp3_ = g_value_array_new ((guint) _tmp2_);
 
357
        data = _tmp3_;
321
358
        {
322
359
                gint c;
323
360
                c = 0;
324
361
                {
325
 
                        gboolean _tmp2_;
326
 
                        _tmp2_ = TRUE;
 
362
                        gboolean _tmp4_;
 
363
                        _tmp4_ = TRUE;
327
364
                        while (TRUE) {
328
 
                                GValue _tmp3_ = {0};
329
 
                                GValue _tmp4_ = {0};
330
 
                                GValue _tmp5_;
331
 
                                GValue _tmp6_;
332
 
                                if (!_tmp2_) {
333
 
                                        c++;
 
365
                                gboolean _tmp5_;
 
366
                                gint _tmp7_;
 
367
                                gint _tmp8_;
 
368
                                gint _tmp9_;
 
369
                                GValue _tmp10_ = {0};
 
370
                                GValue _tmp11_;
 
371
                                GValueArray* _tmp12_;
 
372
                                GValue _tmp13_;
 
373
                                _tmp5_ = _tmp4_;
 
374
                                if (!_tmp5_) {
 
375
                                        gint _tmp6_;
 
376
                                        _tmp6_ = c;
 
377
                                        c = _tmp6_ + 1;
334
378
                                }
335
 
                                _tmp2_ = FALSE;
336
 
                                if (!(c < fields)) {
 
379
                                _tmp4_ = FALSE;
 
380
                                _tmp7_ = c;
 
381
                                _tmp8_ = fields;
 
382
                                if (!(_tmp7_ < _tmp8_)) {
337
383
                                        break;
338
384
                                }
339
 
                                sql_heavy_record_fetch (self, c, &_tmp3_, &_inner_error_);
340
 
                                _tmp4_ = _tmp3_;
341
 
                                _tmp5_ = _tmp4_;
 
385
                                _tmp9_ = c;
 
386
                                sql_heavy_record_fetch (self, _tmp9_, &_tmp10_, &_inner_error_);
 
387
                                _tmp11_ = _tmp10_;
342
388
                                if (_inner_error_ != NULL) {
343
389
                                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
344
390
                                                g_propagate_error (error, _inner_error_);
351
397
                                                return NULL;
352
398
                                        }
353
399
                                }
354
 
                                _tmp6_ = _tmp5_;
355
 
                                g_value_array_append (data, &_tmp6_);
356
 
                                G_IS_VALUE (&_tmp6_) ? (g_value_unset (&_tmp6_), NULL) : NULL;
 
400
                                _tmp12_ = data;
 
401
                                _tmp13_ = _tmp11_;
 
402
                                g_value_array_append (_tmp12_, &_tmp13_);
 
403
                                G_IS_VALUE (&_tmp13_) ? (g_value_unset (&_tmp13_), NULL) : NULL;
357
404
                        }
358
405
                }
359
406
        }
363
410
 
364
411
 
365
412
GValueArray* sql_heavy_record_fetch_row (SQLHeavyRecord* self, GError** error) {
 
413
        g_return_val_if_fail (self != NULL, NULL);
366
414
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch_row (self, error);
367
415
}
368
416
 
376
424
     * @see fetch
377
425
     */
378
426
static void sql_heavy_record_real_fetch_with_type (SQLHeavyRecord* self, GType requested_type, gint field, GValue* result, GError** error) {
379
 
        GValue _tmp0_ = {0};
 
427
        gint _tmp0_;
380
428
        GValue _tmp1_ = {0};
381
429
        GValue val;
382
 
        gboolean _tmp2_;
383
 
        GValue _tmp3_ = {0};
 
430
        GType _tmp2_;
 
431
        gboolean _tmp3_ = FALSE;
384
432
        GValue _tmp4_ = {0};
385
433
        GValue transformed_val;
386
 
        gboolean _tmp5_;
387
 
        GType _tmp6_;
 
434
        gboolean _tmp5_ = FALSE;
 
435
        GType _tmp6_ = 0UL;
388
436
        const gchar* _tmp7_ = NULL;
389
 
        const gchar* _tmp8_ = NULL;
390
 
        GError* _tmp9_ = NULL;
 
437
        GType _tmp8_;
 
438
        const gchar* _tmp9_ = NULL;
 
439
        GError* _tmp10_;
391
440
        GError * _inner_error_ = NULL;
392
 
        sql_heavy_record_fetch (self, field, &_tmp0_, &_inner_error_);
393
 
        _tmp1_ = _tmp0_;
 
441
        _tmp0_ = field;
 
442
        sql_heavy_record_fetch (self, _tmp0_, &_tmp1_, &_inner_error_);
394
443
        val = _tmp1_;
395
444
        if (_inner_error_ != NULL) {
396
445
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
402
451
                        return;
403
452
                }
404
453
        }
405
 
        _tmp2_ = G_VALUE_HOLDS (&val, requested_type);
406
 
        if (_tmp2_) {
 
454
        _tmp2_ = requested_type;
 
455
        _tmp3_ = G_VALUE_HOLDS (&val, _tmp2_);
 
456
        if (_tmp3_) {
407
457
                *result = val;
408
458
                return;
409
459
        }
410
 
        g_value_init (&_tmp3_, G_TYPE_STRING);
411
 
        _tmp4_ = _tmp3_;
 
460
        g_value_init (&_tmp4_, G_TYPE_STRING);
412
461
        transformed_val = _tmp4_;
413
462
        _tmp5_ = g_value_transform (&val, &transformed_val);
414
463
        if (_tmp5_) {
418
467
        }
419
468
        _tmp6_ = G_VALUE_TYPE (&val);
420
469
        _tmp7_ = g_type_name (_tmp6_);
421
 
        _tmp8_ = g_type_name (requested_type);
422
 
        _tmp9_ = g_error_new (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_DATA_TYPE, "Unable to transform %s to %s.", _tmp7_, _tmp8_);
423
 
        _inner_error_ = _tmp9_;
 
470
        _tmp8_ = requested_type;
 
471
        _tmp9_ = g_type_name (_tmp8_);
 
472
        _tmp10_ = g_error_new (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_DATA_TYPE, "Unable to transform %s to %s.", _tmp7_, _tmp9_);
 
473
        _inner_error_ = _tmp10_;
424
474
        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
425
475
                g_propagate_error (error, _inner_error_);
426
476
                G_IS_VALUE (&transformed_val) ? (g_value_unset (&transformed_val), NULL) : NULL;
439
489
 
440
490
 
441
491
void sql_heavy_record_fetch_with_type (SQLHeavyRecord* self, GType requested_type, gint field, GValue* result, GError** error) {
 
492
        g_return_if_fail (self != NULL);
442
493
        SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch_with_type (self, requested_type, field, result, error);
443
494
}
444
495
 
453
504
     */
454
505
static gchar* sql_heavy_record_real_fetch_string (SQLHeavyRecord* self, gint field, GError** error) {
455
506
        gchar* result = NULL;
456
 
        GValue _tmp0_ = {0};
 
507
        gint _tmp0_;
457
508
        GValue _tmp1_ = {0};
458
509
        GValue _tmp2_;
459
 
        GValue _tmp3_;
460
 
        const gchar* _tmp4_ = NULL;
461
 
        gchar* _tmp5_;
462
 
        gchar* _tmp6_;
 
510
        const gchar* _tmp3_ = NULL;
 
511
        gchar* _tmp4_;
463
512
        GError * _inner_error_ = NULL;
464
 
        sql_heavy_record_fetch_with_type (self, G_TYPE_STRING, field, &_tmp0_, &_inner_error_);
465
 
        _tmp1_ = _tmp0_;
 
513
        _tmp0_ = field;
 
514
        sql_heavy_record_fetch_with_type (self, G_TYPE_STRING, _tmp0_, &_tmp1_, &_inner_error_);
466
515
        _tmp2_ = _tmp1_;
467
516
        if (_inner_error_ != NULL) {
468
517
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
474
523
                        return NULL;
475
524
                }
476
525
        }
477
 
        _tmp3_ = _tmp2_;
478
 
        _tmp4_ = g_value_get_string (&_tmp3_);
479
 
        _tmp5_ = g_strdup (_tmp4_);
480
 
        _tmp6_ = _tmp5_;
481
 
        G_IS_VALUE (&_tmp3_) ? (g_value_unset (&_tmp3_), NULL) : NULL;
482
 
        result = _tmp6_;
 
526
        _tmp3_ = g_value_get_string (&_tmp2_);
 
527
        _tmp4_ = g_strdup (_tmp3_);
 
528
        result = _tmp4_;
483
529
        return result;
484
530
}
485
531
 
486
532
 
487
533
gchar* sql_heavy_record_fetch_string (SQLHeavyRecord* self, gint field, GError** error) {
 
534
        g_return_val_if_fail (self != NULL, NULL);
488
535
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch_string (self, field, error);
489
536
}
490
537
 
499
546
     */
500
547
static gchar* sql_heavy_record_real_get_string (SQLHeavyRecord* self, const gchar* field, GError** error) {
501
548
        gchar* result = NULL;
502
 
        gint _tmp0_;
503
 
        gint _tmp1_;
504
 
        gchar* _tmp2_ = NULL;
505
 
        gchar* _tmp3_;
 
549
        const gchar* _tmp0_;
 
550
        gint _tmp1_ = 0;
 
551
        gint _tmp2_;
 
552
        gchar* _tmp3_ = NULL;
 
553
        gchar* _tmp4_;
506
554
        GError * _inner_error_ = NULL;
507
555
        g_return_val_if_fail (field != NULL, NULL);
508
 
        _tmp0_ = sql_heavy_record_field_index (self, field, &_inner_error_);
509
 
        _tmp1_ = _tmp0_;
510
 
        if (_inner_error_ != NULL) {
511
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
512
 
                        g_propagate_error (error, _inner_error_);
513
 
                        return NULL;
514
 
                } else {
515
 
                        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);
516
 
                        g_clear_error (&_inner_error_);
517
 
                        return NULL;
518
 
                }
519
 
        }
520
 
        _tmp2_ = sql_heavy_record_fetch_string (self, _tmp1_, &_inner_error_);
521
 
        _tmp3_ = _tmp2_;
522
 
        if (_inner_error_ != NULL) {
523
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
524
 
                        g_propagate_error (error, _inner_error_);
525
 
                        return NULL;
526
 
                } else {
527
 
                        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);
528
 
                        g_clear_error (&_inner_error_);
529
 
                        return NULL;
530
 
                }
531
 
        }
532
 
        result = _tmp3_;
 
556
        _tmp0_ = field;
 
557
        _tmp1_ = sql_heavy_record_field_index (self, _tmp0_, &_inner_error_);
 
558
        _tmp2_ = _tmp1_;
 
559
        if (_inner_error_ != NULL) {
 
560
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
561
                        g_propagate_error (error, _inner_error_);
 
562
                        return NULL;
 
563
                } else {
 
564
                        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);
 
565
                        g_clear_error (&_inner_error_);
 
566
                        return NULL;
 
567
                }
 
568
        }
 
569
        _tmp3_ = sql_heavy_record_fetch_string (self, _tmp2_, &_inner_error_);
 
570
        _tmp4_ = _tmp3_;
 
571
        if (_inner_error_ != NULL) {
 
572
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
573
                        g_propagate_error (error, _inner_error_);
 
574
                        return NULL;
 
575
                } else {
 
576
                        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);
 
577
                        g_clear_error (&_inner_error_);
 
578
                        return NULL;
 
579
                }
 
580
        }
 
581
        result = _tmp4_;
533
582
        return result;
534
583
}
535
584
 
536
585
 
537
586
gchar* sql_heavy_record_get_string (SQLHeavyRecord* self, const gchar* field, GError** error) {
 
587
        g_return_val_if_fail (self != NULL, NULL);
538
588
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->get_string (self, field, error);
539
589
}
540
590
 
549
599
     */
550
600
static gint sql_heavy_record_real_fetch_int (SQLHeavyRecord* self, gint field, GError** error) {
551
601
        gint result = 0;
552
 
        GValue _tmp0_ = {0};
 
602
        gint _tmp0_;
553
603
        GValue _tmp1_ = {0};
554
604
        GValue _tmp2_;
555
 
        GValue _tmp3_;
556
 
        gint _tmp4_;
557
 
        gint _tmp5_;
 
605
        gint _tmp3_ = 0;
558
606
        GError * _inner_error_ = NULL;
559
 
        sql_heavy_record_fetch_with_type (self, G_TYPE_INT, field, &_tmp0_, &_inner_error_);
560
 
        _tmp1_ = _tmp0_;
 
607
        _tmp0_ = field;
 
608
        sql_heavy_record_fetch_with_type (self, G_TYPE_INT, _tmp0_, &_tmp1_, &_inner_error_);
561
609
        _tmp2_ = _tmp1_;
562
610
        if (_inner_error_ != NULL) {
563
611
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
569
617
                        return 0;
570
618
                }
571
619
        }
572
 
        _tmp3_ = _tmp2_;
573
 
        _tmp4_ = g_value_get_int (&_tmp3_);
574
 
        _tmp5_ = _tmp4_;
575
 
        G_IS_VALUE (&_tmp3_) ? (g_value_unset (&_tmp3_), NULL) : NULL;
576
 
        result = _tmp5_;
 
620
        _tmp3_ = g_value_get_int (&_tmp2_);
 
621
        result = _tmp3_;
577
622
        return result;
578
623
}
579
624
 
580
625
 
581
626
gint sql_heavy_record_fetch_int (SQLHeavyRecord* self, gint field, GError** error) {
 
627
        g_return_val_if_fail (self != NULL, 0);
582
628
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch_int (self, field, error);
583
629
}
584
630
 
593
639
     */
594
640
static gint sql_heavy_record_real_get_int (SQLHeavyRecord* self, const gchar* field, GError** error) {
595
641
        gint result = 0;
596
 
        gint _tmp0_;
597
 
        gint _tmp1_;
 
642
        const gchar* _tmp0_;
 
643
        gint _tmp1_ = 0;
598
644
        gint _tmp2_;
599
 
        gint _tmp3_;
 
645
        gint _tmp3_ = 0;
 
646
        gint _tmp4_;
600
647
        GError * _inner_error_ = NULL;
601
648
        g_return_val_if_fail (field != NULL, 0);
602
 
        _tmp0_ = sql_heavy_record_field_index (self, field, &_inner_error_);
603
 
        _tmp1_ = _tmp0_;
604
 
        if (_inner_error_ != NULL) {
605
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
606
 
                        g_propagate_error (error, _inner_error_);
607
 
                        return 0;
608
 
                } else {
609
 
                        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);
610
 
                        g_clear_error (&_inner_error_);
611
 
                        return 0;
612
 
                }
613
 
        }
614
 
        _tmp2_ = sql_heavy_record_fetch_int (self, _tmp1_, &_inner_error_);
615
 
        _tmp3_ = _tmp2_;
616
 
        if (_inner_error_ != NULL) {
617
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
618
 
                        g_propagate_error (error, _inner_error_);
619
 
                        return 0;
620
 
                } else {
621
 
                        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);
622
 
                        g_clear_error (&_inner_error_);
623
 
                        return 0;
624
 
                }
625
 
        }
626
 
        result = _tmp3_;
 
649
        _tmp0_ = field;
 
650
        _tmp1_ = sql_heavy_record_field_index (self, _tmp0_, &_inner_error_);
 
651
        _tmp2_ = _tmp1_;
 
652
        if (_inner_error_ != NULL) {
 
653
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
654
                        g_propagate_error (error, _inner_error_);
 
655
                        return 0;
 
656
                } else {
 
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 0;
 
660
                }
 
661
        }
 
662
        _tmp3_ = sql_heavy_record_fetch_int (self, _tmp2_, &_inner_error_);
 
663
        _tmp4_ = _tmp3_;
 
664
        if (_inner_error_ != NULL) {
 
665
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
666
                        g_propagate_error (error, _inner_error_);
 
667
                        return 0;
 
668
                } else {
 
669
                        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);
 
670
                        g_clear_error (&_inner_error_);
 
671
                        return 0;
 
672
                }
 
673
        }
 
674
        result = _tmp4_;
627
675
        return result;
628
676
}
629
677
 
630
678
 
631
679
gint sql_heavy_record_get_int (SQLHeavyRecord* self, const gchar* field, GError** error) {
 
680
        g_return_val_if_fail (self != NULL, 0);
632
681
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->get_int (self, field, error);
633
682
}
634
683
 
643
692
     */
644
693
static gint64 sql_heavy_record_real_fetch_int64 (SQLHeavyRecord* self, gint field, GError** error) {
645
694
        gint64 result = 0LL;
646
 
        GValue _tmp0_ = {0};
 
695
        gint _tmp0_;
647
696
        GValue _tmp1_ = {0};
648
697
        GValue _tmp2_;
649
 
        GValue _tmp3_;
650
 
        gint64 _tmp4_;
651
 
        gint64 _tmp5_;
 
698
        gint64 _tmp3_ = 0LL;
652
699
        GError * _inner_error_ = NULL;
653
 
        sql_heavy_record_fetch_with_type (self, G_TYPE_INT64, field, &_tmp0_, &_inner_error_);
654
 
        _tmp1_ = _tmp0_;
 
700
        _tmp0_ = field;
 
701
        sql_heavy_record_fetch_with_type (self, G_TYPE_INT64, _tmp0_, &_tmp1_, &_inner_error_);
655
702
        _tmp2_ = _tmp1_;
656
703
        if (_inner_error_ != NULL) {
657
704
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
663
710
                        return 0LL;
664
711
                }
665
712
        }
666
 
        _tmp3_ = _tmp2_;
667
 
        _tmp4_ = g_value_get_int64 (&_tmp3_);
668
 
        _tmp5_ = _tmp4_;
669
 
        G_IS_VALUE (&_tmp3_) ? (g_value_unset (&_tmp3_), NULL) : NULL;
670
 
        result = _tmp5_;
 
713
        _tmp3_ = g_value_get_int64 (&_tmp2_);
 
714
        result = _tmp3_;
671
715
        return result;
672
716
}
673
717
 
674
718
 
675
719
gint64 sql_heavy_record_fetch_int64 (SQLHeavyRecord* self, gint field, GError** error) {
 
720
        g_return_val_if_fail (self != NULL, 0LL);
676
721
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch_int64 (self, field, error);
677
722
}
678
723
 
687
732
     */
688
733
static gint64 sql_heavy_record_real_get_int64 (SQLHeavyRecord* self, const gchar* field, GError** error) {
689
734
        gint64 result = 0LL;
690
 
        gint _tmp0_;
691
 
        gint _tmp1_;
692
 
        gint64 _tmp2_;
693
 
        gint64 _tmp3_;
 
735
        const gchar* _tmp0_;
 
736
        gint _tmp1_ = 0;
 
737
        gint _tmp2_;
 
738
        gint64 _tmp3_ = 0LL;
 
739
        gint64 _tmp4_;
694
740
        GError * _inner_error_ = NULL;
695
741
        g_return_val_if_fail (field != NULL, 0LL);
696
 
        _tmp0_ = sql_heavy_record_field_index (self, field, &_inner_error_);
697
 
        _tmp1_ = _tmp0_;
698
 
        if (_inner_error_ != NULL) {
699
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
700
 
                        g_propagate_error (error, _inner_error_);
701
 
                        return 0LL;
702
 
                } else {
703
 
                        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);
704
 
                        g_clear_error (&_inner_error_);
705
 
                        return 0LL;
706
 
                }
707
 
        }
708
 
        _tmp2_ = sql_heavy_record_fetch_int64 (self, _tmp1_, &_inner_error_);
709
 
        _tmp3_ = _tmp2_;
710
 
        if (_inner_error_ != NULL) {
711
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
712
 
                        g_propagate_error (error, _inner_error_);
713
 
                        return 0LL;
714
 
                } else {
715
 
                        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);
716
 
                        g_clear_error (&_inner_error_);
717
 
                        return 0LL;
718
 
                }
719
 
        }
720
 
        result = _tmp3_;
 
742
        _tmp0_ = field;
 
743
        _tmp1_ = sql_heavy_record_field_index (self, _tmp0_, &_inner_error_);
 
744
        _tmp2_ = _tmp1_;
 
745
        if (_inner_error_ != NULL) {
 
746
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
747
                        g_propagate_error (error, _inner_error_);
 
748
                        return 0LL;
 
749
                } else {
 
750
                        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);
 
751
                        g_clear_error (&_inner_error_);
 
752
                        return 0LL;
 
753
                }
 
754
        }
 
755
        _tmp3_ = sql_heavy_record_fetch_int64 (self, _tmp2_, &_inner_error_);
 
756
        _tmp4_ = _tmp3_;
 
757
        if (_inner_error_ != NULL) {
 
758
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
759
                        g_propagate_error (error, _inner_error_);
 
760
                        return 0LL;
 
761
                } else {
 
762
                        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);
 
763
                        g_clear_error (&_inner_error_);
 
764
                        return 0LL;
 
765
                }
 
766
        }
 
767
        result = _tmp4_;
721
768
        return result;
722
769
}
723
770
 
724
771
 
725
772
gint64 sql_heavy_record_get_int64 (SQLHeavyRecord* self, const gchar* field, GError** error) {
 
773
        g_return_val_if_fail (self != NULL, 0LL);
726
774
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->get_int64 (self, field, error);
727
775
}
728
776
 
737
785
     */
738
786
static gdouble sql_heavy_record_real_fetch_double (SQLHeavyRecord* self, gint field, GError** error) {
739
787
        gdouble result = 0.0;
740
 
        GValue _tmp0_ = {0};
 
788
        gint _tmp0_;
741
789
        GValue _tmp1_ = {0};
742
790
        GValue _tmp2_;
743
 
        GValue _tmp3_;
744
 
        gdouble _tmp4_;
745
 
        gdouble _tmp5_;
 
791
        gdouble _tmp3_ = 0.0;
746
792
        GError * _inner_error_ = NULL;
747
 
        sql_heavy_record_fetch_with_type (self, G_TYPE_DOUBLE, field, &_tmp0_, &_inner_error_);
748
 
        _tmp1_ = _tmp0_;
 
793
        _tmp0_ = field;
 
794
        sql_heavy_record_fetch_with_type (self, G_TYPE_DOUBLE, _tmp0_, &_tmp1_, &_inner_error_);
749
795
        _tmp2_ = _tmp1_;
750
796
        if (_inner_error_ != NULL) {
751
797
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
757
803
                        return 0.0;
758
804
                }
759
805
        }
760
 
        _tmp3_ = _tmp2_;
761
 
        _tmp4_ = g_value_get_double (&_tmp3_);
762
 
        _tmp5_ = _tmp4_;
763
 
        G_IS_VALUE (&_tmp3_) ? (g_value_unset (&_tmp3_), NULL) : NULL;
764
 
        result = _tmp5_;
 
806
        _tmp3_ = g_value_get_double (&_tmp2_);
 
807
        result = _tmp3_;
765
808
        return result;
766
809
}
767
810
 
768
811
 
769
812
gdouble sql_heavy_record_fetch_double (SQLHeavyRecord* self, gint field, GError** error) {
 
813
        g_return_val_if_fail (self != NULL, 0.0);
770
814
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch_double (self, field, error);
771
815
}
772
816
 
781
825
     */
782
826
static gdouble sql_heavy_record_real_get_double (SQLHeavyRecord* self, const gchar* field, GError** error) {
783
827
        gdouble result = 0.0;
784
 
        gint _tmp0_;
785
 
        gint _tmp1_;
786
 
        gdouble _tmp2_;
787
 
        gdouble _tmp3_;
 
828
        const gchar* _tmp0_;
 
829
        gint _tmp1_ = 0;
 
830
        gint _tmp2_;
 
831
        gdouble _tmp3_ = 0.0;
 
832
        gdouble _tmp4_;
788
833
        GError * _inner_error_ = NULL;
789
834
        g_return_val_if_fail (field != NULL, 0.0);
790
 
        _tmp0_ = sql_heavy_record_field_index (self, field, &_inner_error_);
791
 
        _tmp1_ = _tmp0_;
792
 
        if (_inner_error_ != NULL) {
793
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
794
 
                        g_propagate_error (error, _inner_error_);
795
 
                        return 0.0;
796
 
                } else {
797
 
                        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);
798
 
                        g_clear_error (&_inner_error_);
799
 
                        return 0.0;
800
 
                }
801
 
        }
802
 
        _tmp2_ = sql_heavy_record_fetch_double (self, _tmp1_, &_inner_error_);
803
 
        _tmp3_ = _tmp2_;
804
 
        if (_inner_error_ != NULL) {
805
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
806
 
                        g_propagate_error (error, _inner_error_);
807
 
                        return 0.0;
808
 
                } else {
809
 
                        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);
810
 
                        g_clear_error (&_inner_error_);
811
 
                        return 0.0;
812
 
                }
813
 
        }
814
 
        result = _tmp3_;
 
835
        _tmp0_ = field;
 
836
        _tmp1_ = sql_heavy_record_field_index (self, _tmp0_, &_inner_error_);
 
837
        _tmp2_ = _tmp1_;
 
838
        if (_inner_error_ != NULL) {
 
839
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
840
                        g_propagate_error (error, _inner_error_);
 
841
                        return 0.0;
 
842
                } else {
 
843
                        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);
 
844
                        g_clear_error (&_inner_error_);
 
845
                        return 0.0;
 
846
                }
 
847
        }
 
848
        _tmp3_ = sql_heavy_record_fetch_double (self, _tmp2_, &_inner_error_);
 
849
        _tmp4_ = _tmp3_;
 
850
        if (_inner_error_ != NULL) {
 
851
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
852
                        g_propagate_error (error, _inner_error_);
 
853
                        return 0.0;
 
854
                } else {
 
855
                        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);
 
856
                        g_clear_error (&_inner_error_);
 
857
                        return 0.0;
 
858
                }
 
859
        }
 
860
        result = _tmp4_;
815
861
        return result;
816
862
}
817
863
 
818
864
 
819
865
gdouble sql_heavy_record_get_double (SQLHeavyRecord* self, const gchar* field, GError** error) {
 
866
        g_return_val_if_fail (self != NULL, 0.0);
820
867
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->get_double (self, field, error);
821
868
}
822
869
 
836
883
 
837
884
static guint8* sql_heavy_record_real_fetch_blob (SQLHeavyRecord* self, gint field, int* result_length1, GError** error) {
838
885
        guint8* result = NULL;
839
 
        GValue _tmp0_ = {0};
 
886
        gint _tmp0_;
840
887
        GValue _tmp1_ = {0};
841
888
        GValue _tmp2_;
842
 
        GValue _tmp3_;
843
 
        void* _tmp4_ = NULL;
 
889
        void* _tmp3_ = NULL;
 
890
        guint8* _tmp4_;
 
891
        gint _tmp4__length1;
844
892
        guint8* _tmp5_;
 
893
        gint _tmp5__length1;
845
894
        guint8* _tmp6_;
846
 
        guint8* _tmp7_;
847
 
        guint8* _tmp8_;
 
895
        gint _tmp6__length1;
848
896
        GError * _inner_error_ = NULL;
849
 
        sql_heavy_record_fetch_with_type (self, G_TYPE_BYTE_ARRAY, field, &_tmp0_, &_inner_error_);
850
 
        _tmp1_ = _tmp0_;
 
897
        _tmp0_ = field;
 
898
        sql_heavy_record_fetch_with_type (self, G_TYPE_BYTE_ARRAY, _tmp0_, &_tmp1_, &_inner_error_);
851
899
        _tmp2_ = _tmp1_;
852
900
        if (_inner_error_ != NULL) {
853
901
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
859
907
                        return NULL;
860
908
                }
861
909
        }
862
 
        _tmp3_ = _tmp2_;
863
 
        _tmp4_ = g_value_get_boxed (&_tmp3_);
864
 
        _tmp5_ = (_tmp6_ = ((GByteArray*) _tmp4_)->data, (_tmp6_ == NULL) ? ((gpointer) _tmp6_) : _vala_array_dup2 (_tmp6_, (gint) ((GByteArray*) _tmp4_)->len));
865
 
        _tmp7_ = _tmp5_;
866
 
        G_IS_VALUE (&_tmp3_) ? (g_value_unset (&_tmp3_), NULL) : NULL;
867
 
        _tmp8_ = _tmp7_;
 
910
        _tmp3_ = g_value_get_boxed (&_tmp2_);
 
911
        _tmp4_ = ((GByteArray*) _tmp3_)->data;
 
912
        _tmp4__length1 = (gint) ((GByteArray*) _tmp3_)->len;
 
913
        _tmp5_ = (_tmp4_ != NULL) ? _vala_array_dup2 (_tmp4_, _tmp4__length1) : ((gpointer) _tmp4_);
 
914
        _tmp5__length1 = _tmp4__length1;
 
915
        _tmp6_ = _tmp5_;
 
916
        _tmp6__length1 = _tmp5__length1;
868
917
        if (result_length1) {
869
 
                *result_length1 = (gint) ((GByteArray*) _tmp4_)->len;
 
918
                *result_length1 = _tmp6__length1;
870
919
        }
871
 
        result = _tmp8_;
 
920
        result = _tmp6_;
872
921
        return result;
873
922
}
874
923
 
875
924
 
876
925
guint8* sql_heavy_record_fetch_blob (SQLHeavyRecord* self, gint field, int* result_length1, GError** error) {
 
926
        g_return_val_if_fail (self != NULL, NULL);
877
927
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch_blob (self, field, result_length1, error);
878
928
}
879
929
 
888
938
     */
889
939
static guint8* sql_heavy_record_real_get_blob (SQLHeavyRecord* self, const gchar* field, int* result_length1, GError** error) {
890
940
        guint8* result = NULL;
891
 
        gint _tmp0_;
892
 
        gint _tmp1_;
 
941
        const gchar* _tmp0_;
 
942
        gint _tmp1_ = 0;
893
943
        gint _tmp2_;
894
 
        guint8* _tmp3_ = NULL;
895
 
        guint8* _tmp4_;
896
 
        gint _tmp4__length1;
897
 
        gint __tmp4__size_;
 
944
        gint _tmp3_ = 0;
 
945
        guint8* _tmp4_ = NULL;
898
946
        guint8* _tmp5_;
 
947
        gint _tmp5__length1;
 
948
        gint __tmp5__size_;
 
949
        guint8* _tmp6_;
 
950
        gint _tmp6__length1;
899
951
        GError * _inner_error_ = NULL;
900
952
        g_return_val_if_fail (field != NULL, NULL);
901
 
        _tmp0_ = sql_heavy_record_field_index (self, field, &_inner_error_);
902
 
        _tmp1_ = _tmp0_;
903
 
        if (_inner_error_ != NULL) {
904
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
905
 
                        g_propagate_error (error, _inner_error_);
906
 
                        return NULL;
907
 
                } else {
908
 
                        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);
909
 
                        g_clear_error (&_inner_error_);
910
 
                        return NULL;
911
 
                }
912
 
        }
913
 
        _tmp3_ = sql_heavy_record_fetch_blob (self, _tmp1_, &_tmp2_, &_inner_error_);
914
 
        _tmp4_ = _tmp3_;
915
 
        _tmp4__length1 = _tmp2_;
916
 
        __tmp4__size_ = _tmp2_;
917
 
        if (_inner_error_ != NULL) {
918
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
919
 
                        g_propagate_error (error, _inner_error_);
920
 
                        return NULL;
921
 
                } else {
922
 
                        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);
923
 
                        g_clear_error (&_inner_error_);
924
 
                        return NULL;
925
 
                }
926
 
        }
 
953
        _tmp0_ = field;
 
954
        _tmp1_ = sql_heavy_record_field_index (self, _tmp0_, &_inner_error_);
 
955
        _tmp2_ = _tmp1_;
 
956
        if (_inner_error_ != NULL) {
 
957
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
958
                        g_propagate_error (error, _inner_error_);
 
959
                        return NULL;
 
960
                } else {
 
961
                        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);
 
962
                        g_clear_error (&_inner_error_);
 
963
                        return NULL;
 
964
                }
 
965
        }
 
966
        _tmp4_ = sql_heavy_record_fetch_blob (self, _tmp2_, &_tmp3_, &_inner_error_);
927
967
        _tmp5_ = _tmp4_;
 
968
        _tmp5__length1 = _tmp3_;
 
969
        __tmp5__size_ = _tmp5__length1;
 
970
        if (_inner_error_ != NULL) {
 
971
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
972
                        g_propagate_error (error, _inner_error_);
 
973
                        return NULL;
 
974
                } else {
 
975
                        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);
 
976
                        g_clear_error (&_inner_error_);
 
977
                        return NULL;
 
978
                }
 
979
        }
 
980
        _tmp6_ = _tmp5_;
 
981
        _tmp6__length1 = _tmp5__length1;
928
982
        if (result_length1) {
929
 
                *result_length1 = _tmp4__length1;
 
983
                *result_length1 = _tmp6__length1;
930
984
        }
931
 
        result = _tmp5_;
 
985
        result = _tmp6_;
932
986
        return result;
933
987
}
934
988
 
935
989
 
936
990
guint8* sql_heavy_record_get_blob (SQLHeavyRecord* self, const gchar* field, int* result_length1, GError** error) {
 
991
        g_return_val_if_fail (self != NULL, NULL);
937
992
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->get_blob (self, field, result_length1, error);
938
993
}
939
994
 
948
1003
     */
949
1004
static time_t sql_heavy_record_real_fetch_time_t (SQLHeavyRecord* self, gint field, GError** error) {
950
1005
        time_t result = 0;
951
 
        GValue _tmp0_ = {0};
 
1006
        gint _tmp0_;
952
1007
        GValue _tmp1_ = {0};
953
1008
        GValue _tmp2_;
954
 
        GValue _tmp3_;
955
 
        gint64 _tmp4_;
956
 
        time_t _tmp5_;
 
1009
        gint64 _tmp3_ = 0LL;
957
1010
        GError * _inner_error_ = NULL;
958
 
        sql_heavy_record_fetch_with_type (self, G_TYPE_INT64, field, &_tmp0_, &_inner_error_);
959
 
        _tmp1_ = _tmp0_;
 
1011
        _tmp0_ = field;
 
1012
        sql_heavy_record_fetch_with_type (self, G_TYPE_INT64, _tmp0_, &_tmp1_, &_inner_error_);
960
1013
        _tmp2_ = _tmp1_;
961
1014
        if (_inner_error_ != NULL) {
962
1015
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
968
1021
                        return 0;
969
1022
                }
970
1023
        }
971
 
        _tmp3_ = _tmp2_;
972
 
        _tmp4_ = g_value_get_int64 (&_tmp3_);
973
 
        _tmp5_ = (time_t) _tmp4_;
974
 
        G_IS_VALUE (&_tmp3_) ? (g_value_unset (&_tmp3_), NULL) : NULL;
975
 
        result = _tmp5_;
 
1024
        _tmp3_ = g_value_get_int64 (&_tmp2_);
 
1025
        result = (time_t) _tmp3_;
976
1026
        return result;
977
1027
}
978
1028
 
979
1029
 
980
1030
time_t sql_heavy_record_fetch_time_t (SQLHeavyRecord* self, gint field, GError** error) {
 
1031
        g_return_val_if_fail (self != NULL, 0);
981
1032
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->fetch_time_t (self, field, error);
982
1033
}
983
1034
 
992
1043
     */
993
1044
static time_t sql_heavy_record_real_get_time_t (SQLHeavyRecord* self, const gchar* field, GError** error) {
994
1045
        time_t result = 0;
995
 
        gint _tmp0_;
996
 
        gint _tmp1_;
997
 
        time_t _tmp2_;
998
 
        time_t _tmp3_;
 
1046
        const gchar* _tmp0_;
 
1047
        gint _tmp1_ = 0;
 
1048
        gint _tmp2_;
 
1049
        time_t _tmp3_ = 0;
 
1050
        time_t _tmp4_;
999
1051
        GError * _inner_error_ = NULL;
1000
1052
        g_return_val_if_fail (field != NULL, 0);
1001
 
        _tmp0_ = sql_heavy_record_field_index (self, field, &_inner_error_);
1002
 
        _tmp1_ = _tmp0_;
1003
 
        if (_inner_error_ != NULL) {
1004
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1005
 
                        g_propagate_error (error, _inner_error_);
1006
 
                        return 0;
1007
 
                } else {
1008
 
                        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);
1009
 
                        g_clear_error (&_inner_error_);
1010
 
                        return 0;
1011
 
                }
1012
 
        }
1013
 
        _tmp2_ = sql_heavy_record_fetch_time_t (self, _tmp1_, &_inner_error_);
1014
 
        _tmp3_ = _tmp2_;
1015
 
        if (_inner_error_ != NULL) {
1016
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1017
 
                        g_propagate_error (error, _inner_error_);
1018
 
                        return 0;
1019
 
                } else {
1020
 
                        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);
1021
 
                        g_clear_error (&_inner_error_);
1022
 
                        return 0;
1023
 
                }
1024
 
        }
1025
 
        result = _tmp3_;
 
1053
        _tmp0_ = field;
 
1054
        _tmp1_ = sql_heavy_record_field_index (self, _tmp0_, &_inner_error_);
 
1055
        _tmp2_ = _tmp1_;
 
1056
        if (_inner_error_ != NULL) {
 
1057
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
1058
                        g_propagate_error (error, _inner_error_);
 
1059
                        return 0;
 
1060
                } else {
 
1061
                        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);
 
1062
                        g_clear_error (&_inner_error_);
 
1063
                        return 0;
 
1064
                }
 
1065
        }
 
1066
        _tmp3_ = sql_heavy_record_fetch_time_t (self, _tmp2_, &_inner_error_);
 
1067
        _tmp4_ = _tmp3_;
 
1068
        if (_inner_error_ != NULL) {
 
1069
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
1070
                        g_propagate_error (error, _inner_error_);
 
1071
                        return 0;
 
1072
                } else {
 
1073
                        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);
 
1074
                        g_clear_error (&_inner_error_);
 
1075
                        return 0;
 
1076
                }
 
1077
        }
 
1078
        result = _tmp4_;
1026
1079
        return result;
1027
1080
}
1028
1081
 
1029
1082
 
1030
1083
time_t sql_heavy_record_get_time_t (SQLHeavyRecord* self, const gchar* field, GError** error) {
 
1084
        g_return_val_if_fail (self != NULL, 0);
1031
1085
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->get_time_t (self, field, error);
1032
1086
}
1033
1087
 
1034
1088
 
1035
1089
gint sql_heavy_record_get_field_count (SQLHeavyRecord* self) {
 
1090
        g_return_val_if_fail (self != NULL, 0);
1036
1091
        return SQL_HEAVY_RECORD_GET_INTERFACE (self)->get_field_count (self);
1037
1092
}
1038
1093