// 3.26.0

module lib+ {

    module sqlite3+ {

        module so {

            struct struct {
                sqlite3_open_v2 void;
                sqlite3_close_v2 void;
                sqlite3_exec void;
                sqlite3_prepare_v2 void;
                sqlite3_bind_blob void;
                sqlite3_bind_double void;
                sqlite3_bind_int void;
                sqlite3_bind_null void;
                sqlite3_bind_text void;
                sqlite3_bind_text16 void;
                sqlite3_bind_text64 void;
                sqlite3_bind_value void;
                sqlite3_bind_zeroblob void;
                sqlite3_bind_parameter_count void;
                sqlite3_bind_parameter_name void;
                sqlite3_bind_parameter_index void;
                sqlite3_clear_bindings void;
                sqlite3_data_count void;
                sqlite3_column_count void;
                sqlite3_column_name void;
                sqlite3_column_name16 void;
                sqlite3_step void;
                sqlite3_reset void;
                sqlite3_column_blob void;
                sqlite3_column_double void;
                sqlite3_column_int void;
                sqlite3_column_int64 void;
                sqlite3_column_text void;
                sqlite3_column_text16 void;
                sqlite3_column_value void;
                sqlite3_column_bytes void;
                sqlite3_column_bytes16 void;
                sqlite3_column_type void;
                sqlite3_finalize void;
                sqlite3_vmprintf void;
                sqlite3_vsnprintf void;
                sqlite3_free void;
                sqlite3_last_insert_rowid void;
                sqlite3_threadsafe void;
            }

            var fn struct;

            func init() bool {
                import rt::c;
                return dlsyms(dlopen("libsqlite3.so.0", RTLD_LAZY), &fn,
                    "sqlite3_open_v2",
                    "sqlite3_close_v2",
                    "sqlite3_exec",
                    "sqlite3_prepare_v2",
                    "sqlite3_bind_blob",
                    "sqlite3_bind_double",
                    "sqlite3_bind_int",
                    "sqlite3_bind_null",
                    "sqlite3_bind_text",
                    "sqlite3_bind_text16",
                    "sqlite3_bind_text64",
                    "sqlite3_bind_value",
                    "sqlite3_bind_zeroblob",
                    "sqlite3_bind_parameter_count",
                    "sqlite3_bind_parameter_name",
                    "sqlite3_bind_parameter_index",
                    "sqlite3_clear_bindings",
                    "sqlite3_data_count",
                    "sqlite3_column_count",
                    "sqlite3_column_name",
                    "sqlite3_column_name16",
                    "sqlite3_step",
                    "sqlite3_reset",
                    "sqlite3_column_blob",
                    "sqlite3_column_double",
                    "sqlite3_column_int",
                    "sqlite3_column_int64",
                    "sqlite3_column_text",
                    "sqlite3_column_text16",
                    "sqlite3_column_value",
                    "sqlite3_column_bytes",
                    "sqlite3_column_bytes16",
                    "sqlite3_column_type",
                    "sqlite3_finalize",
                    "sqlite3_vmprintf",
                    "sqlite3_vsnprintf",
                    "sqlite3_free",
                    "sqlite3_last_insert_rowid",
                    "sqlite3_threadsafe"
                );
            }

        }

    }

    module sqlite3+ {

        define {
            SQLITE_OK = 0;
            SQLITE_ERROR = 1;
            SQLITE_INTERNAL = 2;
            SQLITE_PERM = 3;
            SQLITE_ABORT = 4;
            SQLITE_BUSY = 5;
            SQLITE_LOCKED = 6;
            SQLITE_NOMEM = 7;
            SQLITE_READONLY = 8;
            SQLITE_INTERRUPT = 9;
            SQLITE_IOERR = 10;
            SQLITE_CORRUPT = 11;
            SQLITE_NOTFOUND = 12;
            SQLITE_FULL = 13;
            SQLITE_CANTOPEN = 14;
            SQLITE_PROTOCOL = 15;
            SQLITE_EMPTY = 16;
            SQLITE_SCHEMA = 17;
            SQLITE_TOOBIG = 18;
            SQLITE_CONSTRAINT = 19;
            SQLITE_MISMATCH = 20;
            SQLITE_MISUSE = 21;
            SQLITE_NOLFS = 22;
            SQLITE_AUTH = 23;
            SQLITE_FORMAT = 24;
            SQLITE_RANGE = 25;
            SQLITE_NOTADB = 26;
            SQLITE_NOTICE = 27;
            SQLITE_WARNING = 28;
            SQLITE_ROW = 100;
            SQLITE_DONE = 101;
        }

        define {
            SQLITE_OPEN_READONLY = 0x00000001;
            SQLITE_OPEN_READWRITE = 0x00000002;
            SQLITE_OPEN_CREATE = 0x00000004;
            SQLITE_OPEN_URI = 0x00000040;
            SQLITE_OPEN_MEMORY = 0x00000080;
            SQLITE_OPEN_NOMUTEX = 0x00008000;
            SQLITE_OPEN_FULLMUTEX = 0x00010000;
            SQLITE_OPEN_SHAREDCACHE = 0x00020000;
            SQLITE_OPEN_PRIVATECACHE = 0x00040000;
            SQLITE_PREPARE_PERSISTENT = 0x01;
        }

    }

    module sqlite3+ {

        inline sqlite3_open_v2(filename. char, ppDb+ void, flags int, zVfs. char) int {
            return call4<int>(so::fn.sqlite3_open_v2, filename, ppDb, flags, zVfs);
        }

        inline sqlite3_close_v2(db void) int {
            return call1<int>(so::fn.sqlite3_close_v2, db);
        }

        inline sqlite3_exec(db void, sql. char, callback void, callback_param void, errmsg++ char) int {
            return call5<int>(so::fn.sqlite3_exec, db, sql, callback, callback_param, errmsg);
        }

        inline sqlite3_prepare_v2(db void, zSql. char, nByte int, ppStmt void, pzTail++ char) int {
            return call5<int>(so::fn.sqlite3_prepare_v2, db, zSql, nByte, ppStmt, pzTail);
        }

        inline sqlite3_bind_blob(stmt void, index int, blob void, blob_size int, callback void) int {
            return call5<int>(so::fn.sqlite3_bind_blob, stmt, index, blob, blob_size, callback);
        }

        inline sqlite3_bind_double(stmt void, index int, data double) int {
            return call_rrd<int>(so::fn.sqlite3_bind_double, stmt, index, data);
        }

        inline sqlite3_bind_int(stmt void, index int, data int) int {
            return call3<int>(so::fn.sqlite3_bind_int, stmt, index, data);
        }

        inline sqlite3_bind_null(stmt void, index int) int {
            return call2<int>(so::fn.sqlite3_bind_null, stmt, index);
        }

        inline sqlite3_bind_text(stmt void, index int, text. char, text_len int, callback void) int {
            return call5<int>(so::fn.sqlite3_bind_text, stmt, index, text, text_len, callback);
        }

        inline sqlite3_bind_text16(stmt void, index int, text void, text_len int, callback void) int {
            return call5<int>(so::fn.sqlite3_bind_text16, stmt, index, text, text_len, callback);
        }

        inline sqlite3_bind_text64(stmt void, index int, text. char, text_len int64, callback void, encoding char) int {
            return call6<int>(so::fn.sqlite3_bind_text64, stmt, index, text, text_len, callback, encoding);
        }

        inline sqlite3_bind_value(stmt void, index int, value void) int {
            return call3<int>(so::fn.sqlite3_bind_value, stmt, index, value);
        }

        inline sqlite3_bind_zeroblob(stmt void, index int, n int) int {
            return call3<int>(so::fn.sqlite3_bind_zeroblob, stmt, index, n);
        }

        inline sqlite3_bind_parameter_count(stmt void) int {
            return call1<int>(so::fn.sqlite3_bind_parameter_count, stmt);
        }

        inline sqlite3_bind_parameter_name(stmt void, index int) .char {
            return call2<char*>(so::fn.sqlite3_bind_parameter_name, stmt, index);
        }

        inline sqlite3_bind_parameter_index(stmt void, zName. char) int {
            return call2<int>(so::fn.sqlite3_bind_parameter_index, stmt, zName);
        }

        inline sqlite3_clear_bindings(stmt void) int {
            return call1<int>(so::fn.sqlite3_clear_bindings, stmt);
        }

        inline sqlite3_data_count(stmt void) int {
            return call1<int>(so::fn.sqlite3_data_count, stmt);
        }

        inline sqlite3_column_count(stmt void) int {
            return call1<int>(so::fn.sqlite3_column_count, stmt);
        }

        inline sqlite3_column_name(stmt void, index int) .char {
            return call2<char*>(so::fn.sqlite3_column_name, stmt, index);
        }

        inline sqlite3_column_name16(stmt void, index int) void {
            return call2<void>(so::fn.sqlite3_column_name16, stmt, index);
        }

        inline sqlite3_step(stmt void) int {
            return call1<int>(so::fn.sqlite3_step, stmt);
        }

        inline sqlite3_reset(stmt void) int {
            return call1<int>(so::fn.sqlite3_reset, stmt);
        }

        inline sqlite3_column_blob(stmt void, iCol int) void {
            return call2<void>(so::fn.sqlite3_column_blob, stmt, iCol);
        }

        inline sqlite3_column_double(stmt void, iCol int) double {
            return callf_rr<double>(so::fn.sqlite3_column_double, stmt, iCol);
        }

        inline sqlite3_column_int(stmt void, iCol int) int {
            return call2<int>(so::fn.sqlite3_column_int, stmt, iCol);
        }

        inline sqlite3_column_int64(stmt void, iCol int) int64 {
            return call_64_2<int64>(so::fn.sqlite3_column_int64, stmt, iCol);
        }

        inline sqlite3_column_text(stmt void, iCol int) .char {
            return call2<char*>(so::fn.sqlite3_column_text, stmt, iCol);
        }

        inline sqlite3_column_text16(stmt void, iCol int) void {
            return call2<void>(so::fn.sqlite3_column_text16, stmt, iCol);
        }

        inline sqlite3_column_value(stmt void, iCol int) void {
            return call2<void>(so::fn.sqlite3_column_value, stmt, iCol);
        }

        inline sqlite3_column_bytes(stmt void, iCol int) int {
            return call2<int>(so::fn.sqlite3_column_bytes, stmt, iCol);
        }

        inline sqlite3_column_bytes16(stmt void, iCol int) int {
            return call2<int>(so::fn.sqlite3_column_bytes16, stmt, iCol);
        }

        inline sqlite3_column_type(stmt void, iCol int) int {
            return call2<int>(so::fn.sqlite3_column_type, stmt, iCol);
        }

        inline sqlite3_finalize(stmt void) int {
            return call1<int>(so::fn.sqlite3_finalize, stmt);
        }

        inline sqlite3_vmprintf(sql. char, ap void) .char {
            return call2<char*>(so::fn.sqlite3_vmprintf, sql, ap);
        }

        func sqlite3_mprintf(sql. char, ...) .char {
            return sqlite3_vmprintf(sql, va_start(sql));
        }

        inline sqlite3_vsnprintf(len int, str. char, sql. char, ap void) .char {
            return call4<char*>(so::fn.sqlite3_vsnprintf, len, str, sql, ap);
        }

        func sqlite3_snprintf(len int, str. char, sql. char, ...) .char {
            return sqlite3_vsnprintf(len, str, sql, va_start(len));
        }

        inline sqlite3_free(ptr void) {
            call1<void>(so::fn.sqlite3_free, ptr);
        }

        inline sqlite3_last_insert_rowid(db void) int64 {
            return call_64_1<int64>(so::fn.sqlite3_last_insert_rowid, db);
        }

        inline sqlite3_threadsafe() int {
            return call<int>(so::fn.sqlite3_threadsafe);
        }

    }

}