/* * Copyright 2011 - 2017 Maas-Maarten Zeeman * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * sqlite3_nif -- an erlang sqlite nif. */ #include #include #include #include #define MAX_ATOM_LENGTH 255 /* from atom.h, not exposed in erlang include */ #define MAX_SQLITE_NAME_LENGTH 255 /* Maximum name length. Using longer will return misuse */ #define MAX_PATHNAME 512 /* unfortunately not in sqlite.h. */ static ErlNifResourceType *esqlite3_type = NULL; static ErlNifResourceType *esqlite3_stmt_type = NULL; static ErlNifResourceType *esqlite3_backup_type = NULL; /* database connection context */ typedef struct { sqlite3 *db; } esqlite3; /* prepared statement */ typedef struct { sqlite3_stmt *statement; int column_count; } esqlite3_stmt; /* data associated with ongoing backup */ typedef struct { sqlite3_backup *backup; } esqlite3_backup; static ERL_NIF_TERM atom_esqlite3; static ERL_NIF_TERM make_atom(ErlNifEnv *env, const char *atom_name) { ERL_NIF_TERM atom; if(enif_make_existing_atom(env, atom_name, &atom, ERL_NIF_LATIN1)) return atom; return enif_make_atom(env, atom_name); } static ERL_NIF_TERM make_ok_tuple(ErlNifEnv *env, ERL_NIF_TERM value) { return enif_make_tuple2(env, make_atom(env, "ok"), value); } static ERL_NIF_TERM make_error_tuple(ErlNifEnv *env, const char *reason) { return enif_make_tuple2(env, make_atom(env, "error"), make_atom(env, reason)); } static ERL_NIF_TERM make_row_tuple(ErlNifEnv *env, ERL_NIF_TERM value) { return enif_make_tuple2(env, make_atom(env, "row"), value); } static const char * get_sqlite3_return_code_msg(int r) { switch(r) { case SQLITE_OK: return "ok"; case SQLITE_ERROR : return "sqlite_error"; case SQLITE_INTERNAL: return "internal"; case SQLITE_PERM: return "perm"; case SQLITE_ABORT: return "abort"; case SQLITE_BUSY: return "busy"; case SQLITE_LOCKED: return "locked"; case SQLITE_NOMEM: return "nomem"; case SQLITE_READONLY: return "readonly"; case SQLITE_INTERRUPT: return "interrupt"; case SQLITE_IOERR: return "ioerror"; case SQLITE_CORRUPT: return "corrupt"; case SQLITE_NOTFOUND: return "notfound"; case SQLITE_FULL: return "full"; case SQLITE_CANTOPEN: return "cantopen"; case SQLITE_PROTOCOL: return "protocol"; case SQLITE_EMPTY: return "empty"; case SQLITE_SCHEMA: return "schema"; case SQLITE_TOOBIG: return "toobig"; case SQLITE_CONSTRAINT: return "constraint"; case SQLITE_MISMATCH: return "mismatch"; case SQLITE_MISUSE: return "misuse"; case SQLITE_NOLFS: return "nolfs"; case SQLITE_AUTH: return "auth"; case SQLITE_FORMAT: return "format"; case SQLITE_RANGE: return "range"; case SQLITE_NOTADB: return "notadb"; case SQLITE_ROW: return "row"; case SQLITE_DONE: return "done"; } return "unknown"; } ERL_NIF_TERM make_two_atom_tuple(ErlNifEnv *env, const char *one, const char *two) { return enif_make_tuple2(env, make_atom(env, one), make_atom(env, two)); } ERL_NIF_TERM make_extended_error_tuple(ErlNifEnv *env, int code) { switch(code) { case SQLITE_MISUSE: return make_two_atom_tuple(env, "misuse", "invoked_incorrectly"); case SQLITE_ERROR_MISSING_COLLSEQ: return make_two_atom_tuple(env, "error", "missing_collesq"); case SQLITE_ERROR_RETRY: return make_two_atom_tuple(env, "error", "retry"); case SQLITE_ERROR_SNAPSHOT: return make_two_atom_tuple(env, "error", "snapshot"); case SQLITE_IOERR_READ: return make_two_atom_tuple(env, "ioerr", "read"); case SQLITE_IOERR_SHORT_READ: return make_two_atom_tuple(env, "ioerr", "short_read"); case SQLITE_IOERR_WRITE: return make_two_atom_tuple(env, "ioerr", "write"); case SQLITE_IOERR_FSYNC: return make_two_atom_tuple(env, "ioerr", "fsync"); case SQLITE_IOERR_DIR_FSYNC: return make_two_atom_tuple(env, "ioerr", "dir_fsync"); case SQLITE_IOERR_TRUNCATE: return make_two_atom_tuple(env, "ioerr", "truncate"); case SQLITE_IOERR_FSTAT: return make_two_atom_tuple(env, "ioerr", "fstat"); case SQLITE_IOERR_UNLOCK: return make_two_atom_tuple(env, "ioerr", "unlock"); case SQLITE_IOERR_RDLOCK: return make_two_atom_tuple(env, "ioerr", "rdlock"); case SQLITE_IOERR_DELETE: return make_two_atom_tuple(env, "ioerr", "delete"); case SQLITE_IOERR_BLOCKED: return make_two_atom_tuple(env, "ioerr", "blocked"); case SQLITE_IOERR_NOMEM: return make_two_atom_tuple(env, "ioerr", "nomem"); case SQLITE_IOERR_ACCESS: return make_two_atom_tuple(env, "ioerr", "access"); case SQLITE_IOERR_CHECKRESERVEDLOCK: return make_two_atom_tuple(env, "ioerr", "checkreservedlock"); case SQLITE_IOERR_LOCK: return make_two_atom_tuple(env, "ioerr", "lock"); case SQLITE_IOERR_CLOSE: return make_two_atom_tuple(env, "ioerr", "close"); case SQLITE_IOERR_DIR_CLOSE: return make_two_atom_tuple(env, "ioerr", "dir_close"); case SQLITE_IOERR_SHMOPEN: return make_two_atom_tuple(env, "ioerr", "shmopen"); case SQLITE_IOERR_SHMSIZE: return make_two_atom_tuple(env, "ioerr", "shmsize"); case SQLITE_IOERR_SHMLOCK: return make_two_atom_tuple(env, "ioerr", "shmlock"); case SQLITE_IOERR_SHMMAP: return make_two_atom_tuple(env, "ioerr", "shmmap"); case SQLITE_IOERR_SEEK: return make_two_atom_tuple(env, "ioerr", "seek"); case SQLITE_IOERR_DELETE_NOENT: return make_two_atom_tuple(env, "ioerr", "delete_noent"); case SQLITE_IOERR_MMAP: return make_two_atom_tuple(env, "ioerr", "mmap"); case SQLITE_IOERR_GETTEMPPATH: return make_two_atom_tuple(env, "ioerr", "gettemppath"); case SQLITE_IOERR_CONVPATH: return make_two_atom_tuple(env, "ioerr", "convpath"); case SQLITE_IOERR_VNODE: return make_two_atom_tuple(env, "ioerr", "vnode"); case SQLITE_IOERR_AUTH: return make_two_atom_tuple(env, "ioerr", "auth"); case SQLITE_IOERR_BEGIN_ATOMIC: return make_two_atom_tuple(env, "ioerr", "begin_atomic"); case SQLITE_IOERR_COMMIT_ATOMIC: return make_two_atom_tuple(env, "ioerr", "commit_atomic"); case SQLITE_IOERR_ROLLBACK_ATOMIC: return make_two_atom_tuple(env, "ioerr", "rollback_atomic"); case SQLITE_IOERR_DATA: return make_two_atom_tuple(env, "ioerr", "data"); case SQLITE_IOERR_CORRUPTFS: return make_two_atom_tuple(env, "ioerr", "corruptfs"); case SQLITE_LOCKED_SHAREDCACHE: return make_two_atom_tuple(env, "locked", "sharedcache"); case SQLITE_LOCKED_VTAB: return make_two_atom_tuple(env, "locked", "vtab"); case SQLITE_BUSY_RECOVERY: return make_two_atom_tuple(env, "busy", "recovery"); case SQLITE_BUSY_SNAPSHOT: return make_two_atom_tuple(env, "busy", "snapshot"); case SQLITE_BUSY_TIMEOUT: return make_two_atom_tuple(env,"busy", "timeout"); case SQLITE_CANTOPEN_NOTEMPDIR: return make_two_atom_tuple(env, "cantopen", "notempdir"); case SQLITE_CANTOPEN_ISDIR: return make_two_atom_tuple(env, "cantopen", "isdir"); case SQLITE_CANTOPEN_FULLPATH: return make_two_atom_tuple(env, "cantopen", "fullpath"); case SQLITE_CANTOPEN_CONVPATH: return make_two_atom_tuple(env, "cantopen", "convpath"); case SQLITE_CANTOPEN_DIRTYWAL: return make_two_atom_tuple(env, "cantopen", "dirtywal"); case SQLITE_CANTOPEN_SYMLINK: return make_two_atom_tuple(env, "cantopen", "symlink"); case SQLITE_CORRUPT_VTAB: return make_two_atom_tuple(env, "corrupt", "vtab"); case SQLITE_CORRUPT_SEQUENCE: return make_two_atom_tuple(env, "corrupt", "sequence"); case SQLITE_CORRUPT_INDEX: return make_two_atom_tuple(env, "corrupt", "index"); case SQLITE_READONLY_RECOVERY: return make_two_atom_tuple(env, "readonly", "recovery"); case SQLITE_READONLY_CANTLOCK: return make_two_atom_tuple(env, "readonly", "cantlock"); case SQLITE_READONLY_ROLLBACK: return make_two_atom_tuple(env, "readonly", "rollback"); case SQLITE_READONLY_DBMOVED: return make_two_atom_tuple(env, "readonly", "dbmoved"); case SQLITE_READONLY_CANTINIT: return make_two_atom_tuple(env, "readonly", "cantinit"); case SQLITE_READONLY_DIRECTORY: return make_two_atom_tuple(env, "readonly", "directory"); case SQLITE_ABORT_ROLLBACK: return make_two_atom_tuple(env, "abort", "rollback"); case SQLITE_CONSTRAINT_CHECK: return make_two_atom_tuple(env, "constraint", "check"); case SQLITE_CONSTRAINT_COMMITHOOK: return make_two_atom_tuple(env, "constraint", "commithook"); case SQLITE_CONSTRAINT_FOREIGNKEY: return make_two_atom_tuple(env, "constraint", "foreignkey"); case SQLITE_CONSTRAINT_FUNCTION: return make_two_atom_tuple(env, "constraint", "function"); case SQLITE_CONSTRAINT_NOTNULL: return make_two_atom_tuple(env, "constraint", "notnull"); case SQLITE_CONSTRAINT_PRIMARYKEY: return make_two_atom_tuple(env, "constraint", "primarykey"); case SQLITE_CONSTRAINT_TRIGGER: return make_two_atom_tuple(env, "constraint", "trigger"); case SQLITE_CONSTRAINT_UNIQUE: return make_two_atom_tuple(env, "constraint", "unique"); case SQLITE_CONSTRAINT_VTAB: return make_two_atom_tuple(env, "constraint", "vtab"); case SQLITE_CONSTRAINT_ROWID: return make_two_atom_tuple(env, "constraint", "rowid"); case SQLITE_CONSTRAINT_PINNED: return make_two_atom_tuple(env, "constraint", "pinned"); case SQLITE_CONSTRAINT_DATATYPE: return make_two_atom_tuple(env, "constraint", "datatype"); case SQLITE_NOTICE_RECOVER_WAL: return make_two_atom_tuple(env, "notice", "recover_wal"); case SQLITE_NOTICE_RECOVER_ROLLBACK: return make_two_atom_tuple(env, "notice", "recover_rollback"); case SQLITE_WARNING_AUTOINDEX: return make_two_atom_tuple(env, "warning", "autoindex"); case SQLITE_AUTH_USER: return make_two_atom_tuple(env, "auth", "user"); case SQLITE_OK_LOAD_PERMANENTLY: return make_two_atom_tuple(env, "ok", "load_permanently"); case SQLITE_OK_SYMLINK: /* internal use only */ return make_two_atom_tuple(env, "ok", "symlink"); default: return make_two_atom_tuple(env, "error", "unknown"); } } static const char * get_sqlite3_error_msg(int error_code, sqlite3 *db) { static const char *msg; if(error_code == SQLITE_MISUSE) return "Sqlite3 was invoked incorrectly."; msg = sqlite3_errmsg(db); if(!msg) return "No sqlite3 error message found."; return msg; } static ERL_NIF_TERM make_sqlite3_error_tuple(ErlNifEnv *env, int error_code) { return enif_make_tuple2(env, make_atom(env, "error"), make_extended_error_tuple(env, error_code)); } /* * */ static void destruct_esqlite3(ErlNifEnv *env, void *arg) { esqlite3 *db = (esqlite3 *) arg; sqlite3_close_v2(db->db); db->db = NULL; } static void destruct_esqlite3_stmt(ErlNifEnv *env, void *arg) { esqlite3_stmt *stmt = (esqlite3_stmt *) arg; sqlite3_finalize(stmt->statement); stmt->statement = NULL; } static void destruct_esqlite3_backup(ErlNifEnv *env, void *arg) { esqlite3_backup *backup = (esqlite3_backup *) arg; if(backup->backup) { sqlite3_backup_finish(backup->backup); } backup->backup = NULL; } /* void update_callback(void *arg, int sqlite_operation_type, char const *sqlite_database, char const *sqlite_table, sqlite3_int64 sqlite_rowid) { esqlite3 *db = (esqlite3 *)arg; esqlite_command *cmd = NULL; ERL_NIF_TERM type, table, rowid; if(db == NULL) return; cmd = command_create(); if(!cmd) return; rowid = enif_make_int64(cmd->env, sqlite_rowid); table = enif_make_string(cmd->env, sqlite_table, ERL_NIF_LATIN1); switch(sqlite_operation_type) { case SQLITE_INSERT: type = make_atom(cmd->env, "insert"); break; case SQLITE_DELETE: type = make_atom(cmd->env, "delete"); break; case SQLITE_UPDATE: type = make_atom(cmd->env, "update"); break; default: return; } cmd->type = cmd_notification; cmd->arg = enif_make_tuple3(cmd->env, type, table, rowid); push_command(cmd->env, db, cmd); } */ /* static ERL_NIF_TERM do_set_update_hook(ErlNifEnv *env, esqlite3 *conn, const ERL_NIF_TERM arg) { if(!enif_get_local_pid(env, arg, &conn->notification_pid)) { return make_error_tuple(env, "invalid_pid"); } if(!conn->db) { return make_error_tuple(env, "closed"); } sqlite3_update_hook(conn->db, update_callback, conn); return make_atom(env, "ok"); } */ /* static ERL_NIF_TERM do_exec(ErlNifEnv *env, esqlite3 *conn, const ERL_NIF_TERM arg) { ErlNifBinary bin; int rc; ERL_NIF_TERM eos = enif_make_int(env, 0); if(!enif_inspect_iolist_as_binary(env, enif_make_list2(env, arg, eos), &bin)) { return make_error_tuple(env, "no_iodata"); } rc = sqlite3_exec(conn->db, (char *) bin.data, NULL, NULL, NULL); if(rc != SQLITE_OK) return make_sqlite3_error_tuple(env, rc, conn->db); return make_atom(env, "ok"); } */ /* * Nr of changes static ERL_NIF_TERM do_changes(ErlNifEnv *env, esqlite3 *conn, const ERL_NIF_TERM arg) { if(!conn->db) { return make_error_tuple(env, "closed"); } sqlite3_int64 changes = sqlite3_changes64(conn->db); ERL_NIF_TERM changes_term = enif_make_int64(env, changes); return make_ok_tuple(env, changes_term); } */ /* * insert action static ERL_NIF_TERM do_insert(ErlNifEnv *env, esqlite3 *conn, const ERL_NIF_TERM arg) { ErlNifBinary bin; int rc; ERL_NIF_TERM eos = enif_make_int(env, 0); if(!enif_inspect_iolist_as_binary(env, enif_make_list2(env, arg, eos), &bin)) { return make_error_tuple(env, "no_iodata"); } rc = sqlite3_exec(conn->db, (char *) bin.data, NULL, NULL, NULL); if(rc != SQLITE_OK) return make_sqlite3_error_tuple(env, rc, conn->db); sqlite3_int64 last_rowid = sqlite3_last_insert_rowid(conn->db); ERL_NIF_TERM last_rowid_term = enif_make_int64(env, last_rowid); return make_ok_tuple(env, last_rowid_term); } */ /* * Return the last inserted rowid static ERL_NIF_TERM do_last_insert_rowid(ErlNifEnv *env, esqlite3 *conn) { if(!conn->db) { return make_error_tuple(env, "closed"); } sqlite3_int64 last_rowid = sqlite3_last_insert_rowid(conn->db); ERL_NIF_TERM last_rowid_term = enif_make_int64(env, last_rowid); return make_ok_tuple(env, last_rowid_term); } */ /* static int bind_cell(ErlNifEnv *env, const ERL_NIF_TERM cell, sqlite3_stmt *stmt, unsigned int i) { int the_int; ErlNifSInt64 the_long_int; double the_double; char the_atom[MAX_ATOM_LENGTH+1]; ErlNifBinary the_blob; int arity; const ERL_NIF_TERM* tuple; if(enif_get_int(env, cell, &the_int)) return sqlite3_bind_int(stmt, i, the_int); if(enif_get_int64(env, cell, &the_long_int)) return sqlite3_bind_int64(stmt, i, the_long_int); if(enif_get_double(env, cell, &the_double)) return sqlite3_bind_double(stmt, i, the_double); if(enif_get_atom(env, cell, the_atom, sizeof(the_atom), ERL_NIF_LATIN1)) { if(strncmp("undefined", the_atom, strlen("undefined")) == 0) { return sqlite3_bind_null(stmt, i); } if(strncmp("null", the_atom, strlen("null")) == 0) { return sqlite3_bind_null(stmt, i); } return sqlite3_bind_text(stmt, i, the_atom, strlen(the_atom), SQLITE_TRANSIENT); } // Bind as text assume it is utf-8 encoded text if(enif_inspect_iolist_as_binary(env, cell, &the_blob)) { return sqlite3_bind_text(stmt, i, (char *) the_blob.data, the_blob.size, SQLITE_TRANSIENT); } // Check for blob tuple if(enif_get_tuple(env, cell, &arity, &tuple)) { if(arity != 2) return -1; // length 2! if(enif_get_atom(env, tuple[0], the_atom, sizeof(the_atom), ERL_NIF_LATIN1)) { // its a blob... if(0 == strncmp("blob", the_atom, strlen("blob"))) { // with a iolist as argument if(enif_inspect_iolist_as_binary(env, tuple[1], &the_blob)) { // kaboom... get the blob return sqlite3_bind_blob(stmt, i, the_blob.data, the_blob.size, SQLITE_TRANSIENT); } } } } return -1; } */ /* static ERL_NIF_TERM do_bind(ErlNifEnv *env, sqlite3 *db, sqlite3_stmt *stmt, const ERL_NIF_TERM arg) { int parameter_count = sqlite3_bind_parameter_count(stmt); int i, is_list, r; ERL_NIF_TERM list, head, tail; unsigned int list_length; is_list = enif_get_list_length(env, arg, &list_length); if(!is_list) return make_error_tuple(env, "bad_arg_list"); if(parameter_count != list_length) return make_error_tuple(env, "args_wrong_length"); sqlite3_reset(stmt); list = arg; for(i=0; i < list_length; i++) { enif_get_list_cell(env, list, &head, &tail); r = bind_cell(env, head, stmt, i+1); if(r == -1) return make_error_tuple(env, "wrong_type"); if(r != SQLITE_OK) return make_sqlite3_error_tuple(env, r, db); list = tail; } return make_atom(env, "ok"); } */ /* static ERL_NIF_TERM do_get_autocommit(ErlNifEnv *env, esqlite3 *conn) { if(!conn->db) { return make_error_tuple(env, "closed"); } if(sqlite3_get_autocommit(conn->db) != 0) { return make_atom(env, "true"); } return make_atom(env, "false"); } */ static ERL_NIF_TERM make_binary(ErlNifEnv *env, const void *bytes, unsigned int size) { ErlNifBinary blob; ERL_NIF_TERM term; if(!enif_alloc_binary(size, &blob)) { return make_atom(env, "error"); } memcpy(blob.data, bytes, size); term = enif_make_binary(env, &blob); enif_release_binary(&blob); return term; } static ERL_NIF_TERM make_cell(ErlNifEnv *env, sqlite3_stmt *statement, unsigned int i) { int type = sqlite3_column_type(statement, i); switch(type) { case SQLITE_INTEGER: return enif_make_int64(env, sqlite3_column_int64(statement, i)); case SQLITE_FLOAT: return enif_make_double(env, sqlite3_column_double(statement, i)); case SQLITE_BLOB: return enif_make_tuple2(env, make_atom(env, "blob"), make_binary(env, sqlite3_column_blob(statement, i), sqlite3_column_bytes(statement, i))); case SQLITE_NULL: return make_atom(env, "undefined"); case SQLITE_TEXT: return make_binary(env, sqlite3_column_text(statement, i), sqlite3_column_bytes(statement, i)); } return enif_raise_exception(env, make_atom(env, "internal_error")); } /* static ERL_NIF_TERM do_reset(ErlNifEnv *env, sqlite3 *db, sqlite3_stmt *stmt) { int rc = sqlite3_reset(stmt); if(rc != SQLITE_OK) return make_sqlite3_error_tuple(env, rc, db); return make_atom(env, "ok"); } */ /* static ERL_NIF_TERM do_backup_init(ErlNifEnv *env, sqlite3 *db, const ERL_NIF_TERM arg) { int tuple_arity; const ERL_NIF_TERM *elements; sqlite3_backup *backup; unsigned int size; char dst_name[MAX_SQLITE_NAME_LENGTH]; char src_name[MAX_SQLITE_NAME_LENGTH]; esqlite3 *src; esqlite3_backup *esqlite3_backup; ERL_NIF_TERM erl_backup_term; if(db == NULL) { return make_error_tuple(env, "dst_closed"); } if(!enif_get_tuple(env, arg, &tuple_arity, &elements)) { return make_error_tuple(env, "no_tuple"); } if(tuple_arity != 3) { return make_error_tuple(env, "invalid_tuple"); } size = enif_get_string(env, elements[0], dst_name, MAX_PATHNAME, ERL_NIF_LATIN1); if(size <= 0) return make_error_tuple(env, "invalid_dst_name"); if(!enif_get_resource(env, elements[1], esqlite3_type, (void **) &src)) { return make_error_tuple(env, "invalid_src_db"); } if(!src->db) { return make_error_tuple(env, "src_closed"); } size = enif_get_string(env, elements[2], src_name, MAX_PATHNAME, ERL_NIF_LATIN1); if(size <= 0) return make_error_tuple(env, "invalid_src_name"); backup = sqlite3_backup_init(db, dst_name, src->db, src_name); if(backup == NULL) { return make_sqlite3_error_tuple(env, sqlite3_errcode(db), db); } esqlite3_backup = enif_alloc_resource(esqlite3_backup_type, sizeof(esqlite3_backup)); if(!esqlite3_backup) { // Release backup resouces (void) sqlite3_backup_finish(backup); return make_error_tuple(env, "no_memory"); } esqlite3_backup->backup = backup; erl_backup_term = enif_make_resource(env, esqlite3_backup); enif_release_resource(esqlite3_backup); return make_ok_tuple(env, erl_backup_term); } */ /* static ERL_NIF_TERM do_backup_step(ErlNifEnv *env, sqlite3 *db, const ERL_NIF_TERM arg) { int tuple_arity; const ERL_NIF_TERM *elements; esqlite3_backup *esqlite3_backup; int n_page = 0; int rc; if(db == NULL) { return make_error_tuple(env, "closed"); } if(!enif_get_tuple(env, arg, &tuple_arity, &elements)) { return make_error_tuple(env, "no_tuple"); } if(tuple_arity != 2) { return make_error_tuple(env, "invalid_tuple"); } if(!enif_get_resource(env, elements[0], esqlite3_backup_type, (void **) &esqlite3_backup)) { return make_error_tuple(env, "invalid"); } if(!esqlite3_backup->backup) { return make_error_tuple(env, "backup"); } if(!enif_get_int(env, elements[1], &n_page)) { return make_error_tuple(env, "n_page"); } rc = sqlite3_backup_step(esqlite3_backup->backup, n_page); if(rc == SQLITE_DONE) { return make_atom(env, "done"); } if(rc != SQLITE_OK) { return make_sqlite3_error_tuple(env, rc, db); } return make_atom(env, "ok"); } */ /* static ERL_NIF_TERM do_backup_remaining(ErlNifEnv *env, const ERL_NIF_TERM arg) { esqlite3_backup *esqlite3_backup; int remaining; ERL_NIF_TERM remaining_term; if(!enif_get_resource(env, arg, esqlite3_backup_type, (void **) &esqlite3_backup)) { return make_error_tuple(env, "invalid"); } remaining = sqlite3_backup_remaining(esqlite3_backup->backup); remaining_term = enif_make_int64(env, remaining); return make_ok_tuple(env, remaining_term); } */ /* static ERL_NIF_TERM do_backup_pagecount(ErlNifEnv *env, const ERL_NIF_TERM arg) { esqlite3_backup *esqlite3_backup; int pagecount; ERL_NIF_TERM pagecount_term; if(!enif_get_resource(env, arg, esqlite3_backup_type, (void **) &esqlite3_backup)) { return make_error_tuple(env, "invalid"); } pagecount = sqlite3_backup_pagecount(esqlite3_backup->backup); pagecount_term = enif_make_int64(env, pagecount); return make_ok_tuple(env, pagecount_term); } */ /* static ERL_NIF_TERM do_backup_finish(ErlNifEnv *env, const ERL_NIF_TERM arg) { esqlite3_backup *esqlite3_backup; if(!enif_get_resource(env, arg, esqlite3_backup_type, (void **) &esqlite3_backup)) { return make_error_tuple(env, "invalid"); } if(esqlite3_backup->backup) { (void) sqlite3_backup_finish(esqlite3_backup->backup); esqlite3_backup->backup = NULL; } return make_atom(env, "ok"); } */ /* * Open the database */ static ERL_NIF_TERM esqlite_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; char filename[MAX_PATHNAME]; if(argc != 1) { return enif_make_badarg(env); } if(!sqlite3_threadsafe()) { return enif_raise_exception(env, make_atom(env, "not_thread_safe")); } int size = enif_get_string(env, argv[0], filename, MAX_PATHNAME, ERL_NIF_LATIN1); if(size <= 0) { return make_error_tuple(env, "invalid_filename"); } /* Initialize the resource */ conn = enif_alloc_resource(esqlite3_type, sizeof(esqlite3)); if(!conn) { return enif_raise_exception(env, make_atom(env, "no_memory")); } /* Open the database. */ int rc = sqlite3_open(filename, &conn->db); if(rc != SQLITE_OK) { ERL_NIF_TERM error = make_sqlite3_error_tuple(env, rc); sqlite3_close_v2(conn->db); enif_release_resource(conn); return error; } /* Set a standard busy timeout of 2 seconds */ sqlite3_busy_timeout(conn->db, 2000); /* Turn on extended error codes for better error reporting */ sqlite3_extended_result_codes(conn->db, 1); ERL_NIF_TERM db_conn = enif_make_resource(env, conn); enif_release_resource(conn); return make_ok_tuple(env, db_conn); } /* * Close the database */ static ERL_NIF_TERM esqlite_close(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; int rc; if(argc != 1) { return enif_make_badarg(env); } if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) return enif_make_badarg(env); rc = sqlite3_close_v2(conn->db); if(rc != SQLITE_OK) return make_sqlite3_error_tuple(env, rc); conn->db = NULL; return make_atom(env, "ok"); } /* * Prepare the sql statement */ static ERL_NIF_TERM esqlite_prepare(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; if(argc != 3) { return enif_make_badarg(env); } if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) { return enif_make_badarg(env); } ErlNifBinary bin; esqlite3_stmt *stmt; ERL_NIF_TERM esqlite_stmt; const char *tail; int rc; ERL_NIF_TERM eos = enif_make_int(env, 0); if(!enif_inspect_iolist_as_binary(env, enif_make_list2(env, argv[1], eos), &bin)) { return enif_make_badarg(env); } unsigned int prep_flags; if(!enif_get_uint(env, argv[2], &prep_flags)) { return make_error_tuple(env, "invalid_chunk_size"); } stmt = enif_alloc_resource(esqlite3_stmt_type, sizeof(esqlite3_stmt)); if(!stmt) { return enif_raise_exception(env, make_atom(env, "no_memory")); } rc = sqlite3_prepare_v3(conn->db, (char *) bin.data, bin.size, prep_flags, &(stmt->statement), &tail); if(rc != SQLITE_OK) { enif_release_resource(stmt); return make_sqlite3_error_tuple(env, rc); } stmt->column_count = sqlite3_column_count(stmt->statement); esqlite_stmt = enif_make_resource(env, stmt); enif_release_resource(stmt); return make_ok_tuple(env, esqlite_stmt); } /* static ERL_NIF_TERM set_update_hook(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *db; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 4) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &db)) return enif_make_badarg(env); if(!enif_is_ref(env, argv[1])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[2], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); // command cmd->type = cmd_update_hook_set; cmd->ref = enif_make_copy(cmd->env, argv[1]); cmd->pid = pid; cmd->arg = enif_make_copy(cmd->env, argv[3]); return push_command(env, db, cmd); } */ /* * Execute the sql statement static ERL_NIF_TERM esqlite_exec(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *db; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 4) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &db)) return enif_make_badarg(env); if(!enif_is_ref(env, argv[1])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[2], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); // command cmd->type = cmd_exec; cmd->ref = enif_make_copy(cmd->env, argv[1]); cmd->pid = pid; cmd->arg = enif_make_copy(cmd->env, argv[3]); return push_command(env, db, cmd); } */ /* * Count the nr of changes of last statement static ERL_NIF_TERM esqlite_changes(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *db; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 3) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &db)) return enif_make_badarg(env); if(!enif_is_ref(env, argv[1])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[2], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); // command cmd->type = cmd_changes; cmd->ref = enif_make_copy(cmd->env, argv[1]); cmd->pid = pid; return push_command(env, db, cmd); } */ /* static ERL_NIF_TERM esqlite_insert(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *db; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 4) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &db)) return enif_make_badarg(env); if(!enif_is_ref(env, argv[1])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[2], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); // command cmd->type = cmd_insert; cmd->ref = enif_make_copy(cmd->env, argv[1]); cmd->pid = pid; cmd->arg = enif_make_copy(cmd->env, argv[3]); return push_command(env, db, cmd); } */ /* static ERL_NIF_TERM esqlite_last_insert_rowid(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *db; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 3) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &db)) return enif_make_badarg(env); if(!enif_is_ref(env, argv[1])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[2], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); // command cmd->type = cmd_last_insert_rowid; cmd->ref = enif_make_copy(cmd->env, argv[1]); cmd->pid = pid; return push_command(env, db, cmd); } */ /* static ERL_NIF_TERM esqlite_get_autocommit(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *db; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 3) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &db)) return enif_make_badarg(env); if(!enif_is_ref(env, argv[1])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[2], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); // command cmd->type = cmd_get_autocommit; cmd->ref = enif_make_copy(cmd->env, argv[1]); cmd->pid = pid; return push_command(env, db, cmd); } */ /* * Bind a variable to a prepared statement static ERL_NIF_TERM esqlite_bind(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; esqlite3_stmt *stmt; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 5) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) return enif_make_badarg(env); if(!enif_get_resource(env, argv[1], esqlite3_stmt_type, (void **) &stmt)) return enif_make_badarg(env); if(!enif_is_ref(env, argv[2])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[3], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); cmd->type = cmd_bind; cmd->ref = enif_make_copy(cmd->env, argv[2]); cmd->pid = pid; cmd->stmt = enif_make_copy(cmd->env, argv[1]); cmd->arg = enif_make_copy(cmd->env, argv[4]); return push_command(env, conn, cmd); } */ /* * Multi step to a prepared statement static ERL_NIF_TERM esqlite_multi_step(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; esqlite3_stmt *stmt; esqlite_command *cmd = NULL; ErlNifPid pid; int chunk_size = 0; if(argc != 5) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) return enif_make_badarg(env); if(!enif_get_resource(env, argv[1], esqlite3_stmt_type, (void **) &stmt)) return enif_make_badarg(env); if(!enif_get_int(env, argv[2], &chunk_size)) return make_error_tuple(env, "invalid_chunk_size"); if(!enif_is_ref(env, argv[3])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[4], &pid)) return make_error_tuple(env, "invalid_pid"); if(!stmt->statement) return make_error_tuple(env, "no_prepared_statement"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); cmd->type = cmd_multi_step; cmd->ref = enif_make_copy(cmd->env, argv[3]); cmd->pid = pid; cmd->stmt = enif_make_copy(cmd->env, argv[1]); cmd->arg = enif_make_copy(cmd->env, argv[2]); return push_command(env, conn, cmd); } */ /* * Reset a prepared statement to its initial state static ERL_NIF_TERM esqlite_reset(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; esqlite3_stmt *stmt; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 4) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) return enif_make_badarg(env); if(!enif_get_resource(env, argv[1], esqlite3_stmt_type, (void **) &stmt)) return enif_make_badarg(env); if(!enif_is_ref(env, argv[2])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[3], &pid)) return make_error_tuple(env, "invalid_pid"); if(!stmt->statement) return make_error_tuple(env, "no_prepared_statement"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); cmd->type = cmd_reset; cmd->ref = enif_make_copy(cmd->env, argv[2]); cmd->pid = pid; cmd->stmt = enif_make_copy(cmd->env, argv[1]); return push_command(env, conn, cmd); } */ /* * Get the column names of the prepared statement. */ static ERL_NIF_TERM esqlite_column_names(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3_stmt *stmt; if(argc != 1) { return enif_make_badarg(env); } if(!enif_get_resource(env, argv[0], esqlite3_stmt_type, (void **) &stmt)) { return enif_make_badarg(env); } if(!stmt->statement) { return enif_raise_exception(env, make_atom(env, "no_prepared_statement")); } ERL_NIF_TERM column_names = enif_make_list(env, 0); int size = sqlite3_column_count(stmt->statement); if(size < 0) { return enif_raise_exception(env, make_atom(env, "invalid_column_count")); } for(int i=size; i-- > 0; ) { const char *name = sqlite3_column_name(stmt->statement, i); if(name == NULL) { return enif_raise_exception(env, make_atom(env, "sqlite3_malloc_failure")); } ERL_NIF_TERM ename = make_binary(env, name, strlen(name)); column_names = enif_make_list_cell(env, ename, column_names); } return column_names; } /* * Get the column's declared datatypes of a statement. */ static ERL_NIF_TERM esqlite_column_decltypes(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3_stmt *stmt; if(argc != 1) { return enif_make_badarg(env); } if(!enif_get_resource(env, argv[0], esqlite3_stmt_type, (void **) &stmt)) { return enif_make_badarg(env); } if(!stmt->statement) { return enif_raise_exception(env, make_atom(env, "no_prepared_statement")); } ERL_NIF_TERM column_types = enif_make_list(env, 0); int size = sqlite3_column_count(stmt->statement); if(size < 0) { return enif_raise_exception(env, make_atom(env, "invalid_column_count")); } for(int i=size; i-- > 0; ) { ERL_NIF_TERM type_name; const char *type = sqlite3_column_decltype(stmt->statement, i); if(type == NULL) { type_name = make_atom(env, "undefined"); } else { type_name = make_binary(env, type, strlen(type)); } column_types = enif_make_list_cell(env, type_name, column_types); } return column_types; } static ERL_NIF_TERM esqlite_bind_int(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3_stmt *stmt; int index; int value; if(argc != 3) { return enif_make_badarg(env); } if(!enif_get_resource(env, argv[0], esqlite3_stmt_type, (void **) &stmt)) { return enif_make_badarg(env); } if(!stmt->statement) { return enif_raise_exception(env, make_atom(env, "no_prepared_statement")); } if(!enif_get_int(env, argv[1], &index)) { return enif_make_badarg(env); } if(!enif_get_int(env, argv[2], &value)) { return enif_make_badarg(env); } int rc = sqlite3_bind_int(stmt->statement, index, value); if(rc != SQLITE_OK) { return make_sqlite3_error_tuple(env, rc); } return make_atom(env, "ok"); } static ERL_NIF_TERM esqlite_bind_int64(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3_stmt *stmt; int index; ErlNifSInt64 value; if(argc != 3) { return enif_make_badarg(env); } if(!enif_get_resource(env, argv[0], esqlite3_stmt_type, (void **) &stmt)) { return enif_make_badarg(env); } if(!stmt->statement) { return enif_raise_exception(env, make_atom(env, "no_prepared_statement")); } if(!enif_get_int(env, argv[1], &index)) { return enif_make_badarg(env); } if(!enif_get_int64(env, argv[2], &value)) { return enif_make_badarg(env); } int rc = sqlite3_bind_int64(stmt->statement, index, value); if(rc != SQLITE_OK) { return make_sqlite3_error_tuple(env, rc); } return make_atom(env, "ok"); } static ERL_NIF_TERM esqlite_bind_double(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3_stmt *stmt; int index; double value; if(argc != 3) { return enif_make_badarg(env); } if(!enif_get_resource(env, argv[0], esqlite3_stmt_type, (void **) &stmt)) { return enif_make_badarg(env); } if(!stmt->statement) { return enif_raise_exception(env, make_atom(env, "no_prepared_statement")); } if(!enif_get_int(env, argv[1], &index)) { return enif_make_badarg(env); } if(!enif_get_double(env, argv[2], &value)) { return enif_make_badarg(env); } int rc = sqlite3_bind_double(stmt->statement, index, value); if(rc != SQLITE_OK) { return make_sqlite3_error_tuple(env, rc); } return make_atom(env, "ok"); } static ERL_NIF_TERM esqlite_step(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3_stmt *stmt; if(argc != 1) { return enif_make_badarg(env); } if(!enif_get_resource(env, argv[0], esqlite3_stmt_type, (void **) &stmt)) { return enif_make_badarg(env); } if(!stmt->statement) { return enif_raise_exception(env, make_atom(env, "no_prepared_statement")); } int rc = sqlite3_step(stmt->statement); switch(rc) { case SQLITE_ROW: { ERL_NIF_TERM row = enif_make_list(env, 0); for(int i=stmt->column_count; i-- > 0; ) { row = enif_make_list_cell(env, make_cell(env, stmt->statement, i), row); } return row; } case SQLITE_DONE: /* since 3.6.23.1 it is no longer required to do an explict reset. */ return make_atom(env, "done"); case SQLITE_BUSY: return make_atom(env, "busy"); } return make_sqlite3_error_tuple(env, rc); } /* * Backup functions * */ /* static ERL_NIF_TERM esqlite_backup_init(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *destination; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 6) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &destination)) return enif_make_badarg(env); // 1 destination name // 2 source connection with database // 3 source name if(!enif_is_ref(env, argv[4])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[5], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); cmd->type = cmd_backup_init; cmd->ref = enif_make_copy(cmd->env, argv[4]); cmd->pid = pid; cmd->arg = enif_make_tuple3(cmd->env, argv[1], argv[2], argv[3]); // Use the connection of the destination database return push_command(env, destination, cmd); } */ /* static ERL_NIF_TERM esqlite_backup_finish(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; esqlite3_backup *backup; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 4) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) return enif_make_badarg(env); if(!enif_is_ref(env, argv[2])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[3], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); cmd->type = cmd_backup_finish; cmd->ref = enif_make_copy(cmd->env, argv[2]); cmd->pid = pid; cmd->arg = enif_make_copy(cmd->env, argv[1]); return push_command(env, conn, cmd); } */ /* static ERL_NIF_TERM esqlite_backup_step(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; esqlite3_backup *backup; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 5) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) return enif_make_badarg(env); // 1 backup if(!enif_is_number(env, argv[2])) return make_error_tuple(env, "invalid_count"); if(!enif_is_ref(env, argv[3])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[4], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); cmd->type = cmd_backup_step; cmd->ref = enif_make_copy(cmd->env, argv[3]); cmd->pid = pid; cmd->arg = enif_make_tuple2(cmd->env, argv[1], argv[2]); return push_command(env, conn, cmd); } */ /* * Get the remaining pagecount of the backup. static ERL_NIF_TERM esqlite_backup_remaining(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; esqlite3_backup *backup; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 4) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) return enif_make_badarg(env); // backup 1 if(!enif_is_ref(env, argv[2])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[3], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); cmd->type = cmd_backup_remaining; cmd->ref = enif_make_copy(cmd->env, argv[2]); cmd->pid = pid; cmd->arg = enif_make_copy(cmd->env, argv[1]); return push_command(env, conn, cmd); } */ /* * Get the total pagecount of the backup static ERL_NIF_TERM esqlite_backup_pagecount(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; esqlite3_backup *backup; esqlite_command *cmd = NULL; ErlNifPid pid; if(argc != 4) return enif_make_badarg(env); if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) return enif_make_badarg(env); // backup 1 if(!enif_is_ref(env, argv[2])) return make_error_tuple(env, "invalid_ref"); if(!enif_get_local_pid(env, argv[3], &pid)) return make_error_tuple(env, "invalid_pid"); cmd = command_create(); if(!cmd) return make_error_tuple(env, "command_create_failed"); cmd->type = cmd_backup_pagecount; cmd->ref = enif_make_copy(cmd->env, argv[2]); cmd->pid = pid; cmd->arg = enif_make_copy(cmd->env, argv[1]); return push_command(env, conn, cmd); } */ /* * Interrupt currently active query. */ static ERL_NIF_TERM esqlite_interrupt(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { esqlite3 *conn; if(!enif_get_resource(env, argv[0], esqlite3_type, (void **) &conn)) return enif_make_badarg(env); esqlite3 *db = (esqlite3 *) conn; sqlite3_interrupt(db->db); return enif_make_atom(env, "ok"); } /* * Load the nif. Initialize some stuff and such */ static int on_load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info) { ErlNifResourceType *rt; rt = enif_open_resource_type(env, "esqlite3_nif", "esqlite3_type", destruct_esqlite3, ERL_NIF_RT_CREATE, NULL); if(!rt) return -1; esqlite3_type = rt; rt = enif_open_resource_type(env, "esqlite3_nif", "esqlite3_stmt_type", destruct_esqlite3_stmt, ERL_NIF_RT_CREATE, NULL); if(!rt) return -1; esqlite3_stmt_type = rt; rt = enif_open_resource_type(env, "esqlite3_nif", "esqlite3_backup_type", destruct_esqlite3_backup, ERL_NIF_RT_CREATE, NULL); if(!rt) return -1; esqlite3_backup_type = rt; atom_esqlite3 = make_atom(env, "esqlite3"); if(SQLITE_OK != sqlite3_initialize()) { return -1; } return 0; } static int on_reload(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) { return 0; } static int on_upgrade(ErlNifEnv* env, void** priv, void** old_priv_data, ERL_NIF_TERM load_info) { return 0; } static ErlNifFunc nif_funcs[] = { {"open", 1, esqlite_open, ERL_NIF_DIRTY_JOB_IO_BOUND}, {"close", 1, esqlite_close, ERL_NIF_DIRTY_JOB_IO_BOUND}, {"prepare", 3, esqlite_prepare}, {"column_names", 1, esqlite_column_names}, {"column_decltypes", 1, esqlite_column_decltypes}, {"bind_int", 3, esqlite_bind_int}, {"bind_int64", 3, esqlite_bind_int64}, {"bind_double", 3, esqlite_bind_double}, {"step", 1, esqlite_step}, /* {"bind_text", 3, esqlite_bind_blob}, {"bind_blob", 3, esqlite_bind_blob}, {"bind_null", 2, esqlite_bind_blob}, */ {"interrupt", 1, esqlite_interrupt, ERL_NIF_DIRTY_JOB_IO_BOUND} /* {"set_update_hook", 4, set_update_hook}, {"exec", 4, esqlite_exec, ERL_NIF_DIRTY_JOB_IO_BOUND}, {"changes", 3, esqlite_changes}, {"insert", 4, esqlite_insert}, {"last_insert_rowid", 3, esqlite_last_insert_rowid}, {"get_autocommit", 3, esqlite_get_autocommit}, {"reset", 4, esqlite_reset}, // TODO: {"esqlite_bind", 3, esqlite_bind_named}, {"bind", 5, esqlite_bind}, {"backup_init", 6, esqlite_backup_init}, {"backup_step", 5, esqlite_backup_step}, {"backup_remaining", 4, esqlite_backup_remaining}, {"backup_pagecount", 4, esqlite_backup_pagecount}, {"backup_finish", 4, esqlite_backup_finish}, */ }; ERL_NIF_INIT(esqlite3_nif, nif_funcs, on_load, on_reload, on_upgrade, NULL);