This file is indexed.

/usr/include/sqlheavy/sqlheavy-0.1/SQLHeavy.h is in libsqlheavy-dev 0.1.1-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
/* SQLHeavy.h generated by valac 0.16.0, the Vala compiler, do not modify */


#ifndef __SQLHEAVY_H__
#define __SQLHEAVY_H__

#include <glib.h>
#include <glib-object.h>
#include <gio/gio.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <math.h>
#include <time.h>
#include <stdio.h>

G_BEGIN_DECLS


#define SQL_HEAVY_TYPE_BACKUP (sql_heavy_backup_get_type ())
#define SQL_HEAVY_BACKUP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_BACKUP, SQLHeavyBackup))
#define SQL_HEAVY_BACKUP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_BACKUP, SQLHeavyBackupClass))
#define SQL_HEAVY_IS_BACKUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_BACKUP))
#define SQL_HEAVY_IS_BACKUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_BACKUP))
#define SQL_HEAVY_BACKUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_BACKUP, SQLHeavyBackupClass))

typedef struct _SQLHeavyBackup SQLHeavyBackup;
typedef struct _SQLHeavyBackupClass SQLHeavyBackupClass;
typedef struct _SQLHeavyBackupPrivate SQLHeavyBackupPrivate;

#define SQL_HEAVY_TYPE_DATABASE (sql_heavy_database_get_type ())
#define SQL_HEAVY_DATABASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_DATABASE, SQLHeavyDatabase))
#define SQL_HEAVY_DATABASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_DATABASE, SQLHeavyDatabaseClass))
#define SQL_HEAVY_IS_DATABASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_DATABASE))
#define SQL_HEAVY_IS_DATABASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_DATABASE))
#define SQL_HEAVY_DATABASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_DATABASE, SQLHeavyDatabaseClass))

typedef struct _SQLHeavyDatabase SQLHeavyDatabase;
typedef struct _SQLHeavyDatabaseClass SQLHeavyDatabaseClass;

#define SQL_HEAVY_USER_FUNCTION_TYPE_CONTEXT (sql_heavy_user_function_context_get_type ())
#define SQL_HEAVY_USER_FUNCTION_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_USER_FUNCTION_TYPE_CONTEXT, SQLHeavyUserFunctionContext))
#define SQL_HEAVY_USER_FUNCTION_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_USER_FUNCTION_TYPE_CONTEXT, SQLHeavyUserFunctionContextClass))
#define SQL_HEAVY_USER_FUNCTION_IS_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_USER_FUNCTION_TYPE_CONTEXT))
#define SQL_HEAVY_USER_FUNCTION_IS_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_USER_FUNCTION_TYPE_CONTEXT))
#define SQL_HEAVY_USER_FUNCTION_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_USER_FUNCTION_TYPE_CONTEXT, SQLHeavyUserFunctionContextClass))

typedef struct _SQLHeavyUserFunctionContext SQLHeavyUserFunctionContext;
typedef struct _SQLHeavyUserFunctionContextClass SQLHeavyUserFunctionContextClass;

#define SQL_HEAVY_TYPE_RECORD_SET (sql_heavy_record_set_get_type ())
#define SQL_HEAVY_RECORD_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_RECORD_SET, SQLHeavyRecordSet))
#define SQL_HEAVY_IS_RECORD_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_RECORD_SET))
#define SQL_HEAVY_RECORD_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), SQL_HEAVY_TYPE_RECORD_SET, SQLHeavyRecordSetIface))

typedef struct _SQLHeavyRecordSet SQLHeavyRecordSet;
typedef struct _SQLHeavyRecordSetIface SQLHeavyRecordSetIface;

#define SQL_HEAVY_TYPE_CURSOR (sql_heavy_cursor_get_type ())
#define SQL_HEAVY_CURSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_CURSOR, SQLHeavyCursor))
#define SQL_HEAVY_IS_CURSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_CURSOR))
#define SQL_HEAVY_CURSOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), SQL_HEAVY_TYPE_CURSOR, SQLHeavyCursorIface))

typedef struct _SQLHeavyCursor SQLHeavyCursor;
typedef struct _SQLHeavyCursorIface SQLHeavyCursorIface;

#define SQL_HEAVY_TYPE_RECORD (sql_heavy_record_get_type ())
#define SQL_HEAVY_RECORD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_RECORD, SQLHeavyRecord))
#define SQL_HEAVY_IS_RECORD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_RECORD))
#define SQL_HEAVY_RECORD_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), SQL_HEAVY_TYPE_RECORD, SQLHeavyRecordIface))

typedef struct _SQLHeavyRecord SQLHeavyRecord;
typedef struct _SQLHeavyRecordIface SQLHeavyRecordIface;

#define SQL_HEAVY_TYPE_ROW (sql_heavy_row_get_type ())
#define SQL_HEAVY_ROW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_ROW, SQLHeavyRow))
#define SQL_HEAVY_ROW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_ROW, SQLHeavyRowClass))
#define SQL_HEAVY_IS_ROW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_ROW))
#define SQL_HEAVY_IS_ROW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_ROW))
#define SQL_HEAVY_ROW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_ROW, SQLHeavyRowClass))

typedef struct _SQLHeavyRow SQLHeavyRow;
typedef struct _SQLHeavyRowClass SQLHeavyRowClass;

#define SQL_HEAVY_TYPE_QUERYABLE (sql_heavy_queryable_get_type ())
#define SQL_HEAVY_QUERYABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_QUERYABLE, SQLHeavyQueryable))
#define SQL_HEAVY_IS_QUERYABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_QUERYABLE))
#define SQL_HEAVY_QUERYABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), SQL_HEAVY_TYPE_QUERYABLE, SQLHeavyQueryableIface))

typedef struct _SQLHeavyQueryable SQLHeavyQueryable;
typedef struct _SQLHeavyQueryableIface SQLHeavyQueryableIface;

#define SQL_HEAVY_TYPE_QUERY (sql_heavy_query_get_type ())
#define SQL_HEAVY_QUERY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_QUERY, SQLHeavyQuery))
#define SQL_HEAVY_QUERY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_QUERY, SQLHeavyQueryClass))
#define SQL_HEAVY_IS_QUERY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_QUERY))
#define SQL_HEAVY_IS_QUERY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_QUERY))
#define SQL_HEAVY_QUERY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_QUERY, SQLHeavyQueryClass))

typedef struct _SQLHeavyQuery SQLHeavyQuery;
typedef struct _SQLHeavyQueryClass SQLHeavyQueryClass;

#define SQL_HEAVY_TYPE_TRANSACTION (sql_heavy_transaction_get_type ())
#define SQL_HEAVY_TRANSACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_TRANSACTION, SQLHeavyTransaction))
#define SQL_HEAVY_TRANSACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_TRANSACTION, SQLHeavyTransactionClass))
#define SQL_HEAVY_IS_TRANSACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_TRANSACTION))
#define SQL_HEAVY_IS_TRANSACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_TRANSACTION))
#define SQL_HEAVY_TRANSACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_TRANSACTION, SQLHeavyTransactionClass))

typedef struct _SQLHeavyTransaction SQLHeavyTransaction;
typedef struct _SQLHeavyTransactionClass SQLHeavyTransactionClass;
typedef struct _SQLHeavyDatabasePrivate SQLHeavyDatabasePrivate;

#define SQL_HEAVY_TYPE_TABLE (sql_heavy_table_get_type ())
#define SQL_HEAVY_TABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_TABLE, SQLHeavyTable))
#define SQL_HEAVY_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_TABLE, SQLHeavyTableClass))
#define SQL_HEAVY_IS_TABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_TABLE))
#define SQL_HEAVY_IS_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_TABLE))
#define SQL_HEAVY_TABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_TABLE, SQLHeavyTableClass))

typedef struct _SQLHeavyTable SQLHeavyTable;
typedef struct _SQLHeavyTableClass SQLHeavyTableClass;

#define SQL_HEAVY_TYPE_FILE_MODE (sql_heavy_file_mode_get_type ())

#define SQL_HEAVY_TYPE_VERSIONED_DATABASE (sql_heavy_versioned_database_get_type ())
#define SQL_HEAVY_VERSIONED_DATABASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_VERSIONED_DATABASE, SQLHeavyVersionedDatabase))
#define SQL_HEAVY_VERSIONED_DATABASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_VERSIONED_DATABASE, SQLHeavyVersionedDatabaseClass))
#define SQL_HEAVY_IS_VERSIONED_DATABASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_VERSIONED_DATABASE))
#define SQL_HEAVY_IS_VERSIONED_DATABASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_VERSIONED_DATABASE))
#define SQL_HEAVY_VERSIONED_DATABASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_VERSIONED_DATABASE, SQLHeavyVersionedDatabaseClass))

typedef struct _SQLHeavyVersionedDatabase SQLHeavyVersionedDatabase;
typedef struct _SQLHeavyVersionedDatabaseClass SQLHeavyVersionedDatabaseClass;

#define SQL_HEAVY_TYPE_PROFILING_DATABASE (sql_heavy_profiling_database_get_type ())
#define SQL_HEAVY_PROFILING_DATABASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_PROFILING_DATABASE, SQLHeavyProfilingDatabase))
#define SQL_HEAVY_PROFILING_DATABASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_PROFILING_DATABASE, SQLHeavyProfilingDatabaseClass))
#define SQL_HEAVY_IS_PROFILING_DATABASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_PROFILING_DATABASE))
#define SQL_HEAVY_IS_PROFILING_DATABASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_PROFILING_DATABASE))
#define SQL_HEAVY_PROFILING_DATABASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_PROFILING_DATABASE, SQLHeavyProfilingDatabaseClass))

typedef struct _SQLHeavyProfilingDatabase SQLHeavyProfilingDatabase;
typedef struct _SQLHeavyProfilingDatabaseClass SQLHeavyProfilingDatabaseClass;

#define SQL_HEAVY_TYPE_AUTO_VACUUM (sql_heavy_auto_vacuum_get_type ())

#define SQL_HEAVY_TYPE_ENCODING (sql_heavy_encoding_get_type ())

#define SQL_HEAVY_TYPE_JOURNAL_MODE (sql_heavy_journal_mode_get_type ())

#define SQL_HEAVY_TYPE_LOCKING_MODE (sql_heavy_locking_mode_get_type ())

#define SQL_HEAVY_TYPE_SYNCHRONOUS_MODE (sql_heavy_synchronous_mode_get_type ())

#define SQL_HEAVY_TYPE_TEMP_STORE_MODE (sql_heavy_temp_store_mode_get_type ())

#define SQL_HEAVY_TYPE_TRANSACTION_TYPE (sql_heavy_transaction_type_get_type ())

#define SQL_HEAVY_TYPE_TRANSACTION_STATUS (sql_heavy_transaction_status_get_type ())

#define SQL_HEAVY_TYPE_SORT_ORDER (sql_heavy_sort_order_get_type ())

#define SQL_HEAVY_TYPE_MUTABLE_RECORD (sql_heavy_mutable_record_get_type ())
#define SQL_HEAVY_MUTABLE_RECORD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_MUTABLE_RECORD, SQLHeavyMutableRecord))
#define SQL_HEAVY_IS_MUTABLE_RECORD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_MUTABLE_RECORD))
#define SQL_HEAVY_MUTABLE_RECORD_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), SQL_HEAVY_TYPE_MUTABLE_RECORD, SQLHeavyMutableRecordIface))

typedef struct _SQLHeavyMutableRecord SQLHeavyMutableRecord;
typedef struct _SQLHeavyMutableRecordIface SQLHeavyMutableRecordIface;
typedef struct _SQLHeavyVersionedDatabasePrivate SQLHeavyVersionedDatabasePrivate;
typedef struct _SQLHeavyProfilingDatabasePrivate SQLHeavyProfilingDatabasePrivate;
typedef struct _SQLHeavyQueryPrivate SQLHeavyQueryPrivate;

#define SQL_HEAVY_TYPE_QUERY_RESULT (sql_heavy_query_result_get_type ())
#define SQL_HEAVY_QUERY_RESULT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_QUERY_RESULT, SQLHeavyQueryResult))
#define SQL_HEAVY_QUERY_RESULT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_QUERY_RESULT, SQLHeavyQueryResultClass))
#define SQL_HEAVY_IS_QUERY_RESULT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_QUERY_RESULT))
#define SQL_HEAVY_IS_QUERY_RESULT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_QUERY_RESULT))
#define SQL_HEAVY_QUERY_RESULT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_QUERY_RESULT, SQLHeavyQueryResultClass))

typedef struct _SQLHeavyQueryResult SQLHeavyQueryResult;
typedef struct _SQLHeavyQueryResultClass SQLHeavyQueryResultClass;
typedef struct _SQLHeavyQueryResultPrivate SQLHeavyQueryResultPrivate;

#define SQL_HEAVY_TYPE_VALUE_ARRAY (sql_heavy_value_array_get_type ())
#define SQL_HEAVY_VALUE_ARRAY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_VALUE_ARRAY, SQLHeavyValueArray))
#define SQL_HEAVY_VALUE_ARRAY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_VALUE_ARRAY, SQLHeavyValueArrayClass))
#define SQL_HEAVY_IS_VALUE_ARRAY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_VALUE_ARRAY))
#define SQL_HEAVY_IS_VALUE_ARRAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_VALUE_ARRAY))
#define SQL_HEAVY_VALUE_ARRAY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_VALUE_ARRAY, SQLHeavyValueArrayClass))

typedef struct _SQLHeavyValueArray SQLHeavyValueArray;
typedef struct _SQLHeavyValueArrayClass SQLHeavyValueArrayClass;
typedef struct _SQLHeavyRowPrivate SQLHeavyRowPrivate;
typedef struct _SQLHeavyTablePrivate SQLHeavyTablePrivate;

#define SQL_HEAVY_TYPE_TABLE_CURSOR (sql_heavy_table_cursor_get_type ())
#define SQL_HEAVY_TABLE_CURSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_TYPE_TABLE_CURSOR, SQLHeavyTableCursor))
#define SQL_HEAVY_TABLE_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_TYPE_TABLE_CURSOR, SQLHeavyTableCursorClass))
#define SQL_HEAVY_IS_TABLE_CURSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_TYPE_TABLE_CURSOR))
#define SQL_HEAVY_IS_TABLE_CURSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_TYPE_TABLE_CURSOR))
#define SQL_HEAVY_TABLE_CURSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_TYPE_TABLE_CURSOR, SQLHeavyTableCursorClass))

typedef struct _SQLHeavyTableCursor SQLHeavyTableCursor;
typedef struct _SQLHeavyTableCursorClass SQLHeavyTableCursorClass;
typedef struct _SQLHeavyTableCursorPrivate SQLHeavyTableCursorPrivate;
typedef struct _SQLHeavyTransactionPrivate SQLHeavyTransactionPrivate;
typedef struct _SQLHeavyUserFunctionContextPrivate SQLHeavyUserFunctionContextPrivate;
typedef struct _SQLHeavyValueArrayPrivate SQLHeavyValueArrayPrivate;

struct _SQLHeavyBackup {
	GObject parent_instance;
	SQLHeavyBackupPrivate * priv;
};

struct _SQLHeavyBackupClass {
	GObjectClass parent_class;
};

typedef enum  {
	SQL_HEAVY_ERROR_UNKNOWN,
	SQL_HEAVY_ERROR_ERROR,
	SQL_HEAVY_ERROR_INTERNAL,
	SQL_HEAVY_ERROR_ACCESS_DENIED,
	SQL_HEAVY_ERROR_ABORTED,
	SQL_HEAVY_ERROR_BUSY,
	SQL_HEAVY_ERROR_LOCKED,
	SQL_HEAVY_ERROR_NO_MEMORY,
	SQL_HEAVY_ERROR_READ_ONLY,
	SQL_HEAVY_ERROR_INTERRUPTED,
	SQL_HEAVY_ERROR_IO,
	SQL_HEAVY_ERROR_CORRUPT,
	SQL_HEAVY_ERROR_NOT_FOUND,
	SQL_HEAVY_ERROR_FULL,
	SQL_HEAVY_ERROR_CAN_NOT_OPEN,
	SQL_HEAVY_ERROR_PROTOCOL,
	SQL_HEAVY_ERROR_EMPTY,
	SQL_HEAVY_ERROR_SCHEMA,
	SQL_HEAVY_ERROR_TOO_BIG,
	SQL_HEAVY_ERROR_CONSTRAINT,
	SQL_HEAVY_ERROR_MISMATCH,
	SQL_HEAVY_ERROR_MISUSE,
	SQL_HEAVY_ERROR_NOLFS,
	SQL_HEAVY_ERROR_AUTH,
	SQL_HEAVY_ERROR_FORMAT,
	SQL_HEAVY_ERROR_RANGE,
	SQL_HEAVY_ERROR_NOTADB,
	SQL_HEAVY_ERROR_DATA_TYPE,
	SQL_HEAVY_ERROR_THREAD,
	SQL_HEAVY_ERROR_TRANSACTION,
	SQL_HEAVY_ERROR_FEATURE_NOT_SUPPORTED,
	SQL_HEAVY_ERROR_NO_SQL,
	SQL_HEAVY_ERROR_MISSING_PARAMETER
} SQLHeavyError;
#define SQL_HEAVY_ERROR sql_heavy_error_quark ()
struct _SQLHeavyRecordSetIface {
	GTypeInterface parent_iface;
	gboolean (*next) (SQLHeavyRecordSet* self, GError** error);
};

struct _SQLHeavyRecordIface {
	GTypeInterface parent_iface;
	gchar* (*field_name) (SQLHeavyRecord* self, gint field, GError** error);
	gint (*field_index) (SQLHeavyRecord* self, const gchar* field, GError** error);
	gchar** (*field_names) (SQLHeavyRecord* self, int* result_length1);
	GType (*field_type) (SQLHeavyRecord* self, gint field, GError** error);
	void (*fetch) (SQLHeavyRecord* self, gint field, GValue* result, GError** error);
	GValue* (*get) (SQLHeavyRecord* self, const gchar* field, GError** error);
	SQLHeavyRow* (*fetch_foreign_row) (SQLHeavyRecord* self, gint field, GError** error);
	SQLHeavyRow* (*get_foreign_row) (SQLHeavyRecord* self, const gchar* field, GError** error);
	GValueArray* (*fetch_row) (SQLHeavyRecord* self, GError** error);
	void (*fetch_with_type) (SQLHeavyRecord* self, GType requested_type, gint field, GValue* result, GError** error);
	gchar* (*fetch_string) (SQLHeavyRecord* self, gint field, GError** error);
	gchar* (*get_string) (SQLHeavyRecord* self, const gchar* field, GError** error);
	gint (*fetch_int) (SQLHeavyRecord* self, gint field, GError** error);
	gint (*get_int) (SQLHeavyRecord* self, const gchar* field, GError** error);
	gint64 (*fetch_int64) (SQLHeavyRecord* self, gint field, GError** error);
	gint64 (*get_int64) (SQLHeavyRecord* self, const gchar* field, GError** error);
	gdouble (*fetch_double) (SQLHeavyRecord* self, gint field, GError** error);
	gdouble (*get_double) (SQLHeavyRecord* self, const gchar* field, GError** error);
	guint8* (*fetch_blob) (SQLHeavyRecord* self, gint field, int* result_length1, GError** error);
	guint8* (*get_blob) (SQLHeavyRecord* self, const gchar* field, int* result_length1, GError** error);
	time_t (*fetch_time_t) (SQLHeavyRecord* self, gint field, GError** error);
	time_t (*get_time_t) (SQLHeavyRecord* self, const gchar* field, GError** error);
	gint (*get_field_count) (SQLHeavyRecord* self);
};

struct _SQLHeavyCursorIface {
	GTypeInterface parent_iface;
	gboolean (*previous) (SQLHeavyCursor* self, GError** error);
	SQLHeavyRecord* (*get) (SQLHeavyCursor* self, GError** error);
	gboolean (*move_to) (SQLHeavyCursor* self, gint64 offset, GError** error);
};

struct _SQLHeavyQueryableIface {
	GTypeInterface parent_iface;
	void (*lock) (SQLHeavyQueryable* self);
	void (*unlock) (SQLHeavyQueryable* self);
	void (*queue) (SQLHeavyQueryable* self, SQLHeavyQuery* query, GError** error);
	SQLHeavyTransaction* (*begin_transaction) (SQLHeavyQueryable* self, GError** error);
	SQLHeavyQuery* (*prepare) (SQLHeavyQueryable* self, const gchar* sql, GError** error);
	void (*run_script) (SQLHeavyQueryable* self, const gchar* filename, GError** error);
	void (*print_table) (SQLHeavyQueryable* self, const gchar* sql, FILE* fd, GError** error);
	SQLHeavyDatabase* (*get_database) (SQLHeavyQueryable* self);
};

struct _SQLHeavyDatabase {
	GObject parent_instance;
	SQLHeavyDatabasePrivate * priv;
};

struct _SQLHeavyDatabaseClass {
	GObjectClass parent_class;
	gboolean (*init) (SQLHeavyDatabase* self, GCancellable* cancellable, GError** error);
	void (*wal_committed) (SQLHeavyDatabase* self, const gchar* db_name, gint pages);
};

typedef GValue* (*SQLHeavyUserFunctionUserFunc) (SQLHeavyUserFunctionContext* ctx, GValueArray* args, void* user_data, GError** error);
typedef void (*SQLHeavyUserFunctionFinalizeFunc) (SQLHeavyUserFunctionContext* ctx, void* user_data);
typedef enum  {
	SQL_HEAVY_FILE_MODE_READ = 1,
	SQL_HEAVY_FILE_MODE_WRITE = 2,
	SQL_HEAVY_FILE_MODE_CREATE = 4
} SQLHeavyFileMode;

typedef enum  {
	SQL_HEAVY_AUTO_VACUUM_NONE = 0,
	SQL_HEAVY_AUTO_VACUUM_FULL = 1,
	SQL_HEAVY_AUTO_VACUUM_INCREMENTAL = 2
} SQLHeavyAutoVacuum;

typedef enum  {
	SQL_HEAVY_ENCODING_UTF_8,
	SQL_HEAVY_ENCODING_UTF_16,
	SQL_HEAVY_ENCODING_UTF_16LE,
	SQL_HEAVY_ENCODING_UTF_16BE
} SQLHeavyEncoding;

typedef enum  {
	SQL_HEAVY_JOURNAL_MODE_DELETE,
	SQL_HEAVY_JOURNAL_MODE_TRUNCATE,
	SQL_HEAVY_JOURNAL_MODE_PERSIST,
	SQL_HEAVY_JOURNAL_MODE_MEMORY,
	SQL_HEAVY_JOURNAL_MODE_WAL,
	SQL_HEAVY_JOURNAL_MODE_OFF
} SQLHeavyJournalMode;

typedef enum  {
	SQL_HEAVY_LOCKING_MODE_NORMAL,
	SQL_HEAVY_LOCKING_MODE_EXCLUSIVE
} SQLHeavyLockingMode;

typedef enum  {
	SQL_HEAVY_SYNCHRONOUS_MODE_OFF,
	SQL_HEAVY_SYNCHRONOUS_MODE_NORMAL,
	SQL_HEAVY_SYNCHRONOUS_MODE_FULL
} SQLHeavySynchronousMode;

typedef enum  {
	SQL_HEAVY_TEMP_STORE_MODE_DEFAULT,
	SQL_HEAVY_TEMP_STORE_MODE_FILE,
	SQL_HEAVY_TEMP_STORE_MODE_MEMORY
} SQLHeavyTempStoreMode;

typedef enum  {
	SQL_HEAVY_TRANSACTION_TYPE_DEFERRED,
	SQL_HEAVY_TRANSACTION_TYPE_IMMEDIATE,
	SQL_HEAVY_TRANSACTION_TYPE_EXCLUSIVE
} SQLHeavyTransactionType;

typedef enum  {
	SQL_HEAVY_TRANSACTION_STATUS_UNRESOLVED = 0,
	SQL_HEAVY_TRANSACTION_STATUS_COMMITTED,
	SQL_HEAVY_TRANSACTION_STATUS_ROLLED_BACK
} SQLHeavyTransactionStatus;

typedef enum  {
	SQL_HEAVY_SORT_ORDER_ASCENDING,
	SQL_HEAVY_SORT_ORDER_DESCENDING
} SQLHeavySortOrder;

struct _SQLHeavyMutableRecordIface {
	GTypeInterface parent_iface;
	void (*put) (SQLHeavyMutableRecord* self, gint field, GValue* value, GError** error);
	void (*set) (SQLHeavyMutableRecord* self, const gchar* field, GValue* value, GError** error);
	void (*put_string) (SQLHeavyMutableRecord* self, gint field, const gchar* value, GError** error);
	void (*set_string) (SQLHeavyMutableRecord* self, const gchar* field, const gchar* value, GError** error);
	void (*put_null) (SQLHeavyMutableRecord* self, gint field, GError** error);
	void (*set_null) (SQLHeavyMutableRecord* self, const gchar* field, GError** error);
	void (*put_int) (SQLHeavyMutableRecord* self, gint field, gint value, GError** error);
	void (*set_int) (SQLHeavyMutableRecord* self, const gchar* field, gint value, GError** error);
	void (*put_int64) (SQLHeavyMutableRecord* self, gint field, gint64 value, GError** error);
	void (*set_int64) (SQLHeavyMutableRecord* self, const gchar* field, gint64 value, GError** error);
	void (*put_double) (SQLHeavyMutableRecord* self, gint field, gdouble value, GError** error);
	void (*set_double) (SQLHeavyMutableRecord* self, const gchar* field, gdouble value, GError** error);
	void (*put_blob) (SQLHeavyMutableRecord* self, gint field, guint8* value, int value_length1, GError** error);
	void (*set_blob) (SQLHeavyMutableRecord* self, const gchar* field, guint8* value, int value_length1, GError** error);
	void (*put_time_t) (SQLHeavyMutableRecord* self, gint field, time_t value, GError** error);
	void (*set_time_t) (SQLHeavyMutableRecord* self, const gchar* field, time_t value, GError** error);
	void (*save) (SQLHeavyMutableRecord* self, GError** error);
	void (*delete) (SQLHeavyMutableRecord* self, GError** error);
};

struct _SQLHeavyVersionedDatabase {
	SQLHeavyDatabase parent_instance;
	SQLHeavyVersionedDatabasePrivate * priv;
};

struct _SQLHeavyVersionedDatabaseClass {
	SQLHeavyDatabaseClass parent_class;
};

struct _SQLHeavyProfilingDatabase {
	SQLHeavyVersionedDatabase parent_instance;
	SQLHeavyProfilingDatabasePrivate * priv;
};

struct _SQLHeavyProfilingDatabaseClass {
	SQLHeavyVersionedDatabaseClass parent_class;
};

struct _SQLHeavyQuery {
	GObject parent_instance;
	SQLHeavyQueryPrivate * priv;
};

struct _SQLHeavyQueryClass {
	GObjectClass parent_class;
	gboolean (*init) (SQLHeavyQuery* self, GCancellable* cancellable, GError** error);
};

struct _SQLHeavyQueryResult {
	GObject parent_instance;
	SQLHeavyQueryResultPrivate * priv;
};

struct _SQLHeavyQueryResultClass {
	GObjectClass parent_class;
};

struct _SQLHeavyRow {
	GObject parent_instance;
	SQLHeavyRowPrivate * priv;
};

struct _SQLHeavyRowClass {
	GObjectClass parent_class;
};

struct _SQLHeavyTable {
	GObject parent_instance;
	SQLHeavyTablePrivate * priv;
};

struct _SQLHeavyTableClass {
	GObjectClass parent_class;
	void (*row_modified) (SQLHeavyTable* self, gint64 row_id);
};

struct _SQLHeavyTableCursor {
	GObject parent_instance;
	SQLHeavyTableCursorPrivate * priv;
};

struct _SQLHeavyTableCursorClass {
	GObjectClass parent_class;
};

struct _SQLHeavyTransaction {
	GObject parent_instance;
	SQLHeavyTransactionPrivate * priv;
};

struct _SQLHeavyTransactionClass {
	GObjectClass parent_class;
};

struct _SQLHeavyUserFunctionContext {
	GTypeInstance parent_instance;
	volatile int ref_count;
	SQLHeavyUserFunctionContextPrivate * priv;
};

struct _SQLHeavyUserFunctionContextClass {
	GTypeClass parent_class;
	void (*finalize) (SQLHeavyUserFunctionContext *self);
};

struct _SQLHeavyValueArray {
	GObject parent_instance;
	SQLHeavyValueArrayPrivate * priv;
};

struct _SQLHeavyValueArrayClass {
	GObjectClass parent_class;
};


GType sql_heavy_backup_get_type (void) G_GNUC_CONST;
GQuark sql_heavy_error_quark (void);
gboolean sql_heavy_backup_step (SQLHeavyBackup* self, GError** error);
void sql_heavy_backup_execute (SQLHeavyBackup* self, GError** error);
void sql_heavy_backup_execute_async (SQLHeavyBackup* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
void sql_heavy_backup_execute_finish (SQLHeavyBackup* self, GAsyncResult* _res_, GError** error);
GType sql_heavy_database_get_type (void) G_GNUC_CONST;
SQLHeavyBackup* sql_heavy_backup_new_with_db_names (SQLHeavyDatabase* source, const gchar* source_name, SQLHeavyDatabase* destination, const gchar* destination_name, GError** error);
SQLHeavyBackup* sql_heavy_backup_construct_with_db_names (GType object_type, SQLHeavyDatabase* source, const gchar* source_name, SQLHeavyDatabase* destination, const gchar* destination_name, GError** error);
SQLHeavyBackup* sql_heavy_backup_new (SQLHeavyDatabase* source, SQLHeavyDatabase* destination, GError** error);
SQLHeavyBackup* sql_heavy_backup_construct (GType object_type, SQLHeavyDatabase* source, SQLHeavyDatabase* destination, GError** error);
SQLHeavyDatabase* sql_heavy_backup_get_source_db (SQLHeavyBackup* self);
SQLHeavyDatabase* sql_heavy_backup_get_destination_db (SQLHeavyBackup* self);
const gchar* sql_heavy_backup_get_source_db_name (SQLHeavyBackup* self);
const gchar* sql_heavy_backup_get_destination_db_name (SQLHeavyBackup* self);
gint sql_heavy_backup_get_remaining_pages (SQLHeavyBackup* self);
gint sql_heavy_backup_get_total_pages (SQLHeavyBackup* self);
gpointer sql_heavy_user_function_context_ref (gpointer instance);
void sql_heavy_user_function_context_unref (gpointer instance);
GParamSpec* sql_heavy_user_function_param_spec_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void sql_heavy_user_function_value_set_context (GValue* value, gpointer v_object);
void sql_heavy_user_function_value_take_context (GValue* value, gpointer v_object);
gpointer sql_heavy_user_function_value_get_context (const GValue* value);
GType sql_heavy_user_function_context_get_type (void) G_GNUC_CONST;
GValue* sql_heavy_common_function_regex (SQLHeavyUserFunctionContext* ctx, GValueArray* args, GError** error);
GValue* sql_heavy_common_function_md5 (SQLHeavyUserFunctionContext* ctx, GValueArray* args, GError** error);
GValue* sql_heavy_common_function_sha1 (SQLHeavyUserFunctionContext* ctx, GValueArray* args, GError** error);
GValue* sql_heavy_common_function_sha256 (SQLHeavyUserFunctionContext* ctx, GValueArray* args, GError** error);
GValue* sql_heavy_common_function_compress (SQLHeavyUserFunctionContext* ctx, GValueArray* args, GError** error);
GValue* sql_heavy_common_function_decompress (SQLHeavyUserFunctionContext* ctx, GValueArray* args, GError** error);
GType sql_heavy_record_set_get_type (void) G_GNUC_CONST;
GType sql_heavy_row_get_type (void) G_GNUC_CONST;
GType sql_heavy_record_get_type (void) G_GNUC_CONST;
GType sql_heavy_cursor_get_type (void) G_GNUC_CONST;
void sql_heavy_cursor_first (SQLHeavyCursor* self, GError** error);
void sql_heavy_cursor_last (SQLHeavyCursor* self, GError** error);
gboolean sql_heavy_cursor_previous (SQLHeavyCursor* self, GError** error);
SQLHeavyRecord* sql_heavy_cursor_get (SQLHeavyCursor* self, GError** error);
gboolean sql_heavy_cursor_move_to (SQLHeavyCursor* self, gint64 offset, GError** error);
GType sql_heavy_query_get_type (void) G_GNUC_CONST;
GType sql_heavy_transaction_get_type (void) G_GNUC_CONST;
GType sql_heavy_queryable_get_type (void) G_GNUC_CONST;
void sql_heavy_database_interrupt (SQLHeavyDatabase* self);
void sql_heavy_database_incremental_vacuum (SQLHeavyDatabase* self, gint pages, GError** error);
void sql_heavy_database_register_aggregate_function (SQLHeavyDatabase* self, const gchar* name, gint argc, SQLHeavyUserFunctionUserFunc func, void* func_target, GDestroyNotify func_target_destroy_notify, SQLHeavyUserFunctionFinalizeFunc final, void* final_target, GDestroyNotify final_target_destroy_notify);
void sql_heavy_database_register_scalar_function (SQLHeavyDatabase* self, const gchar* name, gint argc, SQLHeavyUserFunctionUserFunc func, void* func_target, GDestroyNotify func_target_destroy_notify);
void sql_heavy_database_unregister_function (SQLHeavyDatabase* self, const gchar* name);
void sql_heavy_database_register_common_functions (SQLHeavyDatabase* self);
void sql_heavy_database_backup (SQLHeavyDatabase* self, const gchar* destination, GError** error);
void sql_heavy_database_backup_async (SQLHeavyDatabase* self, const gchar* destination, GAsyncReadyCallback _callback_, gpointer _user_data_);
void sql_heavy_database_backup_finish (SQLHeavyDatabase* self, GAsyncResult* _res_, GError** error);
void sql_heavy_database_wal_checkpoint (SQLHeavyDatabase* self, const gchar* database, GError** error);
GType sql_heavy_table_get_type (void) G_GNUC_CONST;
SQLHeavyTable* sql_heavy_database_get_table (SQLHeavyDatabase* self, const gchar* table, GError** error);
GHashTable* sql_heavy_database_get_tables (SQLHeavyDatabase* self, GError** error);
gint sql_heavy_database_compare (SQLHeavyDatabase* a, SQLHeavyDatabase* b);
gboolean sql_heavy_database_init (SQLHeavyDatabase* self, GCancellable* cancellable, GError** error);
GType sql_heavy_file_mode_get_type (void) G_GNUC_CONST;
SQLHeavyDatabase* sql_heavy_database_new (const gchar* filename, SQLHeavyFileMode mode, GError** error);
SQLHeavyDatabase* sql_heavy_database_construct (GType object_type, const gchar* filename, SQLHeavyFileMode mode, GError** error);
gint sql_heavy_database_get_wal_auto_checkpoint (SQLHeavyDatabase* self);
void sql_heavy_database_set_wal_auto_checkpoint (SQLHeavyDatabase* self, gint value);
GType sql_heavy_versioned_database_get_type (void) G_GNUC_CONST;
GType sql_heavy_profiling_database_get_type (void) G_GNUC_CONST;
SQLHeavyProfilingDatabase* sql_heavy_database_get_profiling_data (SQLHeavyDatabase* self);
void sql_heavy_database_set_profiling_data (SQLHeavyDatabase* self, SQLHeavyProfilingDatabase* value);
gboolean sql_heavy_database_get_enable_profiling (SQLHeavyDatabase* self);
void sql_heavy_database_set_enable_profiling (SQLHeavyDatabase* self, gboolean value);
const gchar* sql_heavy_database_get_filename (SQLHeavyDatabase* self);
SQLHeavyFileMode sql_heavy_database_get_mode (SQLHeavyDatabase* self);
gint64 sql_heavy_database_get_last_insert_id (SQLHeavyDatabase* self);
gint sql_heavy_database_get_lookaside_used (SQLHeavyDatabase* self);
GType sql_heavy_auto_vacuum_get_type (void) G_GNUC_CONST;
SQLHeavyAutoVacuum sql_heavy_database_get_auto_vacuum (SQLHeavyDatabase* self);
void sql_heavy_database_set_auto_vacuum (SQLHeavyDatabase* self, SQLHeavyAutoVacuum value);
gint sql_heavy_database_get_cache_size (SQLHeavyDatabase* self);
void sql_heavy_database_set_cache_size (SQLHeavyDatabase* self, gint value);
gboolean sql_heavy_database_get_case_sensitive_like (SQLHeavyDatabase* self);
void sql_heavy_database_set_case_sensitive_like (SQLHeavyDatabase* self, gboolean value);
gboolean sql_heavy_database_get_count_changes (SQLHeavyDatabase* self);
void sql_heavy_database_set_count_changes (SQLHeavyDatabase* self, gboolean value);
gint sql_heavy_database_get_default_cache_size (SQLHeavyDatabase* self);
void sql_heavy_database_set_default_cache_size (SQLHeavyDatabase* self, gint value);
gboolean sql_heavy_database_get_empty_result_callbacks (SQLHeavyDatabase* self);
void sql_heavy_database_set_empty_result_callbacks (SQLHeavyDatabase* self, gboolean value);
GType sql_heavy_encoding_get_type (void) G_GNUC_CONST;
SQLHeavyEncoding sql_heavy_database_get_encoding (SQLHeavyDatabase* self);
void sql_heavy_database_set_encoding (SQLHeavyDatabase* self, SQLHeavyEncoding value);
gboolean sql_heavy_database_get_foreign_keys (SQLHeavyDatabase* self);
void sql_heavy_database_set_foreign_keys (SQLHeavyDatabase* self, gboolean value);
gboolean sql_heavy_database_get_full_column_names (SQLHeavyDatabase* self);
void sql_heavy_database_set_full_column_names (SQLHeavyDatabase* self, gboolean value);
gboolean sql_heavy_database_get_full_fsync (SQLHeavyDatabase* self);
void sql_heavy_database_set_full_fsync (SQLHeavyDatabase* self, gboolean value);
GType sql_heavy_journal_mode_get_type (void) G_GNUC_CONST;
SQLHeavyJournalMode sql_heavy_database_get_journal_mode (SQLHeavyDatabase* self);
void sql_heavy_database_set_journal_mode (SQLHeavyDatabase* self, SQLHeavyJournalMode value);
gint sql_heavy_database_get_journal_size_limit (SQLHeavyDatabase* self);
void sql_heavy_database_set_journal_size_limit (SQLHeavyDatabase* self, gint value);
gboolean sql_heavy_database_get_legacy_file_format (SQLHeavyDatabase* self);
void sql_heavy_database_set_legacy_file_format (SQLHeavyDatabase* self, gboolean value);
GType sql_heavy_locking_mode_get_type (void) G_GNUC_CONST;
SQLHeavyLockingMode sql_heavy_database_get_locking_mode (SQLHeavyDatabase* self);
void sql_heavy_database_set_locking_mode (SQLHeavyDatabase* self, SQLHeavyLockingMode value);
gint sql_heavy_database_get_page_size (SQLHeavyDatabase* self);
void sql_heavy_database_set_page_size (SQLHeavyDatabase* self, gint value);
gint sql_heavy_database_get_max_page_count (SQLHeavyDatabase* self);
void sql_heavy_database_set_max_page_count (SQLHeavyDatabase* self, gint value);
gboolean sql_heavy_database_get_read_uncommitted (SQLHeavyDatabase* self);
void sql_heavy_database_set_read_uncommitted (SQLHeavyDatabase* self, gboolean value);
gboolean sql_heavy_database_get_recursive_triggers (SQLHeavyDatabase* self);
void sql_heavy_database_set_recursive_triggers (SQLHeavyDatabase* self, gboolean value);
gboolean sql_heavy_database_get_reverse_unordered_selects (SQLHeavyDatabase* self);
void sql_heavy_database_set_reverse_unordered_selects (SQLHeavyDatabase* self, gboolean value);
gboolean sql_heavy_database_get_short_column_names (SQLHeavyDatabase* self);
void sql_heavy_database_set_short_column_names (SQLHeavyDatabase* self, gboolean value);
GType sql_heavy_synchronous_mode_get_type (void) G_GNUC_CONST;
SQLHeavySynchronousMode sql_heavy_database_get_synchronous (SQLHeavyDatabase* self);
void sql_heavy_database_set_synchronous (SQLHeavyDatabase* self, SQLHeavySynchronousMode value);
GType sql_heavy_temp_store_mode_get_type (void) G_GNUC_CONST;
SQLHeavyTempStoreMode sql_heavy_database_get_temp_store (SQLHeavyDatabase* self);
void sql_heavy_database_set_temp_store (SQLHeavyDatabase* self, SQLHeavyTempStoreMode value);
gchar* sql_heavy_database_get_temp_store_directory (SQLHeavyDatabase* self);
void sql_heavy_database_set_temp_store_directory (SQLHeavyDatabase* self, const gchar* value);
gint sql_heavy_database_get_free_list_count (SQLHeavyDatabase* self);
gint sql_heavy_database_get_page_count (SQLHeavyDatabase* self);
void sql_heavy_database_set_page_count (SQLHeavyDatabase* self, gint value);
gint sql_heavy_database_get_schema_version (SQLHeavyDatabase* self);
void sql_heavy_database_set_schema_version (SQLHeavyDatabase* self, gint value);
gboolean sql_heavy_database_get_secure_delete (SQLHeavyDatabase* self);
void sql_heavy_database_set_secure_delete (SQLHeavyDatabase* self, gboolean value);
gint sql_heavy_database_get_user_version (SQLHeavyDatabase* self);
void sql_heavy_database_set_user_version (SQLHeavyDatabase* self, gint value);
gboolean sql_heavy_database_get_parser_trace (SQLHeavyDatabase* self);
void sql_heavy_database_set_parser_trace (SQLHeavyDatabase* self, gboolean value);
gboolean sql_heavy_database_get_vdbe_trace (SQLHeavyDatabase* self);
void sql_heavy_database_set_vdbe_trace (SQLHeavyDatabase* self, gboolean value);
gboolean sql_heavy_database_get_vdbe_listing (SQLHeavyDatabase* self);
void sql_heavy_database_set_vdbe_listing (SQLHeavyDatabase* self, gboolean value);
GType sql_heavy_transaction_type_get_type (void) G_GNUC_CONST;
const gchar* sql_heavy_transaction_type_to_string (SQLHeavyTransactionType self);
SQLHeavyEncoding sql_heavy_encoding_from_string (const gchar* encoding);
const gchar* sql_heavy_encoding_to_string (SQLHeavyEncoding self);
SQLHeavyJournalMode sql_heavy_journal_mode_from_string (const gchar* journal_mode);
const gchar* sql_heavy_journal_mode_to_string (SQLHeavyJournalMode self);
SQLHeavyLockingMode sql_heavy_locking_mode_from_string (const gchar* locking_mode);
const gchar* sql_heavy_locking_mode_to_string (SQLHeavyLockingMode self);
SQLHeavySynchronousMode sql_heavy_synchronous_mode_from_string (const gchar* synchronous_mode);
const gchar* sql_heavy_synchronous_mode_to_string (SQLHeavySynchronousMode self);
SQLHeavyTempStoreMode sql_heavy_temp_store_mode_from_string (const gchar* temp_store_mode);
const gchar* sql_heavy_temp_store_mode_to_string (SQLHeavyTempStoreMode self);
GType sql_heavy_transaction_status_get_type (void) G_GNUC_CONST;
GType sql_heavy_sort_order_get_type (void) G_GNUC_CONST;
GType sql_heavy_mutable_record_get_type (void) G_GNUC_CONST;
void sql_heavy_mutable_record_put (SQLHeavyMutableRecord* self, gint field, GValue* value, GError** error);
void sql_heavy_mutable_record_set (SQLHeavyMutableRecord* self, const gchar* field, GValue* value, GError** error);
void sql_heavy_mutable_record_put_string (SQLHeavyMutableRecord* self, gint field, const gchar* value, GError** error);
void sql_heavy_mutable_record_set_string (SQLHeavyMutableRecord* self, const gchar* field, const gchar* value, GError** error);
void sql_heavy_mutable_record_put_null (SQLHeavyMutableRecord* self, gint field, GError** error);
void sql_heavy_mutable_record_set_null (SQLHeavyMutableRecord* self, const gchar* field, GError** error);
void sql_heavy_mutable_record_put_int (SQLHeavyMutableRecord* self, gint field, gint value, GError** error);
void sql_heavy_mutable_record_set_int (SQLHeavyMutableRecord* self, const gchar* field, gint value, GError** error);
void sql_heavy_mutable_record_put_int64 (SQLHeavyMutableRecord* self, gint field, gint64 value, GError** error);
void sql_heavy_mutable_record_set_int64 (SQLHeavyMutableRecord* self, const gchar* field, gint64 value, GError** error);
void sql_heavy_mutable_record_put_double (SQLHeavyMutableRecord* self, gint field, gdouble value, GError** error);
void sql_heavy_mutable_record_set_double (SQLHeavyMutableRecord* self, const gchar* field, gdouble value, GError** error);
void sql_heavy_mutable_record_put_blob (SQLHeavyMutableRecord* self, gint field, guint8* value, int value_length1, GError** error);
void sql_heavy_mutable_record_set_blob (SQLHeavyMutableRecord* self, const gchar* field, guint8* value, int value_length1, GError** error);
void sql_heavy_mutable_record_put_time_t (SQLHeavyMutableRecord* self, gint field, time_t value, GError** error);
void sql_heavy_mutable_record_set_time_t (SQLHeavyMutableRecord* self, const gchar* field, time_t value, GError** error);
void sql_heavy_mutable_record_save (SQLHeavyMutableRecord* self, GError** error);
void sql_heavy_mutable_record_delete (SQLHeavyMutableRecord* self, GError** error);
SQLHeavyProfilingDatabase* sql_heavy_profiling_database_new (const gchar* filename, GError** error);
SQLHeavyProfilingDatabase* sql_heavy_profiling_database_construct (GType object_type, const gchar* filename, GError** error);
const gchar* sql_heavy_query_parameter_name (SQLHeavyQuery* self, gint parameter, GError** error);
gint sql_heavy_query_parameter_index (SQLHeavyQuery* self, const gchar* parameter, GError** error);
GType sql_heavy_query_result_get_type (void) G_GNUC_CONST;
SQLHeavyQueryResult* sql_heavy_query_execute (SQLHeavyQuery* self, const gchar* first_parameter, GError** error, ...);
void sql_heavy_query_execute_async (SQLHeavyQuery* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
SQLHeavyQueryResult* sql_heavy_query_execute_finish (SQLHeavyQuery* self, GAsyncResult* _res_, GError** error);
gint64 sql_heavy_query_execute_insert (SQLHeavyQuery* self, const gchar* first_parameter, GError** error, ...);
void sql_heavy_query_execute_insert_async (SQLHeavyQuery* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
gint64 sql_heavy_query_execute_insert_finish (SQLHeavyQuery* self, GAsyncResult* _res_, GError** error);
void sql_heavy_query_bind (SQLHeavyQuery* self, gint parameter, GValue* value, GError** error);
void sql_heavy_query_set (SQLHeavyQuery* self, const gchar* name, GValue* value, GError** error);
void sql_heavy_query_bind_int (SQLHeavyQuery* self, gint field, gint value, GError** error);
void sql_heavy_query_set_int (SQLHeavyQuery* self, const gchar* field, gint value, GError** error);
void sql_heavy_query_bind_int64 (SQLHeavyQuery* self, gint field, gint64 value, GError** error);
void sql_heavy_query_set_int64 (SQLHeavyQuery* self, const gchar* field, gint64 value, GError** error);
void sql_heavy_query_bind_string (SQLHeavyQuery* self, gint field, const gchar* value, GError** error);
void sql_heavy_query_set_string (SQLHeavyQuery* self, const gchar* field, const gchar* value, GError** error);
void sql_heavy_query_bind_null (SQLHeavyQuery* self, gint field, GError** error);
void sql_heavy_query_set_null (SQLHeavyQuery* self, const gchar* field, GError** error);
void sql_heavy_query_bind_double (SQLHeavyQuery* self, gint field, gdouble value, GError** error);
void sql_heavy_query_set_double (SQLHeavyQuery* self, const gchar* field, gdouble value, GError** error);
void sql_heavy_query_bind_blob (SQLHeavyQuery* self, gint field, guint8* value, int value_length1, GError** error);
void sql_heavy_query_set_blob (SQLHeavyQuery* self, const gchar* field, guint8* value, int value_length1, GError** error);
void sql_heavy_query_bind_byte_array (SQLHeavyQuery* self, gint field, GByteArray* value, GError** error);
void sql_heavy_query_set_byte_array (SQLHeavyQuery* self, const gchar* field, GByteArray* value, GError** error);
void sql_heavy_query_clear (SQLHeavyQuery* self);
GPtrArray* sql_heavy_query_get_table (SQLHeavyQuery* self, GError** error);
void sql_heavy_query_print_table (SQLHeavyQuery* self, FILE* fd, GError** error);
gboolean sql_heavy_query_init (SQLHeavyQuery* self, GCancellable* cancellable, GError** error);
SQLHeavyQuery* sql_heavy_query_new (SQLHeavyQueryable* queryable, const gchar* sql, GError** error);
SQLHeavyQuery* sql_heavy_query_construct (GType object_type, SQLHeavyQueryable* queryable, const gchar* sql, GError** error);
SQLHeavyQuery* sql_heavy_query_new_full (SQLHeavyQueryable* queryable, const gchar* sql, gint sql_max_len, const gchar** tail, GError** error);
SQLHeavyQuery* sql_heavy_query_construct_full (GType object_type, SQLHeavyQueryable* queryable, const gchar* sql, gint sql_max_len, const gchar** tail, GError** error);
SQLHeavyQueryable* sql_heavy_query_get_queryable (SQLHeavyQuery* self);
const gchar* sql_heavy_query_get_sql (SQLHeavyQuery* self);
gboolean sql_heavy_query_get_auto_clear (SQLHeavyQuery* self);
void sql_heavy_query_set_auto_clear (SQLHeavyQuery* self, gboolean value);
gint sql_heavy_query_get_parameter_count (SQLHeavyQuery* self);
void sql_heavy_queryable_lock (SQLHeavyQueryable* self);
void sql_heavy_queryable_unlock (SQLHeavyQueryable* self);
void sql_heavy_queryable_queue (SQLHeavyQueryable* self, SQLHeavyQuery* query, GError** error);
SQLHeavyTransaction* sql_heavy_queryable_begin_transaction (SQLHeavyQueryable* self, GError** error);
SQLHeavyQueryResult* sql_heavy_queryable_execute (SQLHeavyQueryable* self, const gchar* sql, GError** error, ...);
void sql_heavy_queryable_run (SQLHeavyQueryable* self, const gchar* sql, GError** error, ...);
gint64 sql_heavy_queryable_execute_insert (SQLHeavyQueryable* self, const gchar* sql, GError** error, ...);
SQLHeavyQuery* sql_heavy_queryable_prepare (SQLHeavyQueryable* self, const gchar* sql, GError** error);
void sql_heavy_queryable_run_script (SQLHeavyQueryable* self, const gchar* filename, GError** error);
void sql_heavy_queryable_print_table (SQLHeavyQueryable* self, const gchar* sql, FILE* fd, GError** error);
SQLHeavyDatabase* sql_heavy_queryable_get_database (SQLHeavyQueryable* self);
void sql_heavy_query_result_next_async (SQLHeavyQueryResult* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
gboolean sql_heavy_query_result_next_finish (SQLHeavyQueryResult* self, GAsyncResult* _res_, GError** error);
void sql_heavy_query_result_complete (SQLHeavyQueryResult* self, GError** error);
void sql_heavy_query_result_complete_async (SQLHeavyQueryResult* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
void sql_heavy_query_result_complete_finish (SQLHeavyQueryResult* self, GAsyncResult* _res_, GError** error);
gchar* sql_heavy_query_result_field_origin_table_name (SQLHeavyQueryResult* self, gint field, GError** error);
SQLHeavyTable* sql_heavy_query_result_field_origin_table (SQLHeavyQueryResult* self, gint field, GError** error);
gchar* sql_heavy_query_result_field_origin_name (SQLHeavyQueryResult* self, gint field, GError** error);
SQLHeavyQueryResult* sql_heavy_query_result_new (SQLHeavyQuery* query, GError** error);
SQLHeavyQueryResult* sql_heavy_query_result_construct (GType object_type, SQLHeavyQuery* query, GError** error);
SQLHeavyQuery* sql_heavy_query_result_get_query (SQLHeavyQueryResult* self);
GType sql_heavy_value_array_get_type (void) G_GNUC_CONST;
SQLHeavyValueArray* sql_heavy_query_result_get_bindings (SQLHeavyQueryResult* self);
gint sql_heavy_query_result_get_full_scan_steps (SQLHeavyQueryResult* self);
gint sql_heavy_query_result_get_sort_operations (SQLHeavyQueryResult* self);
gdouble sql_heavy_query_result_get_execution_time (SQLHeavyQueryResult* self);
gboolean sql_heavy_query_result_get_finished (SQLHeavyQueryResult* self);
gchar* sql_heavy_record_field_name (SQLHeavyRecord* self, gint field, GError** error);
gint sql_heavy_record_field_index (SQLHeavyRecord* self, const gchar* field, GError** error);
gchar** sql_heavy_record_field_names (SQLHeavyRecord* self, int* result_length1);
GType sql_heavy_record_field_type (SQLHeavyRecord* self, gint field, GError** error);
void sql_heavy_record_fetch (SQLHeavyRecord* self, gint field, GValue* result, GError** error);
GValue* sql_heavy_record_get (SQLHeavyRecord* self, const gchar* field, GError** error);
SQLHeavyRow* sql_heavy_record_fetch_foreign_row (SQLHeavyRecord* self, gint field, GError** error);
SQLHeavyRow* sql_heavy_record_get_foreign_row (SQLHeavyRecord* self, const gchar* field, GError** error);
GValueArray* sql_heavy_record_fetch_row (SQLHeavyRecord* self, GError** error);
void sql_heavy_record_fetch_with_type (SQLHeavyRecord* self, GType requested_type, gint field, GValue* result, GError** error);
gchar* sql_heavy_record_fetch_string (SQLHeavyRecord* self, gint field, GError** error);
gchar* sql_heavy_record_get_string (SQLHeavyRecord* self, const gchar* field, GError** error);
gint sql_heavy_record_fetch_int (SQLHeavyRecord* self, gint field, GError** error);
gint sql_heavy_record_get_int (SQLHeavyRecord* self, const gchar* field, GError** error);
gint64 sql_heavy_record_fetch_int64 (SQLHeavyRecord* self, gint field, GError** error);
gint64 sql_heavy_record_get_int64 (SQLHeavyRecord* self, const gchar* field, GError** error);
gdouble sql_heavy_record_fetch_double (SQLHeavyRecord* self, gint field, GError** error);
gdouble sql_heavy_record_get_double (SQLHeavyRecord* self, const gchar* field, GError** error);
guint8* sql_heavy_record_fetch_blob (SQLHeavyRecord* self, gint field, int* result_length1, GError** error);
guint8* sql_heavy_record_get_blob (SQLHeavyRecord* self, const gchar* field, int* result_length1, GError** error);
time_t sql_heavy_record_fetch_time_t (SQLHeavyRecord* self, gint field, GError** error);
time_t sql_heavy_record_get_time_t (SQLHeavyRecord* self, const gchar* field, GError** error);
gint sql_heavy_record_get_field_count (SQLHeavyRecord* self);
gboolean sql_heavy_record_set_next (SQLHeavyRecordSet* self, GError** error);
gint sql_heavy_row_compare (SQLHeavyRow* a, SQLHeavyRow* b);
SQLHeavyRow* sql_heavy_row_new (SQLHeavyTable* table, gint64 id);
SQLHeavyRow* sql_heavy_row_construct (GType object_type, SQLHeavyTable* table, gint64 id);
SQLHeavyTable* sql_heavy_row_get_table (SQLHeavyRow* self);
gboolean sql_heavy_row_get_auto_save (SQLHeavyRow* self);
void sql_heavy_row_set_auto_save (SQLHeavyRow* self, gboolean value);
gint64 sql_heavy_row_get_id (SQLHeavyRow* self);
gboolean sql_heavy_row_get_enable_cache (SQLHeavyRow* self);
void sql_heavy_row_set_enable_cache (SQLHeavyRow* self, gboolean value);
gchar* sql_heavy_table_field_name (SQLHeavyTable* self, gint field, GError** error);
gchar* sql_heavy_table_field_affinity (SQLHeavyTable* self, gint field, GError** error);
GType sql_heavy_table_field_affinity_type (SQLHeavyTable* self, gint field, GError** error);
gint sql_heavy_table_field_index (SQLHeavyTable* self, const gchar* name, GError** error);
gchar* sql_heavy_table_foreign_key_table_name (SQLHeavyTable* self, gint foreign_key, GError** error);
SQLHeavyTable* sql_heavy_table_foreign_key_table (SQLHeavyTable* self, gint foreign_key, GError** error);
gchar* sql_heavy_table_foreign_key_from (SQLHeavyTable* self, gint foreign_key, GError** error);
gchar* sql_heavy_table_foreign_key_to (SQLHeavyTable* self, gint foreign_key, GError** error);
gint sql_heavy_table_foreign_key_index (SQLHeavyTable* self, const gchar* foreign_key, GError** error);
SQLHeavyRow* sql_heavy_table_get (SQLHeavyTable* self, gint64 id, GError** error);
void sql_heavy_table_register_notify_triggers (SQLHeavyTable* self, GError** error);
GType sql_heavy_table_cursor_get_type (void) G_GNUC_CONST;
SQLHeavyTableCursor* sql_heavy_table_iterator (SQLHeavyTable* self);
gint sql_heavy_table_compare (SQLHeavyTable* a, SQLHeavyTable* b);
SQLHeavyTable* sql_heavy_table_new (SQLHeavyQueryable* queryable, const gchar* name, GError** error);
SQLHeavyTable* sql_heavy_table_construct (GType object_type, SQLHeavyQueryable* queryable, const gchar* name, GError** error);
const gchar* sql_heavy_table_get_name (SQLHeavyTable* self);
SQLHeavyQueryable* sql_heavy_table_get_queryable (SQLHeavyTable* self);
gint sql_heavy_table_get_field_count (SQLHeavyTable* self);
gint sql_heavy_table_get_foreign_key_count (SQLHeavyTable* self);
SQLHeavyTableCursor* sql_heavy_table_cursor_new (SQLHeavyTable* table);
SQLHeavyTableCursor* sql_heavy_table_cursor_construct (GType object_type, SQLHeavyTable* table);
SQLHeavyTable* sql_heavy_table_cursor_get_table (SQLHeavyTableCursor* self);
gint64 sql_heavy_table_cursor_get_offset (SQLHeavyTableCursor* self);
SQLHeavySortOrder sql_heavy_table_cursor_get_sort_order (SQLHeavyTableCursor* self);
void sql_heavy_table_cursor_set_sort_order (SQLHeavyTableCursor* self, SQLHeavySortOrder value);
const gchar* sql_heavy_table_cursor_get_sort_column (SQLHeavyTableCursor* self);
void sql_heavy_table_cursor_set_sort_column (SQLHeavyTableCursor* self, const gchar* value);
gint sql_heavy_table_cursor_get_field_count (SQLHeavyTableCursor* self);
void sql_heavy_transaction_commit (SQLHeavyTransaction* self, GError** error);
void sql_heavy_transaction_commit_async (SQLHeavyTransaction* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void sql_heavy_transaction_commit_finish (SQLHeavyTransaction* self, GAsyncResult* _res_, GError** error);
void sql_heavy_transaction_rollback (SQLHeavyTransaction* self, GError** error);
void sql_heavy_transaction_rollback_async (SQLHeavyTransaction* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void sql_heavy_transaction_rollback_finish (SQLHeavyTransaction* self, GAsyncResult* _res_, GError** error);
SQLHeavyTransaction* sql_heavy_transaction_new (SQLHeavyQueryable* parent, GError** error);
SQLHeavyTransaction* sql_heavy_transaction_construct (GType object_type, SQLHeavyQueryable* parent, GError** error);
SQLHeavyTransactionStatus sql_heavy_transaction_get_status (SQLHeavyTransaction* self);
SQLHeavyQueryable* sql_heavy_transaction_get_parent (SQLHeavyTransaction* self);
void sql_heavy_user_function_context_set_user_data (SQLHeavyUserFunctionContext* self, const gchar* key, GValue* value);
GValue* sql_heavy_user_function_context_get_user_data (SQLHeavyUserFunctionContext* self, const gchar* key);
gchar* sql_heavy_escape_string (const gchar* str);
GValue* sql_heavy_value_array_get (SQLHeavyValueArray* self, gint index);
void sql_heavy_value_array_set (SQLHeavyValueArray* self, gint index, GValue* value);
void sql_heavy_value_array_set_string (SQLHeavyValueArray* self, gint index, const gchar* value);
void sql_heavy_value_array_set_int (SQLHeavyValueArray* self, gint index, gint value);
void sql_heavy_value_array_set_int64 (SQLHeavyValueArray* self, gint index, gint64 value);
void sql_heavy_value_array_set_double (SQLHeavyValueArray* self, gint index, gdouble value);
void sql_heavy_value_array_set_byte_array (SQLHeavyValueArray* self, gint index, GByteArray* value);
void sql_heavy_value_array_set_null (SQLHeavyValueArray* self, gint index);
void sql_heavy_value_array_insert (SQLHeavyValueArray* self, gint index, GValue* value);
void sql_heavy_value_array_append (SQLHeavyValueArray* self, GValue* value);
void sql_heavy_value_array_prepend (SQLHeavyValueArray* self, GValue* value);
void sql_heavy_value_array_remove (SQLHeavyValueArray* self, gint index);
void sql_heavy_value_array_insert_padding (SQLHeavyValueArray* self, gint index, gint members);
void sql_heavy_value_array_clear (SQLHeavyValueArray* self);
SQLHeavyValueArray* sql_heavy_value_array_copy (SQLHeavyValueArray* self);
SQLHeavyValueArray* sql_heavy_value_array_new (gint length);
SQLHeavyValueArray* sql_heavy_value_array_construct (GType object_type, gint length);
SQLHeavyValueArray* sql_heavy_value_array_get_source (SQLHeavyValueArray* self);
void sql_heavy_value_array_set_source (SQLHeavyValueArray* self, SQLHeavyValueArray* value);
gint sql_heavy_value_array_get_length (SQLHeavyValueArray* self);
gchar* sql_heavy_version_api (void);
gint sql_heavy_version_library (void);
gint sql_heavy_version_sqlite_library (void);
SQLHeavyVersionedDatabase* sql_heavy_versioned_database_new (const gchar* file, const gchar* directory, GError** error);
SQLHeavyVersionedDatabase* sql_heavy_versioned_database_construct (GType object_type, const gchar* file, const gchar* directory, GError** error);
const gchar* sql_heavy_versioned_database_get_schema (SQLHeavyVersionedDatabase* self);


G_END_DECLS

#endif