ECode CStmt::ColumnBytes(
/* [in] */ Int32 col,
/* [out, callee] */ ArrayOf<unsigned char>** array)
{
VALIDATE_NOT_NULL(array);
#if HAVE_SQLITE3 && HAVE_SQLITE_COMPILE
hvm *v = (hvm *)mHandle;
if (v && v->vm && v->h) {
Int32 ncol = sqlite3_data_count((sqlite3_stmt *) v->vm);
Int32 nbytes = 0;
const unsigned char *data = NULL;
if (col < 0 || col >= ncol) {
*array = NULL;
return E_ILLEGAL_ARGUMENT_EXCEPTION;
}
data = (const unsigned char *)sqlite3_column_blob((sqlite3_stmt *) v->vm, col);
if (data) {
nbytes = sqlite3_column_bytes((sqlite3_stmt *) v->vm, col);
} else {
*array = NULL;
return E_SQL_EXCEPTION;
}
AutoPtr<ArrayOf<unsigned char> > outchar = ArrayOf<unsigned char>::Alloc(nbytes);
outchar->Copy(data,nbytes);
*array = outchar;
} else {
return E_NULL_POINTER_EXCEPTION;
}
#else
return E_SQL_FEATURE_NOT_SUPPORTED_EXCEPTION;
#endif
return NOERROR;
}
static int pdo_sqlite_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, zend_ulong *len, int *caller_frees)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
if (!S->stmt) {
return 0;
}
if(colno >= sqlite3_data_count(S->stmt)) {
/* error invalid column */
pdo_sqlite_error_stmt(stmt);
return 0;
}
switch (sqlite3_column_type(S->stmt, colno)) {
case SQLITE_NULL:
*ptr = NULL;
*len = 0;
return 1;
case SQLITE_BLOB:
*ptr = (char*)sqlite3_column_blob(S->stmt, colno);
*len = sqlite3_column_bytes(S->stmt, colno);
return 1;
default:
*ptr = (char*)sqlite3_column_text(S->stmt, colno);
*len = sqlite3_column_bytes(S->stmt, colno);
return 1;
}
}
bool PDOSqliteStatement::getColumnMeta(int64_t colno, Array &ret) {
if (!m_stmt) {
return false;
}
if (colno >= sqlite3_data_count(m_stmt)) {
/* error invalid column */
handleError(__FILE__, __LINE__);
return false;
}
ret = Array::Create();
Array flags = Array::Create();
switch (sqlite3_column_type(m_stmt, colno)) {
case SQLITE_NULL: ret.set(s_native_type, s_null); break;
case SQLITE_FLOAT: ret.set(s_native_type, s_double); break;
case SQLITE_BLOB: flags.append(s_blob);
case SQLITE_TEXT: ret.set(s_native_type, s_string); break;
case SQLITE_INTEGER: ret.set(s_native_type, s_integer); break;
}
const char *str = sqlite3_column_decltype(m_stmt, colno);
if (str) {
ret.set(s_sqlite_decl_type, String((char *)str, CopyString));
}
#ifdef SQLITE_ENABLE_COLUMN_METADATA
str = sqlite3_column_table_name(m_stmt, colno);
if (str) {
ret.set(s_table, String((char *)str, CopyString));
}
#endif
ret.set(s_flags, flags);
return true;
}
//取得
Magic* MagicManager::getById(int id)
{
std::string sql = "SELECT * FROM " + getTableName() + " WHERE id = ?";
const char *pzTest;
sqlite3_prepare_v2(_db, sql.c_str(), strlen(sql.c_str()), &_stmt, &pzTest);
sqlite3_bind_int(_stmt, 1, id);
sqlite3_step(_stmt);
auto magic = Magic::getInstance();
if(sqlite3_data_count(_stmt)){
magic->setId(sqlite3_column_int(_stmt, 0));
magic->setRank(sqlite3_column_int(_stmt, 1));
magic->setName((char*)sqlite3_column_text(_stmt, 2));
magic->setParamAttack(sqlite3_column_int(_stmt, 3));
magic->setParamCure(sqlite3_column_int(_stmt, 4));
magic->setParamStan(sqlite3_column_int(_stmt, 5));
}
sqlite3_reset(_stmt);
sqlite3_clear_bindings(_stmt);
sqlite3_finalize(_stmt);
return magic;
}
static int pdo_sqlite_stmt_execute(pdo_stmt_t *stmt)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
if (stmt->executed && !S->done) {
sqlite3_reset(S->stmt);
}
S->done = 0;
switch (sqlite3_step(S->stmt)) {
case SQLITE_ROW:
S->pre_fetched = 1;
stmt->column_count = sqlite3_data_count(S->stmt);
return 1;
case SQLITE_DONE:
stmt->column_count = sqlite3_column_count(S->stmt);
stmt->row_count = sqlite3_changes(S->H->db);
sqlite3_reset(S->stmt);
S->done = 1;
return 1;
case SQLITE_ERROR:
sqlite3_reset(S->stmt);
case SQLITE_MISUSE:
case SQLITE_BUSY:
default:
pdo_sqlite_error_stmt(stmt);
return 0;
}
}
bool PDOSqliteStatement::executer() {
if (executed && !m_done) {
sqlite3_reset(m_stmt);
}
m_done = 0;
switch (sqlite3_step(m_stmt)) {
case SQLITE_ROW:
m_pre_fetched = 1;
column_count = sqlite3_data_count(m_stmt);
return true;
case SQLITE_DONE:
column_count = sqlite3_column_count(m_stmt);
row_count = sqlite3_changes(m_db);
sqlite3_reset(m_stmt);
m_done = 1;
return true;
case SQLITE_ERROR:
sqlite3_reset(m_stmt);
case SQLITE_MISUSE:
case SQLITE_BUSY:
default:
handleError(__FILE__, __LINE__);
return false;
}
}
int osux_database_exec_prepared_query(osux_database *db, osux_list *query_result)
{
int ret = sqlite3_step(db->prepared_query);
while (ret != SQLITE_DONE) {
if (ret != SQLITE_ROW) {
osux_debug("%s\n", sqlite3_errmsg(get_handle(db)));
sqlite3_reset(db->prepared_query);
sqlite3_clear_bindings(db->prepared_query);
return -OSUX_ERR_DATABASE;
}
osux_hashtable *dict = osux_hashtable_new(0);
int col_count = sqlite3_data_count(db->prepared_query);
for (int i = 0; i < col_count; ++i) {
char const *col_text;
col_text = (char const*) sqlite3_column_text(db->prepared_query, i);
if (col_text != NULL) {
char const *col_name = sqlite3_column_name(db->prepared_query, i);
osux_hashtable_insert(dict, col_name, g_strdup(col_text));
}
}
osux_list_append(query_result, dict);
ret = sqlite3_step(db->prepared_query);
}
sqlite3_reset(db->prepared_query);
sqlite3_clear_bindings(db->prepared_query);
return 0;
}
int SQLiteStatement::columnCount()
{
ASSERT(m_isPrepared);
if (!m_statement)
return 0;
return sqlite3_data_count(m_statement);
}
int sqlite3_data_count_idr(void* db){
DBinfo* dbi =(DBinfo*) db;
int rc = sqlite3_data_count(dbi->ppStmt);
return rc;
}
void SqliteCursor::drv_getNextRecord()
{
int res = sqlite3_step(d->prepared_st_handle);
if (res == SQLITE_ROW) {
m_fetchResult = FetchOK;
m_fieldCount = sqlite3_data_count(d->prepared_st_handle);
//#else //for SQLITE3 data fetching is delayed. Now we even do not take field count information
// // -- just set a flag that we've a data not fetched but available
m_fieldsToStoreInRecord = m_fieldCount;
}
else {
if (res == SQLITE_DONE) {
m_fetchResult = FetchEnd;
} else {
m_result.setServerErrorCode(res);
m_fetchResult = FetchError;
}
}
//debug
/*
if ((int)m_result == (int)FetchOK && d->curr_coldata) {
for (int i=0;i<m_fieldCount;i++) {
sqliteDebug()<<"col."<< i<<": "<< d->curr_colname[i]<<" "<< d->curr_colname[m_fieldCount+i]
<< " = " << (d->curr_coldata[i] ? QString::fromLocal8Bit(d->curr_coldata[i]) : "(NULL)");
}
// sqliteDebug() << m_fieldCount << "col(s) fetched";
}*/
}
ECode CStmt::ColumnString(
/* [in] */ Int32 col,
/* [out] */ String* str)
{
VALIDATE_NOT_NULL(str);
#if HAVE_SQLITE3 && HAVE_SQLITE_COMPILE
hvm *v = (hvm *)mHandle;
if (v && v->vm && v->h) {
Int32 ncol = sqlite3_data_count((sqlite3_stmt *) v->vm);
Int32 nbytes = 0;
const char *data = NULL;
if (col < 0 || col >= ncol) {
return E_ILLEGAL_ARGUMENT_EXCEPTION;
}
data = (const char *)sqlite3_column_text((sqlite3_stmt *) v->vm, col);
if (data) {
nbytes = sqlite3_column_bytes((sqlite3_stmt *) v->vm, col);
} else {
*str = String(NULL);
return E_SQL_EXCEPTION;
}
*str = String((char *)data);
} else {
return E_NULL_POINTER_EXCEPTION;
}
#else
return E_SQL_FEATURE_NOT_SUPPORTED_EXCEPTION;
#endif
return NOERROR;
}
bool PDOSqliteStatement::getColumn(int colno, Variant &value) {
if (!m_stmt) {
return false;
}
if (colno >= sqlite3_data_count(m_stmt)) {
/* error invalid column */
handleError(__FILE__, __LINE__);
return false;
}
char *ptr; int len;
switch (sqlite3_column_type(m_stmt, colno)) {
case SQLITE_NULL:
ptr = NULL;
len = 0;
break;
case SQLITE_BLOB:
ptr = (char*)sqlite3_column_blob(m_stmt, colno);
len = sqlite3_column_bytes(m_stmt, colno);
break;
case SQLITE3_TEXT:
ptr = (char*)sqlite3_column_text(m_stmt, colno);
len = sqlite3_column_bytes(m_stmt, colno);
break;
default:
ptr = (char*)sqlite3_column_text(m_stmt, colno);
len = sqlite3_column_bytes(m_stmt, colno);
break;
}
value = String(ptr, len, CopyString);
return true;
}
Variant c_SQLite3::t_querysingle(CStrRef sql, bool entire_row /* = false */) {
INSTANCE_METHOD_INJECTION_BUILTIN(SQLite3, SQLite3::querysingle);
validate();
if (!sql.empty()) {
Variant stmt = t_prepare(sql);
if (!same(stmt, false)) {
sqlite3_stmt *pstmt =
stmt.toObject().getTyped<c_SQLite3Stmt>()->m_raw_stmt;
switch (sqlite3_step(pstmt)) {
case SQLITE_ROW: /* Valid Row */
if (entire_row) {
Array ret = Array::Create();
for (int i = 0; i < sqlite3_data_count(pstmt); i++) {
ret.set(String((char*)sqlite3_column_name(pstmt, i), CopyString),
get_column_value(pstmt, i));
}
return ret;
}
return get_column_value(pstmt, 0);
case SQLITE_DONE: /* Valid but no results */
if (entire_row) {
return Array::Create();
} else {
return null;
}
default:
raise_warning("Unable to execute statement: %s",
sqlite3_errmsg(m_raw_db));
}
}
}
return false;
}
void
load_statement(sqlite3_stmt *stmt, Row_t *row, Table_t *table)
{
guint32 i, max;
if (table->header.list.count <= 0) /* Lazy header loading */
load_table_header(stmt, table);
if (!row->fields) /* Lazy memory allocation */
row->fields = calloc(1, sizeof(struct RowFieldSequence));
for (i=0,max=sqlite3_data_count(stmt); i<max ;i++) {
struct RowField *rf = calloc(1, sizeof(*rf));
asn_uint32_to_INTEGER(&(rf->pos), i);
rf->value.present = RowFieldValue_PR_n;
switch (sqlite3_column_type(stmt, i)) {
case SQLITE_NULL:
rf->value.present = RowFieldValue_PR_n;
break;
case SQLITE_INTEGER:
do {
gint64 i64 = sqlite3_column_int64(stmt, i);
asn_int64_to_INTEGER(&(rf->value.choice.i), i64);
rf->value.present = RowFieldValue_PR_i;
} while (0);
break;
case SQLITE_FLOAT:
do {
gdouble d = sqlite3_column_double(stmt, i);
asn_double2REAL(&(rf->value.choice.f), d);
rf->value.present = RowFieldValue_PR_f;
} while (0);
break;
case SQLITE_TEXT:
do {
const guint8 *t = sqlite3_column_text(stmt, i);
gsize tsize = sqlite3_column_bytes(stmt, i);
OCTET_STRING_fromBuf(&(rf->value.choice.s), (char*)t, tsize);
rf->value.present = RowFieldValue_PR_s;
} while (0);
break;
case SQLITE_BLOB:
do {
const void *b = sqlite3_column_blob(stmt, i);
gsize bsize = sqlite3_column_bytes(stmt, i);
OCTET_STRING_fromBuf(&(rf->value.choice.b), (char*)b, bsize);
rf->value.present = RowFieldValue_PR_b;
} while (0);
break;
default:
rf->value.present = RowFieldValue_PR_n;
break;
}
asn_sequence_add(&(row->fields->list), rf);
}
}
/*************************************************************************
*
* Function: sql_num_rows
*
* Purpose: database specific num_rows. Returns number of rows in
* query
*
*************************************************************************/
static int sql_num_rows(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
{
rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
if (sqlite_sock->pStmt)
return sqlite3_data_count(sqlite_sock->pStmt);
return 0;
}
/*
** Check to see if column iCol of the given statement is valid. If
** it is, return a pointer to the Mem for the value of that column.
** If iCol is not valid, return a pointer to a Mem which has a value
** of NULL.
*/
static Mem *columnMem(sqlite3_stmt *pStmt, int i){
Vdbe *pVm = (Vdbe *)pStmt;
int vals = sqlite3_data_count(pStmt);
if( i>=vals || i<0 ){
static const Mem nullMem = {{0}, 0.0, "", 0, MEM_Null, MEM_Null };
sqlite3Error(pVm->db, SQLITE_RANGE, 0);
return (Mem*)&nullMem;
}
return &pVm->pTos[(1-vals)+i];
}
/*
** Check to see if column iCol of the given statement is valid. If
** it is, return a pointer to the Mem for the value of that column.
** If iCol is not valid, return a pointer to a Mem which has a value
** of NULL.
*/
static Mem *columnMem(sqlite3_stmt *pStmt, int i){
Vdbe *pVm = (Vdbe *)pStmt;
int vals = sqlite3_data_count(pStmt);
if( i>=vals || i<0 ){
static Mem nullMem;
if( nullMem.flags==0 ){ nullMem.flags = MEM_Null; }
sqlite3Error(pVm->db, SQLITE_RANGE, 0);
return &nullMem;
}
return &pVm->pTos[(1-vals)+i];
}
static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
const char *str;
zval flags;
if (!S->stmt) {
return FAILURE;
}
if(colno >= sqlite3_data_count(S->stmt)) {
/* error invalid column */
pdo_sqlite_error_stmt(stmt);
return FAILURE;
}
array_init(return_value);
array_init(&flags);
switch (sqlite3_column_type(S->stmt, colno)) {
case SQLITE_NULL:
add_assoc_string(return_value, "native_type", "null");
break;
case SQLITE_FLOAT:
add_assoc_string(return_value, "native_type", "double");
break;
case SQLITE_BLOB:
add_next_index_string(&flags, "blob");
case SQLITE_TEXT:
add_assoc_string(return_value, "native_type", "string");
break;
case SQLITE_INTEGER:
add_assoc_string(return_value, "native_type", "integer");
break;
}
str = sqlite3_column_decltype(S->stmt, colno);
if (str) {
add_assoc_string(return_value, "sqlite:decl_type", (char *)str);
}
#ifdef SQLITE_ENABLE_COLUMN_METADATA
str = sqlite3_column_table_name(S->stmt, colno);
if (str) {
add_assoc_string(return_value, "table", (char *)str);
}
#endif
add_assoc_zval(return_value, "flags", &flags);
return SUCCESS;
}
SWIGEXPORT jint JNICALL Java_com_almworks_sqlite4java__1SQLiteSwiggedJNI_sqlite3_1data_1count(JNIEnv *jenv, jclass jcls, jlong jarg1) {
jint jresult = 0 ;
sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
int result;
(void)jenv;
(void)jcls;
arg1 = *(sqlite3_stmt **)&jarg1;
result = (int)sqlite3_data_count(arg1);
jresult = (jint)result;
return jresult;
}
jint JNICALL Java_com_baidu_javalite_PrepareStmt_sqlite3_1data_1count(
JNIEnv *env, jclass cls, jlong handle)
{
if (handle == 0)
{
throwSqliteException(env, "handle is NULL");
return 0;
}
sqlite3_stmt* stmt = (sqlite3_stmt*) handle;
return sqlite3_data_count(stmt);
}
static void
load_table_header(sqlite3_stmt *stmt, Table_t *t)
{
guint32 i, max;
for (i=0,max=sqlite3_data_count(stmt); i<max ;i++) {
const char *cname = sqlite3_column_name(stmt, i);
struct RowName *rname = calloc(1, sizeof(*rname));
asn_uint32_to_INTEGER(&(rname->pos), i);
OCTET_STRING_fromBuf(&(rname->name), cname, strlen(cname));
asn_sequence_add(&(t->header.list), rname);
}
}
static int echoColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
int iCol = i + 1;
sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
if( simulateVtabError((echo_vtab *)(cur->pVtab), "xColumn") ){
return SQLITE_ERROR;
}
if( !pStmt ){
sqlite3_result_null(ctx);
}else{
assert( sqlite3_data_count(pStmt)>iCol );
sqlite3_result_value(ctx, sqlite3_column_value(pStmt, iCol));
}
return SQLITE_OK;
}
void DBBrowserDB::getTableRecords( const QString & tablename )
{
sqlite3_stmt *vm;
const char *tail;
int ncol;
QStringList r;
// char *errmsg;
int err=0;
// int tabnum = 0;
browseRecs.clear();
idmap.clear();
lastErrorMessage = QString("no error");
QString statement = "SELECT rowid, * FROM ";
statement.append( GetEncodedQString(tablename) );
statement.append(" ORDER BY rowid; ");
//qDebug(statement);
logSQL(statement, kLogMsg_App);
err=sqlite3_prepare(_db,statement,statement.length(),
&vm, &tail);
if (err == SQLITE_OK) {
int rownum = 0;
while ( sqlite3_step(vm) == SQLITE_ROW ) {
r.clear();
ncol = sqlite3_data_count(vm);
for (int e=0; e<ncol; e++) {
char * strresult = 0;
QString rv;
strresult = (char *) sqlite3_column_text(vm, e);
rv = QString(strresult);
r << GetDecodedQString(rv);
if (e==0) {
idmap.insert(rv.toInt(),rownum);
rownum++;
}
}
browseRecs.append(r);
}
sqlite3_finalize(vm);
} else {
lastErrorMessage = QString ("could not get fields");
}
}
QStringList SqliteTableModel::getColumns(const QString sQuery)
{
sqlite3_stmt* stmt;
QByteArray utf8Query = sQuery.toUtf8();
int status = sqlite3_prepare_v2(m_db->_db, utf8Query, utf8Query.size(), &stmt, NULL);
QStringList listColumns;
if(SQLITE_OK == status)
{
status = sqlite3_step(stmt);
int columns = sqlite3_data_count(stmt);
for(int i = 0; i < columns; ++i)
listColumns.append(QString::fromUtf8((const char*)sqlite3_column_name(stmt, i)));
}
sqlite3_finalize(stmt);
return listColumns;
}
static JSBool
js_db_step(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
js_db_t *jd = JS_GetPrivate(cx, obj);
if(js_db_check(cx, jd))
return JS_FALSE;
if(jd->jd_stmt == NULL) {
*rval = JSVAL_NULL;
} else if(jd->jd_step_rc == SQLITE_ROW) {
int cols = sqlite3_data_count(jd->jd_stmt);
int i;
JSObject *r = JS_NewObjectWithGivenProto(cx, NULL, NULL, obj);
*rval = OBJECT_TO_JSVAL(r);
if(!JS_EnterLocalRootScope(cx))
return JS_FALSE;
for(i = 0; i < cols; i++) {
const char *cn = sqlite3_column_name(jd->jd_stmt, i);
switch(sqlite3_column_type(jd->jd_stmt, i)) {
case SQLITE_INTEGER:
js_set_prop_int(cx, r, cn, sqlite3_column_int(jd->jd_stmt, i));
break;
case SQLITE_TEXT:
js_set_prop_str(cx, r, cn,
(const char *)sqlite3_column_text(jd->jd_stmt, i));
break;
case SQLITE_FLOAT:
js_set_prop_dbl(cx, r, cn, sqlite3_column_double(jd->jd_stmt, i));
break;
}
}
JS_LeaveLocalRootScope(cx);
return js_stmt_step(cx, jd, rval);
}
*rval = JSVAL_FALSE;
return JS_TRUE;
}
void SqliteTableModel::setQuery(const QString& sQuery, bool dontClearHeaders)
{
// clear
if(!dontClearHeaders)
{
m_mWhere.clear();
m_headers.clear();
}
if(!m_db->isOpen())
return;
m_sQuery = removeComments(sQuery).trimmed();
// do a count query to get the full row count in a fast manner
m_rowCount = getQueryRowCount();
if(m_rowCount == -1)
{
m_valid = false;
return;
}
// headers
if(!dontClearHeaders)
{
sqlite3_stmt* stmt;
QByteArray utf8Query = sQuery.toUtf8();
int status = sqlite3_prepare_v2(m_db->_db, utf8Query, utf8Query.size(), &stmt, NULL);
if(SQLITE_OK == status)
{
status = sqlite3_step(stmt);
int columns = sqlite3_data_count(stmt);
for(int i = 0; i < columns; ++i)
m_headers.append(QString::fromUtf8((const char*)sqlite3_column_name(stmt, i)));
}
sqlite3_finalize(stmt);
}
// now fetch the first entries
clearCache();
fetchData(0, m_chunkSize);
m_valid = true;
emit layoutChanged();
}
/*
* mode: 0 = direct, 1 = integer, 2 = alphanumeric
*/
static int l_sqlite3_row_mode(lua_State * L, int mode)
{
/* Old code / Just a reminder / To be removed:
** checkargs(L, 1, 2, CHECK_PTR, CHECK_NILTABLE, 0);
*/
sqlite3_stmt * stmt = checkstmt_stmt(L, 1);
int num_columns = sqlite3_data_count(stmt); /* Maybe wrong state, so don't use sqlite3_column_count */
int index;
/* XXX Should really be cleaned up... Fixme! */
if (mode == 0)
lua_checkstack(L, num_columns);
else
if (!lua_istable(L, -1))
lua_newtable(L);
for (index=0; index<num_columns; index++)
switch(mode)
{
case 0: /* direct mode */
push_column(L, stmt, index);
break;
case 1: /* integer mode */
push_column(L, stmt, index);
lua_rawseti(L, -2, index+1);
break;
case 2: /* alphanumeric mode */
lua_pushstring(L, sqlite3_column_name(stmt, index));
push_column(L, stmt, index);
lua_rawset(L, -3);
break;
default:
report_error(L, "libluasqlite3: Internal error in sqlite3_row_mode");
}
if (mode)
return 1;
else
return num_columns;
}
/*
** This procedure runs in the thread to step the virtual machine.
*/
static void do_step(Thread *p){
int i;
if( p->pStmt==0 ){
p->zErr = p->zStaticErr = "no virtual machine available";
p->rc = SQLITE_ERROR;
return;
}
p->rc = sqlite3_client_step(p->pStmt);
if( p->rc==SQLITE_ROW ){
p->argc = sqlite3_column_count(p->pStmt);
for(i=0; i<sqlite3_data_count(p->pStmt); i++){
p->argv[i] = (char*)sqlite3_column_text(p->pStmt, i);
}
for(i=0; i<p->argc; i++){
p->colv[i] = sqlite3_column_name(p->pStmt, i);
}
}
}
static int
es_sqlite_step(duk_context *ctx)
{
es_sqlite_t *es = es_resource_get(ctx, 0, &es_resource_sqlite);
if(es->es_stmt == NULL) {
duk_push_null(ctx);
return 1;
}
const int cols = sqlite3_data_count(es->es_stmt);
duk_push_object(ctx);
for(int i = 0; i < cols; i++) {
int64_t i64;
switch(sqlite3_column_type(es->es_stmt, i)) {
case SQLITE_INTEGER:
i64 = sqlite3_column_int64(es->es_stmt, i);
if(i64 >= INT32_MIN && i64 <= INT32_MAX)
duk_push_int(ctx, i64);
else if(i64 >= 0 && i64 <= UINT32_MAX)
duk_push_uint(ctx, i64);
else
duk_push_number(ctx, i64);
break;
case SQLITE_TEXT:
duk_push_string(ctx, (const char *)sqlite3_column_text(es->es_stmt, i));
break;
case SQLITE_FLOAT:
duk_push_number(ctx, sqlite3_column_double(es->es_stmt, i));
break;
default:
continue;
}
duk_put_prop_string(ctx, -2, sqlite3_column_name(es->es_stmt, i));
}
es_sqlite_stmt_step(ctx, es);
return 1;
}
/*
** Check to see if column iCol of the given statement is valid. If
** it is, return a pointer to the Mem for the value of that column.
** If iCol is not valid, return a pointer to a Mem which has a value
** of NULL.
*/
static Mem *columnMem(sqlite3_stmt *pStmt, int i){
Vdbe *pVm;
int vals;
Mem *pOut;
pVm = (Vdbe *)pStmt;
if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
sqlite3_mutex_enter(pVm->db->mutex);
vals = sqlite3_data_count(pStmt);
pOut = &pVm->pResultSet[i];
}else{
static const Mem nullMem = {{0}, 0.0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };
if( pVm->db ){
sqlite3_mutex_enter(pVm->db->mutex);
sqlite3Error(pVm->db, SQLITE_RANGE, 0);
}
pOut = (Mem*)&nullMem;
}
return pOut;
}
