自学教程：C++ sqlite3_column_type函数代码示例

	bool Statement::GetInt(unsigned int Column, Nullable<int> &Out)	{		if (Inner == nullptr)			return false;		if (sqlite3_column_type(Inner, Column) == SQLITE_NULL)		{			Out = Nullable<int>();			return true;		}		Out = Nullable<int>(sqlite3_column_int(Inner, Column));		return true;	}

	bool Statement::GetString(unsigned int Column, Nullable<std::string> &Out)	{		if (Inner == nullptr)			return false;		if (sqlite3_column_type(Inner, Column) == SQLITE_NULL)		{			Out = Nullable<std::string>();			return true;		}		Out = Nullable<std::string>(std::string(reinterpret_cast<const char *>(sqlite3_column_text(Inner, Column))));		return true;	}

	void sqlite_table::retrieve_data(sqlite3_stmt* stmt)	{		tu_autolock locker(s_sqlite_plugin_mutex);		int col_count = sqlite3_column_count(stmt);		m_title.resize(col_count);		for (int i = 0; i < col_count; i++)		{			m_title[i] = sqlite3_column_name(stmt, i);		} 		int rc;		do		{			as_object* row = new as_object(get_player());			m_data.push_back(row);			for (int i = 0; i < col_count; i++)			{				as_value val;				int col_type = sqlite3_column_type(stmt, i);				switch (col_type)				{					case SQLITE_INTEGER :						val.set_int(sqlite3_column_int(stmt, i));						break;					case SQLITE_FLOAT :						val.set_double(sqlite3_column_double(stmt, i));						break;					case SQLITE_BLOB :// FIXME:						val.set_string((const char*) sqlite3_column_blob(stmt, i));						break;					case SQLITE_NULL ://						val.set_null();						val.set_string("");						break;					case SQLITE3_TEXT :						val.set_string((const char*) sqlite3_column_text(stmt, i));						break;					default:						assert(0);						break;				}				row->set_member(m_title[i], val);			}			rc = sqlite3_step(stmt);		}		while (rc == SQLITE_ROW);	}

static krb5_error_code KRB5_CALLCONVscc_get_principal(krb5_context context,		  krb5_ccache id,		  krb5_principal *principal){    krb5_scache *s = SCACHE(id);    krb5_error_code ret;    const char *str;    *principal = NULL;    ret = make_database(context, s);    if (ret)	return ret;    sqlite3_bind_int(s->scache, 1, s->cid);    if (sqlite3_step(s->scache) != SQLITE_ROW) {	sqlite3_reset(s->scache);	krb5_set_error_message(context, KRB5_CC_END,			       N_("No principal for cache SCC:%s:%s", ""),			       s->name, s->file);	return KRB5_CC_END;    }    if (sqlite3_column_type(s->scache, 0) != SQLITE_TEXT) {	sqlite3_reset(s->scache);	krb5_set_error_message(context, KRB5_CC_END,			       N_("Principal data of wrong type "				  "for SCC:%s:%s", ""),			       s->name, s->file);	return KRB5_CC_END;    }    str = (const char *)sqlite3_column_text(s->scache, 0);    if (str == NULL) {	sqlite3_reset(s->scache);	krb5_set_error_message(context, KRB5_CC_END,			       N_("Principal not set for SCC:%s:%s", ""),			       s->name, s->file);	return KRB5_CC_END;    }    ret = krb5_parse_name(context, str, principal);    sqlite3_reset(s->scache);    return ret;}

		bool					sqlite_db::step()		{			if(!_stmt)				return false;			sqlite3_stmt* stmt=(sqlite3_stmt*)_stmt;			int ret=sqlite3_step(stmt);			if(ret==SQLITE_DONE)			{				if(sqlite3_column_count(stmt))					_array_res.push_back(sqlite_res());						// check if the statement will produce resultset, add a blank even if no rows to keep consistent				return true;			}			if(ret!=SQLITE_ROW)			{				_err_msg=(const wchar_t*)sqlite3_errmsg16((sqlite3*)_handle);				return false;			}			if(ret==SQLITE_ROW)				_array_res.push_back(sqlite_res());			sqlite_res& res=*(_array_res.end()-1);			int row=0;			while(ret==SQLITE_ROW)			{				res._res.push_back(vector<sqlite_res::VALUE>());				int i;				int count=sqlite3_column_count(stmt);				for(i=0;i<count;++i)				{					res._res[row].push_back(sqlite_res::VALUE());					int type=sqlite3_column_type(stmt,i);					if(type==SQLITE_NULL)						continue;					if(type==SQLITE_BLOB)					{						if(!sqlite3_column_bytes(stmt,i))							continue;						vector<char>& blob=res._res[row][i].blob;						blob.resize(sqlite3_column_bytes(stmt,i));						memcpy(&blob[0],sqlite3_column_blob(stmt,i),sqlite3_column_bytes(stmt,i));						continue;					}					res._res[row][i].text=(const wchar_t*)sqlite3_column_text16(stmt,i);				}				++row;				ret=sqlite3_step(stmt);			}			return true;		}

void genGateKeeperApprovedAppRow(sqlite3_stmt* const stmt, Row& r) {  for (int i = 0; i < sqlite3_column_count(stmt); i++) {    auto column_name = std::string(sqlite3_column_name(stmt, i));    auto column_type = sqlite3_column_type(stmt, i);    if (column_type == SQLITE_TEXT) {      auto value = sqlite3_column_text(stmt, i);      if (value != nullptr) {        r[column_name] = std::string(reinterpret_cast<const char*>(value));      }    } else if (column_type == SQLITE_FLOAT) {      auto value = sqlite3_column_double(stmt, i);      r[column_name] = DOUBLE(value);    }  }}

void genPkgRow(sqlite3_stmt* stmt, Row& r) {  for (int i = 0; i < sqlite3_column_count(stmt); i++) {    auto column_name = std::string(sqlite3_column_name(stmt, i));    auto column_type = sqlite3_column_type(stmt, i);    if (column_type == SQLITE_TEXT) {      auto value = sqlite3_column_text(stmt, i);      if (value != nullptr) {        r[column_name] = std::string((const char*)value);      }    } else if (column_type == SQLITE_INTEGER) {      auto value = sqlite3_column_int(stmt, i);      r[column_name] = INTEGER(value);    }  }}

ResultSet::FieldType SQLiteResult::fieldType(int field){	if (field>num_fields) throw FieldNotInResultSetException("%d",field);	if (!stmt) throw NoResultException();	if (last_res!=SQLITE_ROW) throw NoResultException();	int type=sqlite3_column_type(stmt, field);	switch (type) {		case SQLITE_INTEGER: return ResultSet::TYPE_INTEGER;		case SQLITE_FLOAT: return ResultSet::TYPE_FLOAT;		case SQLITE_BLOB: return ResultSet::TYPE_BINARY;		case SQLITE_NULL: return ResultSet::TYPE_INTEGER;		case SQLITE_TEXT: return ResultSet::TYPE_STRING;	}	return ResultSet::TYPE_UNKNOWN;}

QVariant QgsSpatiaLiteFeatureIterator::getFeatureAttribute( sqlite3_stmt* stmt, int ic, const QVariant::Type& type ){  if ( sqlite3_column_type( stmt, ic ) == SQLITE_INTEGER )  {    // INTEGER value    return sqlite3_column_int( stmt, ic );  }  if ( sqlite3_column_type( stmt, ic ) == SQLITE_FLOAT )  {    // DOUBLE value    return sqlite3_column_double( stmt, ic );  }  if ( sqlite3_column_type( stmt, ic ) == SQLITE_TEXT )  {    // TEXT value    const char *txt = ( const char * ) sqlite3_column_text( stmt, ic );    return QString::fromUtf8( txt );  }  // assuming NULL  return QVariant( type );}

void QSpatiaLiteResultPrivate::initColumns(bool emptyResultset){    int nCols = sqlite3_column_count(stmt);    if (nCols <= 0)        return;    q->init(nCols);    for (int i = 0; i < nCols; ++i) {        QString colName = QString::fromUtf16( (const ushort *) sqlite3_column_name16(stmt, i) ).remove(QLatin1Char('"'));        // must use typeName for resolving the type to match QSqliteDriver::record        QString typeName = QString::fromUtf16( (const ushort *) sqlite3_column_decltype16(stmt, i) );        // sqlite3_column_type is documented to have undefined behavior if the result set is empty        int stp = emptyResultset ? -1 : sqlite3_column_type(stmt, i);        QVariant::Type fieldType;        if (!typeName.isEmpty()) {            fieldType = qGetColumnType(typeName);        } else {            // Get the proper type for the field based on stp value            switch (stp) {            case SQLITE_INTEGER:                fieldType = QVariant::Int;                break;            case SQLITE_FLOAT:                fieldType = QVariant::Double;                break;            case SQLITE_BLOB:                fieldType = QVariant::ByteArray;                break;            case SQLITE_TEXT:                fieldType = QVariant::String;                break;            case SQLITE_NULL:            default:                fieldType = QVariant::Invalid;                break;            }        }        int dotIdx = colName.lastIndexOf(QLatin1Char('.'));        QSqlField fld(colName.mid(dotIdx == -1 ? 0 : dotIdx + 1), fieldType);        fld.setSqlType(stp);        rInf.append(fld);    }}

char *cws_query2json (char *dbfile, char *stmt){    int i;    const char *aux;    char *json;        json_object *root;    json_object *array;    sqlite3 *db;    sqlite3_stmt *pp;        sqlite3_open (dbfile, &db);    sqlite3_prepare (db, stmt, strlen (stmt), &pp, NULL);     array = json_object_new_array ();        while (sqlite3_step (pp) == SQLITE_ROW)    {        int ncol = sqlite3_column_count (pp);        json_object *row = json_object_new_object ();         for (i = 0; i < ncol; i++)        {            json_object *col = NULL;            switch (sqlite3_column_type (pp, i))            {                case SQLITE_FLOAT :                    col = json_object_new_double (sqlite3_column_double (pp, i));                    break;                case SQLITE_INTEGER :                     col = json_object_new_int (sqlite3_column_int (pp, i));                    break;                case SQLITE_TEXT :                     col = json_object_new_string ((char *) sqlite3_column_text (pp, i));                    break;            }            json_object_object_add (row, sqlite3_column_name (pp, i), col);        }        json_object_array_add (array, row);    }    sqlite3_finalize (pp);    sqlite3_close (db);    root = json_object_new_object ();    json_object_object_add (root, "records", array);    aux = json_object_to_json_string (root);    json = malloc (sizeof (char) * (strlen (aux) + 1));    strcpy (json, aux);    json_object_put (root);    return json;}

	/*		Return the data type of a column	*/	Statement::Type StatementPrivate::dataType(unsigned int column) const {		switch (sqlite3_column_type(stmt_, column)) {		case SQLITE_INTEGER:			return Statement::Type::Integer;		case SQLITE_FLOAT:			return Statement::Type::Real;		case SQLITE_BLOB:			return Statement::Type::Binary;		case SQLITE_NULL:			return Statement::Type::Null;		case SQLITE_TEXT:			return Statement::Type::Text;		default:			return Statement::Type::Null;		};	}

const char* wyResultSet::dataForColumnIndex(int columnIdx, size_t* outLen) {	// check type    if (sqlite3_column_type(m_statement->getStatement(), columnIdx) == SQLITE_NULL || (columnIdx < 0)) {    	*outLen = 0;        return NULL;    }    // copy data    int dataSize = sqlite3_column_bytes(m_statement->getStatement(), columnIdx);    char* buf = (char*)wyMalloc(dataSize * sizeof(char));    memcpy(buf, sqlite3_column_blob(m_statement->getStatement(), columnIdx), dataSize);    // return buffer    *outLen = dataSize;    return (const char*)buf;}

 query_result run(sqlite3_stmt *stmt) {     query_result data(new Result);     int rc;     do {         rc=sqlite3_step(stmt);         if (rc==SQLITE_ROW) {             data->resize(data->size()+1);             rowResult cur=data->back();             int nrows=sqlite3_column_count(stmt);             for (int i=0;i<nrows;++i) {                 LOCK_COUT                 cout << "[DB] query " << stmt                           << ": result row " << i+1 << "/" << nrows                           << endl;                 UNLOCK_COUT                 switch (sqlite3_column_type(stmt,i)) {                 case SQLITE_NULL:                     cur[i]=dbValue::ptr(new dbValue);                     break;                 case SQLITE_INTEGER:                     cur[i]=dbValue::ptr(new dbValue((s64)sqlite3_column_int(stmt,i)));                     break;                 case SQLITE_FLOAT:                     cur[i]=dbValue::ptr(new dbValue((double)sqlite3_column_double(stmt,i)));                     break;                 case SQLITE_TEXT:                     cur[i]=dbValue::ptr(new dbValue((const char *)sqlite3_column_text(stmt,i)));                     break;                 case SQLITE_BLOB:                     cur[i]=dbValue::ptr(                         new dbValue(                             (const char *)sqlite3_column_text(stmt,i),                             sqlite3_column_bytes(stmt,i)                         ));                     break;                 }             }         }     } while (rc==SQLITE_ROW);     if (rc!=SQLITE_DONE) {         DBError::busy_aware_throw(rc,sqlite3_errmsg(db));     }     LOCK_COUT     cout << "[DB] " << stmt << ": " << data->size() << " rows returned." << endl;     UNLOCK_COUT     return data; }

static int sqlite3_odbx_column_type( odbx_result_t* result, unsigned long pos ){#ifdef HAVE_SQLITE3_TABLE_COLUMN_METADATA	const char *type, *collation;	int notnull, primarykey, autoinc;#endif	switch( sqlite3_column_type( (sqlite3_stmt*) result->generic, pos ) )	{		case SQLITE_INTEGER:			return ODBX_TYPE_BIGINT;		case SQLITE_FLOAT:			return ODBX_TYPE_DOUBLE;		case SQLITE_BLOB:			return ODBX_TYPE_BLOB;		case SQLITE_TEXT:			return ODBX_TYPE_CLOB;		default:#ifdef HAVE_SQLITE3_TABLE_COLUMN_METADATA			if( sqlite3_table_column_metadata( (sqlite3*) result->handle->generic,				sqlite3_column_database_name( (sqlite3_stmt*) result->generic, pos ),				sqlite3_column_table_name( (sqlite3_stmt*) result->generic, pos ),				sqlite3_column_origin_name( (sqlite3_stmt*) result->generic, pos ),				&type, &collation, &notnull, &primarykey, &autoinc ) != SQLITE_OK )			{				return ODBX_TYPE_UNKNOWN;			}			if( strstr( type, "DOUBLE" ) != NULL || strcmp( type, "FLOAT" ) == 0 || strcmp( type, "REAL" ) == 0 ) {				return ODBX_TYPE_DOUBLE;			} else if( strstr( type, "INT" ) != NULL || strcmp( type, "BOOLEAN" ) == 0 ) {				return ODBX_TYPE_BIGINT;			} else if( strstr( type, "CHAR" ) != NULL || strcmp( type, "CLOB" ) == 0 || strcmp( type, "TEXT" ) == 0 ) {				return ODBX_TYPE_CLOB;			} else if( strstr( type, "DATE" ) != NULL || strstr( type, "TIME" ) != NULL || strstr( type, "DECIMAL" ) != NULL ) {				return ODBX_TYPE_CLOB;			} else if( strcmp( type, "BLOB" ) == 0 ) {				return ODBX_TYPE_BLOB;			} else {				return ODBX_TYPE_UNKNOWN;			}#else			return ODBX_TYPE_UNKNOWN;#endif	}}

shared_ptr<DBValue> SQLiteDataReader::makeDBValue(sqlite3_stmt *statement, std::size_t column) {    if (column >= (std::size_t) sqlite3_column_count(statement)) {        return 0;    }    const int type = sqlite3_column_type(statement, column);    switch (type) {    case SQLITE_INTEGER:        return new DBIntValue(sqlite3_column_int(statement, column));    case SQLITE_FLOAT:        return new DBRealValue(sqlite3_column_double(statement, column));    case SQLITE_TEXT:        return new DBTextValue((const char *) sqlite3_column_text(statement, column));    case SQLITE_NULL:        return DBValue::create(DBValue::DBNULL);    }    return 0;}

void Query::ViewRes(){	if (!res)	{		printf("no result stored/n");		return;	}	printf("result column count = %d/n", sqlite3_column_count(res));	for (int i = 0; i < sqlite3_column_count(res); i++)	{		printf(" %2d   type %d   name '%s'", i, sqlite3_column_type(res, i), sqlite3_column_name(res, i));		printf("  / '%s'", (char *)sqlite3_column_text(res, i));		printf("  / %d", sqlite3_column_int(res, i));		printf("  / %f", sqlite3_column_double(res, i));		printf("/n");	}}

static pse_op_error_t sqlite_query_int_value(sqlite3 *db, const char* sql_sentence, int* value){    pse_op_error_t ret = OP_SUCCESS;    int rc;    sqlite3_stmt *stat = NULL;    rc = sqlite3_prepare_v2(db, sql_sentence, -1, &stat, 0);    if(SQLITE_OK != rc)    {        ret = OP_ERROR_SQLITE_INTERNAL;        goto exit;    }    rc = sqlite3_step(stat);    if (SQLITE_DONE == rc)    {        *value = 0;		ret = OP_ERROR_SQLITE_NOT_FOUND;        goto exit;    }    if(SQLITE_ROW != rc)    {        ret = OP_ERROR_SQLITE_INTERNAL;        goto exit;    }    rc = sqlite3_column_type(stat, 0);    if(SQLITE_INTEGER != rc)    {        if(SQLITE_NULL == rc)        {            ret = OP_ERROR_SQLITE_NOT_FOUND; // SQlite returned a NULL record that indicates "NOT FOUND"        }        else        {            ret = OP_ERROR_INVALID_VMC_DB; // this will trigger DB re-initialization        }        goto exit;    }    *value = sqlite3_column_int(stat, 0);exit:    sqlite3_finalize(stat);     return ret;}

/* --------------------------------------------------------------- */void R_sqlget( const int func ){	int col, bytes;	if (ARGN==0) {		Licpy(ARGR, sqlite3_column_count(sqlstmt));		return;	}	if (ARGN>1) Lerror(ERR_INCORRECT_CALL,0);	get_i0(1,col);	col--;	switch (sqlite3_column_type(sqlstmt, col)) {		case SQLITE_INTEGER:			Licpy(ARGR, sqlite3_column_int(sqlstmt, col));			break;		case SQLITE_FLOAT:			Lrcpy(ARGR, sqlite3_column_double(sqlstmt, col));			break;		case SQLITE_TEXT:			Lscpy(ARGR, (char*)sqlite3_column_text(sqlstmt, col));			break;		case SQLITE_BLOB:			bytes = sqlite3_column_bytes(sqlstmt, col);			Lfx(ARGR, bytes);			LLEN(*ARGR) = bytes;			LTYPE(*ARGR) = LSTRING_TY;			MEMCPY(LSTR(*ARGR), sqlite3_column_blob(sqlstmt, col), bytes);			break;		case SQLITE_NULL:			Lfx(ARGR,1);			LTYPE(*ARGR)   = LSTRING_TY;			LLEN(*ARGR)    = 1;			LSTR(*ARGR)[0] = 0;			break;		default:			Lfx(ARGR,0);			LTYPE(*ARGR) = LSTRING_TY;			LLEN(*ARGR)  = 0;	}} /* R_sqlget */

const CommonCardData* ClientDatabase::getCardData(CardId id){	auto found = _cards.find(id);	if(found == _cards.end()) // not found: create and return	{		sqlite3_reset(_getCardStmt);		sqliteThrowExcept(sqlite3_bind_int64(_getCardStmt, 1, id));		assert(sqliteThrowExcept(sqlite3_step(_getCardStmt)) == SQLITE_ROW);		CommonCardData * cardData;		if(sqlite3_column_type(_getCardStmt, 4) == SQLITE_NULL)  // Spell		{			cardData = new ClientSpellData(				id,				reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 0)),  // name				sqlite3_column_int(_getCardStmt, 1),  // cost				reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 2))  // description			);		}		else // Creature		{			cardData = new ClientCreatureData(				id,				reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 0)),  // name				sqlite3_column_int(_getCardStmt, 1),  // cost				reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 2)),  // description				sqlite3_column_int(_getCardStmt, 3),  // attack				sqlite3_column_int(_getCardStmt, 4),  // health				sqlite3_column_int(_getCardStmt, 5),  // shield				sqlite3_column_int(_getCardStmt, 6)  // shieldType			);		}		return _cards.emplace(std::make_pair<>(		                          id,		                          std::unique_ptr<CommonCardData>(cardData)		                      )).first->second.get();	}	else // card already created	{		return found->second.get();	}}

 void Experiment::deserialize(sqlite3* db) {     sqlite3_stmt *read;     db_prepare(db, read, boost::format("select "         "name, "         "paramset_id, "         "response_id, "         "train_set, "         "test_set, "         "time, "         "vcs_commit, "         "human_note, "         "machine_note, "         "batch, "         "skip, "          "flags "          "from experiment where id=%d;") % id);     db_step(read, SQLITE_ROW);     int c = 0;      name = string((const char*) sqlite3_column_text(read, c++));     paramset.id = sqlite3_column_int64(read, c++);     has_run = (sqlite3_column_type(read, c) != SQLITE_NULL);     if (has_run) {         response.id = sqlite3_column_int64(read, c++);     } else {         response.id = -1;         c++;     }     train_set = string((const char*) sqlite3_column_text(read, c++));     test_set = string((const char*) sqlite3_column_text(read, c++));     if (has_run) {         time = string((const char*) sqlite3_column_text(read, c++));         vcs_commit = string((const char*) sqlite3_column_text(read, c++));     } else {         c += 2;     }     human_note = string((const char*) sqlite3_column_text(read, c++));     machine_note = string((const char*) sqlite3_column_text(read, c++));     batch = string((const char*) sqlite3_column_text(read, c++));     skip = sqlite3_column_int(read, c++) != 0;     flags = sqlite3_column_int(read, c++);     sqlite3_finalize(read);     paramset.deserialize(db);     if (has_run) {         response.deserialize(db);     } }

LJEntry*journal_store_get_entry(JournalStore *js, int get_itemid) {	LJEntry *entry;	sqlite3_stmt *stmt = NULL;	int ret;	time_t timestamp;	SQLCHECK(sqlite3_prepare(js->db,		"SELECT anum, subject, event, moodid, mood, " /* 0-4 */		"music, pickeyword, preformatted, backdated, " /* 5-9 */ 		"comments, timestamp, security, taglist " /* 10-13 */		"FROM entry WHERE itemid=?1",		-1, &stmt, NULL));	SQLCHECK(sqlite3_bind_int(stmt, 1, get_itemid));	ret = sqlite3_step(stmt);	if (ret != SQLITE_ROW) {		SQLCHECK(sqlite3_finalize(stmt));		return NULL;	}	entry = lj_entry_new();	entry->itemid = get_itemid;	entry->anum = sqlite3_column_int(stmt, 0);	entry->subject = dup_col_or_null(stmt, 1);	entry->event = dup_col_or_null(stmt, 2);	entry->moodid = sqlite3_column_int(stmt, 3);	entry->mood = dup_col_or_null(stmt, 4);	entry->music = dup_col_or_null(stmt, 5);	entry->pickeyword = dup_col_or_null(stmt, 6);	entry->preformatted = sqlite3_column_int(stmt, 7);	entry->backdated = sqlite3_column_int(stmt, 8);	entry->comments = sqlite3_column_int(stmt, 9);	entry->taglist = dup_col_or_null(stmt, 12);	timestamp = sqlite3_column_int(stmt, 10);	gmtime_r(&timestamp, &entry->time);	if (sqlite3_column_type(stmt, 11) != SQLITE_NULL)		security_from_int(&entry->security, sqlite3_column_int(stmt, 11));	SQLCHECK(sqlite3_finalize(stmt));	return entry;}

mxArray *get_column(sqlite3_stmt *stmt, int index){    int type = sqlite3_column_type(stmt, index);    if (type == SQLITE_TEXT) {        const char *text = sqlite3_column_text(stmt, index);        return mxCreateCharMatrixFromStrings(1, &text);    } else if (type == SQLITE_FLOAT) {        return mxCreateDoubleScalar(sqlite3_column_double(stmt, index));    } else if (type == SQLITE_INTEGER) {        mxArray *a = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);        int64_t val = sqlite3_column_int64(stmt, index);        memcpy(mxGetData(a), &val, sizeof val);        return a;    }    mexErrMsgIdAndTxt("sqlite3:get_column", "unsupported column type");    return NULL;}

static JSBooljs_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;}

/** * Fetch the current branch if attached. * Return NULL if detached. * */void sg_wc_db__branch__get_branch(SG_context * pCtx,                                  sg_wc_db * pDb,                                  char ** ppszBranchName){    sqlite3_stmt * pStmt = NULL;    int rc;    SG_ERR_CHECK(  sg_sqlite__prepare(pCtx, pDb->psql, &pStmt,                                      ("SELECT"                                       "    name"	// 0                                       "  FROM tbl_branch"                                       "  WHERE id = ?"))  );    SG_ERR_CHECK(  sg_sqlite__bind_int64(pCtx, pStmt, 1, ID_KEY)  );    rc = sqlite3_step(pStmt);    switch (rc)    {    case SQLITE_ROW:        if (sqlite3_column_type(pStmt, 0) == SQLITE_NULL)            *ppszBranchName = NULL;        else            SG_ERR_CHECK(  SG_STRDUP(pCtx, (const char *)sqlite3_column_text(pStmt, 0), ppszBranchName)  );        break;    case SQLITE_DONE:        *ppszBranchName = NULL;        break;    default:        SG_ERR_THROW2(  SG_ERR_SQLITE(rc),                        (pCtx, "sg_wc_db:tbl_branch can't get branch name.")  );    }    SG_ERR_CHECK(  sg_sqlite__nullfinalize(pCtx, &pStmt)  );#if TRACE_WC_DB    SG_ERR_IGNORE(  SG_console(pCtx, SG_CS_STDERR,                               "sg_wc_db__branch__get_branch: %s/n",                               ((*ppszBranchName) ? (*ppszBranchName) : "<detached>"))  );#endif    return;fail:    SG_ERR_IGNORE(  sg_sqlite__nullfinalize(pCtx, &pStmt)  );}

EphySQLiteColumnTypeephy_sqlite_statement_get_column_type (EphySQLiteStatement *self, int column){  int column_type = sqlite3_column_type (self->priv->prepared_statement, column);  switch (column_type) {    case SQLITE_INTEGER:      return EPHY_SQLITE_COLUMN_TYPE_INT;    case SQLITE_FLOAT:      return EPHY_SQLITE_COLUMN_TYPE_FLOAT;    case SQLITE_TEXT:      return EPHY_SQLITE_COLUMN_TYPE_STRING;    case SQLITE_BLOB:      return EPHY_SQLITE_COLUMN_TYPE_BLOB;    case SQLITE_NULL:    default:      return EPHY_SQLITE_COLUMN_TYPE_NULL;  }}

/* Static */static gint_highest_logged_session_id(){  gchar *cmd = NULL;  sqlite3_stmt *stmt = NULL;  gint id = 0;  cmd = sqlite3_mprintf("select max(id) from sessionslog;");  sqlite3_prepare(ccl->db, cmd, -1, &stmt, NULL);  sqlite3_free(cmd);  if (sqlite3_step(stmt) == SQLITE_ROW &&      sqlite3_column_type(stmt, 0) != SQLITE_NULL)    id = sqlite3_column_int(stmt, 0);    sqlite3_finalize(stmt);  return id;}

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

gbooleanjournal_store_scan(JournalStore *js,                   JournalStoreScanCallback scan_cb,                   const gpointer scan_data,                   JournalStoreSummaryCallback cb_func,                   const gpointer cb_data) {	int ret;	sqlite3_stmt *stmt = NULL;	int matchcount = 0;	SQLCHECK(sqlite3_prepare(js->db,		"SELECT itemid, timestamp, subject, event, security "		"FROM entry ORDER BY itemid ASC",		-1, &stmt, NULL));	ret = sqlite3_step(stmt);	while (ret == SQLITE_ROW) {		int itemid = sqlite3_column_int(stmt, 0);		time_t timestamp = sqlite3_column_int(stmt, 1);		const char *subject = (char*)sqlite3_column_text(stmt, 2);		const char *event = (char*)sqlite3_column_text(stmt, 3);		LJSecurity sec = {0};		if (sqlite3_column_type(stmt, 4) != SQLITE_NULL)			security_from_int(&sec, sqlite3_column_int(stmt, 4));		if (scan_cb(subject, scan_data) || scan_cb(event, scan_data)) {			const char *summary = lj_get_summary(subject, event);			cb_func(itemid, timestamp, summary, &sec, cb_data);			if (++matchcount == MAX_MATCHES)				break;		}		ret = sqlite3_step(stmt);	}	if (ret != SQLITE_ROW && ret != SQLITE_DONE) {		SQLCHECK(ret);		SQLCHECK(sqlite3_finalize(stmt));		return FALSE;	}	SQLCHECK(sqlite3_finalize(stmt));	return TRUE;}

QgsPolyline QgsOSMDatabase::wayPoints( QgsOSMId id ) const{  QgsPolyline points;  // bind the way identifier  sqlite3_bind_int64( mStmtWayNodePoints, 1, id );  while ( sqlite3_step( mStmtWayNodePoints ) == SQLITE_ROW )  {    if ( sqlite3_column_type( mStmtWayNodePoints, 0 ) == SQLITE_NULL )      return QgsPolyline(); // missing some nodes    double lon = sqlite3_column_double( mStmtWayNodePoints, 0 );    double lat = sqlite3_column_double( mStmtWayNodePoints, 1 );    points.append( QgsPoint( lon, lat ) );  }  sqlite3_reset( mStmtWayNodePoints );  return points;}