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);
}