/* sqlheavy-0.1-internal.h generated by valac 0.16.0, the Vala compiler, do not modify */


#ifndef __SQLHEAVY_0_1_INTERNAL_H__
#define __SQLHEAVY_0_1_INTERNAL_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 <sqlite3.h>
#include <stdio.h>
#include <stdarg.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;

#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 _SQLHeavyQueryPrivate SQLHeavyQueryPrivate;

#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 _SQLHeavyQueryResultPrivate SQLHeavyQueryResultPrivate;
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;

#define SQL_HEAVY_USER_FUNCTION_TYPE_USER_FUNC_DATA (sql_heavy_user_function_user_func_data_get_type ())
#define SQL_HEAVY_USER_FUNCTION_USER_FUNC_DATA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SQL_HEAVY_USER_FUNCTION_TYPE_USER_FUNC_DATA, SQLHeavyUserFunctionUserFuncData))
#define SQL_HEAVY_USER_FUNCTION_USER_FUNC_DATA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SQL_HEAVY_USER_FUNCTION_TYPE_USER_FUNC_DATA, SQLHeavyUserFunctionUserFuncDataClass))
#define SQL_HEAVY_USER_FUNCTION_IS_USER_FUNC_DATA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SQL_HEAVY_USER_FUNCTION_TYPE_USER_FUNC_DATA))
#define SQL_HEAVY_USER_FUNCTION_IS_USER_FUNC_DATA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SQL_HEAVY_USER_FUNCTION_TYPE_USER_FUNC_DATA))
#define SQL_HEAVY_USER_FUNCTION_USER_FUNC_DATA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SQL_HEAVY_USER_FUNCTION_TYPE_USER_FUNC_DATA, SQLHeavyUserFunctionUserFuncDataClass))

typedef struct _SQLHeavyUserFunctionUserFuncData SQLHeavyUserFunctionUserFuncData;
typedef struct _SQLHeavyUserFunctionUserFuncDataClass SQLHeavyUserFunctionUserFuncDataClass;
typedef struct _SQLHeavyUserFunctionUserFuncDataPrivate SQLHeavyUserFunctionUserFuncDataPrivate;
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);
};

typedef gint (*SQLHeavyWALCheckpointFunc) (sqlite3* db, const gchar* dbname);
typedef gint (*SQLHeavyWALHookCallback) (sqlite3* db, const gchar* dbname, gint pages, void* user_data);
typedef gint (*SQLHeavyWALHookFunc) (sqlite3* db, SQLHeavyWALHookCallback hook, void* hook_target);
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 _SQLHeavyUserFunctionUserFuncData {
	GObject parent_instance;
	SQLHeavyUserFunctionUserFuncDataPrivate * priv;
	SQLHeavyDatabase* db;
	gchar* name;
	gint argc;
	gboolean is_scalar;
	SQLHeavyUserFunctionUserFunc func;
	gpointer func_target;
	GDestroyNotify func_target_destroy_notify;
	SQLHeavyUserFunctionFinalizeFunc final;
	gpointer final_target;
	GDestroyNotify final_target_destroy_notify;
};

struct _SQLHeavyUserFunctionUserFuncDataClass {
	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_checksum (GChecksumType cs, 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_convert_blob (GConverter* converter, 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);
void g_sequence_free (GSequence* seq);
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;
GType sql_heavy_table_get_type (void) G_GNUC_CONST;
void sql_heavy_database_register_orm_table (SQLHeavyDatabase* self, SQLHeavyTable* table);
void sql_heavy_database_unregister_orm_table (SQLHeavyDatabase* self, SQLHeavyTable* table);
sqlite3* sql_heavy_database_get_sqlite_db (SQLHeavyDatabase* self);
void sql_heavy_database_step_lock (SQLHeavyDatabase* self);
void sql_heavy_database_step_unlock (SQLHeavyDatabase* self);
void sql_heavy_database_add_step_unlock_notify_row (SQLHeavyDatabase* self, SQLHeavyRow* row);
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);
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);
gint sql_heavy_database_direct_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;
gboolean sql_heavy_error_if_not_ok (gint ec, SQLHeavyQueryable* queryable, GError** error);
gint sql_heavy_sqlite_code_from_error (GError* e);
const gchar* sql_heavy_sqlite_errstr (gint ec);
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);
GType sql_heavy_query_result_get_type (void) G_GNUC_CONST;
void sql_heavy_profiling_database_insert (SQLHeavyProfilingDatabase* self, SQLHeavyQueryResult* query_result);
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);
gint sqlite3_prepare_v2 (sqlite3* db, const gchar* sql, gint n_bytes, sqlite3_stmt** stmt, const gchar** tail);
gint sqlite3_finalize (sqlite3_stmt* stmt);
GType sql_heavy_value_array_get_type (void) G_GNUC_CONST;
SQLHeavyValueArray* sql_heavy_query_get_bindings (SQLHeavyQuery* self);
sqlite3_stmt* sql_heavy_query_try_to_steal_stmt (SQLHeavyQuery* self);
void sql_heavy_query_return_stmt (SQLHeavyQuery* self);
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);
void sql_heavy_query_set_list (SQLHeavyQuery* self, gboolean has_first_parameter, const gchar* first_parameter, va_list args, GError** error);
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);
gboolean sql_heavy_query_result_next_internal (SQLHeavyQueryResult* self, GError** error);
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_next_internal_async (SQLHeavyQueryResult* self, GCancellable* cancellable, gint steps, GAsyncReadyCallback _callback_, gpointer _user_data_);
gboolean sql_heavy_query_result_next_internal_finish (SQLHeavyQueryResult* self, GAsyncResult* _res_, gint64* last_insert_id, 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_no_lock (SQLHeavyQuery* query, GError** error);
SQLHeavyQueryResult* sql_heavy_query_result_construct_no_lock (GType object_type, SQLHeavyQuery* query, GError** error);
SQLHeavyQueryResult* sql_heavy_query_result_new_insert (SQLHeavyQuery* query, gint64* insert_id, GError** error);
SQLHeavyQueryResult* sql_heavy_query_result_construct_insert (GType object_type, SQLHeavyQuery* query, gint64* insert_id, GError** error);
SQLHeavyQueryResult* sql_heavy_query_result_new_no_exec (SQLHeavyQuery* query, GError** error);
SQLHeavyQueryResult* sql_heavy_query_result_construct_no_exec (GType object_type, SQLHeavyQuery* query, 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);
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);
void sql_heavy_row_on_delete (SQLHeavyRow* self);
void sql_heavy_row_update_cache (SQLHeavyRow* self, GError** error);
gint sql_heavy_row_compare (SQLHeavyRow* a, SQLHeavyRow* b);
gint sql_heavy_row_direct_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);
void sql_heavy_table_register_row (SQLHeavyTable* self, SQLHeavyRow* row);
void sql_heavy_table_unregister_row (SQLHeavyTable* self, SQLHeavyRow* row);
gint sql_heavy_table_compare (SQLHeavyTable* a, SQLHeavyTable* b);
gint sql_heavy_table_direct_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);
GType sql_heavy_user_function_user_func_data_get_type (void) G_GNUC_CONST;
SQLHeavyUserFunctionUserFuncData* sql_heavy_user_function_user_func_data_new_scalar (SQLHeavyDatabase* db, const gchar* name, gint argc, SQLHeavyUserFunctionUserFunc func, void* func_target);
SQLHeavyUserFunctionUserFuncData* sql_heavy_user_function_user_func_data_construct_scalar (GType object_type, SQLHeavyDatabase* db, const gchar* name, gint argc, SQLHeavyUserFunctionUserFunc func, void* func_target);
SQLHeavyUserFunctionUserFuncData* sql_heavy_user_function_user_func_data_new_aggregate (SQLHeavyDatabase* db, const gchar* name, gint argc, SQLHeavyUserFunctionUserFunc func, void* func_target, SQLHeavyUserFunctionFinalizeFunc final, void* final_target);
SQLHeavyUserFunctionUserFuncData* sql_heavy_user_function_user_func_data_construct_aggregate (GType object_type, SQLHeavyDatabase* db, const gchar* name, gint argc, SQLHeavyUserFunctionUserFunc func, void* func_target, SQLHeavyUserFunctionFinalizeFunc final, void* final_target);
SQLHeavyUserFunctionUserFuncData* sql_heavy_user_function_user_func_data_new (void);
SQLHeavyUserFunctionUserFuncData* sql_heavy_user_function_user_func_data_construct (GType object_type);
void g_hash_table_unref (GHashTable* ht);
GHashTable* g_hash_table_ref (GHashTable* ht);
void g_boxed_free (GType type, void* ptr);
void sql_heavy_user_function_g_boxed_value_free (void* value);
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);
void sql_heavy_user_function_context_handle_result (SQLHeavyUserFunctionContext* self, GValue* value);
void sql_heavy_user_function_context_call_user_func (SQLHeavyUserFunctionContext* self, sqlite3_value** args, int args_length1);
void sql_heavy_user_function_context_call_finalize_func (SQLHeavyUserFunctionContext* self);
SQLHeavyUserFunctionContext* sql_heavy_user_function_context_new (sqlite3_context* ctx);
SQLHeavyUserFunctionContext* sql_heavy_user_function_context_construct (GType object_type, sqlite3_context* ctx);
void sql_heavy_user_function_on_user_function_called (sqlite3_context* context, int args_length1, sqlite3_value** args);
void sql_heavy_user_function_on_user_finalize_called (sqlite3_context* context);
GType sql_heavy_sqlite_type_to_g_type (gint stype, GError** error);
GType sql_heavy_sqlite_type_string_to_g_type (const gchar* stype, GError** error);
gboolean sql_heavy_value_equal (GValue* a, GValue* b);
void sql_heavy_sqlite_value_to_g_value (sqlite3_value* value, GValue* result);
GValueArray* sql_heavy_sqlite_value_array_to_g_value_array (sqlite3_value** values, int values_length1);
gchar* sql_heavy_escape_string (const gchar* str);
gboolean sql_heavy_check_type (GType gtype);
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
