void StatementHandle::finalize()
{
if (m_stmt) {
sqlite3 *handle = sqlite3_db_handle((sqlite3_stmt *) m_stmt);
int rc = sqlite3_finalize((sqlite3_stmt *) m_stmt);
m_stmt = nullptr;
if (rc == SQLITE_OK) {
m_error.reset();
return;
}
Error::ReportSQLite(m_handle.getTag(), m_handle.path,
Error::HandleOperation::Finalize, rc,
sqlite3_extended_errcode(handle),
sqlite3_errmsg(handle), &m_error);
}
}
/* call-seq: stmt.close
*
* Closes the statement by finalizing the underlying statement
* handle. The statement must not be used after being closed.
*/
static VALUE sqlite3_rb_close(VALUE self)
{
sqlite3StmtRubyPtr ctx;
sqlite3 * db;
Data_Get_Struct(self, sqlite3StmtRuby, ctx);
REQUIRE_OPEN_STMT(ctx);
db = sqlite3_db_handle(ctx->st);
CHECK(db, sqlite3_finalize(ctx->st));
ctx->st = NULL;
return self;
}
bool step_next ()
{
const int status = sqlite3_step (stmt_);
if (status != SQLITE_ROW && status != SQLITE_DONE)
{
std::ostringstream s;
s << "SQLite Plugin: retrieving next row failed";
std::string msg(sqlite3_errmsg(sqlite3_db_handle(stmt_)));
if (msg != "unknown error")
{
s << ": " << msg;
}
throw mapnik::datasource_exception(s.str());
}
return status == SQLITE_ROW;
}
static int
bindargs(lua_State *T, sqlite3_stmt *stmt)
{
int top = lua_gettop(T);
int i;
for (i = 2; i <= top; i++) {
int ret;
switch (lua_type(T, i)) {
case LUA_TNIL:
/* Should nil mean NULL..
ret = sqlite3_bind_null(stmt, i-1);
break;
..or don't bind.. */
continue;
case LUA_TNUMBER:
ret = sqlite3_bind_double(stmt, i-1,
lua_tonumber(T, i));
break;
case LUA_TSTRING:
{
size_t len;
const char *str = lua_tolstring(T, i, &len);
ret = sqlite3_bind_text(stmt, i-1,
str, len, SQLITE_STATIC);
}
break;
default:
(void)sqlite3_clear_bindings(stmt);
return luaL_argerror(T, i, "expected nil, number or string");
}
if (ret != SQLITE_OK) {
(void)sqlite3_clear_bindings(stmt);
return luaL_argerror(T, i, sqlite3_errmsg(
sqlite3_db_handle(stmt)));
}
}
return 0;
}
SqlStatement &SqlStatement::execute() {
require(mpVM);
mBindNext = 1; // Next call to bind() should replace the first parameter (it's not zero-indexed)
if (!mEndOfRows)
sqlite3_reset(mpVM); // User wants to reset the query even though we haven't finished going through all rows...
const int result = sqlite3_step(mpVM);
if (result == SQLITE_DONE) {
mEndOfRows = true; // No rows were returned
mColsInResult = 0;
return *this;
} else if (result == SQLITE_ROW) {
mEndOfRows = false; // At least one row was returned
mColsInResult = sqlite3_column_count(mpVM);
return *this;
} else {
throw SqlDatabaseException(sqlite3_errmsg(sqlite3_db_handle(mpVM)));
}
}
int
lms_db_bind_double(sqlite3_stmt *stmt, int col, double value)
{
int r;
r = sqlite3_bind_double(stmt, col, value);
if (r == SQLITE_OK)
return 0;
else {
sqlite3 *db;
const char *err;
db = sqlite3_db_handle(stmt);
err = sqlite3_errmsg(db);
fprintf(stderr, "ERROR: could not bind SQL value %d: %s\n", col, err);
return -col;
}
}
static int fetch(lua_State* L, int mode) {
stmt* s = (stmt*)luaL_checkudata(L, 1, MT_STMT);
sqlite3* db = sqlite3_db_handle(s->handle);
int ret;
while((ret = sqlite3_step(s->handle)) == SQLITE_SCHEMA) {}
if(ret == SQLITE_DONE) {
lua_pushnil(L);
return 1;
} else if(ret == SQLITE_ROW) {
int i;
int col_count = sqlite3_column_count(s->handle);
lua_createtable(L, col_count, 0);
for(i = 0; i < col_count; i++) {
if(mode == 0) {
/* fetch, rows */
lua_pushstring(L, sqlite3_column_name(s->handle, i));
} else if(mode == 1) {
/* ifetch, irows */
lua_pushinteger(L, i + 1);
}
switch(sqlite3_column_type(s->handle, i)) {
case SQLITE_INTEGER:
lua_pushinteger(L, sqlite3_column_int(s->handle, i));
break;
case SQLITE_FLOAT:
lua_pushnumber(L, sqlite3_column_double(s->handle, i));
break;
case SQLITE_TEXT:
lua_pushstring(L, (const char*)sqlite3_column_text(s->handle, i));
break;
case SQLITE_BLOB:
case SQLITE_NULL:
lua_pushnil(L);
break;
}
lua_settable(L, -3);
}
return 1;
}
return luaL_error(L, "[%d] %s", ret, sqlite3_errmsg(db));
}
int
lms_db_update_file_info(sqlite3_stmt *stmt, const struct lms_file_info *finfo, unsigned int update_id)
{
int r, ret;
ret = lms_db_bind_int(stmt, 1, finfo->mtime);
if (ret != 0)
goto done;
ret = lms_db_bind_int(stmt, 2, finfo->dtime);
if (ret != 0)
goto done;
ret = lms_db_bind_int(stmt, 3, finfo->itime);
if (ret != 0)
goto done;
ret = lms_db_bind_int(stmt, 4, finfo->size);
if (ret != 0)
goto done;
ret = lms_db_bind_int(stmt, 5, update_id);
if (ret != 0)
goto done;
ret = lms_db_bind_int(stmt, 6, finfo->id);
if (ret != 0)
goto done;
r = sqlite3_step(stmt);
if (r != SQLITE_DONE) {
fprintf(stderr, "ERROR: could not update file info: %s\n",
sqlite3_errmsg(sqlite3_db_handle(stmt)));
ret = -5;
goto done;
}
ret = 0;
done:
lms_db_reset_stmt(stmt);
return ret;
}
void JNICALL Java_com_baidu_javalite_PrepareStmt_sqlite3_1bind_1zeroblob(
JNIEnv *env, jclass cls, jlong handle, jint column, jint bytes)
{
if (handle == 0)
{
throwSqliteException(env, "handle is NULL");
return;
}
sqlite3_stmt* stmt = (sqlite3_stmt*) handle;
int rc = sqlite3_bind_zeroblob(stmt, column, bytes);
if (rc != SQLITE_OK)
{
sqlite3* conn = sqlite3_db_handle(stmt);
throwSqliteException2(env, sqlite3_errcode(conn), sqlite3_errmsg(conn));
}
}
static int
bindargs(lua_State *T, sqlite3_stmt *stmt)
{
int top = lua_gettop(T);
int i;
for (i = 2; i <= top; i++) {
int ret;
ret = _bind_arg(T, i, stmt, i-1);
if (ret != SQLITE_OK) {
(void)sqlite3_clear_bindings(stmt);
return luaL_argerror(T, i, sqlite3_errmsg(
sqlite3_db_handle(stmt)));
}
}
return 0;
}
void JNICALL Java_com_baidu_javalite_PrepareStmt_sqlite3_1reset(JNIEnv *env,
jclass cls, jlong handle)
{
if (handle == 0)
{
throwSqliteException(env, "handle is NULL");
return;
}
sqlite3_stmt* stmt = (sqlite3_stmt*) handle;
int rc = sqlite3_reset(stmt);
if (rc != SQLITE_OK)
{
sqlite3* conn = sqlite3_db_handle(stmt);
throwSqliteException2(env, sqlite3_errcode(conn), sqlite3_errmsg(conn));
}
}
int Java_ua_boberproduction_floristx_sqlite_SQLiteCursor_step(JNIEnv* env, jobject object, int statementHandle) {
sqlite3_stmt* handle = (sqlite3_stmt*)statementHandle;
int errcode = 0 ;
errcode = sqlite3_step(handle);
if (errcode==SQLITE_ROW)
{
return 0;
}else if(errcode == SQLITE_DONE)
{
return 1;
}
else if(errcode == SQLITE_BUSY)
{
return -1;
}
throw_sqlite3_exception(env, sqlite3_db_handle(handle), errcode);
}
bool step_next ()
{
const int status = sqlite3_step(stmt_);
if (status != SQLITE_DONE)
{
std::ostringstream s;
s << "SQLite Plugin: inserting bbox into rtree index failed";
std::string msg(sqlite3_errmsg(sqlite3_db_handle(stmt_)));
if (msg != "unknown error")
{
s << ": " << msg;
}
throw mapnik::datasource_exception(s.str());
}
sqlite3_clear_bindings(stmt_);
if (sqlite3_reset(stmt_) != SQLITE_OK)
{
throw mapnik::datasource_exception("sqlite3_reset failed");
}
return true;
}
int
lms_db_bind_int64_or_null(sqlite3_stmt *stmt, int col, int64_t *p_value)
{
int r;
if (p_value)
r = sqlite3_bind_int64(stmt, col, *p_value);
else
r = sqlite3_bind_null(stmt, col);
if (r == SQLITE_OK)
return 0;
else {
sqlite3 *db;
const char *err;
db = sqlite3_db_handle(stmt);
err = sqlite3_errmsg(db);
fprintf(stderr, "ERROR: could not bind SQL value %d: %s\n", col, err);
return -col;
}
}
static int
bindtable(lua_State *T, sqlite3_stmt *stmt)
{
int parameters = sqlite3_bind_parameter_count(stmt);
const char *name;
const char *err;
int i;
for (i = 1; i <= parameters; i++) {
int ret;
name = sqlite3_bind_parameter_name(stmt, i);
lua_settop(T, 2);
if (name == NULL || name[0] == '?')
lua_rawgeti(T, 2, i);
else if (name[0] == '@')
lua_getfield(T, 2, name + 1);
else
lua_getfield(T, 2, name);
ret = _bind_arg(T, 3, stmt, i);
if (ret != SQLITE_OK) {
err = sqlite3_errmsg(sqlite3_db_handle(stmt));
goto error;
}
}
return 0;
error:
(void)sqlite3_clear_bindings(stmt);
luaL_where(T, 1);
if (name == NULL || name[0] == '?')
lua_pushfstring(T, "error binding %d: %s", i, err);
else
lua_pushfstring(T, "error binding '%s': %s", name, err);
lua_concat(T, 2);
return -1;
}
int
lms_db_bind_blob(sqlite3_stmt *stmt, int col, const void *blob, int len)
{
int r;
if (blob)
r = sqlite3_bind_blob(stmt, col, blob, len, SQLITE_STATIC);
else
r = sqlite3_bind_null(stmt, col);
if (r == SQLITE_OK)
return 0;
else {
sqlite3 *db;
const char *err;
db = sqlite3_db_handle(stmt);
err = sqlite3_errmsg(db);
fprintf(stderr, "ERROR: could not bind SQL value %d: %s\n", col, err);
return -col;
}
}
int
lms_db_delete_file_info(sqlite3_stmt *stmt, const struct lms_file_info *finfo)
{
int r, ret;
ret = lms_db_bind_int64(stmt, 1, finfo->id);
if (ret != 0)
goto done;
r = sqlite3_step(stmt);
if (r != SQLITE_DONE) {
fprintf(stderr, "ERROR: could not delete file info: %s\n",
sqlite3_errmsg(sqlite3_db_handle(stmt)));
ret = -2;
goto done;
}
ret = 0;
done:
lms_db_reset_stmt(stmt);
return ret;
}
static int
stmt_reset(lua_State *T)
{
struct stmt *stmt;
int ret;
luaL_checktype(T, 1, LUA_TUSERDATA);
stmt = lua_touserdata(T, 1);
if (stmt->handle == NULL)
return stmt_finalized(T);
if (stmt->db->T != NULL)
return db_busy(T);
ret = sqlite3_reset(stmt->handle);
(void)sqlite3_clear_bindings(stmt->handle);
if (ret != SQLITE_OK) {
lua_pushnil(T);
lua_pushstring(T, sqlite3_errmsg(sqlite3_db_handle(stmt->handle)));
return 2;
}
lua_pushboolean(T, 1);
return 1;
}
/*
** Execute SQL code. Return one of the SQLITE_ success/failure
** codes. Also write an error message into memory obtained from
** malloc() and make *pzErrMsg point to that message.
**
** If the SQL is a query, then for each row in the query result
** the xCallback() function is called. pArg becomes the first
** argument to xCallback(). If xCallback=NULL then no callback
** is invoked, even for queries.
*/
int sqlite3_exec_stmt(
sqlite3_stmt *pStmt, /* The SQL to be executed */
sqlite3_callback xCallback, /* Invoke this callback routine */
void *pArg, /* First argument to xCallback() */
char **pzErrMsg /* Write error messages here */
){
int rc = SQLITE_OK;
sqlite3 *db = 0;
char **azCols = 0;
int nRetry = 0;
int nChange = 0;
int nCallback;
if( pStmt ==0 ) return SQLITE_OK;
db = sqlite3_db_handle(pStmt);
while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2))){
int nCol;
char **azVals = 0;
nCallback = 0;
nCol = sqlite3_column_count(pStmt);
azCols = (char **) malloc(2*nCol*sizeof(const char *) + 1);
if( azCols==0 ){
goto exec_out;
}
while( 1 ){
int i;
rc = sqlite3_step(pStmt);
/* Invoke the callback function if required */
if( xCallback && (SQLITE_ROW==rc ||
(SQLITE_DONE==rc && !nCallback))
){
if( 0==nCallback ){
for(i=0; i<nCol; i++){
azCols[i] = (char *)sqlite3_column_name(pStmt, i);
}
nCallback++;
}
if( rc==SQLITE_ROW ){
azVals = &azCols[nCol];
for(i=0; i<nCol; i++){
azVals[i] = (char *)sqlite3_column_text(pStmt, i);
}
if( xCallback(pArg, nCol, azVals, azCols) ){
rc = SQLITE_ABORT;
goto exec_out;
}
}
}
if( rc!=SQLITE_ROW ){
break;
}
}
}
exec_out:
if( azCols ) free(azCols);
sqlite3_reset(pStmt);
return rc;
}
/* call-seq: stmt.bind_param(key, value)
*
* Binds value to the named (or positional) placeholder. If +param+ is a
* Fixnum, it is treated as an index for a positional placeholder.
* Otherwise it is used as the name of the placeholder to bind to.
*
* See also #bind_params.
*/
static VALUE bind_param(VALUE self, VALUE key, VALUE value)
{
sqlite3StmtRubyPtr ctx;
int status;
int index;
Data_Get_Struct(self, sqlite3StmtRuby, ctx);
REQUIRE_OPEN_STMT(ctx);
switch(TYPE(key)) {
case T_SYMBOL:
key = rb_funcall(key, rb_intern("to_s"), 0);
case T_STRING:
if(RSTRING_PTR(key)[0] != ':') key = rb_str_plus(rb_str_new2(":"), key);
index = sqlite3_bind_parameter_index(ctx->st, StringValuePtr(key));
break;
default:
index = (int)NUM2INT(key);
}
if(index == 0)
rb_raise(rb_path2class("SQLite3::Exception"), "no such bind parameter");
switch(TYPE(value)) {
case T_STRING:
if(CLASS_OF(value) == cSqlite3Blob
|| rb_enc_get_index(value) == rb_ascii8bit_encindex()
) {
status = sqlite3_bind_blob(
ctx->st,
index,
(const char *)StringValuePtr(value),
(int)RSTRING_LEN(value),
SQLITE_TRANSIENT
);
} else {
if (UTF16_LE_P(value) || UTF16_BE_P(value)) {
status = sqlite3_bind_text16(
ctx->st,
index,
(const char *)StringValuePtr(value),
(int)RSTRING_LEN(value),
SQLITE_TRANSIENT
);
} else {
if (!UTF8_P(value) || !USASCII_P(value)) {
value = rb_str_encode(value, rb_enc_from_encoding(rb_utf8_encoding()), 0, Qnil);
}
status = sqlite3_bind_text(
ctx->st,
index,
(const char *)StringValuePtr(value),
(int)RSTRING_LEN(value),
SQLITE_TRANSIENT
);
}
}
break;
case T_BIGNUM: {
sqlite3_int64 num64;
if (bignum_to_int64(value, &num64)) {
status = sqlite3_bind_int64(ctx->st, index, num64);
break;
}
}
case T_FLOAT:
status = sqlite3_bind_double(ctx->st, index, NUM2DBL(value));
break;
case T_FIXNUM:
status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)FIX2LONG(value));
break;
case T_NIL:
status = sqlite3_bind_null(ctx->st, index);
break;
default:
rb_raise(rb_eRuntimeError, "can't prepare %s",
rb_class2name(CLASS_OF(value)));
break;
}
CHECK(sqlite3_db_handle(ctx->st), status);
return self;
}
static VALUE step(VALUE self)
{
sqlite3StmtRubyPtr ctx;
sqlite3_stmt *stmt;
int value, length;
VALUE list;
rb_encoding * internal_encoding;
Data_Get_Struct(self, sqlite3StmtRuby, ctx);
REQUIRE_OPEN_STMT(ctx);
if(ctx->done_p) return Qnil;
{
VALUE db = rb_iv_get(self, "@connection");
rb_funcall(db, rb_intern("encoding"), 0);
internal_encoding = rb_default_internal_encoding();
}
stmt = ctx->st;
value = sqlite3_step(stmt);
length = sqlite3_column_count(stmt);
list = rb_ary_new2((long)length);
switch(value) {
case SQLITE_ROW:
{
int i;
for(i = 0; i < length; i++) {
switch(sqlite3_column_type(stmt, i)) {
case SQLITE_INTEGER:
rb_ary_push(list, LL2NUM(sqlite3_column_int64(stmt, i)));
break;
case SQLITE_FLOAT:
rb_ary_push(list, rb_float_new(sqlite3_column_double(stmt, i)));
break;
case SQLITE_TEXT:
{
VALUE str = rb_tainted_str_new(
(const char *)sqlite3_column_text(stmt, i),
(long)sqlite3_column_bytes(stmt, i)
);
rb_enc_associate_index(str, rb_utf8_encindex());
if(internal_encoding)
str = rb_str_export_to_enc(str, internal_encoding);
rb_ary_push(list, str);
}
break;
case SQLITE_BLOB:
{
VALUE str = rb_tainted_str_new(
(const char *)sqlite3_column_blob(stmt, i),
(long)sqlite3_column_bytes(stmt, i)
);
rb_ary_push(list, str);
}
break;
case SQLITE_NULL:
rb_ary_push(list, Qnil);
break;
default:
rb_raise(rb_eRuntimeError, "bad type");
}
}
}
break;
case SQLITE_DONE:
ctx->done_p = 1;
return Qnil;
break;
default:
sqlite3_reset(stmt);
ctx->done_p = 0;
CHECK(sqlite3_db_handle(ctx->st), value);
}
return list;
}
/* Return a data.frame containing the requested number of rows from
the resultset.
We try to determine the correct R type for each column in the
result. Currently, type detection happens only for the first fetch
on a given resultset and the first row of the resultset is used for
type interpolation. If a NULL value appears in the first row of
the resultset and the column corresponds to a DB table column, we
guess the type based on the DB schema definition for the column.
If the NULL value does not correspond to a table column, then we
force character.
*/
SEXP rsqlite_query_fetch(SEXP handle, SEXP max_rec) {
SQLiteResult* res = rsqlite_result_from_handle(handle);
if (res->isSelect != 1) {
warning("resultSet does not correspond to a SELECT statement");
return R_NilValue;
}
if (res->completed == 1) {
return R_NilValue;
}
/* We need to step once to be able to create the data mappings */
int row_idx = 0;
int state = do_select_step(res, row_idx);
sqlite3_stmt* db_statement = (sqlite3_stmt*) res->drvResultSet;
if (state != SQLITE_ROW && state != SQLITE_DONE) {
error("rsqlite_query_fetch: failed first step: %s",
sqlite3_errmsg(sqlite3_db_handle(db_statement)));
}
SQLiteFields* flds = rsqlite_result_fields(res);
int num_fields = flds->num_fields;
int num_rec = asInteger(max_rec);
int expand = (num_rec < 0); /* dyn expand output to accommodate all rows*/
if (expand || num_rec == 0) {
num_rec = rsqlite_driver()->fetch_default_rec;
}
SEXP output = PROTECT(NEW_LIST(num_fields));
rsqlite_output_alloc(output, flds, num_rec);
while (state != SQLITE_DONE) {
fill_one_row(db_statement, output, row_idx, flds);
row_idx++;
if (row_idx == num_rec) { /* request satisfied or exhausted allocated space */
if (expand) { /* do we extend or return the records fetched so far*/
num_rec = 1.5 * num_rec;
rsqlite_output_expand(output, flds, num_rec);
} else {
break; /* okay, no more fetching for now */
}
}
state = do_select_step(res, row_idx);
if (state != SQLITE_ROW && state != SQLITE_DONE) {
error("rsqlite_query_fetch: failed: %s",
sqlite3_errmsg(sqlite3_db_handle(db_statement)));
}
} /* end row loop */
if (state == SQLITE_DONE) {
res->completed = 1;
}
/* size to actual number of records fetched */
if (row_idx < num_rec) {
num_rec = row_idx;
/* adjust the length of each of the members in the output_list */
for (int j = 0; j < num_fields; j++) {
SEXP s_tmp = VECTOR_ELT(output, j);
PROTECT(SET_LENGTH(s_tmp, num_rec));
SET_VECTOR_ELT(output, j, s_tmp);
UNPROTECT(1);
}
}
res->rowCount += num_rec;
UNPROTECT(1);
return output;
}
bool DoStep(JSContext *cx, JS::HandleObject obj, JS::MutableHandleValue rval) {
sqlite3_stmt *pStmt = (sqlite3_stmt*)JL_GetPrivate(obj);
JL_ASSERT_THIS_OBJECT_STATE( pStmt );
DatabasePrivate *dbpv;
{
JS::RootedValue dbVal(cx);
JL_CHK( JL_GetReservedSlot(obj, SLOT_RESULT_DATABASE, &dbVal) );
JL_ASSERT( dbVal.isObject() );
JS::RootedObject dbValObj(cx, &dbVal.toObject());
dbpv = (DatabasePrivate*)JL_GetPrivate(dbValObj);
JL_ASSERT_OBJECT_STATE(dbpv, JL_GetClassName(dbValObj));
}
sqlite3 *db;
db = dbpv->db;
ASSERT( db == sqlite3_db_handle(pStmt) );
{
// check if bindings are up to date
JS::RootedValue bindingUpToDate(cx);
JL_CHK( JL_GetReservedSlot(obj, SLOT_RESULT_BINDING_UP_TO_DATE, &bindingUpToDate) );
if ( bindingUpToDate != JSVAL_TRUE ) {
JS::RootedValue queryArgument(cx);
JS::RootedObject queryArgumentObj(cx);
JL_CHK(jl::getSlot(cx, obj, SLOT_RESULT_QUERY_ARGUMENT_OBJECT, &queryArgumentObj));
JL_CHK(SqliteSetupBindings(cx, pStmt, queryArgumentObj, obj)); // ":" use result object. "@" is the object passed to Query()
JL_CHK( JL_SetReservedSlot(obj, SLOT_RESULT_BINDING_UP_TO_DATE, JL_TRUE) );
// doc: The sqlite3_bind_*() routines must be called AFTER sqlite3_prepare() or sqlite3_reset() and BEFORE sqlite3_step().
// Bindings are not cleared by the sqlite3_reset() routine. Unbound parameters are interpreted as NULL.
}
}
dbpv->tmpcx = cx;
int status;
status = sqlite3_step( pStmt ); // The return value will be either SQLITE_BUSY, SQLITE_DONE, SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE.
dbpv->tmpcx = NULL;
JL_CHK( !JL_IsExceptionPending(cx) );
switch ( status ) {
case SQLITE_ROW: // SQLITE_ROW is returned each time a new row of data is ready for processing by the caller
rval.setBoolean(true);
return true;
case SQLITE_DONE: // means that the statement has finished executing successfully. sqlite3_step() should not be called again on this virtual machine without first calling sqlite3_reset() to reset the virtual machine back to its initial state.
rval.setBoolean(false);
return true;
case SQLITE_MISUSE:
// doc. means that the this routine was called inappropriately. Perhaps it was called on a virtual machine that had already been finalized or on one that had previously returned SQLITE_ERROR or SQLITE_DONE.
// Or it could be the case that a database connection is being used by a different thread than the one it was created it.
// doc. If an interface fails with SQLITE_MISUSE, that means the interface was invoked incorrectly by the application. In that case, the error code and message may or may not be set.
JL_CHK( SqliteThrowError(cx, db) );
// case SQLITE_ERROR:
// case SQLITE_SCHEMA: // (TBD) check for another error (doc. The database schema changed)
// JL_CHK( SqliteThrowError(cx, db) );
}
// JL_REPORT_ERROR("invalid case (status:%d)", status );
JL_CHK( SqliteThrowError(cx, db) );
JL_BAD;
}
long long StatementHandle::getLastInsertedRowID()
{
return sqlite3_last_insert_rowid(
sqlite3_db_handle((sqlite3_stmt *) m_stmt));
}
int StatementHandle::getChanges()
{
sqlite3 *handle = sqlite3_db_handle((sqlite3_stmt *) m_stmt);
return sqlite3_changes((sqlite3 *) handle);
}
void sqlite_source::prepare_data(
const std::string & database_name,
const std::string & sql)
throw(
std::logic_error,
std::invalid_argument)
{
check_not_running();
delete_data();
sqlite3_stmt* data = get_stmt(database_name, sql);
int column_count = sqlite3_column_count(data);
if (column_count == 0) //statement is no SELECT statement
{
throw std::invalid_argument("Statement is no SQL SELECT statement.");
}
m_data = data;
m_column_count = column_count;
m_time_column = sqlite3_bind_parameter_index(m_data, get_duration_string().c_str());
m_database_name = database_name;
m_sql = sql;
std::vector<column_info> column_infos;
sqlite3* db_handle = sqlite3_db_handle(m_data);
char const* data_type = NULL;
char const* coll_seq = NULL;
int not_null = 0;
int primary_key = 0;
int auto_inc = 0;
for (int i = 0; i < m_column_count; ++i)
{
std::string column_name = sqlite3_column_origin_name(m_data, i);
int result_code = sqlite3_table_column_metadata(
db_handle,
sqlite3_column_database_name(m_data, i),
sqlite3_column_table_name(m_data, i),
column_name.c_str(),
&data_type,
&coll_seq,
¬_null,
&primary_key,
&auto_inc);
if (result_code != SQLITE_OK)
{
//TODO: do something with the error...this error can only be an internal db error
}
if (i + 1 != m_time_column)
{
std::string type(data_type);
column_info info(column_name, m_source_name, get_data_type(data_type));
column_infos.push_back(info);
}
}
m_stream_schema = stream_schema_ptr(new stream_schema(m_source_name, column_infos));
}
/******************************************************************************
*
* Find/Query helper functions
*
* ****************************************************************************/
int
gf_sql_query_function (sqlite3_stmt *prep_stmt,
gf_query_callback_t query_callback,
void *_query_cbk_args)
{
int ret = -1;
gfdb_query_record_t *gfdb_query_record = NULL;
char *text_column = NULL;
sqlite3 *db_conn = NULL;
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, prep_stmt, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, query_callback, out);
db_conn = sqlite3_db_handle(prep_stmt);
gfdb_query_record = gfdb_query_record_init ();
if (!gfdb_query_record) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FAILED, "Failed to create "
"gfdb_query_record");
goto out;
}
/*Loop to access queried rows*/
while ((ret = sqlite3_step (prep_stmt)) == SQLITE_ROW) {
/*Clear the query record*/
memset (gfdb_query_record, 0, sizeof(*gfdb_query_record));
if (sqlite3_column_count(prep_stmt) > 0) {
/*Retriving GFID - column index is 0*/
text_column = (char *)sqlite3_column_text
(prep_stmt, 0);
if (!text_column) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_GET_ID_FAILED, "Failed "
"retriving GF_ID");
goto out;
}
ret = gf_uuid_parse (text_column, gfdb_query_record->gfid);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_PARSE_FAILED, "Failed parsing "
"GF_ID");
goto out;
}
/*Retrive Link Buffer - column index 1*/
text_column = (char *)sqlite3_column_text
(prep_stmt, 1);
/* Get link string. Do shallow copy here
* query_callback function should do a
* deep copy and then do operations on this field*/
gfdb_query_record->_link_info_str = text_column;
gfdb_query_record->link_info_size = strlen
(text_column);
/* Call the call back function provided*/
ret = query_callback (gfdb_query_record,
_query_cbk_args);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_QUERY_CALL_BACK_FAILED,
"Query Call back failed!");
goto out;
}
}
}
if (ret != SQLITE_DONE) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_GET_RECORD_FAILED, "Failed retriving records "
"from db : %s", sqlite3_errmsg (db_conn));
ret = -1;
goto out;
}
ret = 0;
out:
gfdb_query_record_fini (&gfdb_query_record);
return ret;
}
SqlException::SqlException(sqlite3_stmt* statement, const std::string& message)
: SqlException(sqlite3_db_handle(statement), sqlite3_sql(statement), message) {
}
void
publish_services (void)
{
struct gen_ssid_arg arg = {
.ssid = "##",
.ssid_len = 2,
.last_pos = -1,
.rc = ERR_SUCCESS,
};
char *err_msg;
int rc;
sqlite3 *db;
if (sqlite3_open_v2 (SERVICE_LIST_DB, &db, SQLITE_OPEN_READONLY, NULL))
{
SQLITE3_ERR (db,
"Cannot open DB in read-only mode for publishing services");
goto error;
}
if ((rc = sqlite3_exec (db,
"select "
COLUMN_CAT_ID ", " COLUMN_DESC ", " COLUMN_POSITION
" from " TABLE_SERVICE_LIST
" order by " COLUMN_POSITION " asc",
gen_ssid, &arg, &err_msg)) != SQLITE_ABORT
&& rc != SQLITE_OK)
{
SQLITE3_ERR_STR (err_msg, "Cannot select services to publish");
goto error;
}
if (rc == SQLITE_ABORT)
{
sqlite3_free (err_msg);
l->APP_ERR (arg.rc, "Cannot publish services");
goto error;
}
if ((rc = set_ssid (arg.ssid, arg.ssid_len)))
{
l->APP_ERR (rc, "Cannot set SSID");
}
error:
if (sqlite3_close (db))
{
SQLITE3_ERR (db,
"Cannot close read-only DB for reading published services");
}
}
/**
* The callback function used with sqlite3_exec() to not change the modification
* time of unmodified record. The SQL select in sqlite3_exec()
* <strong>MUST</strong> select all columns with '*'.
*
* @param [in] stmt the prepared statement to adjust the modification time.
* @param [in] col_count the number of columns in this record.
* @param [in] cols the columns of this record.
* @param [in] col_names the column names of this record.
*
* @return 0 if there is no error or non-zero if there is one.
*/
static int
adjust_mod_time (void *stmt, int col_count, char **cols, char **col_names)
{
sqlite3_stmt *updt_stmt = stmt;
sqlite3 *db = sqlite3_db_handle (updt_stmt);
if (sqlite3_bind_text (stmt, 1, cols[COLPOS_MOD_TIME], -1, SQLITE_STATIC))
{
SQLITE3_ERR (db, "Cannot bind mod_time to updt stmt");
return -1;
}
if (sqlite3_bind_text (stmt, 2, cols[COLPOS_POSITION], -1, SQLITE_STATIC))
{
SQLITE3_ERR (db, "Cannot bind position to updt stmt");
return -1;
}
if (sqlite3_bind_text (stmt, 3, cols[COLPOS_CAT_ID], -1, SQLITE_STATIC))
{
SQLITE3_ERR (db, "Cannot bind cat_id to updt stmt");
return -1;
}
if (sqlite3_bind_text (stmt, 4, cols[COLPOS_DESC], -1, SQLITE_STATIC))
{
SQLITE3_ERR (db, "Cannot bind desc to updt stmt");
return -1;
}
if (sqlite3_bind_text (stmt, 5, cols[COLPOS_LONG_DESC], -1, SQLITE_STATIC))
{
SQLITE3_ERR (db, "Cannot bind long_desc to updt stmt");
return -1;
}
if (sqlite3_bind_text (stmt, 6, cols[COLPOS_URI], -1, SQLITE_STATIC))
{
SQLITE3_ERR (db, "Cannot bind uri to updt stmt");
return -1;
}
if (sqlite3_step (stmt) != SQLITE_DONE)
{
SQLITE3_ERR (db, "Cannot execute updt stmt");
return -1;
}
if (sqlite3_reset (stmt))
{
SQLITE3_ERR (db, "Cannot reset updt stmt");
return -1;
}
if (sqlite3_clear_bindings (stmt))
{
SQLITE3_ERR (db, "Cannot clear updt stmt bindings");
return -1;
}
return 0;
}
Execerror::Execerror(const char* function, sqlite3_stmt* stmt, int _errcode)
: SqliteError(function, sqlite3_errmsg(sqlite3_db_handle(stmt))),
errcode(_errcode)
{ }
