« back to all changes in this revision
Viewing changes to sqlheavy/sqlheavy-query-result.c
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- 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
* 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.
* 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.
- files added:
- m4/introspection.m4
- files removed:
- sqlheavy/sqlheavy-version.vala.in
- files modified:
- ChangeLog
added
removed
sqlheavy/sqlheavy-query-result.c
1
/* sqlheavy-query-result.c generated by valac 0.12.1, the Vala compiler
1
/* sqlheavy-query-result.c generated by valac 0.16.0, the Vala compiler
2
2
* generated from sqlheavy-query-result.vala, do not modify */
3
3
4
4
45
45
GCancellable* cancellable;
46
46
gboolean result;
47
47
gint64 insert_id;
48
gint64 _tmp0_;
49
gboolean _tmp1_;
48
GCancellable* _tmp0_;
49
gint64 _tmp1_;
50
50
gboolean _tmp2_;
51
gboolean _tmp3_;
51
52
GError * _inner_error_;
52
53
};
53
54
81
82
gint64 last_insert_id;
82
83
gboolean result;
83
84
Block2Data* _data2_;
84
SQLHeavyQueryable* _tmp0_;
85
SQLHeavyQueryable* _tmp1_;
86
SQLHeavyDatabase* _tmp2_;
87
GMainContext* _tmp3_;
88
GSource* _tmp4_;
89
gulong _tmp5_;
90
GError * e;
91
GError* _tmp6_;
92
GError* _tmp7_;
85
GCancellable* _tmp0_;
86
GCancellable* _tmp1_;
87
gint _tmp2_;
88
SQLHeavyQuery* _tmp3_;
89
SQLHeavyQueryable* _tmp4_;
90
SQLHeavyQueryable* _tmp5_;
91
SQLHeavyQueryable* _tmp6_;
92
SQLHeavyQueryable* _tmp7_;
93
SQLHeavyDatabase* _tmp8_;
94
SQLHeavyDatabase* _tmp9_;
95
GMainContext* _tmp10_;
96
GSource* _tmp11_;
97
GSource* _tmp12_;
98
GCancellable* _tmp13_;
99
GCancellable* _tmp14_;
100
gulong _tmp15_;
101
GError* e;
102
GError* _tmp16_;
103
const gchar* _tmp17_;
104
GError* _tmp18_;
105
gint _tmp19_;
106
GError* _tmp20_;
107
GError* _tmp21_;
108
GError* _tmp22_;
109
GError* _tmp23_;
110
gint64 _tmp24_;
111
gboolean _tmp25_;
93
112
GError * _inner_error_;
94
113
};
95
114
101
120
SQLHeavyQueryResult* self;
102
121
GCancellable* cancellable;
103
122
gint64 insert_id;
104
gint64 _tmp0_;
123
GCancellable* _tmp0_;
124
gint64 _tmp1_;
105
125
GError * _inner_error_;
106
126
};
107
127
133
153
void sql_heavy_database_step_unlock (SQLHeavyDatabase* self);
134
154
static gboolean sql_heavy_query_result_real_next (SQLHeavyRecordSet* base, GError** error);
135
155
static void sql_heavy_query_result_next_async_data_free (gpointer _data);
136
static gboolean sql_heavy_query_result_next_async_co (SqlHeavyQueryResultNextAsyncData* data);
156
static gboolean sql_heavy_query_result_next_async_co (SqlHeavyQueryResultNextAsyncData* _data_);
137
157
void sql_heavy_query_result_next_internal_async (SQLHeavyQueryResult* self, GCancellable* cancellable, gint steps, GAsyncReadyCallback _callback_, gpointer _user_data_);
138
158
gboolean sql_heavy_query_result_next_internal_finish (SQLHeavyQueryResult* self, GAsyncResult* _res_, gint64* last_insert_id, GError** error);
139
159
static void sql_heavy_query_result_next_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
140
160
static void sql_heavy_query_result_next_internal_async_data_free (gpointer _data);
141
static gboolean sql_heavy_query_result_next_internal_async_co (SqlHeavyQueryResultNextInternalAsyncData* data);
161
static gboolean sql_heavy_query_result_next_internal_async_co (SqlHeavyQueryResultNextInternalAsyncData* _data_);
142
162
static Block2Data* block2_data_ref (Block2Data* _data2_);
143
static void block2_data_unref (Block2Data* _data2_);
163
static void block2_data_unref (void * _userdata_);
144
164
static gboolean _sql_heavy_query_result_next_internal_async_co_gsource_func (gpointer self);
145
static void _lambda4_ (Block2Data* _data2_);
165
static void ___lambda6_ (Block2Data* _data2_);
146
166
const gchar* sql_heavy_sqlite_errstr (gint ec);
147
static void __lambda4__g_cancellable_cancelled (GCancellable* _sender, gpointer self);
148
static void* _lambda5_ (Block2Data* _data2_);
149
static gpointer __lambda5__gthread_func (gpointer self);
167
static void ____lambda6__g_cancellable_cancelled (GCancellable* _sender, gpointer self);
168
static void* ___lambda7_ (Block2Data* _data2_);
169
static gpointer ____lambda7__gthread_func (gpointer self);
150
170
static void sql_heavy_query_result_complete_async_data_free (gpointer _data);
151
static gboolean sql_heavy_query_result_complete_async_co (SqlHeavyQueryResultCompleteAsyncData* data);
171
static gboolean sql_heavy_query_result_complete_async_co (SqlHeavyQueryResultCompleteAsyncData* _data_);
152
172
static void sql_heavy_query_result_complete_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
153
173
static gint sql_heavy_query_result_field_check_index (SQLHeavyQueryResult* self, gint field, GError** error);
154
174
static gchar* sql_heavy_query_result_real_field_name (SQLHeavyRecord* base, gint field, GError** error);
191
211
*/
192
212
gboolean sql_heavy_query_result_next_internal (SQLHeavyQueryResult* self, GError** error) {
193
213
gboolean result = FALSE;
214
sqlite3_stmt* _tmp0_;
194
215
sqlite3_stmt* stmt;
195
gint _tmp0_;
216
gboolean _tmp1_;
217
GTimer* _tmp2_;
218
sqlite3_stmt* _tmp3_;
219
gint _tmp4_ = 0;
220
GTimer* _tmp5_;
221
gint _tmp6_;
196
222
GError * _inner_error_ = NULL;
197
223
g_return_val_if_fail (self != NULL, FALSE);
198
stmt = self->priv->stmt;
199
if (self->priv->_finished) {
224
_tmp0_ = self->priv->stmt;
225
stmt = _tmp0_;
226
_tmp1_ = self->priv->_finished;
227
if (_tmp1_) {
200
228
result = FALSE;
201
229
return result;
202
230
}
203
g_timer_continue (self->priv->execution_timer);
204
_tmp0_ = sqlite3_step (stmt);
205
self->priv->error_code = _tmp0_;
206
g_timer_stop (self->priv->execution_timer);
207
switch (self->priv->error_code) {
231
_tmp2_ = self->priv->execution_timer;
232
g_timer_continue (_tmp2_);
233
_tmp3_ = stmt;
234
_tmp4_ = sqlite3_step (_tmp3_);
235
self->priv->error_code = _tmp4_;
236
_tmp5_ = self->priv->execution_timer;
237
g_timer_stop (_tmp5_);
238
_tmp6_ = self->priv->error_code;
239
switch (_tmp6_) {
208
240
case SQLITE_ROW:
209
241
{
210
242
self->priv->error_code = SQLITE_OK;
221
253
}
222
254
default:
223
255
{
224
SQLHeavyQueryable* _tmp1_ = NULL;
225
_tmp1_ = sql_heavy_query_get_queryable (self->priv->_query);
226
sql_heavy_error_if_not_ok (self->priv->error_code, _tmp1_, &_inner_error_);
256
gint _tmp7_;
257
SQLHeavyQuery* _tmp8_;
258
SQLHeavyQueryable* _tmp9_;
259
SQLHeavyQueryable* _tmp10_;
260
_tmp7_ = self->priv->error_code;
261
_tmp8_ = self->priv->_query;
262
_tmp9_ = sql_heavy_query_get_queryable (_tmp8_);
263
_tmp10_ = _tmp9_;
264
sql_heavy_error_if_not_ok (_tmp7_, _tmp10_, &_inner_error_);
227
265
if (_inner_error_ != NULL) {
228
266
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
229
267
g_propagate_error (error, _inner_error_);
247
285
* @param database the relevant {@link Database}
248
286
*/
249
287
static void sql_heavy_query_result_acquire_locks (SQLHeavyQueryResult* self, SQLHeavyQueryable* queryable, SQLHeavyDatabase* database) {
288
SQLHeavyQueryable* _tmp0_;
289
SQLHeavyDatabase* _tmp1_;
250
290
g_return_if_fail (self != NULL);
251
291
g_return_if_fail (queryable != NULL);
252
292
g_return_if_fail (database != NULL);
253
sql_heavy_queryable_lock (queryable);
254
sql_heavy_database_step_lock (database);
293
_tmp0_ = queryable;
294
sql_heavy_queryable_lock (_tmp0_);
295
_tmp1_ = database;
296
sql_heavy_database_step_lock (_tmp1_);
255
297
}
256
298
257
299
262
304
* @param database the relevant {@link Database}
263
305
*/
264
306
static void sql_heavy_query_result_release_locks (SQLHeavyQueryResult* self, SQLHeavyQueryable* queryable, SQLHeavyDatabase* database) {
307
SQLHeavyDatabase* _tmp0_;
308
SQLHeavyQueryable* _tmp1_;
265
309
g_return_if_fail (self != NULL);
266
310
g_return_if_fail (queryable != NULL);
267
311
g_return_if_fail (database != NULL);
268
sql_heavy_database_step_unlock (database);
269
sql_heavy_queryable_unlock (queryable);
312
_tmp0_ = database;
313
sql_heavy_database_step_unlock (_tmp0_);
314
_tmp1_ = queryable;
315
sql_heavy_queryable_unlock (_tmp1_);
270
316
}
271
317
272
318
280
326
static gboolean sql_heavy_query_result_real_next (SQLHeavyRecordSet* base, GError** error) {
281
327
SQLHeavyQueryResult * self;
282
328
gboolean result = FALSE;
283
SQLHeavyQueryable* _tmp0_ = NULL;
329
SQLHeavyQuery* _tmp0_;
330
SQLHeavyQueryable* _tmp1_;
331
SQLHeavyQueryable* _tmp2_;
284
332
SQLHeavyQueryable* queryable;
285
SQLHeavyDatabase* _tmp1_ = NULL;
333
SQLHeavyDatabase* _tmp3_;
334
SQLHeavyDatabase* _tmp4_;
286
335
SQLHeavyDatabase* db;
287
gboolean _tmp2_;
336
gboolean _tmp5_ = FALSE;
288
337
gboolean res;
289
338
GError * _inner_error_ = NULL;
290
339
self = (SQLHeavyQueryResult*) base;
291
_tmp0_ = sql_heavy_query_get_queryable (self->priv->_query);
292
queryable = _tmp0_;
293
_tmp1_ = sql_heavy_queryable_get_database (queryable);
294
db = _tmp1_;
340
_tmp0_ = self->priv->_query;
341
_tmp1_ = sql_heavy_query_get_queryable (_tmp0_);
342
_tmp2_ = _tmp1_;
343
queryable = _tmp2_;
344
_tmp3_ = sql_heavy_queryable_get_database (queryable);
345
_tmp4_ = _tmp3_;
346
db = _tmp4_;
295
347
sql_heavy_query_result_acquire_locks (self, queryable, db);
296
_tmp2_ = sql_heavy_query_result_next_internal (self, &_inner_error_);
297
res = _tmp2_;
348
_tmp5_ = sql_heavy_query_result_next_internal (self, &_inner_error_);
349
res = _tmp5_;
298
350
if (_inner_error_ != NULL) {
299
351
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
300
352
g_propagate_error (error, _inner_error_);
315
367
316
368
317
369
static void sql_heavy_query_result_next_async_data_free (gpointer _data) {
318
SqlHeavyQueryResultNextAsyncData* data;
319
data = _data;
320
_g_object_unref0 (data->cancellable);
321
_g_object_unref0 (data->self);
322
g_slice_free (SqlHeavyQueryResultNextAsyncData, data);
370
SqlHeavyQueryResultNextAsyncData* _data_;
371
_data_ = _data;
372
_g_object_unref0 (_data_->cancellable);
373
_g_object_unref0 (_data_->self);
374
g_slice_free (SqlHeavyQueryResultNextAsyncData, _data_);
323
375
}
324
376
325
377
330
382
331
383
void sql_heavy_query_result_next_async (SQLHeavyQueryResult* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
332
384
SqlHeavyQueryResultNextAsyncData* _data_;
385
SQLHeavyQueryResult* _tmp0_;
386
GCancellable* _tmp1_;
387
GCancellable* _tmp2_;
333
388
_data_ = g_slice_new0 (SqlHeavyQueryResultNextAsyncData);
334
389
_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, sql_heavy_query_result_next_async);
335
390
g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, sql_heavy_query_result_next_async_data_free);
336
_data_->self = _g_object_ref0 (self);
337
_data_->cancellable = _g_object_ref0 (cancellable);
391
_tmp0_ = _g_object_ref0 (self);
392
_data_->self = _tmp0_;
393
_tmp1_ = cancellable;
394
_tmp2_ = _g_object_ref0 (_tmp1_);
395
_data_->cancellable = _tmp2_;
338
396
sql_heavy_query_result_next_async_co (_data_);
339
397
}
340
398
359
417
* @see next
360
418
*/
361
419
static void sql_heavy_query_result_next_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
362
SqlHeavyQueryResultNextAsyncData* data;
363
data = _user_data_;
364
data->_source_object_ = source_object;
365
data->_res_ = _res_;
366
sql_heavy_query_result_next_async_co (data);
420
SqlHeavyQueryResultNextAsyncData* _data_;
421
_data_ = _user_data_;
422
_data_->_source_object_ = source_object;
423
_data_->_res_ = _res_;
424
sql_heavy_query_result_next_async_co (_data_);
367
425
}
368
426
369
427
370
static gboolean sql_heavy_query_result_next_async_co (SqlHeavyQueryResultNextAsyncData* data) {
371
switch (data->_state_) {
428
static gboolean sql_heavy_query_result_next_async_co (SqlHeavyQueryResultNextAsyncData* _data_) {
429
switch (_data_->_state_) {
372
430
case 0:
373
431
goto _state_0;
374
432
case 1:
377
435
g_assert_not_reached ();
378
436
}
379
437
_state_0:
380
data->insert_id = (gint64) 0;
381
data->_state_ = 1;
382
sql_heavy_query_result_next_internal_async (data->self, data->cancellable, 1, sql_heavy_query_result_next_async_ready, data);
438
_data_->insert_id = (gint64) 0;
439
_data_->_tmp0_ = _data_->cancellable;
440
_data_->_tmp1_ = 0LL;
441
_data_->_state_ = 1;
442
sql_heavy_query_result_next_internal_async (_data_->self, _data_->_tmp0_, 1, sql_heavy_query_result_next_async_ready, _data_);
383
443
return FALSE;
384
444
_state_1:
385
data->_tmp1_ = sql_heavy_query_result_next_internal_finish (data->self, data->_res_, &data->_tmp0_, &data->_inner_error_);
386
data->insert_id = data->_tmp0_;
387
data->_tmp2_ = data->_tmp1_;
388
if (data->_inner_error_ != NULL) {
389
if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
390
g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
391
g_error_free (data->_inner_error_);
392
if (data->_state_ == 0) {
393
g_simple_async_result_complete_in_idle (data->_async_result);
445
_data_->_tmp2_ = FALSE;
446
_data_->_tmp2_ = sql_heavy_query_result_next_internal_finish (_data_->self, _data_->_res_, &_data_->_tmp1_, &_data_->_inner_error_);
447
_data_->insert_id = _data_->_tmp1_;
448
_data_->_tmp3_ = _data_->_tmp2_;
449
if (_data_->_inner_error_ != NULL) {
450
if (_data_->_inner_error_->domain == SQL_HEAVY_ERROR) {
451
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
452
g_error_free (_data_->_inner_error_);
453
if (_data_->_state_ == 0) {
454
g_simple_async_result_complete_in_idle (_data_->_async_result);
394
455
} else {
395
g_simple_async_result_complete (data->_async_result);
456
g_simple_async_result_complete (_data_->_async_result);
396
457
}
397
g_object_unref (data->_async_result);
458
g_object_unref (_data_->_async_result);
398
459
return FALSE;
399
460
} else {
400
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
401
g_clear_error (&data->_inner_error_);
461
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
462
g_clear_error (&_data_->_inner_error_);
402
463
return FALSE;
403
464
}
404
465
}
405
data->result = data->_tmp2_;
406
if (data->_state_ == 0) {
407
g_simple_async_result_complete_in_idle (data->_async_result);
466
_data_->result = _data_->_tmp3_;
467
if (_data_->_state_ == 0) {
468
g_simple_async_result_complete_in_idle (_data_->_async_result);
408
469
} else {
409
g_simple_async_result_complete (data->_async_result);
470
g_simple_async_result_complete (_data_->_async_result);
410
471
}
411
g_object_unref (data->_async_result);
472
g_object_unref (_data_->_async_result);
412
473
return FALSE;
413
if (data->_state_ == 0) {
414
g_simple_async_result_complete_in_idle (data->_async_result);
474
if (_data_->_state_ == 0) {
475
g_simple_async_result_complete_in_idle (_data_->_async_result);
415
476
} else {
416
g_simple_async_result_complete (data->_async_result);
477
g_simple_async_result_complete (_data_->_async_result);
417
478
}
418
g_object_unref (data->_async_result);
479
g_object_unref (_data_->_async_result);
419
480
return FALSE;
420
481
}
421
482
422
483
423
484
static void sql_heavy_query_result_next_internal_async_data_free (gpointer _data) {
424
SqlHeavyQueryResultNextInternalAsyncData* data;
425
data = _data;
426
_g_object_unref0 (data->cancellable);
427
_g_object_unref0 (data->self);
428
g_slice_free (SqlHeavyQueryResultNextInternalAsyncData, data);
485
SqlHeavyQueryResultNextInternalAsyncData* _data_;
486
_data_ = _data;
487
_g_object_unref0 (_data_->cancellable);
488
_g_object_unref0 (_data_->self);
489
g_slice_free (SqlHeavyQueryResultNextInternalAsyncData, _data_);
429
490
}
430
491
431
492
432
493
void sql_heavy_query_result_next_internal_async (SQLHeavyQueryResult* self, GCancellable* cancellable, gint steps, GAsyncReadyCallback _callback_, gpointer _user_data_) {
433
494
SqlHeavyQueryResultNextInternalAsyncData* _data_;
495
SQLHeavyQueryResult* _tmp0_;
496
GCancellable* _tmp1_;
497
GCancellable* _tmp2_;
498
gint _tmp3_;
434
499
_data_ = g_slice_new0 (SqlHeavyQueryResultNextInternalAsyncData);
435
500
_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, sql_heavy_query_result_next_internal_async);
436
501
g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, sql_heavy_query_result_next_internal_async_data_free);
437
_data_->self = _g_object_ref0 (self);
438
_data_->cancellable = _g_object_ref0 (cancellable);
439
_data_->steps = steps;
502
_tmp0_ = _g_object_ref0 (self);
503
_data_->self = _tmp0_;
504
_tmp1_ = cancellable;
505
_tmp2_ = _g_object_ref0 (_tmp1_);
506
_data_->cancellable = _tmp2_;
507
_tmp3_ = steps;
508
_data_->steps = _tmp3_;
440
509
sql_heavy_query_result_next_internal_async_co (_data_);
441
510
}
442
511
448
517
return FALSE;
449
518
}
450
519
_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
451
*last_insert_id = _data_->last_insert_id;
520
if (last_insert_id) {
521
*last_insert_id = _data_->last_insert_id;
522
}
452
523
result = _data_->result;
453
524
return result;
454
525
}
468
539
}
469
540
470
541
471
static void block2_data_unref (Block2Data* _data2_) {
542
static void block2_data_unref (void * _userdata_) {
543
Block2Data* _data2_;
544
_data2_ = (Block2Data*) _userdata_;
472
545
if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
473
_g_object_unref0 (_data2_->self);
546
SQLHeavyQueryResult * self;
547
self = _data2_->self;
474
548
_g_source_unref0 (_data2_->idle_source);
475
549
_g_error_free0 (_data2_->_error_);
476
550
_g_object_unref0 (_data2_->database);
477
551
_g_object_unref0 (_data2_->queryable);
478
552
g_static_mutex_free (&_data2_->executing_lock);
479
553
_g_object_unref0 (_data2_->cancellable);
554
_g_object_unref0 (self);
480
555
g_slice_free (Block2Data, _data2_);
481
556
}
482
557
}
489
564
}
490
565
491
566
492
static void _lambda4_ (Block2Data* _data2_) {
567
static void ___lambda6_ (Block2Data* _data2_) {
493
568
SQLHeavyQueryResult * self;
569
gboolean _tmp0_;
494
570
self = _data2_->self;
495
571
g_static_mutex_lock (&_data2_->executing_lock);
496
if (_data2_->executing) {
497
sql_heavy_database_interrupt (_data2_->database);
572
_tmp0_ = _data2_->executing;
573
if (_tmp0_) {
574
SQLHeavyDatabase* _tmp1_;
575
_tmp1_ = _data2_->database;
576
sql_heavy_database_interrupt (_tmp1_);
498
577
} else {
499
const gchar* _tmp0_ = NULL;
500
GError* _tmp1_ = NULL;
501
_tmp0_ = sql_heavy_sqlite_errstr (SQLITE_INTERRUPT);
502
_tmp1_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_INTERRUPTED, _tmp0_);
578
const gchar* _tmp2_ = NULL;
579
GError* _tmp3_;
580
GSource* _tmp4_;
581
GMainContext* _tmp5_;
582
GThread* _tmp6_;
583
SQLHeavyQueryable* _tmp8_;
584
SQLHeavyDatabase* _tmp9_;
585
_tmp2_ = sql_heavy_sqlite_errstr (SQLITE_INTERRUPT);
586
_tmp3_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_INTERRUPTED, _tmp2_);
503
587
_g_error_free0 (_data2_->_error_);
504
_data2_->_error_ = _tmp1_;
505
g_source_attach (_data2_->idle_source, _data2_->thread_context);
506
if (_data2_->thread != NULL) {
588
_data2_->_error_ = _tmp3_;
589
_tmp4_ = _data2_->idle_source;
590
_tmp5_ = _data2_->thread_context;
591
g_source_attach (_tmp4_, _tmp5_);
592
_tmp6_ = _data2_->thread;
593
if (_tmp6_ != NULL) {
594
GThread* _tmp7_;
595
_tmp7_ = _data2_->thread;
507
596
g_thread_exit (NULL);
508
597
}
509
sql_heavy_query_result_release_locks (self, _data2_->queryable, _data2_->database);
598
_tmp8_ = _data2_->queryable;
599
_tmp9_ = _data2_->database;
600
sql_heavy_query_result_release_locks (self, _tmp8_, _tmp9_);
510
601
}
511
602
g_static_mutex_unlock (&_data2_->executing_lock);
512
603
}
513
604
514
605
515
static void __lambda4__g_cancellable_cancelled (GCancellable* _sender, gpointer self) {
516
_lambda4_ (self);
606
static void ____lambda6__g_cancellable_cancelled (GCancellable* _sender, gpointer self) {
607
___lambda6_ (self);
517
608
}
518
609
519
610
522
613
}
523
614
524
615
525
static void* _lambda5_ (Block2Data* _data2_) {
616
static void* ___lambda7_ (Block2Data* _data2_) {
526
617
SQLHeavyQueryResult * self;
527
618
void* result = NULL;
528
gint64 _tmp6_;
619
SQLHeavyQueryable* _tmp0_;
620
SQLHeavyDatabase* _tmp1_;
621
SQLHeavyDatabase* _tmp17_;
622
gint64 _tmp18_;
623
gint64 _tmp19_;
624
SQLHeavyQueryable* _tmp20_;
625
SQLHeavyDatabase* _tmp21_;
626
gulong _tmp22_;
627
GSource* _tmp25_;
628
GMainContext* _tmp26_;
529
629
GError * _inner_error_ = NULL;
530
630
self = _data2_->self;
531
sql_heavy_query_result_acquire_locks (self, _data2_->queryable, _data2_->database);
631
_tmp0_ = _data2_->queryable;
632
_tmp1_ = _data2_->database;
633
sql_heavy_query_result_acquire_locks (self, _tmp0_, _tmp1_);
532
634
g_static_mutex_lock (&_data2_->executing_lock);
533
635
_data2_->executing = TRUE;
534
636
g_static_mutex_unlock (&_data2_->executing_lock);
535
while (TRUE) {
536
gboolean _tmp0_ = FALSE;
537
gboolean _tmp1_ = FALSE;
538
if (!(_data2_->steps != 0)) {
539
break;
540
}
541
if (_data2_->cancellable != NULL) {
542
gboolean _tmp2_;
543
_tmp2_ = g_cancellable_is_cancelled (_data2_->cancellable);
544
_tmp1_ = _tmp2_;
545
} else {
546
_tmp1_ = FALSE;
547
}
548
if (_tmp1_) {
549
_tmp0_ = TRUE;
550
} else {
551
gboolean _tmp3_;
552
gboolean _tmp4_;
553
_tmp3_ = sql_heavy_query_result_next_internal (self, &_inner_error_);
554
_tmp4_ = _tmp3_;
555
if (_inner_error_ != NULL) {
556
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
557
goto __catch25_sql_heavy_error;
637
{
638
while (TRUE) {
639
gint _tmp2_;
640
gboolean _tmp3_ = FALSE;
641
gboolean _tmp4_ = FALSE;
642
GCancellable* _tmp5_;
643
gboolean _tmp8_;
644
gboolean _tmp12_;
645
gint _tmp13_;
646
_tmp2_ = _data2_->steps;
647
if (!(_tmp2_ != 0)) {
648
break;
649
}
650
_tmp5_ = _data2_->cancellable;
651
if (_tmp5_ != NULL) {
652
GCancellable* _tmp6_;
653
gboolean _tmp7_ = FALSE;
654
_tmp6_ = _data2_->cancellable;
655
_tmp7_ = g_cancellable_is_cancelled (_tmp6_);
656
_tmp4_ = _tmp7_;
657
} else {
658
_tmp4_ = FALSE;
659
}
660
_tmp8_ = _tmp4_;
661
if (_tmp8_) {
662
_tmp3_ = TRUE;
663
} else {
664
gboolean _tmp9_ = FALSE;
665
gboolean _tmp10_;
666
gboolean _tmp11_;
667
_tmp9_ = sql_heavy_query_result_next_internal (self, &_inner_error_);
668
_tmp10_ = _tmp9_;
669
if (_inner_error_ != NULL) {
670
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
671
goto __catch25_sql_heavy_error;
672
}
673
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);
674
g_clear_error (&_inner_error_);
675
return NULL;
558
676
}
559
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);
560
g_clear_error (&_inner_error_);
561
return NULL;
562
}
563
_data2_->step_res = _tmp4_;
564
_tmp0_ = !_data2_->step_res;
565
}
566
if (_tmp0_) {
567
break;
568
}
569
if (_data2_->steps > 0) {
570
_data2_->steps--;
677
_data2_->step_res = _tmp10_;
678
_tmp11_ = _data2_->step_res;
679
_tmp3_ = !_tmp11_;
680
}
681
_tmp12_ = _tmp3_;
682
if (_tmp12_) {
683
break;
684
}
685
_tmp13_ = _data2_->steps;
686
if (_tmp13_ > 0) {
687
gint _tmp14_;
688
_tmp14_ = _data2_->steps;
689
_data2_->steps = _tmp14_ - 1;
690
}
571
691
}
572
692
}
573
693
goto __finally25;
574
694
__catch25_sql_heavy_error:
575
695
{
576
GError * e;
577
GError* _tmp5_;
696
GError* e = NULL;
697
GError* _tmp15_;
698
GError* _tmp16_;
578
699
e = _inner_error_;
579
700
_inner_error_ = NULL;
580
_tmp5_ = _g_error_copy0 (e);
701
_tmp15_ = e;
702
_tmp16_ = _g_error_copy0 (_tmp15_);
581
703
_g_error_free0 (_data2_->_error_);
582
_data2_->_error_ = _tmp5_;
704
_data2_->_error_ = _tmp16_;
583
705
_g_error_free0 (e);
584
706
}
585
707
__finally25:
588
710
g_clear_error (&_inner_error_);
589
711
return NULL;
590
712
}
591
_tmp6_ = sql_heavy_database_get_last_insert_id (_data2_->database);
592
_data2_->insert_id = _tmp6_;
593
sql_heavy_query_result_release_locks (self, _data2_->queryable, _data2_->database);
594
if (_data2_->cancellable_sig != 0) {
595
g_cancellable_disconnect (_data2_->cancellable, _data2_->cancellable_sig);
713
_tmp17_ = _data2_->database;
714
_tmp18_ = sql_heavy_database_get_last_insert_id (_tmp17_);
715
_tmp19_ = _tmp18_;
716
_data2_->insert_id = _tmp19_;
717
_tmp20_ = _data2_->queryable;
718
_tmp21_ = _data2_->database;
719
sql_heavy_query_result_release_locks (self, _tmp20_, _tmp21_);
720
_tmp22_ = _data2_->cancellable_sig;
721
if (_tmp22_ != ((gulong) 0)) {
722
GCancellable* _tmp23_;
723
gulong _tmp24_;
724
_tmp23_ = _data2_->cancellable;
725
_tmp24_ = _data2_->cancellable_sig;
726
g_cancellable_disconnect (_tmp23_, _tmp24_);
596
727
}
597
g_source_attach (_data2_->idle_source, _data2_->thread_context);
728
_tmp25_ = _data2_->idle_source;
729
_tmp26_ = _data2_->thread_context;
730
g_source_attach (_tmp25_, _tmp26_);
598
731
result = NULL;
599
732
return result;
600
733
}
601
734
602
735
603
static gpointer __lambda5__gthread_func (gpointer self) {
736
static gpointer ____lambda7__gthread_func (gpointer self) {
604
737
gpointer result;
605
result = _lambda5_ (self);
738
result = ___lambda7_ (self);
606
739
return result;
607
740
}
608
741
609
742
610
static gboolean sql_heavy_query_result_next_internal_async_co (SqlHeavyQueryResultNextInternalAsyncData* data) {
611
switch (data->_state_) {
743
static gboolean sql_heavy_query_result_next_internal_async_co (SqlHeavyQueryResultNextInternalAsyncData* _data_) {
744
switch (_data_->_state_) {
612
745
case 0:
613
746
goto _state_0;
614
747
case 1:
617
750
g_assert_not_reached ();
618
751
}
619
752
_state_0:
620
data->_data2_ = g_slice_new0 (Block2Data);
621
data->_data2_->_ref_count_ = 1;
622
data->_data2_->self = g_object_ref (data->self);
623
data->_data2_->cancellable = _g_object_ref0 (data->cancellable);
624
data->_data2_->steps = data->steps;
625
data->_data2_->_async_data_ = data;
626
data->_data2_->executing = FALSE;
627
g_static_mutex_init (&data->_data2_->executing_lock);
628
data->_tmp0_ = NULL;
629
data->_tmp0_ = sql_heavy_query_get_queryable (data->self->priv->_query);
630
data->_tmp1_ = _g_object_ref0 (data->_tmp0_);
631
data->_data2_->queryable = data->_tmp1_;
632
data->_tmp2_ = NULL;
633
data->_tmp2_ = sql_heavy_queryable_get_database (data->_data2_->queryable);
634
data->_data2_->database = data->_tmp2_;
635
data->_data2_->thread = NULL;
636
data->_data2_->_error_ = NULL;
637
data->_data2_->insert_id = (gint64) 0;
638
data->_data2_->cancellable_sig = (gulong) 0;
639
data->_data2_->step_res = FALSE;
640
data->_tmp3_ = NULL;
641
data->_tmp3_ = g_main_context_get_thread_default ();
642
data->_data2_->thread_context = data->_tmp3_;
643
data->_tmp4_ = NULL;
644
data->_tmp4_ = g_idle_source_new ();
645
data->_data2_->idle_source = data->_tmp4_;
646
g_source_set_callback (data->_data2_->idle_source, _sql_heavy_query_result_next_internal_async_co_gsource_func, data, NULL);
647
if (data->_data2_->cancellable != NULL) {
648
data->_tmp5_ = g_signal_connect_data (data->_data2_->cancellable, "cancelled", (GCallback) __lambda4__g_cancellable_cancelled, block2_data_ref (data->_data2_), (GClosureNotify) block2_data_unref, 0);
649
data->_data2_->cancellable_sig = data->_tmp5_;
753
_data_->_data2_ = g_slice_new0 (Block2Data);
754
_data_->_data2_->_ref_count_ = 1;
755
_data_->_data2_->self = g_object_ref (_data_->self);
756
_data_->_tmp0_ = _data_->cancellable;
757
_data_->_tmp1_ = _g_object_ref0 (_data_->_tmp0_);
758
_data_->_data2_->cancellable = _data_->_tmp1_;
759
_data_->_tmp2_ = _data_->steps;
760
_data_->_data2_->steps = _data_->_tmp2_;
761
_data_->_data2_->_async_data_ = _data_;
762
_data_->_data2_->executing = FALSE;
763
g_static_mutex_init (&_data_->_data2_->executing_lock);
764
_data_->_tmp3_ = _data_->self->priv->_query;
765
_data_->_tmp4_ = sql_heavy_query_get_queryable (_data_->_tmp3_);
766
_data_->_tmp5_ = _data_->_tmp4_;
767
_data_->_tmp6_ = _g_object_ref0 (_data_->_tmp5_);
768
_data_->_data2_->queryable = _data_->_tmp6_;
769
_data_->_tmp7_ = _data_->_data2_->queryable;
770
_data_->_tmp8_ = sql_heavy_queryable_get_database (_data_->_tmp7_);
771
_data_->_tmp9_ = _data_->_tmp8_;
772
_data_->_data2_->database = _data_->_tmp9_;
773
_data_->_data2_->thread = NULL;
774
_data_->_data2_->_error_ = NULL;
775
_data_->_data2_->insert_id = (gint64) 0;
776
_data_->_data2_->cancellable_sig = (gulong) 0;
777
_data_->_data2_->step_res = FALSE;
778
_data_->_tmp10_ = NULL;
779
_data_->_tmp10_ = g_main_context_get_thread_default ();
780
_data_->_data2_->thread_context = _data_->_tmp10_;
781
_data_->_tmp11_ = g_idle_source_new ();
782
_data_->_data2_->idle_source = _data_->_tmp11_;
783
_data_->_tmp12_ = _data_->_data2_->idle_source;
784
g_source_set_callback (_data_->_tmp12_, _sql_heavy_query_result_next_internal_async_co_gsource_func, _data_, NULL);
785
_data_->_tmp13_ = _data_->_data2_->cancellable;
786
if (_data_->_tmp13_ != NULL) {
787
_data_->_tmp14_ = _data_->_data2_->cancellable;
788
_data_->_tmp15_ = 0UL;
789
_data_->_tmp15_ = g_signal_connect_data (_data_->_tmp14_, "cancelled", (GCallback) ____lambda6__g_cancellable_cancelled, block2_data_ref (_data_->_data2_), (GClosureNotify) block2_data_unref, 0);
790
_data_->_data2_->cancellable_sig = _data_->_tmp15_;
650
791
}
651
g_thread_create (__lambda5__gthread_func, data->_data2_, FALSE, &data->_inner_error_);
652
if (data->_inner_error_ != NULL) {
653
if (data->_inner_error_->domain == G_THREAD_ERROR) {
654
goto __catch24_g_thread_error;
792
{
793
g_thread_create (____lambda7__gthread_func, _data_->_data2_, FALSE, &_data_->_inner_error_);
794
if (_data_->_inner_error_ != NULL) {
795
if (_data_->_inner_error_->domain == G_THREAD_ERROR) {
796
goto __catch24_g_thread_error;
797
}
798
block2_data_unref (_data_->_data2_);
799
_data_->_data2_ = NULL;
800
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
801
g_clear_error (&_data_->_inner_error_);
802
return FALSE;
655
803
}
656
block2_data_unref (data->_data2_);
657
data->_data2_ = NULL;
658
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
659
g_clear_error (&data->_inner_error_);
660
return FALSE;
661
804
}
662
805
goto __finally24;
663
806
__catch24_g_thread_error:
664
807
{
665
data->e = data->_inner_error_;
666
data->_inner_error_ = NULL;
667
data->_tmp6_ = NULL;
668
data->_tmp6_ = g_error_new (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_THREAD, "Thread error: %s (%d)", data->e->message, data->e->code);
669
data->_inner_error_ = data->_tmp6_;
670
_g_error_free0 (data->e);
808
_data_->e = _data_->_inner_error_;
809
_data_->_inner_error_ = NULL;
810
_data_->_tmp16_ = _data_->e;
811
_data_->_tmp17_ = _data_->_tmp16_->message;
812
_data_->_tmp18_ = _data_->e;
813
_data_->_tmp19_ = _data_->_tmp18_->code;
814
_data_->_tmp20_ = g_error_new (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_THREAD, "Thread error: %s (%d)", _data_->_tmp17_, _data_->_tmp19_);
815
_data_->_inner_error_ = _data_->_tmp20_;
816
_g_error_free0 (_data_->e);
671
817
goto __finally24;
672
818
}
673
819
__finally24:
674
if (data->_inner_error_ != NULL) {
675
if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
676
g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
677
g_error_free (data->_inner_error_);
678
block2_data_unref (data->_data2_);
679
data->_data2_ = NULL;
680
if (data->_state_ == 0) {
681
g_simple_async_result_complete_in_idle (data->_async_result);
820
if (_data_->_inner_error_ != NULL) {
821
if (_data_->_inner_error_->domain == SQL_HEAVY_ERROR) {
822
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
823
g_error_free (_data_->_inner_error_);
824
block2_data_unref (_data_->_data2_);
825
_data_->_data2_ = NULL;
826
if (_data_->_state_ == 0) {
827
g_simple_async_result_complete_in_idle (_data_->_async_result);
682
828
} else {
683
g_simple_async_result_complete (data->_async_result);
829
g_simple_async_result_complete (_data_->_async_result);
684
830
}
685
g_object_unref (data->_async_result);
831
g_object_unref (_data_->_async_result);
686
832
return FALSE;
687
833
} else {
688
block2_data_unref (data->_data2_);
689
data->_data2_ = NULL;
690
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
691
g_clear_error (&data->_inner_error_);
834
block2_data_unref (_data_->_data2_);
835
_data_->_data2_ = NULL;
836
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
837
g_clear_error (&_data_->_inner_error_);
692
838
return FALSE;
693
839
}
694
840
}
695
data->_state_ = 1;
841
_data_->_state_ = 1;
696
842
return FALSE;
697
843
_state_1:
698
844
;
699
if (data->_data2_->_error_ != NULL) {
700
data->_tmp7_ = _g_error_copy0 (data->_data2_->_error_);
701
data->_inner_error_ = data->_tmp7_;
702
if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
703
g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
704
g_error_free (data->_inner_error_);
705
block2_data_unref (data->_data2_);
706
data->_data2_ = NULL;
707
if (data->_state_ == 0) {
708
g_simple_async_result_complete_in_idle (data->_async_result);
845
_data_->_tmp21_ = _data_->_data2_->_error_;
846
if (_data_->_tmp21_ != NULL) {
847
_data_->_tmp22_ = _data_->_data2_->_error_;
848
_data_->_tmp23_ = _g_error_copy0 (_data_->_tmp22_);
849
_data_->_inner_error_ = _data_->_tmp23_;
850
if (_data_->_inner_error_->domain == SQL_HEAVY_ERROR) {
851
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
852
g_error_free (_data_->_inner_error_);
853
block2_data_unref (_data_->_data2_);
854
_data_->_data2_ = NULL;
855
if (_data_->_state_ == 0) {
856
g_simple_async_result_complete_in_idle (_data_->_async_result);
709
857
} else {
710
g_simple_async_result_complete (data->_async_result);
858
g_simple_async_result_complete (_data_->_async_result);
711
859
}
712
g_object_unref (data->_async_result);
860
g_object_unref (_data_->_async_result);
713
861
return FALSE;
714
862
} else {
715
block2_data_unref (data->_data2_);
716
data->_data2_ = NULL;
717
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
718
g_clear_error (&data->_inner_error_);
863
block2_data_unref (_data_->_data2_);
864
_data_->_data2_ = NULL;
865
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
866
g_clear_error (&_data_->_inner_error_);
719
867
return FALSE;
720
868
}
721
869
}
722
data->last_insert_id = data->_data2_->insert_id;
723
data->result = data->_data2_->step_res;
724
block2_data_unref (data->_data2_);
725
data->_data2_ = NULL;
726
if (data->_state_ == 0) {
727
g_simple_async_result_complete_in_idle (data->_async_result);
870
_data_->_tmp24_ = _data_->_data2_->insert_id;
871
_data_->last_insert_id = _data_->_tmp24_;
872
_data_->_tmp25_ = _data_->_data2_->step_res;
873
_data_->result = _data_->_tmp25_;
874
block2_data_unref (_data_->_data2_);
875
_data_->_data2_ = NULL;
876
if (_data_->_state_ == 0) {
877
g_simple_async_result_complete_in_idle (_data_->_async_result);
728
878
} else {
729
g_simple_async_result_complete (data->_async_result);
879
g_simple_async_result_complete (_data_->_async_result);
730
880
}
731
g_object_unref (data->_async_result);
881
g_object_unref (_data_->_async_result);
732
882
return FALSE;
733
block2_data_unref (data->_data2_);
734
data->_data2_ = NULL;
735
if (data->_state_ == 0) {
736
g_simple_async_result_complete_in_idle (data->_async_result);
883
block2_data_unref (_data_->_data2_);
884
_data_->_data2_ = NULL;
885
if (_data_->_state_ == 0) {
886
g_simple_async_result_complete_in_idle (_data_->_async_result);
737
887
} else {
738
g_simple_async_result_complete (data->_async_result);
888
g_simple_async_result_complete (_data_->_async_result);
739
889
}
740
g_object_unref (data->_async_result);
890
g_object_unref (_data_->_async_result);
741
891
return FALSE;
742
892
}
743
893
746
896
* Finish iterating through the result set.
747
897
*/
748
898
void sql_heavy_query_result_complete (SQLHeavyQueryResult* self, GError** error) {
749
SQLHeavyQueryable* _tmp0_ = NULL;
899
SQLHeavyQuery* _tmp0_;
900
SQLHeavyQueryable* _tmp1_;
901
SQLHeavyQueryable* _tmp2_;
750
902
SQLHeavyQueryable* queryable;
751
SQLHeavyDatabase* _tmp1_ = NULL;
903
SQLHeavyQueryable* _tmp3_;
904
SQLHeavyDatabase* _tmp4_;
905
SQLHeavyDatabase* _tmp5_;
752
906
SQLHeavyDatabase* db;
907
SQLHeavyQueryable* _tmp6_;
908
SQLHeavyDatabase* _tmp7_;
909
SQLHeavyDatabase* _tmp9_;
910
SQLHeavyQueryable* _tmp10_;
753
911
GError * _inner_error_ = NULL;
754
912
g_return_if_fail (self != NULL);
755
_tmp0_ = sql_heavy_query_get_queryable (self->priv->_query);
756
queryable = _tmp0_;
757
_tmp1_ = sql_heavy_queryable_get_database (queryable);
758
db = _tmp1_;
759
sql_heavy_queryable_lock (queryable);
760
sql_heavy_database_step_lock (db);
913
_tmp0_ = self->priv->_query;
914
_tmp1_ = sql_heavy_query_get_queryable (_tmp0_);
915
_tmp2_ = _tmp1_;
916
queryable = _tmp2_;
917
_tmp3_ = queryable;
918
_tmp4_ = sql_heavy_queryable_get_database (_tmp3_);
919
_tmp5_ = _tmp4_;
920
db = _tmp5_;
921
_tmp6_ = queryable;
922
sql_heavy_queryable_lock (_tmp6_);
923
_tmp7_ = db;
924
sql_heavy_database_step_lock (_tmp7_);
761
925
while (TRUE) {
762
if (!(!self->priv->_finished)) {
926
gboolean _tmp8_;
927
_tmp8_ = self->priv->_finished;
928
if (!(!_tmp8_)) {
763
929
break;
764
930
}
765
931
sql_heavy_query_result_next_internal (self, &_inner_error_);
776
942
}
777
943
}
778
944
}
779
sql_heavy_database_step_unlock (db);
780
sql_heavy_queryable_unlock (queryable);
945
_tmp9_ = db;
946
sql_heavy_database_step_unlock (_tmp9_);
947
_tmp10_ = queryable;
948
sql_heavy_queryable_unlock (_tmp10_);
781
949
_g_object_unref0 (db);
782
950
}
783
951
784
952
785
953
static void sql_heavy_query_result_complete_async_data_free (gpointer _data) {
786
SqlHeavyQueryResultCompleteAsyncData* data;
787
data = _data;
788
_g_object_unref0 (data->cancellable);
789
_g_object_unref0 (data->self);
790
g_slice_free (SqlHeavyQueryResultCompleteAsyncData, data);
954
SqlHeavyQueryResultCompleteAsyncData* _data_;
955
_data_ = _data;
956
_g_object_unref0 (_data_->cancellable);
957
_g_object_unref0 (_data_->self);
958
g_slice_free (SqlHeavyQueryResultCompleteAsyncData, _data_);
791
959
}
792
960
793
961
794
962
void sql_heavy_query_result_complete_async (SQLHeavyQueryResult* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
795
963
SqlHeavyQueryResultCompleteAsyncData* _data_;
964
SQLHeavyQueryResult* _tmp0_;
965
GCancellable* _tmp1_;
966
GCancellable* _tmp2_;
796
967
_data_ = g_slice_new0 (SqlHeavyQueryResultCompleteAsyncData);
797
968
_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, sql_heavy_query_result_complete_async);
798
969
g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, sql_heavy_query_result_complete_async_data_free);
799
_data_->self = _g_object_ref0 (self);
800
_data_->cancellable = _g_object_ref0 (cancellable);
970
_tmp0_ = _g_object_ref0 (self);
971
_data_->self = _tmp0_;
972
_tmp1_ = cancellable;
973
_tmp2_ = _g_object_ref0 (_tmp1_);
974
_data_->cancellable = _tmp2_;
801
975
sql_heavy_query_result_complete_async_co (_data_);
802
976
}
803
977
817
991
* @param cancellable optional cancellable for aborting the operation
818
992
*/
819
993
static void sql_heavy_query_result_complete_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
820
SqlHeavyQueryResultCompleteAsyncData* data;
821
data = _user_data_;
822
data->_source_object_ = source_object;
823
data->_res_ = _res_;
824
sql_heavy_query_result_complete_async_co (data);
994
SqlHeavyQueryResultCompleteAsyncData* _data_;
995
_data_ = _user_data_;
996
_data_->_source_object_ = source_object;
997
_data_->_res_ = _res_;
998
sql_heavy_query_result_complete_async_co (_data_);
825
999
}
826
1000
827
1001
828
static gboolean sql_heavy_query_result_complete_async_co (SqlHeavyQueryResultCompleteAsyncData* data) {
829
switch (data->_state_) {
1002
static gboolean sql_heavy_query_result_complete_async_co (SqlHeavyQueryResultCompleteAsyncData* _data_) {
1003
switch (_data_->_state_) {
830
1004
case 0:
831
1005
goto _state_0;
832
1006
case 1:
835
1009
g_assert_not_reached ();
836
1010
}
837
1011
_state_0:
838
data->insert_id = (gint64) 0;
839
data->_state_ = 1;
840
sql_heavy_query_result_next_internal_async (data->self, data->cancellable, 0, sql_heavy_query_result_complete_async_ready, data);
1012
_data_->insert_id = (gint64) 0;
1013
_data_->_tmp0_ = _data_->cancellable;
1014
_data_->_tmp1_ = 0LL;
1015
_data_->_state_ = 1;
1016
sql_heavy_query_result_next_internal_async (_data_->self, _data_->_tmp0_, 0, sql_heavy_query_result_complete_async_ready, _data_);
841
1017
return FALSE;
842
1018
_state_1:
843
sql_heavy_query_result_next_internal_finish (data->self, data->_res_, &data->_tmp0_, &data->_inner_error_);
844
data->insert_id = data->_tmp0_;
845
if (data->_inner_error_ != NULL) {
846
if (data->_inner_error_->domain == SQL_HEAVY_ERROR) {
847
g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
848
g_error_free (data->_inner_error_);
849
if (data->_state_ == 0) {
850
g_simple_async_result_complete_in_idle (data->_async_result);
1019
sql_heavy_query_result_next_internal_finish (_data_->self, _data_->_res_, &_data_->_tmp1_, &_data_->_inner_error_);
1020
_data_->insert_id = _data_->_tmp1_;
1021
if (_data_->_inner_error_ != NULL) {
1022
if (_data_->_inner_error_->domain == SQL_HEAVY_ERROR) {
1023
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
1024
g_error_free (_data_->_inner_error_);
1025
if (_data_->_state_ == 0) {
1026
g_simple_async_result_complete_in_idle (_data_->_async_result);
851
1027
} else {
852
g_simple_async_result_complete (data->_async_result);
1028
g_simple_async_result_complete (_data_->_async_result);
853
1029
}
854
g_object_unref (data->_async_result);
1030
g_object_unref (_data_->_async_result);
855
1031
return FALSE;
856
1032
} else {
857
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
858
g_clear_error (&data->_inner_error_);
1033
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
1034
g_clear_error (&_data_->_inner_error_);
859
1035
return FALSE;
860
1036
}
861
1037
}
862
if (data->_state_ == 0) {
863
g_simple_async_result_complete_in_idle (data->_async_result);
1038
if (_data_->_state_ == 0) {
1039
g_simple_async_result_complete_in_idle (_data_->_async_result);
864
1040
} else {
865
g_simple_async_result_complete (data->_async_result);
1041
g_simple_async_result_complete (_data_->_async_result);
866
1042
}
867
g_object_unref (data->_async_result);
1043
g_object_unref (_data_->_async_result);
868
1044
return FALSE;
869
1045
}
870
1046
875
1051
static gint sql_heavy_query_result_field_check_index (SQLHeavyQueryResult* self, gint field, GError** error) {
876
1052
gint result = 0;
877
1053
gboolean _tmp0_ = FALSE;
1054
gint _tmp1_;
1055
gboolean _tmp5_;
1056
gint _tmp8_;
878
1057
GError * _inner_error_ = NULL;
879
1058
g_return_val_if_fail (self != NULL, 0);
880
if (field < 0) {
1059
_tmp1_ = field;
1060
if (_tmp1_ < 0) {
881
1061
_tmp0_ = TRUE;
882
1062
} else {
883
gint _tmp1_;
884
_tmp1_ = sql_heavy_record_get_field_count ((SQLHeavyRecord*) self);
885
_tmp0_ = field > _tmp1_;
1063
gint _tmp2_;
1064
gint _tmp3_;
1065
gint _tmp4_;
1066
_tmp2_ = field;
1067
_tmp3_ = sql_heavy_record_get_field_count ((SQLHeavyRecord*) self);
1068
_tmp4_ = _tmp3_;
1069
_tmp0_ = _tmp2_ > _tmp4_;
886
1070
}
887
if (_tmp0_) {
888
const gchar* _tmp2_ = NULL;
889
GError* _tmp3_ = NULL;
890
_tmp2_ = sql_heavy_sqlite_errstr (SQLITE_RANGE);
891
_tmp3_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_RANGE, _tmp2_);
892
_inner_error_ = _tmp3_;
1071
_tmp5_ = _tmp0_;
1072
if (_tmp5_) {
1073
const gchar* _tmp6_ = NULL;
1074
GError* _tmp7_;
1075
_tmp6_ = sql_heavy_sqlite_errstr (SQLITE_RANGE);
1076
_tmp7_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_RANGE, _tmp6_);
1077
_inner_error_ = _tmp7_;
893
1078
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
894
1079
g_propagate_error (error, _inner_error_);
895
1080
return 0;
899
1084
return 0;
900
1085
}
901
1086
}
902
result = field;
1087
_tmp8_ = field;
1088
result = _tmp8_;
903
1089
return result;
904
1090
}
905
1091
911
1097
SQLHeavyQueryResult * self;
912
1098
gchar* result = NULL;
913
1099
gint _tmp0_;
914
gint _tmp1_;
915
const gchar* _tmp2_ = NULL;
916
gchar* _tmp3_;
1100
gint _tmp1_ = 0;
1101
gint _tmp2_;
1102
sqlite3_stmt* _tmp3_;
1103
const gchar* _tmp4_ = NULL;
1104
gchar* _tmp5_;
917
1105
GError * _inner_error_ = NULL;
918
1106
self = (SQLHeavyQueryResult*) base;
919
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
920
_tmp1_ = _tmp0_;
1107
_tmp0_ = field;
1108
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1109
_tmp2_ = _tmp1_;
921
1110
if (_inner_error_ != NULL) {
922
1111
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
923
1112
g_propagate_error (error, _inner_error_);
928
1117
return NULL;
929
1118
}
930
1119
}
931
_tmp2_ = sqlite3_column_name (self->priv->stmt, _tmp1_);
932
_tmp3_ = g_strdup (_tmp2_);
933
result = _tmp3_;
1120
_tmp3_ = self->priv->stmt;
1121
_tmp4_ = sqlite3_column_name (_tmp3_, _tmp2_);
1122
_tmp5_ = g_strdup (_tmp4_);
1123
result = _tmp5_;
934
1124
return result;
935
1125
}
936
1126
945
1135
gchar* sql_heavy_query_result_field_origin_table_name (SQLHeavyQueryResult* self, gint field, GError** error) {
946
1136
gchar* result = NULL;
947
1137
gint _tmp0_;
948
gint _tmp1_;
949
const gchar* _tmp2_ = NULL;
950
gchar* _tmp3_;
1138
gint _tmp1_ = 0;
1139
gint _tmp2_;
1140
sqlite3_stmt* _tmp3_;
1141
const gchar* _tmp4_ = NULL;
1142
gchar* _tmp5_;
951
1143
GError * _inner_error_ = NULL;
952
1144
g_return_val_if_fail (self != NULL, NULL);
953
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
954
_tmp1_ = _tmp0_;
1145
_tmp0_ = field;
1146
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1147
_tmp2_ = _tmp1_;
955
1148
if (_inner_error_ != NULL) {
956
1149
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
957
1150
g_propagate_error (error, _inner_error_);
962
1155
return NULL;
963
1156
}
964
1157
}
965
_tmp2_ = sqlite3_column_table_name (self->priv->stmt, _tmp1_);
966
_tmp3_ = g_strdup (_tmp2_);
967
result = _tmp3_;
1158
_tmp3_ = self->priv->stmt;
1159
_tmp4_ = sqlite3_column_table_name (_tmp3_, _tmp2_);
1160
_tmp5_ = g_strdup (_tmp4_);
1161
result = _tmp5_;
968
1162
return result;
969
1163
}
970
1164
978
1172
*/
979
1173
SQLHeavyTable* sql_heavy_query_result_field_origin_table (SQLHeavyQueryResult* self, gint field, GError** error) {
980
1174
SQLHeavyTable* result = NULL;
981
gchar* _tmp0_ = NULL;
982
gchar* _tmp1_;
983
SQLHeavyQueryable* _tmp2_ = NULL;
984
gchar* _tmp3_;
985
SQLHeavyTable* _tmp4_ = NULL;
986
SQLHeavyTable* _tmp5_;
987
SQLHeavyTable* _tmp6_;
1175
gint _tmp0_;
1176
gchar* _tmp1_ = NULL;
1177
gchar* _tmp2_;
1178
SQLHeavyQuery* _tmp3_;
1179
SQLHeavyQueryable* _tmp4_;
1180
SQLHeavyQueryable* _tmp5_;
1181
gchar* _tmp6_;
1182
SQLHeavyTable* _tmp7_;
1183
SQLHeavyTable* _tmp8_;
1184
SQLHeavyTable* _tmp9_;
988
1185
GError * _inner_error_ = NULL;
989
1186
g_return_val_if_fail (self != NULL, NULL);
990
_tmp0_ = sql_heavy_query_result_field_origin_table_name (self, field, &_inner_error_);
991
_tmp1_ = _tmp0_;
1187
_tmp0_ = field;
1188
_tmp1_ = sql_heavy_query_result_field_origin_table_name (self, _tmp0_, &_inner_error_);
1189
_tmp2_ = _tmp1_;
992
1190
if (_inner_error_ != NULL) {
993
1191
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
994
1192
g_propagate_error (error, _inner_error_);
999
1197
return NULL;
1000
1198
}
1001
1199
}
1002
_tmp2_ = sql_heavy_query_get_queryable (self->priv->_query);
1003
_tmp3_ = _tmp1_;
1004
_tmp4_ = sql_heavy_table_new (_tmp2_, _tmp3_, &_inner_error_);
1200
_tmp3_ = self->priv->_query;
1201
_tmp4_ = sql_heavy_query_get_queryable (_tmp3_);
1005
1202
_tmp5_ = _tmp4_;
1006
_g_free0 (_tmp3_);
1007
_tmp6_ = _tmp5_;
1203
_tmp6_ = _tmp2_;
1204
_tmp7_ = sql_heavy_table_new (_tmp5_, _tmp6_, &_inner_error_);
1205
_tmp8_ = _tmp7_;
1206
_g_free0 (_tmp6_);
1207
_tmp9_ = _tmp8_;
1008
1208
if (_inner_error_ != NULL) {
1009
1209
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1010
1210
g_propagate_error (error, _inner_error_);
1015
1215
return NULL;
1016
1216
}
1017
1217
}
1018
result = _tmp6_;
1218
result = _tmp9_;
1019
1219
return result;
1020
1220
}
1021
1221
1029
1229
gchar* sql_heavy_query_result_field_origin_name (SQLHeavyQueryResult* self, gint field, GError** error) {
1030
1230
gchar* result = NULL;
1031
1231
gint _tmp0_;
1032
gint _tmp1_;
1033
const gchar* _tmp2_ = NULL;
1034
gchar* _tmp3_;
1232
gint _tmp1_ = 0;
1233
gint _tmp2_;
1234
sqlite3_stmt* _tmp3_;
1235
const gchar* _tmp4_ = NULL;
1236
gchar* _tmp5_;
1035
1237
GError * _inner_error_ = NULL;
1036
1238
g_return_val_if_fail (self != NULL, NULL);
1037
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
1038
_tmp1_ = _tmp0_;
1239
_tmp0_ = field;
1240
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1241
_tmp2_ = _tmp1_;
1039
1242
if (_inner_error_ != NULL) {
1040
1243
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1041
1244
g_propagate_error (error, _inner_error_);
1046
1249
return NULL;
1047
1250
}
1048
1251
}
1049
_tmp2_ = sqlite3_column_origin_name (self->priv->stmt, _tmp1_);
1050
_tmp3_ = g_strdup (_tmp2_);
1051
result = _tmp3_;
1252
_tmp3_ = self->priv->stmt;
1253
_tmp4_ = sqlite3_column_origin_name (_tmp3_, _tmp2_);
1254
_tmp5_ = g_strdup (_tmp4_);
1255
result = _tmp5_;
1052
1256
return result;
1053
1257
}
1054
1258
1072
1276
static gint sql_heavy_query_result_real_field_index (SQLHeavyRecord* base, const gchar* field, GError** error) {
1073
1277
SQLHeavyQueryResult * self;
1074
1278
gint result = 0;
1075
gconstpointer _tmp6_ = NULL;
1076
gint* _tmp7_;
1279
GHashTable* _tmp0_;
1280
GHashTable* _tmp19_;
1281
const gchar* _tmp20_;
1282
gconstpointer _tmp21_ = NULL;
1283
gint* _tmp22_;
1077
1284
gint* field_number;
1285
gint* _tmp23_;
1286
gint* _tmp26_;
1078
1287
GError * _inner_error_ = NULL;
1079
1288
self = (SQLHeavyQueryResult*) base;
1080
1289
g_return_val_if_fail (field != NULL, 0);
1081
if (self->priv->_field_names == NULL) {
1082
GHashTable* _tmp0_ = NULL;
1083
gint _tmp1_;
1290
_tmp0_ = self->priv->_field_names;
1291
if (_tmp0_ == NULL) {
1292
GHashFunc _tmp1_;
1293
GEqualFunc _tmp2_;
1294
GDestroyNotify _tmp3_;
1295
GDestroyNotify _tmp4_;
1296
GHashTable* _tmp5_;
1297
gint _tmp6_;
1298
gint _tmp7_;
1084
1299
gint fields;
1085
_tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1300
_tmp1_ = g_str_hash;
1301
_tmp2_ = g_str_equal;
1302
_tmp3_ = g_free;
1303
_tmp4_ = g_free;
1304
_tmp5_ = g_hash_table_new_full (_tmp1_, _tmp2_, _tmp3_, _tmp4_);
1086
1305
_g_hash_table_unref0 (self->priv->_field_names);
1087
self->priv->_field_names = _tmp0_;
1088
_tmp1_ = sql_heavy_record_get_field_count ((SQLHeavyRecord*) self);
1089
fields = _tmp1_;
1306
self->priv->_field_names = _tmp5_;
1307
_tmp6_ = sql_heavy_record_get_field_count ((SQLHeavyRecord*) self);
1308
_tmp7_ = _tmp6_;
1309
fields = _tmp7_;
1090
1310
{
1091
1311
gint i;
1092
1312
i = 0;
1093
1313
{
1094
gboolean _tmp2_;
1095
_tmp2_ = TRUE;
1314
gboolean _tmp8_;
1315
_tmp8_ = TRUE;
1096
1316
while (TRUE) {
1097
gchar* _tmp3_ = NULL;
1098
gchar* _tmp4_;
1099
gint* _tmp5_;
1100
if (!_tmp2_) {
1101
i++;
1317
gboolean _tmp9_;
1318
gint _tmp11_;
1319
gint _tmp12_;
1320
gint _tmp13_;
1321
gchar* _tmp14_ = NULL;
1322
gchar* _tmp15_;
1323
GHashTable* _tmp16_;
1324
gint _tmp17_;
1325
gint* _tmp18_;
1326
_tmp9_ = _tmp8_;
1327
if (!_tmp9_) {
1328
gint _tmp10_;
1329
_tmp10_ = i;
1330
i = _tmp10_ + 1;
1102
1331
}
1103
_tmp2_ = FALSE;
1104
if (!(i < fields)) {
1332
_tmp8_ = FALSE;
1333
_tmp11_ = i;
1334
_tmp12_ = fields;
1335
if (!(_tmp11_ < _tmp12_)) {
1105
1336
break;
1106
1337
}
1107
_tmp3_ = sql_heavy_record_field_name ((SQLHeavyRecord*) self, i, &_inner_error_);
1108
_tmp4_ = _tmp3_;
1338
_tmp13_ = i;
1339
_tmp14_ = sql_heavy_record_field_name ((SQLHeavyRecord*) self, _tmp13_, &_inner_error_);
1340
_tmp15_ = _tmp14_;
1109
1341
if (_inner_error_ != NULL) {
1110
1342
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1111
1343
g_propagate_error (error, _inner_error_);
1116
1348
return 0;
1117
1349
}
1118
1350
}
1119
_tmp5_ = __int_dup0 (&i);
1120
g_hash_table_replace (self->priv->_field_names, _tmp4_, _tmp5_);
1351
_tmp16_ = self->priv->_field_names;
1352
_tmp17_ = i;
1353
_tmp18_ = __int_dup0 (&_tmp17_);
1354
g_hash_table_replace (_tmp16_, _tmp15_, _tmp18_);
1121
1355
}
1122
1356
}
1123
1357
}
1124
1358
}
1125
_tmp6_ = g_hash_table_lookup (self->priv->_field_names, field);
1126
_tmp7_ = __int_dup0 ((gint*) _tmp6_);
1127
field_number = _tmp7_;
1128
if (field_number == NULL) {
1129
const gchar* _tmp8_ = NULL;
1130
GError* _tmp9_ = NULL;
1131
_tmp8_ = sql_heavy_sqlite_errstr (SQLITE_RANGE);
1132
_tmp9_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_RANGE, _tmp8_);
1133
_inner_error_ = _tmp9_;
1359
_tmp19_ = self->priv->_field_names;
1360
_tmp20_ = field;
1361
_tmp21_ = g_hash_table_lookup (_tmp19_, _tmp20_);
1362
_tmp22_ = __int_dup0 ((gint*) _tmp21_);
1363
field_number = _tmp22_;
1364
_tmp23_ = field_number;
1365
if (_tmp23_ == NULL) {
1366
const gchar* _tmp24_ = NULL;
1367
GError* _tmp25_;
1368
_tmp24_ = sql_heavy_sqlite_errstr (SQLITE_RANGE);
1369
_tmp25_ = g_error_new_literal (SQL_HEAVY_ERROR, SQL_HEAVY_ERROR_RANGE, _tmp24_);
1370
_inner_error_ = _tmp25_;
1134
1371
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1135
1372
g_propagate_error (error, _inner_error_);
1136
1373
_g_free0 (field_number);
1142
1379
return 0;
1143
1380
}
1144
1381
}
1145
result = (gint) (*field_number);
1382
_tmp26_ = field_number;
1383
result = (gint) (*_tmp26_);
1146
1384
_g_free0 (field_number);
1147
1385
return result;
1148
1386
}
1155
1393
SQLHeavyQueryResult * self;
1156
1394
GType result = 0UL;
1157
1395
gint _tmp0_;
1158
gint _tmp1_;
1396
gint _tmp1_ = 0;
1159
1397
gint _tmp2_;
1160
GType _tmp3_;
1161
GType _tmp4_;
1398
sqlite3_stmt* _tmp3_;
1399
gint _tmp4_ = 0;
1400
GType _tmp5_ = 0UL;
1401
GType _tmp6_;
1162
1402
GError * _inner_error_ = NULL;
1163
1403
self = (SQLHeavyQueryResult*) base;
1164
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
1165
_tmp1_ = _tmp0_;
1166
if (_inner_error_ != NULL) {
1167
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1168
g_propagate_error (error, _inner_error_);
1169
return 0UL;
1170
} else {
1171
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);
1172
g_clear_error (&_inner_error_);
1173
return 0UL;
1174
}
1175
}
1176
_tmp2_ = sqlite3_column_type (self->priv->stmt, _tmp1_);
1177
_tmp3_ = sql_heavy_sqlite_type_to_g_type (_tmp2_, &_inner_error_);
1178
_tmp4_ = _tmp3_;
1179
if (_inner_error_ != NULL) {
1180
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1181
g_propagate_error (error, _inner_error_);
1182
return 0UL;
1183
} else {
1184
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);
1185
g_clear_error (&_inner_error_);
1186
return 0UL;
1187
}
1188
}
1189
result = _tmp4_;
1404
_tmp0_ = field;
1405
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1406
_tmp2_ = _tmp1_;
1407
if (_inner_error_ != NULL) {
1408
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1409
g_propagate_error (error, _inner_error_);
1410
return 0UL;
1411
} else {
1412
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);
1413
g_clear_error (&_inner_error_);
1414
return 0UL;
1415
}
1416
}
1417
_tmp3_ = self->priv->stmt;
1418
_tmp4_ = sqlite3_column_type (_tmp3_, _tmp2_);
1419
_tmp5_ = sql_heavy_sqlite_type_to_g_type (_tmp4_, &_inner_error_);
1420
_tmp6_ = _tmp5_;
1421
if (_inner_error_ != NULL) {
1422
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1423
g_propagate_error (error, _inner_error_);
1424
return 0UL;
1425
} else {
1426
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);
1427
g_clear_error (&_inner_error_);
1428
return 0UL;
1429
}
1430
}
1431
result = _tmp6_;
1190
1432
return result;
1191
1433
}
1192
1434
1197
1439
static void sql_heavy_query_result_real_fetch (SQLHeavyRecord* base, gint field, GValue* result, GError** error) {
1198
1440
SQLHeavyQueryResult * self;
1199
1441
gint _tmp0_;
1200
gint _tmp1_;
1201
sqlite3_value* _tmp2_ = NULL;
1202
GValue _tmp3_ = {0};
1203
GValue _tmp4_ = {0};
1442
gint _tmp1_ = 0;
1443
gint _tmp2_;
1444
sqlite3_stmt* _tmp3_;
1445
sqlite3_value* _tmp4_ = NULL;
1446
GValue _tmp5_ = {0};
1204
1447
GError * _inner_error_ = NULL;
1205
1448
self = (SQLHeavyQueryResult*) base;
1206
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
1207
_tmp1_ = _tmp0_;
1449
_tmp0_ = field;
1450
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1451
_tmp2_ = _tmp1_;
1208
1452
if (_inner_error_ != NULL) {
1209
1453
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1210
1454
g_propagate_error (error, _inner_error_);
1215
1459
return;
1216
1460
}
1217
1461
}
1218
_tmp2_ = sqlite3_column_value (self->priv->stmt, _tmp1_);
1219
sql_heavy_sqlite_value_to_g_value (_tmp2_, &_tmp3_);
1220
_tmp4_ = _tmp3_;
1221
*result = _tmp4_;
1462
_tmp3_ = self->priv->stmt;
1463
_tmp4_ = sqlite3_column_value (_tmp3_, _tmp2_);
1464
sql_heavy_sqlite_value_to_g_value (_tmp4_, &_tmp5_);
1465
*result = _tmp5_;
1222
1466
return;
1223
1467
}
1224
1468
1230
1474
SQLHeavyQueryResult * self;
1231
1475
gchar* result = NULL;
1232
1476
gint _tmp0_;
1233
gint _tmp1_;
1234
const gchar* _tmp2_ = NULL;
1235
gchar* _tmp3_;
1477
gint _tmp1_ = 0;
1478
gint _tmp2_;
1479
sqlite3_stmt* _tmp3_;
1480
const gchar* _tmp4_ = NULL;
1481
gchar* _tmp5_;
1236
1482
GError * _inner_error_ = NULL;
1237
1483
self = (SQLHeavyQueryResult*) base;
1238
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
1239
_tmp1_ = _tmp0_;
1484
_tmp0_ = field;
1485
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1486
_tmp2_ = _tmp1_;
1240
1487
if (_inner_error_ != NULL) {
1241
1488
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1242
1489
g_propagate_error (error, _inner_error_);
1247
1494
return NULL;
1248
1495
}
1249
1496
}
1250
_tmp2_ = sqlite3_column_text (self->priv->stmt, _tmp1_);
1251
_tmp3_ = g_strdup (_tmp2_);
1252
result = _tmp3_;
1497
_tmp3_ = self->priv->stmt;
1498
_tmp4_ = sqlite3_column_text (_tmp3_, _tmp2_);
1499
_tmp5_ = g_strdup (_tmp4_);
1500
result = _tmp5_;
1253
1501
return result;
1254
1502
}
1255
1503
1261
1509
SQLHeavyQueryResult * self;
1262
1510
gint result = 0;
1263
1511
gint _tmp0_;
1264
gint _tmp1_;
1512
gint _tmp1_ = 0;
1265
1513
gint _tmp2_;
1514
sqlite3_stmt* _tmp3_;
1515
gint _tmp4_ = 0;
1266
1516
GError * _inner_error_ = NULL;
1267
1517
self = (SQLHeavyQueryResult*) base;
1268
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
1269
_tmp1_ = _tmp0_;
1518
_tmp0_ = field;
1519
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1520
_tmp2_ = _tmp1_;
1270
1521
if (_inner_error_ != NULL) {
1271
1522
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1272
1523
g_propagate_error (error, _inner_error_);
1277
1528
return 0;
1278
1529
}
1279
1530
}
1280
_tmp2_ = sqlite3_column_int (self->priv->stmt, _tmp1_);
1281
result = _tmp2_;
1531
_tmp3_ = self->priv->stmt;
1532
_tmp4_ = sqlite3_column_int (_tmp3_, _tmp2_);
1533
result = _tmp4_;
1282
1534
return result;
1283
1535
}
1284
1536
1290
1542
SQLHeavyQueryResult * self;
1291
1543
gint64 result = 0LL;
1292
1544
gint _tmp0_;
1293
gint _tmp1_;
1294
gint64 _tmp2_;
1545
gint _tmp1_ = 0;
1546
gint _tmp2_;
1547
sqlite3_stmt* _tmp3_;
1548
gint64 _tmp4_ = 0LL;
1295
1549
GError * _inner_error_ = NULL;
1296
1550
self = (SQLHeavyQueryResult*) base;
1297
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
1298
_tmp1_ = _tmp0_;
1551
_tmp0_ = field;
1552
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1553
_tmp2_ = _tmp1_;
1299
1554
if (_inner_error_ != NULL) {
1300
1555
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1301
1556
g_propagate_error (error, _inner_error_);
1306
1561
return 0LL;
1307
1562
}
1308
1563
}
1309
_tmp2_ = sqlite3_column_int64 (self->priv->stmt, _tmp1_);
1310
result = _tmp2_;
1564
_tmp3_ = self->priv->stmt;
1565
_tmp4_ = sqlite3_column_int64 (_tmp3_, _tmp2_);
1566
result = _tmp4_;
1311
1567
return result;
1312
1568
}
1313
1569
1319
1575
SQLHeavyQueryResult * self;
1320
1576
gdouble result = 0.0;
1321
1577
gint _tmp0_;
1322
gint _tmp1_;
1323
gdouble _tmp2_;
1578
gint _tmp1_ = 0;
1579
gint _tmp2_;
1580
sqlite3_stmt* _tmp3_;
1581
gdouble _tmp4_ = 0.0;
1324
1582
GError * _inner_error_ = NULL;
1325
1583
self = (SQLHeavyQueryResult*) base;
1326
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
1327
_tmp1_ = _tmp0_;
1584
_tmp0_ = field;
1585
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1586
_tmp2_ = _tmp1_;
1328
1587
if (_inner_error_ != NULL) {
1329
1588
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1330
1589
g_propagate_error (error, _inner_error_);
1335
1594
return 0.0;
1336
1595
}
1337
1596
}
1338
_tmp2_ = sqlite3_column_double (self->priv->stmt, _tmp1_);
1339
result = _tmp2_;
1597
_tmp3_ = self->priv->stmt;
1598
_tmp4_ = sqlite3_column_double (_tmp3_, _tmp2_);
1599
result = _tmp4_;
1340
1600
return result;
1341
1601
}
1342
1602
1348
1608
SQLHeavyQueryResult * self;
1349
1609
guint8* result = NULL;
1350
1610
gint _tmp0_;
1351
gint _tmp1_;
1611
gint _tmp1_ = 0;
1352
1612
gint _tmp2_;
1353
guint8* _tmp3_ = NULL;
1613
sqlite3_stmt* _tmp3_;
1614
gint _tmp4_ = 0;
1615
guint8* _tmp5_ = NULL;
1354
1616
guint8* res;
1355
1617
gint res_length1;
1356
1618
gint _res_size_;
1357
void* _tmp4_ = NULL;
1358
guint8* _tmp5_;
1619
guint8* _tmp6_;
1620
gint _tmp6__length1;
1621
sqlite3_stmt* _tmp7_;
1622
gint _tmp8_;
1623
void* _tmp9_ = NULL;
1624
guint8* _tmp10_;
1625
gint _tmp10__length1;
1626
guint8* _tmp11_;
1627
gint _tmp11__length1;
1359
1628
GError * _inner_error_ = NULL;
1360
1629
self = (SQLHeavyQueryResult*) base;
1361
_tmp0_ = sql_heavy_query_result_field_check_index (self, field, &_inner_error_);
1362
_tmp1_ = _tmp0_;
1630
_tmp0_ = field;
1631
_tmp1_ = sql_heavy_query_result_field_check_index (self, _tmp0_, &_inner_error_);
1632
_tmp2_ = _tmp1_;
1363
1633
if (_inner_error_ != NULL) {
1364
1634
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1365
1635
g_propagate_error (error, _inner_error_);
1370
1640
return NULL;
1371
1641
}
1372
1642
}
1373
_tmp2_ = sqlite3_column_bytes (self->priv->stmt, _tmp1_);
1374
_tmp3_ = g_new0 (guint8, _tmp2_);
1375
res = _tmp3_;
1376
res_length1 = _tmp2_;
1377
_res_size_ = _tmp2_;
1378
_tmp4_ = sqlite3_column_blob (self->priv->stmt, field);
1379
memcpy (res, _tmp4_, (gsize) res_length1);
1380
_tmp5_ = res;
1643
_tmp3_ = self->priv->stmt;
1644
_tmp4_ = sqlite3_column_bytes (_tmp3_, _tmp2_);
1645
_tmp5_ = g_new0 (guint8, _tmp4_);
1646
res = _tmp5_;
1647
res_length1 = _tmp4_;
1648
_res_size_ = res_length1;
1649
_tmp6_ = res;
1650
_tmp6__length1 = res_length1;
1651
_tmp7_ = self->priv->stmt;
1652
_tmp8_ = field;
1653
_tmp9_ = sqlite3_column_blob (_tmp7_, _tmp8_);
1654
_tmp10_ = res;
1655
_tmp10__length1 = res_length1;
1656
memcpy (_tmp6_, _tmp9_, (gsize) _tmp10__length1);
1657
_tmp11_ = res;
1658
_tmp11__length1 = res_length1;
1381
1659
if (result_length1) {
1382
*result_length1 = res_length1;
1660
*result_length1 = _tmp11__length1;
1383
1661
}
1384
result = _tmp5_;
1662
result = _tmp11_;
1385
1663
return result;
1386
1664
}
1387
1665
1400
1678
static SQLHeavyRow* sql_heavy_query_result_real_fetch_foreign_row (SQLHeavyRecord* base, gint field, GError** error) {
1401
1679
SQLHeavyQueryResult * self;
1402
1680
SQLHeavyRow* result = NULL;
1403
SQLHeavyTable* _tmp0_ = NULL;
1681
gint _tmp0_;
1682
SQLHeavyTable* _tmp1_ = NULL;
1404
1683
SQLHeavyTable* table;
1405
gchar* _tmp1_ = NULL;
1406
gchar* _tmp2_;
1407
gchar* _tmp3_;
1408
gint _tmp4_;
1409
gint _tmp5_;
1684
gint _tmp2_;
1685
gchar* _tmp3_ = NULL;
1686
gchar* _tmp4_;
1687
SQLHeavyTable* _tmp5_;
1688
gchar* _tmp6_;
1689
gint _tmp7_ = 0;
1690
gint _tmp8_;
1410
1691
gint foreign_key_idx;
1411
SQLHeavyTable* _tmp6_ = NULL;
1692
SQLHeavyTable* _tmp9_;
1693
gint _tmp10_;
1694
SQLHeavyTable* _tmp11_ = NULL;
1412
1695
SQLHeavyTable* foreign_table;
1413
gchar* _tmp7_ = NULL;
1696
SQLHeavyTable* _tmp12_;
1697
gint _tmp13_;
1698
gchar* _tmp14_ = NULL;
1414
1699
gchar* foreign_column;
1415
SQLHeavyQueryable* _tmp8_ = NULL;
1416
const gchar* _tmp9_ = NULL;
1417
const gchar* _tmp10_ = NULL;
1418
const gchar* _tmp11_ = NULL;
1419
gchar* _tmp12_ = NULL;
1420
gchar* _tmp13_;
1421
SQLHeavyQuery* _tmp14_ = NULL;
1422
1700
SQLHeavyQuery* _tmp15_;
1701
SQLHeavyQueryable* _tmp16_;
1702
SQLHeavyQueryable* _tmp17_;
1703
SQLHeavyTable* _tmp18_;
1704
const gchar* _tmp19_;
1705
const gchar* _tmp20_;
1706
const gchar* _tmp21_ = NULL;
1707
const gchar* _tmp22_;
1708
const gchar* _tmp23_ = NULL;
1709
gchar* _tmp24_ = NULL;
1710
gchar* _tmp25_;
1711
SQLHeavyQuery* _tmp26_;
1712
SQLHeavyQuery* _tmp27_;
1423
1713
SQLHeavyQuery* q;
1424
gint64 _tmp16_;
1425
gint64 _tmp17_;
1426
SQLHeavyQueryResult* _tmp18_ = NULL;
1427
SQLHeavyQueryResult* _tmp19_;
1428
SQLHeavyQueryResult* _tmp20_;
1429
gint64 _tmp21_;
1430
gint64 _tmp22_;
1431
gint64 _tmp23_;
1432
SQLHeavyRow* _tmp24_ = NULL;
1714
gint _tmp28_;
1715
gint64 _tmp29_ = 0LL;
1716
gint64 _tmp30_;
1717
SQLHeavyQuery* _tmp31_;
1718
SQLHeavyQuery* _tmp32_;
1719
SQLHeavyQueryResult* _tmp33_ = NULL;
1720
SQLHeavyQueryResult* _tmp34_;
1721
SQLHeavyQueryResult* _tmp35_;
1722
gint64 _tmp36_ = 0LL;
1723
gint64 _tmp37_;
1724
gint64 _tmp38_;
1725
SQLHeavyTable* _tmp39_;
1726
SQLHeavyRow* _tmp40_;
1433
1727
GError * _inner_error_ = NULL;
1434
1728
self = (SQLHeavyQueryResult*) base;
1435
_tmp0_ = sql_heavy_query_result_field_origin_table (self, field, &_inner_error_);
1436
table = _tmp0_;
1437
if (_inner_error_ != NULL) {
1438
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1439
g_propagate_error (error, _inner_error_);
1440
return NULL;
1441
} else {
1442
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);
1443
g_clear_error (&_inner_error_);
1444
return NULL;
1445
}
1446
}
1447
_tmp1_ = sql_heavy_query_result_field_origin_name (self, field, &_inner_error_);
1448
_tmp2_ = _tmp1_;
1449
if (_inner_error_ != NULL) {
1450
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1451
g_propagate_error (error, _inner_error_);
1452
_g_object_unref0 (table);
1453
return NULL;
1454
} else {
1455
_g_object_unref0 (table);
1456
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);
1457
g_clear_error (&_inner_error_);
1458
return NULL;
1459
}
1460
}
1461
_tmp3_ = _tmp2_;
1462
_tmp4_ = sql_heavy_table_foreign_key_index (table, _tmp3_, &_inner_error_);
1463
_tmp5_ = _tmp4_;
1464
_g_free0 (_tmp3_);
1465
foreign_key_idx = _tmp5_;
1466
if (_inner_error_ != NULL) {
1467
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1468
g_propagate_error (error, _inner_error_);
1469
_g_object_unref0 (table);
1470
return NULL;
1471
} else {
1472
_g_object_unref0 (table);
1473
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);
1474
g_clear_error (&_inner_error_);
1475
return NULL;
1476
}
1477
}
1478
_tmp6_ = sql_heavy_table_foreign_key_table (table, foreign_key_idx, &_inner_error_);
1479
foreign_table = _tmp6_;
1480
if (_inner_error_ != NULL) {
1481
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1482
g_propagate_error (error, _inner_error_);
1483
_g_object_unref0 (table);
1484
return NULL;
1485
} else {
1486
_g_object_unref0 (table);
1487
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);
1488
g_clear_error (&_inner_error_);
1489
return NULL;
1490
}
1491
}
1492
_tmp7_ = sql_heavy_table_foreign_key_to (table, foreign_key_idx, &_inner_error_);
1493
foreign_column = _tmp7_;
1494
if (_inner_error_ != NULL) {
1495
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1496
g_propagate_error (error, _inner_error_);
1497
_g_object_unref0 (foreign_table);
1498
_g_object_unref0 (table);
1499
return NULL;
1500
} else {
1501
_g_object_unref0 (foreign_table);
1502
_g_object_unref0 (table);
1503
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);
1504
g_clear_error (&_inner_error_);
1505
return NULL;
1506
}
1507
}
1508
_tmp8_ = sql_heavy_query_get_queryable (self->priv->_query);
1509
_tmp9_ = sql_heavy_table_get_name (foreign_table);
1510
_tmp10_ = string_to_string (_tmp9_);
1511
_tmp11_ = string_to_string (foreign_column);
1512
_tmp12_ = g_strconcat ("SELECT `ROWID` FROM `", _tmp10_, "` WHERE `", _tmp11_, "` = :value;", NULL);
1513
_tmp13_ = _tmp12_;
1514
_tmp14_ = sql_heavy_query_new (_tmp8_, _tmp13_, &_inner_error_);
1515
_tmp15_ = _tmp14_;
1516
_g_free0 (_tmp13_);
1517
q = _tmp15_;
1518
if (_inner_error_ != NULL) {
1519
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1520
g_propagate_error (error, _inner_error_);
1521
_g_free0 (foreign_column);
1522
_g_object_unref0 (foreign_table);
1523
_g_object_unref0 (table);
1524
return NULL;
1525
} else {
1526
_g_free0 (foreign_column);
1527
_g_object_unref0 (foreign_table);
1528
_g_object_unref0 (table);
1529
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);
1530
g_clear_error (&_inner_error_);
1531
return NULL;
1532
}
1533
}
1534
_tmp16_ = sql_heavy_record_fetch_int64 ((SQLHeavyRecord*) self, field, &_inner_error_);
1729
_tmp0_ = field;
1730
_tmp1_ = sql_heavy_query_result_field_origin_table (self, _tmp0_, &_inner_error_);
1731
table = _tmp1_;
1732
if (_inner_error_ != NULL) {
1733
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1734
g_propagate_error (error, _inner_error_);
1735
return NULL;
1736
} else {
1737
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);
1738
g_clear_error (&_inner_error_);
1739
return NULL;
1740
}
1741
}
1742
_tmp2_ = field;
1743
_tmp3_ = sql_heavy_query_result_field_origin_name (self, _tmp2_, &_inner_error_);
1744
_tmp4_ = _tmp3_;
1745
if (_inner_error_ != NULL) {
1746
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1747
g_propagate_error (error, _inner_error_);
1748
_g_object_unref0 (table);
1749
return NULL;
1750
} else {
1751
_g_object_unref0 (table);
1752
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);
1753
g_clear_error (&_inner_error_);
1754
return NULL;
1755
}
1756
}
1757
_tmp5_ = table;
1758
_tmp6_ = _tmp4_;
1759
_tmp7_ = sql_heavy_table_foreign_key_index (_tmp5_, _tmp6_, &_inner_error_);
1760
_tmp8_ = _tmp7_;
1761
_g_free0 (_tmp6_);
1762
foreign_key_idx = _tmp8_;
1763
if (_inner_error_ != NULL) {
1764
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1765
g_propagate_error (error, _inner_error_);
1766
_g_object_unref0 (table);
1767
return NULL;
1768
} else {
1769
_g_object_unref0 (table);
1770
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);
1771
g_clear_error (&_inner_error_);
1772
return NULL;
1773
}
1774
}
1775
_tmp9_ = table;
1776
_tmp10_ = foreign_key_idx;
1777
_tmp11_ = sql_heavy_table_foreign_key_table (_tmp9_, _tmp10_, &_inner_error_);
1778
foreign_table = _tmp11_;
1779
if (_inner_error_ != NULL) {
1780
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1781
g_propagate_error (error, _inner_error_);
1782
_g_object_unref0 (table);
1783
return NULL;
1784
} else {
1785
_g_object_unref0 (table);
1786
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);
1787
g_clear_error (&_inner_error_);
1788
return NULL;
1789
}
1790
}
1791
_tmp12_ = table;
1792
_tmp13_ = foreign_key_idx;
1793
_tmp14_ = sql_heavy_table_foreign_key_to (_tmp12_, _tmp13_, &_inner_error_);
1794
foreign_column = _tmp14_;
1795
if (_inner_error_ != NULL) {
1796
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1797
g_propagate_error (error, _inner_error_);
1798
_g_object_unref0 (foreign_table);
1799
_g_object_unref0 (table);
1800
return NULL;
1801
} else {
1802
_g_object_unref0 (foreign_table);
1803
_g_object_unref0 (table);
1804
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);
1805
g_clear_error (&_inner_error_);
1806
return NULL;
1807
}
1808
}
1809
_tmp15_ = self->priv->_query;
1810
_tmp16_ = sql_heavy_query_get_queryable (_tmp15_);
1535
1811
_tmp17_ = _tmp16_;
1536
if (_inner_error_ != NULL) {
1537
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1538
g_propagate_error (error, _inner_error_);
1539
_g_object_unref0 (q);
1540
_g_free0 (foreign_column);
1541
_g_object_unref0 (foreign_table);
1542
_g_object_unref0 (table);
1543
return NULL;
1544
} else {
1545
_g_object_unref0 (q);
1546
_g_free0 (foreign_column);
1547
_g_object_unref0 (foreign_table);
1548
_g_object_unref0 (table);
1549
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);
1550
g_clear_error (&_inner_error_);
1551
return NULL;
1552
}
1553
}
1554
sql_heavy_query_bind_int64 (q, 1, _tmp17_, &_inner_error_);
1555
if (_inner_error_ != NULL) {
1556
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1557
g_propagate_error (error, _inner_error_);
1558
_g_object_unref0 (q);
1559
_g_free0 (foreign_column);
1560
_g_object_unref0 (foreign_table);
1561
_g_object_unref0 (table);
1562
return NULL;
1563
} else {
1564
_g_object_unref0 (q);
1565
_g_free0 (foreign_column);
1566
_g_object_unref0 (foreign_table);
1567
_g_object_unref0 (table);
1568
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);
1569
g_clear_error (&_inner_error_);
1570
return NULL;
1571
}
1572
}
1573
_tmp18_ = sql_heavy_query_execute (q, NULL, &_inner_error_, NULL);
1574
_tmp19_ = _tmp18_;
1575
if (_inner_error_ != NULL) {
1576
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1577
g_propagate_error (error, _inner_error_);
1578
_g_object_unref0 (q);
1579
_g_free0 (foreign_column);
1580
_g_object_unref0 (foreign_table);
1581
_g_object_unref0 (table);
1582
return NULL;
1583
} else {
1584
_g_object_unref0 (q);
1585
_g_free0 (foreign_column);
1586
_g_object_unref0 (foreign_table);
1587
_g_object_unref0 (table);
1588
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);
1589
g_clear_error (&_inner_error_);
1590
return NULL;
1591
}
1592
}
1812
_tmp18_ = foreign_table;
1813
_tmp19_ = sql_heavy_table_get_name (_tmp18_);
1593
1814
_tmp20_ = _tmp19_;
1594
_tmp21_ = sql_heavy_record_fetch_int64 ((SQLHeavyRecord*) _tmp20_, 0, &_inner_error_);
1595
_tmp22_ = _tmp21_;
1596
_g_object_unref0 (_tmp20_);
1597
_tmp23_ = _tmp22_;
1598
if (_inner_error_ != NULL) {
1599
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1600
g_propagate_error (error, _inner_error_);
1601
_g_object_unref0 (q);
1602
_g_free0 (foreign_column);
1603
_g_object_unref0 (foreign_table);
1604
_g_object_unref0 (table);
1605
return NULL;
1606
} else {
1607
_g_object_unref0 (q);
1608
_g_free0 (foreign_column);
1609
_g_object_unref0 (foreign_table);
1610
_g_object_unref0 (table);
1611
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);
1612
g_clear_error (&_inner_error_);
1613
return NULL;
1614
}
1615
}
1616
_tmp24_ = sql_heavy_row_new (foreign_table, _tmp23_);
1617
result = _tmp24_;
1815
_tmp21_ = string_to_string (_tmp20_);
1816
_tmp22_ = foreign_column;
1817
_tmp23_ = string_to_string (_tmp22_);
1818
_tmp24_ = g_strconcat ("SELECT `ROWID` FROM `", _tmp21_, "` WHERE `", _tmp23_, "` = :value;", NULL);
1819
_tmp25_ = _tmp24_;
1820
_tmp26_ = sql_heavy_query_new (_tmp17_, _tmp25_, &_inner_error_);
1821
_tmp27_ = _tmp26_;
1822
_g_free0 (_tmp25_);
1823
q = _tmp27_;
1824
if (_inner_error_ != NULL) {
1825
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1826
g_propagate_error (error, _inner_error_);
1827
_g_free0 (foreign_column);
1828
_g_object_unref0 (foreign_table);
1829
_g_object_unref0 (table);
1830
return NULL;
1831
} else {
1832
_g_free0 (foreign_column);
1833
_g_object_unref0 (foreign_table);
1834
_g_object_unref0 (table);
1835
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);
1836
g_clear_error (&_inner_error_);
1837
return NULL;
1838
}
1839
}
1840
_tmp28_ = field;
1841
_tmp29_ = sql_heavy_record_fetch_int64 ((SQLHeavyRecord*) self, _tmp28_, &_inner_error_);
1842
_tmp30_ = _tmp29_;
1843
if (_inner_error_ != NULL) {
1844
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1845
g_propagate_error (error, _inner_error_);
1846
_g_object_unref0 (q);
1847
_g_free0 (foreign_column);
1848
_g_object_unref0 (foreign_table);
1849
_g_object_unref0 (table);
1850
return NULL;
1851
} else {
1852
_g_object_unref0 (q);
1853
_g_free0 (foreign_column);
1854
_g_object_unref0 (foreign_table);
1855
_g_object_unref0 (table);
1856
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);
1857
g_clear_error (&_inner_error_);
1858
return NULL;
1859
}
1860
}
1861
_tmp31_ = q;
1862
sql_heavy_query_bind_int64 (_tmp31_, 1, _tmp30_, &_inner_error_);
1863
if (_inner_error_ != NULL) {
1864
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1865
g_propagate_error (error, _inner_error_);
1866
_g_object_unref0 (q);
1867
_g_free0 (foreign_column);
1868
_g_object_unref0 (foreign_table);
1869
_g_object_unref0 (table);
1870
return NULL;
1871
} else {
1872
_g_object_unref0 (q);
1873
_g_free0 (foreign_column);
1874
_g_object_unref0 (foreign_table);
1875
_g_object_unref0 (table);
1876
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);
1877
g_clear_error (&_inner_error_);
1878
return NULL;
1879
}
1880
}
1881
_tmp32_ = q;
1882
_tmp33_ = sql_heavy_query_execute (_tmp32_, NULL, &_inner_error_, NULL);
1883
_tmp34_ = _tmp33_;
1884
if (_inner_error_ != NULL) {
1885
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1886
g_propagate_error (error, _inner_error_);
1887
_g_object_unref0 (q);
1888
_g_free0 (foreign_column);
1889
_g_object_unref0 (foreign_table);
1890
_g_object_unref0 (table);
1891
return NULL;
1892
} else {
1893
_g_object_unref0 (q);
1894
_g_free0 (foreign_column);
1895
_g_object_unref0 (foreign_table);
1896
_g_object_unref0 (table);
1897
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);
1898
g_clear_error (&_inner_error_);
1899
return NULL;
1900
}
1901
}
1902
_tmp35_ = _tmp34_;
1903
_tmp36_ = sql_heavy_record_fetch_int64 ((SQLHeavyRecord*) _tmp35_, 0, &_inner_error_);
1904
_tmp37_ = _tmp36_;
1905
_g_object_unref0 (_tmp35_);
1906
_tmp38_ = _tmp37_;
1907
if (_inner_error_ != NULL) {
1908
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1909
g_propagate_error (error, _inner_error_);
1910
_g_object_unref0 (q);
1911
_g_free0 (foreign_column);
1912
_g_object_unref0 (foreign_table);
1913
_g_object_unref0 (table);
1914
return NULL;
1915
} else {
1916
_g_object_unref0 (q);
1917
_g_free0 (foreign_column);
1918
_g_object_unref0 (foreign_table);
1919
_g_object_unref0 (table);
1920
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);
1921
g_clear_error (&_inner_error_);
1922
return NULL;
1923
}
1924
}
1925
_tmp39_ = foreign_table;
1926
_tmp40_ = sql_heavy_row_new (_tmp39_, _tmp38_);
1927
result = _tmp40_;
1618
1928
_g_object_unref0 (q);
1619
1929
_g_free0 (foreign_column);
1620
1930
_g_object_unref0 (foreign_table);
1630
1940
*/
1631
1941
SQLHeavyQueryResult* sql_heavy_query_result_construct_no_lock (GType object_type, SQLHeavyQuery* query, GError** error) {
1632
1942
SQLHeavyQueryResult * self = NULL;
1943
SQLHeavyQuery* _tmp0_;
1633
1944
GError * _inner_error_ = NULL;
1634
1945
g_return_val_if_fail (query != NULL, NULL);
1635
self = (SQLHeavyQueryResult*) g_object_new (object_type, "query", query, NULL);
1946
_tmp0_ = query;
1947
self = (SQLHeavyQueryResult*) g_object_new (object_type, "query", _tmp0_, NULL);
1636
1948
sql_heavy_query_result_next_internal (self, &_inner_error_);
1637
1949
if (_inner_error_ != NULL) {
1638
1950
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1662
1974
* @see Query.execute_insert
1663
1975
*/
1664
1976
SQLHeavyQueryResult* sql_heavy_query_result_construct_insert (GType object_type, SQLHeavyQuery* query, gint64* insert_id, GError** error) {
1665
gint64 _insert_id = 0LL;
1977
gint64 _vala_insert_id = 0LL;
1666
1978
SQLHeavyQueryResult * self = NULL;
1667
SQLHeavyQueryable* _tmp0_ = NULL;
1979
SQLHeavyQuery* _tmp0_;
1980
SQLHeavyQuery* _tmp1_;
1981
SQLHeavyQueryable* _tmp2_;
1982
SQLHeavyQueryable* _tmp3_;
1668
1983
SQLHeavyQueryable* queryable;
1669
SQLHeavyDatabase* _tmp1_ = NULL;
1984
SQLHeavyQueryable* _tmp4_;
1985
SQLHeavyDatabase* _tmp5_;
1986
SQLHeavyDatabase* _tmp6_;
1670
1987
SQLHeavyDatabase* db;
1671
gint64 _tmp2_;
1988
SQLHeavyQueryable* _tmp7_;
1989
SQLHeavyDatabase* _tmp8_;
1990
SQLHeavyQueryable* _tmp16_;
1991
SQLHeavyDatabase* _tmp17_;
1672
1992
GError * _inner_error_ = NULL;
1673
1993
g_return_val_if_fail (query != NULL, NULL);
1674
self = (SQLHeavyQueryResult*) g_object_new (object_type, "query", query, NULL);
1675
_tmp0_ = sql_heavy_query_get_queryable (query);
1676
queryable = _tmp0_;
1677
_tmp1_ = sql_heavy_queryable_get_database (queryable);
1678
db = _tmp1_;
1679
sql_heavy_query_result_acquire_locks (self, queryable, db);
1680
sql_heavy_query_result_next_internal (self, &_inner_error_);
1681
if (_inner_error_ != NULL) {
1682
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1683
goto __catch26_sql_heavy_error;
1994
_tmp0_ = query;
1995
self = (SQLHeavyQueryResult*) g_object_new (object_type, "query", _tmp0_, NULL);
1996
_tmp1_ = query;
1997
_tmp2_ = sql_heavy_query_get_queryable (_tmp1_);
1998
_tmp3_ = _tmp2_;
1999
queryable = _tmp3_;
2000
_tmp4_ = queryable;
2001
_tmp5_ = sql_heavy_queryable_get_database (_tmp4_);
2002
_tmp6_ = _tmp5_;
2003
db = _tmp6_;
2004
_tmp7_ = queryable;
2005
_tmp8_ = db;
2006
sql_heavy_query_result_acquire_locks (self, _tmp7_, _tmp8_);
2007
{
2008
SQLHeavyDatabase* _tmp9_;
2009
gint64 _tmp10_;
2010
gint64 _tmp11_;
2011
sql_heavy_query_result_next_internal (self, &_inner_error_);
2012
if (_inner_error_ != NULL) {
2013
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
2014
goto __catch26_sql_heavy_error;
2015
}
2016
_g_object_unref0 (db);
2017
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);
2018
g_clear_error (&_inner_error_);
2019
return NULL;
1684
2020
}
1685
_g_object_unref0 (db);
1686
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);
1687
g_clear_error (&_inner_error_);
1688
return NULL;
2021
_tmp9_ = db;
2022
_tmp10_ = sql_heavy_database_get_last_insert_id (_tmp9_);
2023
_tmp11_ = _tmp10_;
2024
_vala_insert_id = _tmp11_;
1689
2025
}
1690
_tmp2_ = sql_heavy_database_get_last_insert_id (db);
1691
_insert_id = _tmp2_;
1692
2026
goto __finally26;
1693
2027
__catch26_sql_heavy_error:
1694
2028
{
1695
GError * e;
1696
GError* _tmp3_;
2029
GError* e = NULL;
2030
SQLHeavyQueryable* _tmp12_;
2031
SQLHeavyDatabase* _tmp13_;
2032
GError* _tmp14_;
2033
GError* _tmp15_;
1697
2034
e = _inner_error_;
1698
2035
_inner_error_ = NULL;
1699
sql_heavy_query_result_release_locks (self, queryable, db);
1700
_tmp3_ = _g_error_copy0 (e);
1701
_inner_error_ = _tmp3_;
2036
_tmp12_ = queryable;
2037
_tmp13_ = db;
2038
sql_heavy_query_result_release_locks (self, _tmp12_, _tmp13_);
2039
_tmp14_ = e;
2040
_tmp15_ = _g_error_copy0 (_tmp14_);
2041
_inner_error_ = _tmp15_;
1702
2042
_g_error_free0 (e);
1703
2043
goto __finally26;
1704
2044
}
1716
2056
return NULL;
1717
2057
}
1718
2058
}
1719
sql_heavy_query_result_release_locks (self, queryable, db);
2059
_tmp16_ = queryable;
2060
_tmp17_ = db;
2061
sql_heavy_query_result_release_locks (self, _tmp16_, _tmp17_);
1720
2062
_g_object_unref0 (db);
1721
2063
if (insert_id) {
1722
*insert_id = _insert_id;
2064
*insert_id = _vala_insert_id;
1723
2065
}
1724
2066
return self;
1725
2067
}
1737
2079
*/
1738
2080
SQLHeavyQueryResult* sql_heavy_query_result_construct_no_exec (GType object_type, SQLHeavyQuery* query, GError** error) {
1739
2081
SQLHeavyQueryResult * self = NULL;
2082
SQLHeavyQuery* _tmp0_;
1740
2083
g_return_val_if_fail (query != NULL, NULL);
1741
self = (SQLHeavyQueryResult*) g_object_new (object_type, "query", query, NULL);
2084
_tmp0_ = query;
2085
self = (SQLHeavyQueryResult*) g_object_new (object_type, "query", _tmp0_, NULL);
1742
2086
return self;
1743
2087
}
1744
2088
1755
2099
*/
1756
2100
SQLHeavyQueryResult* sql_heavy_query_result_construct (GType object_type, SQLHeavyQuery* query, GError** error) {
1757
2101
SQLHeavyQueryResult * self = NULL;
2102
SQLHeavyQuery* _tmp0_;
1758
2103
GError * _inner_error_ = NULL;
1759
2104
g_return_val_if_fail (query != NULL, NULL);
1760
self = (SQLHeavyQueryResult*) g_object_new (object_type, "query", query, NULL);
2105
_tmp0_ = query;
2106
self = (SQLHeavyQueryResult*) g_object_new (object_type, "query", _tmp0_, NULL);
1761
2107
sql_heavy_record_set_next ((SQLHeavyRecordSet*) self, &_inner_error_);
1762
2108
if (_inner_error_ != NULL) {
1763
2109
if (_inner_error_->domain == SQL_HEAVY_ERROR) {
1781
2127
1782
2128
SQLHeavyQuery* sql_heavy_query_result_get_query (SQLHeavyQueryResult* self) {
1783
2129
SQLHeavyQuery* result;
2130
SQLHeavyQuery* _tmp0_;
1784
2131
g_return_val_if_fail (self != NULL, NULL);
1785
result = self->priv->_query;
2132
_tmp0_ = self->priv->_query;
2133
result = _tmp0_;
1786
2134
return result;
1787
2135
}
1788
2136
1789
2137
1790
2138
static void sql_heavy_query_result_set_query (SQLHeavyQueryResult* self, SQLHeavyQuery* value) {
1791
2139
SQLHeavyQuery* _tmp0_;
2140
SQLHeavyQuery* _tmp1_;
1792
2141
g_return_if_fail (self != NULL);
1793
_tmp0_ = _g_object_ref0 (value);
2142
_tmp0_ = value;
2143
_tmp1_ = _g_object_ref0 (_tmp0_);
1794
2144
_g_object_unref0 (self->priv->_query);
1795
self->priv->_query = _tmp0_;
2145
self->priv->_query = _tmp1_;
1796
2146
g_object_notify ((GObject *) self, "query");
1797
2147
}
1798
2148
1799
2149
1800
2150
SQLHeavyValueArray* sql_heavy_query_result_get_bindings (SQLHeavyQueryResult* self) {
1801
2151
SQLHeavyValueArray* result;
2152
SQLHeavyValueArray* _tmp0_;
1802
2153
g_return_val_if_fail (self != NULL, NULL);
1803
result = self->priv->_bindings;
2154
_tmp0_ = self->priv->_bindings;
2155
result = _tmp0_;
1804
2156
return result;
1805
2157
}
1806
2158
1807
2159
1808
2160
static void sql_heavy_query_result_set_bindings (SQLHeavyQueryResult* self, SQLHeavyValueArray* value) {
1809
2161
SQLHeavyValueArray* _tmp0_;
2162
SQLHeavyValueArray* _tmp1_;
1810
2163
g_return_if_fail (self != NULL);
1811
_tmp0_ = _g_object_ref0 (value);
2164
_tmp0_ = value;
2165
_tmp1_ = _g_object_ref0 (_tmp0_);
1812
2166
_g_object_unref0 (self->priv->_bindings);
1813
self->priv->_bindings = _tmp0_;
2167
self->priv->_bindings = _tmp1_;
1814
2168
g_object_notify ((GObject *) self, "bindings");
1815
2169
}
1816
2170
1817
2171
1818
2172
gint sql_heavy_query_result_get_full_scan_steps (SQLHeavyQueryResult* self) {
1819
2173
gint result;
1820
gint _tmp0_;
2174
sqlite3_stmt* _tmp0_;
2175
gint _tmp1_ = 0;
1821
2176
g_return_val_if_fail (self != NULL, 0);
1822
_tmp0_ = sqlite3_stmt_status (self->priv->stmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, 0);
1823
result = _tmp0_;
2177
_tmp0_ = self->priv->stmt;
2178
_tmp1_ = sqlite3_stmt_status (_tmp0_, SQLITE_STMTSTATUS_FULLSCAN_STEP, 0);
2179
result = _tmp1_;
1824
2180
return result;
1825
2181
}
1826
2182
1827
2183
1828
2184
gint sql_heavy_query_result_get_sort_operations (SQLHeavyQueryResult* self) {
1829
2185
gint result;
1830
gint _tmp0_;
2186
sqlite3_stmt* _tmp0_;
2187
gint _tmp1_ = 0;
1831
2188
g_return_val_if_fail (self != NULL, 0);
1832
_tmp0_ = sqlite3_stmt_status (self->priv->stmt, SQLITE_STMTSTATUS_SORT, 0);
1833
result = _tmp0_;
2189
_tmp0_ = self->priv->stmt;
2190
_tmp1_ = sqlite3_stmt_status (_tmp0_, SQLITE_STMTSTATUS_SORT, 0);
2191
result = _tmp1_;
1834
2192
return result;
1835
2193
}
1836
2194
1837
2195
1838
2196
gdouble sql_heavy_query_result_get_execution_time (SQLHeavyQueryResult* self) {
1839
2197
gdouble result;
1840
gdouble _tmp0_;
2198
GTimer* _tmp0_;
2199
gdouble _tmp1_ = 0.0;
1841
2200
g_return_val_if_fail (self != NULL, 0.0);
1842
_tmp0_ = g_timer_elapsed (self->priv->execution_timer, NULL);
1843
result = _tmp0_;
2201
_tmp0_ = self->priv->execution_timer;
2202
_tmp1_ = g_timer_elapsed (_tmp0_, NULL);
2203
result = _tmp1_;
1844
2204
return result;
1845
2205
}
1846
2206
1847
2207
1848
2208
gboolean sql_heavy_query_result_get_finished (SQLHeavyQueryResult* self) {
1849
2209
gboolean result;
2210
gboolean _tmp0_;
1850
2211
g_return_val_if_fail (self != NULL, FALSE);
1851
result = self->priv->_finished;
2212
_tmp0_ = self->priv->_finished;
2213
result = _tmp0_;
1852
2214
return result;
1853
2215
}
1854
2216
1855
2217
1856
2218
static void sql_heavy_query_result_set_finished (SQLHeavyQueryResult* self, gboolean value) {
2219
gboolean _tmp0_;
1857
2220
g_return_if_fail (self != NULL);
1858
self->priv->_finished = value;
2221
_tmp0_ = value;
2222
self->priv->_finished = _tmp0_;
1859
2223
g_object_notify ((GObject *) self, "finished");
1860
2224
}
1861
2225
1863
2227
static gint sql_heavy_query_result_real_get_field_count (SQLHeavyRecord* base) {
1864
2228
gint result;
1865
2229
SQLHeavyQueryResult* self;
2230
gint _tmp0_;
1866
2231
self = (SQLHeavyQueryResult*) base;
1867
result = self->priv->_field_count;
2232
_tmp0_ = self->priv->_field_count;
2233
result = _tmp0_;
1868
2234
return result;
1869
2235
}
1870
2236
1878
2244
GObject * obj;
1879
2245
GObjectClass * parent_class;
1880
2246
SQLHeavyQueryResult * self;
1881
GTimer* _tmp0_ = NULL;
1882
sqlite3_stmt* _tmp1_ = NULL;
1883
gint _tmp10_;
1884
gint _tmp13_;
2247
GTimer* _tmp0_;
2248
GTimer* _tmp1_;
2249
GTimer* _tmp2_;
2250
SQLHeavyQuery* _tmp3_;
2251
sqlite3_stmt* _tmp4_ = NULL;
2252
sqlite3_stmt* _tmp5_;
2253
sqlite3_stmt* _tmp20_;
2254
gint _tmp21_ = 0;
2255
SQLHeavyValueArray* _tmp22_;
2256
SQLHeavyValueArray* _tmp26_;
2257
gint _tmp27_;
2258
gint _tmp28_;
1885
2259
gint bindings_length;
1886
2260
parent_class = G_OBJECT_CLASS (sql_heavy_query_result_parent_class);
1887
2261
obj = parent_class->constructor (type, n_construct_properties, construct_properties);
1889
2263
_tmp0_ = g_timer_new ();
1890
2264
_g_timer_destroy0 (self->priv->execution_timer);
1891
2265
self->priv->execution_timer = _tmp0_;
1892
g_timer_stop (self->priv->execution_timer);
1893
g_timer_reset (self->priv->execution_timer);
1894
_tmp1_ = sql_heavy_query_try_to_steal_stmt (self->priv->_query);
1895
self->priv->stmt = _tmp1_;
1896
if (self->priv->stmt == NULL) {
1897
SQLHeavyQueryable* _tmp2_ = NULL;
1898
SQLHeavyDatabase* _tmp3_ = NULL;
1899
SQLHeavyDatabase* _tmp4_;
1900
sqlite3* _tmp5_ = NULL;
1901
sqlite3* _tmp6_;
2266
_tmp1_ = self->priv->execution_timer;
2267
g_timer_stop (_tmp1_);
2268
_tmp2_ = self->priv->execution_timer;
2269
g_timer_reset (_tmp2_);
2270
_tmp3_ = self->priv->_query;
2271
_tmp4_ = sql_heavy_query_try_to_steal_stmt (_tmp3_);
2272
self->priv->stmt = _tmp4_;
2273
_tmp5_ = self->priv->stmt;
2274
if (_tmp5_ == NULL) {
2275
SQLHeavyQuery* _tmp6_;
2276
SQLHeavyQueryable* _tmp7_;
2277
SQLHeavyQueryable* _tmp8_;
2278
SQLHeavyDatabase* _tmp9_;
2279
SQLHeavyDatabase* _tmp10_;
2280
SQLHeavyDatabase* _tmp11_;
2281
sqlite3* _tmp12_ = NULL;
2282
sqlite3* _tmp13_;
1902
2283
sqlite3* db;
1903
const gchar* _tmp7_ = NULL;
1904
sqlite3_stmt* _tmp8_ = NULL;
1905
gint _tmp9_;
2284
sqlite3* _tmp14_;
2285
SQLHeavyQuery* _tmp15_;
2286
const gchar* _tmp16_;
2287
const gchar* _tmp17_;
2288
sqlite3_stmt* _tmp18_ = NULL;
2289
gint _tmp19_ = 0;
1906
2290
self->priv->stmt_is_owned = TRUE;
1907
_tmp2_ = sql_heavy_query_get_queryable (self->priv->_query);
1908
_tmp3_ = sql_heavy_queryable_get_database (_tmp2_);
1909
_tmp4_ = _tmp3_;
1910
_tmp5_ = sql_heavy_database_get_sqlite_db (_tmp4_);
1911
_tmp6_ = _tmp5_;
1912
_g_object_unref0 (_tmp4_);
1913
db = _tmp6_;
1914
_tmp7_ = sql_heavy_query_get_sql (self->priv->_query);
1915
_tmp9_ = sqlite3_prepare_v2 (db, _tmp7_, -1, &_tmp8_, NULL);
1916
self->priv->stmt = _tmp8_;
1917
g_assert (_tmp9_ == SQLITE_OK);
2291
_tmp6_ = self->priv->_query;
2292
_tmp7_ = sql_heavy_query_get_queryable (_tmp6_);
2293
_tmp8_ = _tmp7_;
2294
_tmp9_ = sql_heavy_queryable_get_database (_tmp8_);
2295
_tmp10_ = _tmp9_;
2296
_tmp11_ = _tmp10_;
2297
_tmp12_ = sql_heavy_database_get_sqlite_db (_tmp11_);
2298
_tmp13_ = _tmp12_;
2299
_g_object_unref0 (_tmp11_);
2300
db = _tmp13_;
2301
_tmp14_ = db;
2302
_tmp15_ = self->priv->_query;
2303
_tmp16_ = sql_heavy_query_get_sql (_tmp15_);
2304
_tmp17_ = _tmp16_;
2305
_tmp19_ = sqlite3_prepare_v2 (_tmp14_, _tmp17_, -1, &_tmp18_, NULL);
2306
self->priv->stmt = _tmp18_;
2307
g_assert (_tmp19_ == SQLITE_OK);
1918
2308
} else {
1919
2309
self->priv->stmt_is_owned = FALSE;
1920
2310
}
1921
_tmp10_ = sqlite3_column_count (self->priv->stmt);
1922
self->priv->_field_count = _tmp10_;
1923
if (self->priv->_bindings == NULL) {
1924
SQLHeavyValueArray* _tmp11_ = NULL;
1925
SQLHeavyValueArray* _tmp12_;
1926
_tmp11_ = sql_heavy_query_get_bindings (self->priv->_query);
1927
_tmp12_ = _tmp11_;
1928
sql_heavy_query_result_set_bindings (self, _tmp12_);
1929
_g_object_unref0 (_tmp12_);
2311
_tmp20_ = self->priv->stmt;
2312
_tmp21_ = sqlite3_column_count (_tmp20_);
2313
self->priv->_field_count = _tmp21_;
2314
_tmp22_ = self->priv->_bindings;
2315
if (_tmp22_ == NULL) {
2316
SQLHeavyQuery* _tmp23_;
2317
SQLHeavyValueArray* _tmp24_ = NULL;
2318
SQLHeavyValueArray* _tmp25_;
2319
_tmp23_ = self->priv->_query;
2320
_tmp24_ = sql_heavy_query_get_bindings (_tmp23_);
2321
_tmp25_ = _tmp24_;
2322
sql_heavy_query_result_set_bindings (self, _tmp25_);
2323
_g_object_unref0 (_tmp25_);
1930
2324
}
1931
_tmp13_ = sql_heavy_value_array_get_length (self->priv->_bindings);
1932
bindings_length = _tmp13_;
2325
_tmp26_ = self->priv->_bindings;
2326
_tmp27_ = sql_heavy_value_array_get_length (_tmp26_);
2327
_tmp28_ = _tmp27_;
2328
bindings_length = _tmp28_;
1933
2329
{
1934
2330
gint i;
1935
2331
i = 0;
1936
2332
{
1937
gboolean _tmp14_;
1938
_tmp14_ = TRUE;
2333
gboolean _tmp29_;
2334
_tmp29_ = TRUE;
1939
2335
while (TRUE) {
1940
GValue* _tmp15_ = NULL;
2336
gboolean _tmp30_;
2337
gint _tmp32_;
2338
gint _tmp33_;
2339
SQLHeavyValueArray* _tmp34_;
2340
gint _tmp35_;
2341
GValue* _tmp36_ = NULL;
1941
2342
GValue* val;
1942
if (!_tmp14_) {
1943
i++;
2343
GValue* _tmp37_;
2344
_tmp30_ = _tmp29_;
2345
if (!_tmp30_) {
2346
gint _tmp31_;
2347
_tmp31_ = i;
2348
i = _tmp31_ + 1;
1944
2349
}
1945
_tmp14_ = FALSE;
1946
if (!(i < bindings_length)) {
2350
_tmp29_ = FALSE;
2351
_tmp32_ = i;
2352
_tmp33_ = bindings_length;
2353
if (!(_tmp32_ < _tmp33_)) {
1947
2354
break;
1948
2355
}
1949
_tmp15_ = sql_heavy_value_array_get (self->priv->_bindings, i);
1950
val = _tmp15_;
1951
if (val == NULL) {
2356
_tmp34_ = self->priv->_bindings;
2357
_tmp35_ = i;
2358
_tmp36_ = sql_heavy_value_array_get (_tmp34_, _tmp35_);
2359
val = _tmp36_;
2360
_tmp37_ = val;
2361
if (_tmp37_ == NULL) {
1952
2362
g_critical ("sqlheavy-query-result.vala:459: Incomplete bindings");
1953
2363
} else {
1954
GType _tmp16_;
2364
GValue* _tmp38_;
2365
GType _tmp39_ = 0UL;
1955
2366
GType val_t;
2367
gint _tmp40_;
1956
2368
gint index;
1957
_tmp16_ = G_VALUE_TYPE (val);
1958
val_t = _tmp16_;
1959
index = i + 1;
1960
if (val_t == G_TYPE_STRING) {
1961
const gchar* _tmp17_ = NULL;
1962
_tmp17_ = g_value_get_string (val);
1963
sqlite3_bind_text (self->priv->stmt, index, _tmp17_, -1, NULL);
2369
GType _tmp41_;
2370
_tmp38_ = val;
2371
_tmp39_ = G_VALUE_TYPE (_tmp38_);
2372
val_t = _tmp39_;
2373
_tmp40_ = i;
2374
index = _tmp40_ + 1;
2375
_tmp41_ = val_t;
2376
if (_tmp41_ == G_TYPE_STRING) {
2377
sqlite3_stmt* _tmp42_;
2378
gint _tmp43_;
2379
GValue* _tmp44_;
2380
const gchar* _tmp45_ = NULL;
2381
_tmp42_ = self->priv->stmt;
2382
_tmp43_ = index;
2383
_tmp44_ = val;
2384
_tmp45_ = g_value_get_string (_tmp44_);
2385
sqlite3_bind_text (_tmp42_, _tmp43_, _tmp45_, -1, NULL);
1964
2386
} else {
1965
if (val_t == G_TYPE_INT) {
1966
gint _tmp18_;
1967
_tmp18_ = g_value_get_int (val);
1968
sqlite3_bind_int (self->priv->stmt, index, _tmp18_);
2387
GType _tmp46_;
2388
_tmp46_ = val_t;
2389
if (_tmp46_ == G_TYPE_INT) {
2390
sqlite3_stmt* _tmp47_;
2391
gint _tmp48_;
2392
GValue* _tmp49_;
2393
gint _tmp50_ = 0;
2394
_tmp47_ = self->priv->stmt;
2395
_tmp48_ = index;
2396
_tmp49_ = val;
2397
_tmp50_ = g_value_get_int (_tmp49_);
2398
sqlite3_bind_int (_tmp47_, _tmp48_, _tmp50_);
1969
2399
} else {
1970
if (val_t == G_TYPE_INT64) {
1971
gint64 _tmp19_;
1972
_tmp19_ = g_value_get_int64 (val);
1973
sqlite3_bind_int64 (self->priv->stmt, index, _tmp19_);
2400
GType _tmp51_;
2401
_tmp51_ = val_t;
2402
if (_tmp51_ == G_TYPE_INT64) {
2403
sqlite3_stmt* _tmp52_;
2404
gint _tmp53_;
2405
GValue* _tmp54_;
2406
gint64 _tmp55_ = 0LL;
2407
_tmp52_ = self->priv->stmt;
2408
_tmp53_ = index;
2409
_tmp54_ = val;
2410
_tmp55_ = g_value_get_int64 (_tmp54_);
2411
sqlite3_bind_int64 (_tmp52_, _tmp53_, _tmp55_);
1974
2412
} else {
1975
if (val_t == G_TYPE_FLOAT) {
1976
gfloat _tmp20_;
1977
_tmp20_ = g_value_get_float (val);
1978
sqlite3_bind_double (self->priv->stmt, index, (gdouble) _tmp20_);
2413
GType _tmp56_;
2414
_tmp56_ = val_t;
2415
if (_tmp56_ == G_TYPE_FLOAT) {
2416
sqlite3_stmt* _tmp57_;
2417
gint _tmp58_;
2418
GValue* _tmp59_;
2419
gfloat _tmp60_ = 0.0F;
2420
_tmp57_ = self->priv->stmt;
2421
_tmp58_ = index;
2422
_tmp59_ = val;
2423
_tmp60_ = g_value_get_float (_tmp59_);
2424
sqlite3_bind_double (_tmp57_, _tmp58_, (gdouble) _tmp60_);
1979
2425
} else {
1980
if (val_t == G_TYPE_DOUBLE) {
1981
gdouble _tmp21_;
1982
_tmp21_ = g_value_get_double (val);
1983
sqlite3_bind_double (self->priv->stmt, index, _tmp21_);
2426
GType _tmp61_;
2427
_tmp61_ = val_t;
2428
if (_tmp61_ == G_TYPE_DOUBLE) {
2429
sqlite3_stmt* _tmp62_;
2430
gint _tmp63_;
2431
GValue* _tmp64_;
2432
gdouble _tmp65_ = 0.0;
2433
_tmp62_ = self->priv->stmt;
2434
_tmp63_ = index;
2435
_tmp64_ = val;
2436
_tmp65_ = g_value_get_double (_tmp64_);
2437
sqlite3_bind_double (_tmp62_, _tmp63_, _tmp65_);
1984
2438
} else {
1985
if (val_t == G_TYPE_POINTER) {
1986
sqlite3_bind_null (self->priv->stmt, index);
2439
GType _tmp66_;
2440
_tmp66_ = val_t;
2441
if (_tmp66_ == G_TYPE_POINTER) {
2442
sqlite3_stmt* _tmp67_;
2443
gint _tmp68_;
2444
_tmp67_ = self->priv->stmt;
2445
_tmp68_ = index;
2446
sqlite3_bind_null (_tmp67_, _tmp68_);
1987
2447
} else {
1988
if (val_t == G_TYPE_BYTE_ARRAY) {
1989
GByteArray* _tmp22_;
2448
GType _tmp69_;
2449
_tmp69_ = val_t;
2450
if (_tmp69_ == G_TYPE_BYTE_ARRAY) {
2451
GValue* _tmp70_;
2452
GByteArray* _tmp71_;
1990
2453
GByteArray* ba;
1991
_tmp22_ = _g_byte_array_ref0 (g_value_get_boxed (val));
1992
ba = _tmp22_;
1993
sqlite3_bind_blob (self->priv->stmt, index, ba->data, (gint) ba->len, NULL);
2454
sqlite3_stmt* _tmp72_;
2455
gint _tmp73_;
2456
GByteArray* _tmp74_;
2457
guint8* _tmp75_;
2458
gint _tmp75__length1;
2459
GByteArray* _tmp76_;
2460
guint _tmp77_;
2461
_tmp70_ = val;
2462
_tmp71_ = _g_byte_array_ref0 (g_value_get_boxed (_tmp70_));
2463
ba = _tmp71_;
2464
_tmp72_ = self->priv->stmt;
2465
_tmp73_ = index;
2466
_tmp74_ = ba;
2467
_tmp75_ = _tmp74_->data;
2468
_tmp75__length1 = (gint) _tmp74_->len;
2469
_tmp76_ = ba;
2470
_tmp77_ = _tmp76_->len;
2471
sqlite3_bind_blob (_tmp72_, _tmp73_, _tmp75_, (gint) _tmp77_, NULL);
1994
2472
_g_byte_array_unref0 (ba);
1995
2473
}
1996
2474
}
2054
2532
/**
2055
2533
* {@inheritDoc}
2056
2534
*/
2057
g_object_class_override_property (G_OBJECT_CLASS (klass), SQL_HEAVY_QUERY_RESULT_FIELD_COUNT, "field-count");
2535
g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_QUERY_RESULT_FIELD_COUNT, g_param_spec_int ("field-count", "field-count", "field-count", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2058
2536
/**
2059
2537
* Signal which is emitted each time a row is recieved.
2060
2538
*/
2064
2542
2065
2543
static void sql_heavy_query_result_sql_heavy_record_interface_init (SQLHeavyRecordIface * iface) {
2066
2544
sql_heavy_query_result_sql_heavy_record_parent_iface = g_type_interface_peek_parent (iface);
2067
iface->field_name = (gchar* (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_query_result_real_field_name;
2068
iface->field_index = (gint (*)(SQLHeavyRecord* ,const gchar* ,GError**)) sql_heavy_query_result_real_field_index;
2069
iface->field_type = (GType (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_query_result_real_field_type;
2070
iface->fetch = (GValue (*)(SQLHeavyRecord* ,gint ,GValue* ,GError**)) sql_heavy_query_result_real_fetch;
2071
iface->fetch_string = (gchar* (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_query_result_real_fetch_string;
2072
iface->fetch_int = (gint (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_query_result_real_fetch_int;
2073
iface->fetch_int64 = (gint64 (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_query_result_real_fetch_int64;
2074
iface->fetch_double = (gdouble (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_query_result_real_fetch_double;
2075
iface->fetch_blob = (guint8* (*)(SQLHeavyRecord* ,gint ,int* ,GError**)) sql_heavy_query_result_real_fetch_blob;
2076
iface->fetch_foreign_row = (SQLHeavyRow* (*)(SQLHeavyRecord* ,gint ,GError**)) sql_heavy_query_result_real_fetch_foreign_row;
2545
iface->field_name = (gchar* (*)(SQLHeavyRecord*, gint, GError**)) sql_heavy_query_result_real_field_name;
2546
iface->field_index = (gint (*)(SQLHeavyRecord*, const gchar*, GError**)) sql_heavy_query_result_real_field_index;
2547
iface->field_type = (GType (*)(SQLHeavyRecord*, gint, GError**)) sql_heavy_query_result_real_field_type;
2548
iface->fetch = (void (*)(SQLHeavyRecord*, gint, GValue*, GError**)) sql_heavy_query_result_real_fetch;
2549
iface->fetch_string = (gchar* (*)(SQLHeavyRecord*, gint, GError**)) sql_heavy_query_result_real_fetch_string;
2550
iface->fetch_int = (gint (*)(SQLHeavyRecord*, gint, GError**)) sql_heavy_query_result_real_fetch_int;
2551
iface->fetch_int64 = (gint64 (*)(SQLHeavyRecord*, gint, GError**)) sql_heavy_query_result_real_fetch_int64;
2552
iface->fetch_double = (gdouble (*)(SQLHeavyRecord*, gint, GError**)) sql_heavy_query_result_real_fetch_double;
2553
iface->fetch_blob = (guint8* (*)(SQLHeavyRecord*, gint, int*, GError**)) sql_heavy_query_result_real_fetch_blob;
2554
iface->fetch_foreign_row = (SQLHeavyRow* (*)(SQLHeavyRecord*, gint, GError**)) sql_heavy_query_result_real_fetch_foreign_row;
2077
2555
iface->get_field_count = sql_heavy_query_result_real_get_field_count;
2078
2556
}
2079
2557
2080
2558
2081
2559
static void sql_heavy_query_result_sql_heavy_record_set_interface_init (SQLHeavyRecordSetIface * iface) {
2082
2560
sql_heavy_query_result_sql_heavy_record_set_parent_iface = g_type_interface_peek_parent (iface);
2083
iface->next = (gboolean (*)(SQLHeavyRecordSet* ,GError**)) sql_heavy_query_result_real_next;
2561
iface->next = (gboolean (*)(SQLHeavyRecordSet*, GError**)) sql_heavy_query_result_real_next;
2084
2562
}
2085
2563
2086
2564
2093
2571
2094
2572
static void sql_heavy_query_result_finalize (GObject* obj) {
2095
2573
SQLHeavyQueryResult * self;
2574
SQLHeavyQuery* _tmp0_;
2096
2575
SQLHeavyQuery* query;
2097
SQLHeavyQueryable* _tmp0_ = NULL;
2576
SQLHeavyQuery* _tmp1_;
2577
SQLHeavyQueryable* _tmp2_;
2578
SQLHeavyQueryable* _tmp3_;
2098
2579
SQLHeavyQueryable* queryable;
2099
SQLHeavyDatabase* _tmp1_ = NULL;
2100
SQLHeavyDatabase* _tmp2_;
2101
SQLHeavyProfilingDatabase* _tmp3_ = NULL;
2102
SQLHeavyProfilingDatabase* _tmp4_;
2580
SQLHeavyQueryable* _tmp4_;
2581
SQLHeavyDatabase* _tmp5_;
2582
SQLHeavyDatabase* _tmp6_;
2583
SQLHeavyDatabase* _tmp7_;
2584
SQLHeavyProfilingDatabase* _tmp8_;
2585
SQLHeavyProfilingDatabase* _tmp9_;
2586
SQLHeavyProfilingDatabase* _tmp10_;
2103
2587
SQLHeavyProfilingDatabase* prof_db;
2104
gboolean _tmp5_;
2588
SQLHeavyQueryable* _tmp11_;
2589
SQLHeavyQuery* _tmp12_;
2590
SQLHeavyProfilingDatabase* _tmp13_;
2591
sqlite3_stmt* _tmp15_;
2592
SQLHeavyQuery* _tmp16_;
2593
gboolean _tmp17_;
2594
gboolean _tmp18_;
2595
gboolean _tmp20_;
2105
2596
self = SQL_HEAVY_QUERY_RESULT (obj);
2106
query = self->priv->_query;
2107
_tmp0_ = sql_heavy_query_get_queryable (query);
2108
queryable = _tmp0_;
2109
_tmp1_ = sql_heavy_queryable_get_database (queryable);
2110
_tmp2_ = _tmp1_;
2111
_tmp3_ = sql_heavy_database_get_profiling_data (_tmp2_);
2112
_tmp4_ = _tmp3_;
2113
_g_object_unref0 (_tmp2_);
2114
prof_db = _tmp4_;
2115
g_signal_emit_by_name (queryable, "query-executed", query);
2116
if (prof_db != NULL) {
2117
sql_heavy_profiling_database_insert (prof_db, self);
2118
}
2119
sqlite3_reset (self->priv->stmt);
2120
_tmp5_ = sql_heavy_query_get_auto_clear (query);
2121
if (_tmp5_) {
2122
sql_heavy_query_clear (query);
2123
}
2124
if (self->priv->stmt_is_owned) {
2125
sqlite3_finalize (self->priv->stmt);
2597
_tmp0_ = self->priv->_query;
2598
query = _tmp0_;
2599
_tmp1_ = query;
2600
_tmp2_ = sql_heavy_query_get_queryable (_tmp1_);
2601
_tmp3_ = _tmp2_;
2602
queryable = _tmp3_;
2603
_tmp4_ = queryable;
2604
_tmp5_ = sql_heavy_queryable_get_database (_tmp4_);
2605
_tmp6_ = _tmp5_;
2606
_tmp7_ = _tmp6_;
2607
_tmp8_ = sql_heavy_database_get_profiling_data (_tmp7_);
2608
_tmp9_ = _tmp8_;
2609
_tmp10_ = _tmp9_;
2610
_g_object_unref0 (_tmp7_);
2611
prof_db = _tmp10_;
2612
_tmp11_ = queryable;
2613
_tmp12_ = query;
2614
g_signal_emit_by_name (_tmp11_, "query-executed", _tmp12_);
2615
_tmp13_ = prof_db;
2616
if (_tmp13_ != NULL) {
2617
SQLHeavyProfilingDatabase* _tmp14_;
2618
_tmp14_ = prof_db;
2619
sql_heavy_profiling_database_insert (_tmp14_, self);
2620
}
2621
_tmp15_ = self->priv->stmt;
2622
sqlite3_reset (_tmp15_);
2623
_tmp16_ = query;
2624
_tmp17_ = sql_heavy_query_get_auto_clear (_tmp16_);
2625
_tmp18_ = _tmp17_;
2626
if (_tmp18_) {
2627
SQLHeavyQuery* _tmp19_;
2628
_tmp19_ = query;
2629
sql_heavy_query_clear (_tmp19_);
2630
}
2631
_tmp20_ = self->priv->stmt_is_owned;
2632
if (_tmp20_) {
2633
sqlite3_stmt* _tmp21_;
2634
_tmp21_ = self->priv->stmt;
2635
sqlite3_finalize (_tmp21_);
2126
2636
} else {
2127
sql_heavy_query_return_stmt (query);
2637
SQLHeavyQuery* _tmp22_;
2638
_tmp22_ = query;
2639
sql_heavy_query_return_stmt (_tmp22_);
2128
2640
}
2129
2641
_g_object_unref0 (self->priv->_query);
2130
2642
_g_object_unref0 (self->priv->_bindings);
Loggerhead is a web-based interface for Breezy
Version: 2.0.1