static ERL_NIF_TERM do_set_update_hook(ErlNifEnv *env, esqlite_connection *db, const ERL_NIF_TERM arg) { if(!enif_get_local_pid(env, arg, &db->notification_pid)) return make_error_tuple(env, "invalid_pid"); sqlite3_update_hook(db->db, NULL, NULL); if(sqlite3_update_hook(db->db, update_callback, db) != SQLITE_OK) return make_error_tuple(env, "sqlite3_update_hook_fail"); return make_atom(env, "ok"); }
int main(int argc, char **argv) { sqlite3 *db; int rc; char *sql; int is_fine = 1; if (access("demo.db", R_OK|W_OK)) { is_fine = 0; } rc = sqlite3_open("demo.db", &db); if(rc) { fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db)); goto quit; } /* initialize db */ if (!is_fine) { rc = _db_init(db); if (rc) { goto quit; } } _db_show_all(db); char name[32]; db_get_account_name_by_id(db, name, 2); fprintf(stdout, "name of id %d is %s\n", 2, name); /* register hooks */ char *data = "this is a hook test"; sqlite3_commit_hook(db, _db_commit_hook, data); sqlite3_update_hook(db, _db_update_hook, data); sqlite3_set_authorizer(db, _db_auth_hook, data); puts("insert"); sql = "insert into account (name,rank) values ('guest',2);"; rc = sqlite3_exec(db, sql, NULL, NULL, NULL); _db_show_all(db); puts("update"); sql = "update account set name='test' where id=4;"; rc = sqlite3_exec(db, sql, NULL, NULL, NULL); _db_show_all(db); puts("delete"); sql = "delete from account where name='test';"; rc = sqlite3_exec(db, sql, NULL, NULL, NULL); _db_show_all(db); quit: sqlite3_close(db); return 0; }
int DBConnection_SQLITE::basicExec(const char *q, unsigned int *rows) { char *err; int t_return_value = 0; if (rows == NULL) t_return_value = sqlite3_exec(mDB.getHandle(), q, 0, 0, &err); else { int t_changed_row_count; t_changed_row_count = 0; sqlite3_update_hook(mDB.getHandle(),dataChangeCallback, &t_changed_row_count); *rows = 0; t_return_value = sqlite3_exec(mDB.getHandle(), q, exec_callback, rows, &err); int t_changed_rows; t_changed_rows = sqlite3_changes(mDB.getHandle()); sqlite3_update_hook(mDB.getHandle(), NULL, NULL); // OK-2007-07-13: NOTE: When executing a delete query with no WHERE clause, SQLite deletes // and recreates the table, meaning that the row count will end up being 0 when it shouldnt be. // If *rows != 0 then rows was populated by the exec_callback function, which implies that the query // has returned a result set. As we are only executing the query here, we return 0 as the number of affected rows. if (*rows != 0) *rows = 0; else *rows = t_changed_row_count; } if (t_return_value != SQLITE_OK) { mIsError = true; setErrorStr(err); sqlite3_free(err); } return t_return_value; }
void* Utility::eventHookRegister(sqlite3* pDB, UpdateCallbackType callbackFn, void* pParam) { typedef void(*pF)(void*, int, const char*, const char*, sqlite3_int64); return sqlite3_update_hook(pDB, reinterpret_cast<pF>(callbackFn), pParam); }
void database::set_update_handler(update_handler h) { uh_ = h; sqlite3_update_hook(db_, uh_ ? update_hook_impl : 0, &uh_); }
SQLerror Query(SQLrequest &req) { /* Pointer to the buffer we screw around with substitution in */ char* query; /* Pointer to the current end of query, where we append new stuff */ char* queryend; /* Total length of the unescaped parameters */ unsigned long maxparamlen, paramcount; /* The length of the longest parameter */ maxparamlen = 0; for(ParamL::iterator i = req.query.p.begin(); i != req.query.p.end(); i++) { if (i->size() > maxparamlen) maxparamlen = i->size(); } /* How many params are there in the query? */ paramcount = count(req.query.q.c_str(), '?'); /* This stores copy of params to be inserted with using numbered params 1;3B*/ ParamL paramscopy(req.query.p); /* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be. * sizeofquery + (maxtotalparamlength*2) + 1 * * The +1 is for null-terminating the string */ query = new char[req.query.q.length() + (maxparamlen*paramcount*2) + 1]; queryend = query; for(unsigned long i = 0; i < req.query.q.length(); i++) { if(req.query.q[i] == '?') { /* We found a place to substitute..what fun. * use sqlite calls to escape and write the * escaped string onto the end of our query buffer, * then we "just" need to make sure queryend is * pointing at the right place. */ /* Is it numbered parameter? */ bool numbered; numbered = false; /* Numbered parameter number :| */ unsigned int paramnum; paramnum = 0; /* Let's check if it's a numbered param. And also calculate it's number. */ while ((i < req.query.q.length() - 1) && (req.query.q[i+1] >= '0') && (req.query.q[i+1] <= '9')) { numbered = true; ++i; paramnum = paramnum * 10 + req.query.q[i] - '0'; } if (paramnum > paramscopy.size() - 1) { /* index is out of range! */ numbered = false; } if (numbered) { char* escaped; escaped = sqlite3_mprintf("%q", paramscopy[paramnum].c_str()); for (char* n = escaped; *n; n++) { *queryend = *n; queryend++; } sqlite3_free(escaped); } else if (req.query.p.size()) { char* escaped; escaped = sqlite3_mprintf("%q", req.query.p.front().c_str()); for (char* n = escaped; *n; n++) { *queryend = *n; queryend++; } sqlite3_free(escaped); req.query.p.pop_front(); } else break; } else { *queryend = req.query.q[i]; queryend++; } } *queryend = 0; req.query.q = query; SQLite3Result* res = new SQLite3Result(mod, req.GetSource(), req.id); res->dbid = host.id; res->query = req.query.q; paramlist params; params.push_back(this); params.push_back(res); char *errmsg = 0; sqlite3_update_hook(conn, QueryUpdateHook, ¶ms); if (sqlite3_exec(conn, req.query.q.data(), QueryResult, ¶ms, &errmsg) != SQLITE_OK) { std::string error(errmsg); sqlite3_free(errmsg); delete[] query; delete res; return SQLerror(SQL_QSEND_FAIL, error); } delete[] query; results.push_back(res); SendNotify(); return SQLerror(); }
__declspec(dllexport) void * WINAPI sqlite3_update_hook_interop(sqlite3 *pDb, SQLITEUPDATEHOOK func) { return sqlite3_update_hook(pDb, sqlite3_update_callback, func); }
/** @SYMTestCaseID SYSLIB-SQLITE3-UT-4004 @SYMTestCaseDesc Database handle SQLITE3 tests. List of called SQLITE3 functions: - sqlite3_config; - sqlite3_initialize; - sqlite3_threadsafe; - sqlite3_vfs_find; - sqlite3_open; - sqlite3_db_config; - sqlite3_libversion; - sqlite3_libversion_number; - sqlite3_set_authorizer; - sqlite3_commit_hook; - sqlite3_rollback_hook; - sqlite3_update_hook; - sqlite3_close; - sqlite3_shutdown; @SYMTestPriority High @SYMTestActions Database handle SQLITE3 tests. @SYMTestExpectedResults Test must not fail @SYMREQ REQ8782 */ static void TestSqliteApi() { void* prev = 0; const char* libverstr = 0; int libvernum = 0; int err; int threadSafe = -1; sqlite3_vfs* vfs = 0; TEST(!TheDb); TestStart("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4004: Test \"sqlite3_config()\""); err = sqlite3_config(SQLITE_CONFIG_MEMSTATUS, 0); TEST2(err, SQLITE_OK); TestNext("Test \"sqlite3_initialize()\""); err = sqlite3_initialize(); TEST2(err, SQLITE_OK); TestNext("Test \"sqlite3_threadsafe()\""); threadSafe = sqlite3_threadsafe(); PrintI("SQLITE_THREADSAFE=%d\r\n", threadSafe); vfs = sqlite3_vfs_find(0); TEST(vfs != NULL); PrintS("Vfs name=\"%s\"\r\n", vfs->zName); err = sqlite3_open(TheTestDbName, &TheDb); TEST2(err, SQLITE_OK); TEST(TheDb != 0); err = sqlite3_db_config(TheDb, SQLITE_DBCONFIG_LOOKASIDE, 0, 128, 100); TEST2(err, SQLITE_OK); libverstr = sqlite3_libversion(); libvernum = sqlite3_libversion_number(); PrintSI("SQLITE version: \"%s\", Number: %d\r\n", libverstr, libvernum); err = sqlite3_set_authorizer(TheDb, &authorizer_callback, 0); TEST2(err, SQLITE_OK); prev = sqlite3_commit_hook(TheDb, &commit_hook, 0); TEST(!prev); prev = sqlite3_rollback_hook(TheDb, &rollback_hook, 0); TEST(!prev); prev = sqlite3_update_hook(TheDb, &update_hook, 0); TEST(!prev); TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4001: Test \"sqlite3\" handle API"); TestExec(); TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4002: Test \"sqlite3_stmt\" handle API-1"); TestStatement1(); TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4003: Test \"sqlite3_stmt\" handle API-2"); TestStatement2(); TestNext("@SYMTestCaseID:PDS-SQLITE3-UT-4038: Test more sqlite3 API"); TestSqliteApi2(); TestNext("@SYMTestCaseID:PDS-SQLITE3-UT-4039: Test blob API"); TestSqliteBlobApi(); TestNext("@SYMTestCaseID:PDS-SQLITE3-UT-4040: Test mutex API"); TestSqliteMutexApi(); err = sqlite3_close(TheDb); TEST2(err, SQLITE_OK); TheDb = 0; TestNext("Test \"sqlite3_shutdown()\""); err = sqlite3_shutdown(); TEST2(err, SQLITE_OK); err = remove(TheTestDbName); TEST2(err, 0); }