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

bool SQLiteResultPrivate::fetchNext(SqlCachedResult::ValueCache &values, int idx, bool initialFetch){    int res;    int i;    if (skipRow) {        // already fetched        Q_ASSERT(!initialFetch);        skipRow = false;        for(int i=0;i<firstRow.count();i++)            values[i]=firstRow[i];        return skippedStatus;    }    skipRow = initialFetch;    if(initialFetch) {        firstRow.clear();        firstRow.resize(sqlite3_column_count(stmt));    }    if (!stmt) {        q->setLastError(QSqlError(QCoreApplication::translate("SQLiteResult", "Unable to fetch row"),                                  QCoreApplication::translate("SQLiteResult", "No query"), QSqlError::ConnectionError));        q->setAt(QSql::AfterLastRow);        return false;    }    res = sqlite3_step(stmt);    switch(res) {    case SQLITE_ROW:        // check to see if should fill out columns        if (rInf.isEmpty())            // must be first call.            initColumns(false);        if (idx < 0 && !initialFetch)            return true;        for (i = 0; i < rInf.count(); ++i) {            switch (sqlite3_column_type(stmt, i)) {            case SQLITE_BLOB:                values[i + idx] = QByteArray(static_cast<const char *>(                            sqlite3_column_blob(stmt, i)),                            sqlite3_column_bytes(stmt, i));                break;            case SQLITE_INTEGER:                values[i + idx] = sqlite3_column_int64(stmt, i);                break;            case SQLITE_FLOAT:                switch(q->numericalPrecisionPolicy()) {                    case QSql::LowPrecisionInt32:                        values[i + idx] = sqlite3_column_int(stmt, i);                        break;                    case QSql::LowPrecisionInt64:                        values[i + idx] = sqlite3_column_int64(stmt, i);                        break;                    case QSql::LowPrecisionDouble:                    case QSql::HighPrecision:                    default:                        values[i + idx] = sqlite3_column_double(stmt, i);                        break;                };                break;            case SQLITE_NULL:                values[i + idx] = QVariant(QVariant::String);                break;            default:                values[i + idx] = QString(reinterpret_cast<const QChar *>(                            sqlite3_column_text16(stmt, i)),                            sqlite3_column_bytes16(stmt, i) / sizeof(QChar));                break;            }        }        return true;    case SQLITE_DONE:        if (rInf.isEmpty())            // must be first call.            initColumns(true);        q->setAt(QSql::AfterLastRow);        sqlite3_reset(stmt);        return false;    case SQLITE_CONSTRAINT:    case SQLITE_ERROR:        // SQLITE_ERROR is a generic error code and we must call sqlite3_reset()        // to get the specific error message.        res = sqlite3_reset(stmt);        q->setLastError(qMakeError(access, QCoreApplication::translate("SQLiteResult",                        "Unable to fetch row"), QSqlError::ConnectionError, res));        q->setAt(QSql::AfterLastRow);        return false;    case SQLITE_MISUSE:    case SQLITE_BUSY:    default:        // something wrong, don't get col info, but still return false        q->setLastError(qMakeError(access, QCoreApplication::translate("SQLiteResult",                        "Unable to fetch row"), QSqlError::ConnectionError, res));        sqlite3_reset(stmt);        q->setAt(QSql::AfterLastRow);        return false;    }    return false;}

svn_boolean_tsvn_sqlite__column_boolean(svn_sqlite__stmt_t *stmt, int column){  return sqlite3_column_int64(stmt->s3stmt, column) != 0;}

static GList* daemon_data_sqlite_data_real_GetLog (DaemonDataIDataAccess* base, const gchar* channel, const gchar* server, GError** error) {	DaemonDataSqliteData * self;	GList* result = NULL;	gchar* _tmp0_;	gchar* commandText;	sqlite3_stmt* statement = NULL;	sqlite3_stmt* _tmp1_ = NULL;	gchar* _tmp2_;	gchar* _tmp3_;	gint _result_;	GList* results;	GError * _inner_error_ = NULL;	self = (DaemonDataSqliteData*) base;	g_return_val_if_fail (channel != NULL, NULL);	g_return_val_if_fail (server != NULL, NULL);	_tmp0_ = g_strdup ("SELECT * FROM Log WHERE Channel = @1 AND Server = @2 ORDER BY Timestam" /"p DESC LIMIT 50");	commandText = _tmp0_;	sqlite3_prepare_v2 (self->priv->_database, commandText, -1, &_tmp1_, NULL);	_sqlite3_finalize0 (statement);	statement = _tmp1_;	_tmp2_ = g_strdup (channel);	sqlite3_bind_text (statement, 1, _tmp2_, -1, g_free);	_tmp3_ = g_strdup (server);	sqlite3_bind_text (statement, 2, _tmp3_, -1, g_free);	_result_ = 0;	results = NULL;	{		gboolean _tmp4_;		_tmp4_ = TRUE;		while (TRUE) {			gint _tmp5_;			if (!_tmp4_) {				if (!(_result_ == SQLITE_ROW)) {					break;				}			}			_tmp4_ = FALSE;			_tmp5_ = sqlite3_step (statement);			_result_ = _tmp5_;			switch (_result_) {				case SQLITE_DONE:				{					{						break;					}				}				case SQLITE_ROW:				{					{						const gchar* _tmp6_ = NULL;						gchar* _tmp7_;						gchar* username;						const gchar* _tmp8_ = NULL;						gchar* _tmp9_;						gchar* data;						const gchar* _tmp10_ = NULL;						gchar* _tmp11_;						gchar* eventChannel;						const gchar* _tmp12_ = NULL;						gchar* _tmp13_;						gchar* eventServer;						gint64 _tmp14_;						GDateTime* _tmp15_ = NULL;						GDateTime* timestamp;						gint _tmp16_;						DaemonDataEventTypes type;						DaemonEventsLogEvent* current;						DaemonEventsLogEvent* _tmp21_;						_tmp6_ = sqlite3_column_text (statement, 0);						_tmp7_ = g_strdup (_tmp6_);						username = _tmp7_;						_tmp8_ = sqlite3_column_text (statement, 1);						_tmp9_ = g_strdup (_tmp8_);						data = _tmp9_;						_tmp10_ = sqlite3_column_text (statement, 2);						_tmp11_ = g_strdup (_tmp10_);						eventChannel = _tmp11_;						_tmp12_ = sqlite3_column_text (statement, 3);						_tmp13_ = g_strdup (_tmp12_);						eventServer = _tmp13_;						_tmp14_ = sqlite3_column_int64 (statement, 4);						_tmp15_ = daemon_helpers_date_time_converter_FromUnixTimestamp (_tmp14_);						timestamp = _tmp15_;						_tmp16_ = sqlite3_column_int (statement, 5);						type = (DaemonDataEventTypes) _tmp16_;						current = NULL;						switch (type) {							case DAEMON_DATA_EVENT_TYPES_Joined:							{								{									DaemonEventsStatusEvent* _tmp17_ = NULL;									_tmp17_ = daemon_events_status_event_new_WithTimestamp (username, DAEMON_EVENTS_STATUS_CHANGE_Join, eventChannel, eventServer, timestamp);									_g_object_unref0 (current);									current = (DaemonEventsLogEvent*) _tmp17_;									break;								}							}							case DAEMON_DATA_EVENT_TYPES_Left:							{//.........这里部分代码省略.........

long CCResultSet::longForColumnIndex(int columnIdx) {	return (long)sqlite3_column_int64(m_statement->getStatement(), columnIdx);}

/*!  /brief Load geometry (polygon BUD/PAR layers)  /return number of invalid features*/int VFKDataBlockSQLite::LoadGeometryPolygon(){    VFKReaderSQLite *poReader = (VFKReaderSQLite*) m_poReader;    VFKDataBlockSQLite *poDataBlockLines1 = NULL;    VFKDataBlockSQLite *poDataBlockLines2 = NULL;    bool bIsPar = false;    if (EQUAL (m_pszName, "PAR")) {        poDataBlockLines1 = (VFKDataBlockSQLite *) m_poReader->GetDataBlock("HP");        poDataBlockLines2 = poDataBlockLines1;        bIsPar = true;    }    else {        poDataBlockLines1 = (VFKDataBlockSQLite *) m_poReader->GetDataBlock("OB");        poDataBlockLines2 = (VFKDataBlockSQLite *) m_poReader->GetDataBlock("SBP");        bIsPar = false;    }    if( NULL == poDataBlockLines1 )    {        CPLError(CE_Warning, CPLE_FileIO,                 "Data block %s not found. Unable to build geometry for %s.",                 bIsPar ? "HP" : "OB", m_pszName);        return -1;    }    if( NULL == poDataBlockLines2 )    {        CPLError(CE_Warning, CPLE_FileIO,                 "Data block %s not found. Unable to build geometry for %s.",                 "SBP", m_pszName);        return -1;    }    poDataBlockLines1->LoadGeometry();    poDataBlockLines2->LoadGeometry();    if( LoadGeometryFromDB() )  // Try to load geometry from DB.        return 0;    const char *vrColumn[2] = { NULL, NULL };    GUIntBig vrValue[2] = { 0, 0 };    if (bIsPar) {        vrColumn[0] = "PAR_ID_1";        vrColumn[1] = "PAR_ID_2";    }    else {        vrColumn[0] = "OB_ID";        vrColumn[1] = "PORADOVE_CISLO_BODU";        vrValue[1]  = 1;    }    CPLString osSQL;    osSQL.Printf("SELECT ID,%s,rowid FROM %s", FID_COLUMN, m_pszName);    sqlite3_stmt *hStmt = poReader->PrepareStatement(osSQL.c_str());    if (poReader->IsSpatial())        poReader->ExecuteSQL("BEGIN");    VFKFeatureSQLiteList poLineList;    /* first is to be considered as exterior */    PointListArray poRingList;    std::vector<OGRLinearRing *> poLinearRingList;    OGRPolygon ogrPolygon;    int nInvalidNoLines = 0;    int nInvalidNoRings = 0;    int nGeometries = 0;    while(poReader->ExecuteSQL(hStmt) == OGRERR_NONE) {        /* read values */        const GUIntBig id = sqlite3_column_int64(hStmt, 0);        const long iFID = static_cast<long>(sqlite3_column_int64(hStmt, 1));        const int rowId = sqlite3_column_int(hStmt, 2);        VFKFeatureSQLite *poFeature =            (VFKFeatureSQLite *) GetFeatureByIndex(rowId - 1);        CPLAssert(NULL != poFeature && poFeature->GetFID() == iFID);        if( bIsPar )        {            vrValue[0] = vrValue[1] = id;            poLineList = poDataBlockLines1->GetFeatures(vrColumn, vrValue, 2);        }        else        {            // std::vector<VFKFeatureSQLite *> poLineListOb;            osSQL.Printf("SELECT ID FROM %s WHERE BUD_ID = " CPL_FRMT_GUIB,                         poDataBlockLines1->GetName(), id);            if (poReader->IsSpatial()) {                CPLString osColumn;                osColumn.Printf(" AND %s IS NULL", GEOM_COLUMN);                osSQL += osColumn;            }            sqlite3_stmt *hStmtOb = poReader->PrepareStatement(osSQL.c_str());//.........这里部分代码省略.........

Track* TrackDAOSqlite3Impl::getTrack( Track* criterion ) {	Track* track = NULL;	Artist* artist_criterion;	Album* album_criterion;	int column = 0;	QueryCriteriaList queryCriteriaList;	std::string* sql;	checkDb();	if( criterion != NULL ) {		if( criterion->id >= 0 ) {			QueryCriteria qc = {"TrackId", ":trackid", QueryCriteria::LONG};			qc.value = &criterion->id;			queryCriteriaList.push_back(qc);		}		if( !criterion->filename.empty() ) {			QueryCriteria qc = {"Filename", ":filename", QueryCriteria::TEXT};			qc.value = criterion->filename.c_str();			queryCriteriaList.push_back(qc);		}		if( !criterion->name.empty() ) {			QueryCriteria qc = {"Name", ":name", QueryCriteria::TEXT};			qc.value = criterion->name.c_str();			queryCriteriaList.push_back(qc);		}		if( !criterion->artFilename.empty() ) {			QueryCriteria qc = {"Art_Filename", ":artfilename", QueryCriteria::TEXT};			qc.value = criterion->artFilename.c_str();			queryCriteriaList.push_back(qc);		}		if( criterion->artist && criterion->artist->id >= 0 ) {			QueryCriteria qc = {"ArtistId", ":artistid", QueryCriteria::LONG};			qc.value = &criterion->artist->id;			queryCriteriaList.push_back(qc);		}		if( criterion->album && criterion->album->artist && criterion->album->artist->id >= 0 ) {			QueryCriteria qc = {"AlbumArtistId", ":albumartistid", QueryCriteria::LONG};			qc.value = &criterion->album->artist->id;			queryCriteriaList.push_back(qc);		}		if( criterion->album && criterion->album->id >= 0 ) {			QueryCriteria qc = {"AlbumId", ":albumid", QueryCriteria::LONG};			qc.value = &criterion->album->id;			queryCriteriaList.push_back(qc);		}		if( criterion->discNumber > 0 ) {			QueryCriteria qc = {"DiscNumber", ":discnumber", QueryCriteria::INT};			qc.value = &criterion->discNumber;			queryCriteriaList.push_back(qc);		}		if( criterion->trackNumber > 0 ) {			QueryCriteria qc = {"TrackNumber", ":tracknumber", QueryCriteria::INT};			qc.value = &criterion->trackNumber;			queryCriteriaList.push_back(qc);		}		if( criterion->replayGain > -99.0 ) {			QueryCriteria qc = {"ReplayGain", ":replaygain", QueryCriteria::DOUBLE};			qc.value = &criterion->replayGain;			queryCriteriaList.push_back(qc);		}	}	sql = buildSqlFromQueryCriteria( "Tracks", queryCriteriaList );	sqlite3_stmt* pStmt = prepare( sql->c_str() );	bindVariablesFromQueryCriteria( pStmt, queryCriteriaList );	if( step( pStmt ) == SQLITE_ROW ) {		track = new Track();		artist_criterion = new Artist();		album_criterion = new Album();		album_criterion->artist = new Artist();		track->id = sqlite3_column_int64( pStmt, column++ );		track->filename.assign( (const char*) sqlite3_column_text( pStmt, column++ ) );		column++; //track->checksum.assign( (const char*)sqlite3_column_text( pStmt, column++;  ) );		track->name.assign( (const char*) sqlite3_column_text( pStmt, column++ ) );		track->artFilename.assign( (const char*) sqlite3_column_text( pStmt, column++ ) );		artist_criterion->id = sqlite3_column_int64( pStmt, column++ );		album_criterion->artist->id = sqlite3_column_int64( pStmt, column++ );		album_criterion->id = sqlite3_column_int64( pStmt, column++ );		track->trackNumber = sqlite3_column_int( pStmt, column++ );		track->discNumber = sqlite3_column_int( pStmt, column++ );		track->replayGain = sqlite3_column_double( pStmt, column++ );		if( artist_criterion->id >= 0 ) {			track->artist = artistDAO->getArtist( artist_criterion );		}		if( album_criterion->id >= 0 ) {			track->album = albumDAO->getAlbum( album_criterion );		}		delete album_criterion->artist;		delete album_criterion;		delete artist_criterion;	}	finalize( pStmt );	delete sql;	return track;//.........这里部分代码省略.........

//.........这里部分代码省略.........	sqlite3_bind_text(stmt_pkg, 2, pkg_get(pkg, PKG_NAME), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 3, pkg_get(pkg, PKG_VERSION), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 4, pkg_get(pkg, PKG_COMMENT), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 5, pkg_get(pkg, PKG_DESC), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 6, pkg_get(pkg, PKG_MTREE), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 7, pkg_get(pkg, PKG_MESSAGE), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 8, pkg_get(pkg, PKG_ARCH), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 9, pkg_get(pkg, PKG_OSVERSION), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 10, pkg_get(pkg, PKG_MAINTAINER), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 11, pkg_get(pkg, PKG_WWW), -1, SQLITE_STATIC);	sqlite3_bind_text(stmt_pkg, 12, pkg_get(pkg, PKG_PREFIX), -1, SQLITE_STATIC);	sqlite3_bind_int64(stmt_pkg, 13, pkg_flatsize(pkg));	if ((ret = sqlite3_step(stmt_pkg)) != SQLITE_DONE) {		if ( ret == SQLITE_CONSTRAINT)			retcode = pkg_error_set(EPKG_FATAL, "constraint violation on "					"pkg with %s", pkg_get(pkg, PKG_ORIGIN));		else			retcode = ERROR_SQLITE(s);		goto cleanup;	}	/*	 * Get the generated package_id	 */	if (sqlite3_prepare_v2(s, sql_sel_pkg, -1, &stmt_sel_pkg, NULL) != SQLITE_OK) {		retcode = ERROR_SQLITE(s);		goto cleanup;	}	sqlite3_bind_text(stmt_sel_pkg, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);	ret = sqlite3_step(stmt_sel_pkg);	if (ret == SQLITE_ROW) {		package_id = sqlite3_column_int64(stmt_sel_pkg, 0);		ret = SQLITE_DONE;	} else {		retcode = ERROR_SQLITE(s);		goto cleanup;	}	/*	 * Insert dependencies list	 */	if (sqlite3_prepare_v2(s, sql_dep, -1, &stmt_dep, NULL) != SQLITE_OK) {		retcode = ERROR_SQLITE(s);		goto cleanup;	}	deps = pkg_deps(pkg);	for (i = 0; deps[i] != NULL; i++) {		sqlite3_bind_text(stmt_dep, 1, pkg_get(deps[i], PKG_ORIGIN), -1, SQLITE_STATIC);		sqlite3_bind_text(stmt_dep, 2, pkg_get(deps[i], PKG_NAME), -1, SQLITE_STATIC);		sqlite3_bind_text(stmt_dep, 3, pkg_get(deps[i], PKG_VERSION), -1, SQLITE_STATIC);		sqlite3_bind_int64(stmt_dep, 4, package_id);		if ((ret = sqlite3_step(stmt_dep)) != SQLITE_DONE) {			if ( ret == SQLITE_CONSTRAINT)				retcode = pkg_error_set(EPKG_FATAL, "constraint violation on "						"deps with %s", pkg_get(deps[i], PKG_ORIGIN));			else				retcode = ERROR_SQLITE(s);			goto cleanup;		}

DatabaseResult Database::exec(const String sqlStmt){	DatabaseColumn dbCol;	DatabaseRow dbRow;	DatabaseResult dbRes;	if(sqliteStatus != SQLITE_OK)		throw DatabaseNotOpenException() << DebugInfo(TRACE(), DebugInfo::Error);	sqliteStatus = sqlite3_prepare_v2(db, sqlStmt.data(),		-1, &dbStmt, NULL);	if(sqliteStatus != SQLITE_OK)		throw DatabaseStatementInvalidException() << DebugInfo(String(sqlStmt) << "/n/"" << sqlite3_errmsg(db) << "/"/n" << TRACE(), DebugInfo::Error);	int iCol = 0, colType = -1;	int colCount = sqlite3_column_count(dbStmt);	int stepRet = sqlite3_step(dbStmt);	bool isNoResult = true;	if(stepRet == SQLITE_ROW)		isNoResult = false;	while(stepRet == SQLITE_ROW)	{		for(iCol=0; iCol<colCount; ++iCol)		{			colType = sqlite3_column_type(dbStmt, iCol);			if(colType == SQLITE_INTEGER)			{				dbCol = DatabaseColumn(sqlite3_column_int(dbStmt, iCol));				dbCol.setInt64Data(sqlite3_column_int64(dbStmt, iCol));			}			else if(colType == SQLITE_FLOAT)			{				dbCol = DatabaseColumn(sqlite3_column_double(dbStmt, iCol));			}			else if(colType == SQLITE_TEXT)			{				dbCol = DatabaseColumn(String(sqlite3_column_text(dbStmt, iCol)));			}			else if(colType == SQLITE_BLOB)			{				dbCol = DatabaseColumn((unsigned char*)sqlite3_column_blob(dbStmt, iCol));			}			else if(colType == SQLITE_NULL)			{				dbCol = DatabaseColumn(true);			}			dbRow.addColumn(dbCol);		}		dbRes.addRowData(dbRow);		dbRow = DatabaseRow();		stepRet = sqlite3_step(dbStmt);	}	sqlite3_finalize(dbStmt);	if(stepRet != SQLITE_DONE)		throw DatabaseResultNotDoneException() << DebugInfo(sqlite3_errmsg(db) << TRACE(), DebugInfo::Error);	if(isNoResult == true)		dbRes.setRowChanged(sqlite3_changes(db));	return dbRes;}

bool QgsSpatiaLiteFeatureIterator::getFeature( sqlite3_stmt *stmt, QgsFeature &feature ){  bool subsetAttributes = mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes;  int ret = sqlite3_step( stmt );  if ( ret == SQLITE_DONE )  {    // there are no more rows to fetch    return false;  }  if ( ret != SQLITE_ROW )  {    // some unexpected error occurred    QgsMessageLog::logMessage( QObject::tr( "SQLite error getting feature: %1" ).arg( QString::fromUtf8( sqlite3_errmsg( mHandle->handle() ) ) ), QObject::tr( "SpatiaLite" ) );    return false;  }  // one valid row has been fetched from the result set  if ( !mFetchGeometry )  {    // no geometry was required    feature.setGeometryAndOwnership( 0, 0 );  }  feature.initAttributes( mSource->mFields.count() );  feature.setFields( &mSource->mFields ); // allow name-based attribute lookups  int ic;  int n_columns = sqlite3_column_count( stmt );  for ( ic = 0; ic < n_columns; ic++ )  {    if ( ic == 0 )    {      // first column always contains the ROWID (or the primary key)      QgsFeatureId fid = sqlite3_column_int64( stmt, ic );      QgsDebugMsgLevel( QString( "fid=%1" ).arg( fid ), 3 );      feature.setFeatureId( fid );    }    else if ( mFetchGeometry && ic == mGeomColIdx )    {      getFeatureGeometry( stmt, ic, feature );    }    else    {      if ( subsetAttributes )      {        if ( ic <= mRequest.subsetOfAttributes().size() )        {          int attrIndex = mRequest.subsetOfAttributes()[ic-1];          feature.setAttribute( attrIndex, getFeatureAttribute( stmt, ic, mSource->mFields[attrIndex].type() ) );        }      }      else      {        int attrIndex = ic - 1;        feature.setAttribute( attrIndex, getFeatureAttribute( stmt, ic, mSource->mFields[attrIndex].type() ) );      }    }  }  return true;}

intpkgdb_it_next(struct pkgdb_it *it, struct pkg **pkg_p, int flags){	struct pkg *pkg;	int ret;	if (it == NULL)		return (ERROR_BAD_ARG("it"));	switch (sqlite3_step(it->stmt)) {	case SQLITE_ROW:		if (*pkg_p == NULL)			pkg_new(pkg_p, PKG_INSTALLED);		else			pkg_reset(*pkg_p, PKG_INSTALLED);		pkg = *pkg_p;		pkg->rowid = sqlite3_column_int64(it->stmt, 0);		pkg_set(pkg, PKG_ORIGIN, sqlite3_column_text(it->stmt, 1));		pkg_set(pkg, PKG_NAME, sqlite3_column_text(it->stmt, 2));		pkg_set(pkg, PKG_VERSION, sqlite3_column_text(it->stmt, 3));		pkg_set(pkg, PKG_COMMENT, sqlite3_column_text(it->stmt, 4));		pkg_set(pkg, PKG_DESC, sqlite3_column_text(it->stmt, 5));		pkg_set(pkg, PKG_MESSAGE, sqlite3_column_text(it->stmt, 6));		pkg_set(pkg, PKG_ARCH, sqlite3_column_text(it->stmt, 7));		pkg_set(pkg, PKG_OSVERSION, sqlite3_column_text(it->stmt, 8));		pkg_set(pkg, PKG_MAINTAINER, sqlite3_column_text(it->stmt, 9));		pkg_set(pkg, PKG_WWW, sqlite3_column_text(it->stmt, 10));		pkg_set(pkg, PKG_PREFIX, sqlite3_column_text(it->stmt, 11));		pkg_setflatsize(pkg, sqlite3_column_int64(it->stmt, 12));		if (it->type == IT_UPGRADE) {			pkg->type = PKG_UPGRADE;			pkg_set(pkg, PKG_NEWVERSION, sqlite3_column_text(it->stmt, 13));			pkg_setnewflatsize(pkg, sqlite3_column_int64(it->stmt, 14));			pkg_setnewpkgsize(pkg, sqlite3_column_int64(it->stmt, 15));			pkg_set(pkg, PKG_REPOPATH, sqlite3_column_text(it->stmt, 16));		}		if (flags & PKG_LOAD_DEPS)			if ((ret = pkgdb_loaddeps(it->db, pkg)) != EPKG_OK)				return (ret);		if (flags & PKG_LOAD_RDEPS)			if ((ret = pkgdb_loadrdeps(it->db, pkg)) != EPKG_OK)				return (ret);		if (flags & PKG_LOAD_CONFLICTS)			if ((ret = pkgdb_loadconflicts(it->db, pkg)) != EPKG_OK)				return (ret);		if (flags & PKG_LOAD_FILES)			if ((ret = pkgdb_loadfiles(it->db, pkg)) != EPKG_OK)				return (ret);		if (flags & PKG_LOAD_SCRIPTS)			if ((ret = pkgdb_loadscripts(it->db, pkg)) != EPKG_OK)				return (ret);		if (flags & PKG_LOAD_OPTIONS)			if ((ret = pkgdb_loadoptions(it->db, pkg)) != EPKG_OK)				return (ret);		if (flags & PKG_LOAD_MTREE)			if ((ret = pkgdb_loadmtree(it->db, pkg)) != EPKG_OK)				return (ret);		return (EPKG_OK);	case SQLITE_DONE:		return (EPKG_END);	default:		return (ERROR_SQLITE(it->db->sqlite));	}}

int overlay_rhizome_add_advertisements(int interface_number,overlay_buffer *e){  int pass;  int bytes=e->sizeLimit-e->length;  int overhead=1+8+1+3+1+1+1; /* maximum overhead */  int slots=(bytes-overhead)/RHIZOME_BAR_BYTES;  if (slots>30) slots=30;  int slots_used=0;  int bytes_used=0;  int bytes_available=bytes-overhead-1 /* one byte held for expanding RFS */;  int bundles_advertised=0;  if (slots<1) return WHY("No room for node advertisements");  if (!rhizome_db) return WHY("Rhizome not enabled");  if (ob_append_byte(e,OF_TYPE_RHIZOME_ADVERT))    return WHY("could not add rhizome bundle advertisement header");  ob_append_byte(e,1); /* TTL */  int rfs_offset=e->length; /* remember where the RFS byte gets stored 			       so that we can patch it later */  ob_append_byte(e,1+8+1+1+1+RHIZOME_BAR_BYTES*slots_used/* RFS */);  /* Stuff in dummy address fields */  ob_append_byte(e,OA_CODE_BROADCAST);  { int i; for(i=0;i<8;i++) ob_append_byte(e,random()&0xff); } /* BPI for broadcast */  ob_append_byte(e,OA_CODE_PREVIOUS);  ob_append_byte(e,OA_CODE_SELF);  /* Randomly choose whether to advertise manifests or BARs first. */  int skipmanifests=random()&1;  /* Version of rhizome advert block:     1 = manifests then BARs,     2 = BARs only */  ob_append_byte(e,1+skipmanifests);  /* XXX Should add priority bundles here.     XXX Should prioritise bundles for subscribed groups, Serval-authorised files     etc over common bundles.     XXX Should wait a while after going through bundle list so that we don't waste     CPU on db queries if there are not many bundles.  Actually, we probably just     shouldn't be sending bundles blindly on every tick.     XXX How do we indicate group membership with BARs? Or do groups actively poll?  */    if (debug&DEBUG_RHIZOME)    WHY("Group handling not completely thought out here yet.");  /* Get number of bundles available if required */  bundles_available=sqlite_exec_int64("SELECT COUNT(BAR) FROM MANIFESTS;");  if (bundles_available==-1||(bundle_offset[0]>=bundles_available))     bundle_offset[0]=0;  if (bundles_available==-1||(bundle_offset[1]>=bundles_available))     bundle_offset[1]=0;    for(pass=skipmanifests;pass<2;pass++)    {      sqlite3_stmt *statement;      char query[1024];      switch(pass) {      case 0: /* Full manifests */	snprintf(query,1024,"SELECT MANIFEST,ROWID FROM MANIFESTS LIMIT %d,%d",		 bundle_offset[pass],slots);	break;      case 1: /* BARs */	snprintf(query,1024,"SELECT BAR,ROWID FROM MANIFESTS LIMIT %d,%d",		 bundle_offset[pass],slots);	break;      }            switch (sqlite3_prepare_v2(rhizome_db,query,-1,&statement,NULL))	{	case SQLITE_OK: case SQLITE_DONE: case SQLITE_ROW:	  break;	default:	  sqlite3_finalize(statement);	  sqlite3_close(rhizome_db);	  rhizome_db=NULL;	  WHY(query);	  WHY(sqlite3_errmsg(rhizome_db));	  return WHY("Could not prepare sql statement for fetching BARs for advertisement.");	}      while((bytes_used<bytes_available)&&(sqlite3_step(statement)==SQLITE_ROW)&&	    (e->length+RHIZOME_BAR_BYTES<=e->sizeLimit))	{	  sqlite3_blob *blob;	  int column_type=sqlite3_column_type(statement, 0);	  switch(column_type) {	  case SQLITE_BLOB:	    if (sqlite3_blob_open(rhizome_db,"main","manifests",				  pass?"bar":"manifest",				  sqlite3_column_int64(statement,1) /* rowid */,				  0 /* read only */,&blob)!=SQLITE_OK)	      {		WHY("Couldn't open blob");		continue;	      }	    int blob_bytes=sqlite3_blob_bytes(blob);	    if (pass&&(blob_bytes!=RHIZOME_BAR_BYTES)) {	      if (debug&DEBUG_RHIZOME) //.........这里部分代码省略.........

 sqlite3_int64 Query::ColumnInt64(int index) {     return sqlite3_column_int64(statement, index); }

static int fulltextRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){  fulltext_cursor *c = (fulltext_cursor *) pCursor;  *pRowid = sqlite3_column_int64(c->pStmt, 0);  return SQLITE_OK;}

int database::fillTable(sqlite3_stmt* stmt, DBDataTable* dataTable){    int numColumns = sqlite3_column_count(stmt);    dataTable->setColumnCount(numColumns);    int addedRows = 0;    while (1) {        int err = sqlite3_step(stmt);        if (err == SQLITE_ROW) {            dataTable->addRow();            for (int i = 0; i < numColumns; i++) {                int type = sqlite3_column_type(stmt, i);                if (type == SQLITE_TEXT) {                    // TEXT data                    dataTable->setColumnType(i, DBDataType_String);                    const char* text = reinterpret_cast<const char*>(sqlite3_column_text(stmt, i));                    size_t sizeIncludingNull = sqlite3_column_bytes(stmt, i) + 1;                    if (!dataTable->putString(addedRows, i, text, sizeIncludingNull)) {                        // NCDBH_SQL_LOGD("Failed allocating %u bytes for text at %d,%d", sizeIncludingNull, addedRows, i);                        std::cout << "failed allocating bytes/n";                        break;                    }                    // NCDBH_SQL_LOGD("%d,%d is TEXT with %u bytes", addedRows, i, sizeIncludingNull);                }                else if (type == SQLITE_INTEGER) {                    // INTEGER data                    dataTable->setColumnType(i, DBDataType_Integer);                    int64_t value = sqlite3_column_int64(stmt, i);                    if (!dataTable->putLong(addedRows, i, value)) {                        // NCDBH_SQL_LOGD("Failed allocating space for a long in column %d", i);                        break;                    }                    // NCDBH_SQL_LOGD("%d,%d is INTEGER 0x%016llx", addedRows, i, value);                }                else if (type == SQLITE_FLOAT) {                    // FLOAT data                    dataTable->setColumnType(i, DBDataType_Float);                    double value = sqlite3_column_double(stmt, i);                    if (!dataTable->putDouble(addedRows, i, value)) {                        // NCDBH_SQL_LOGD("Failed allocating space for a double in column %d", i);                        break;                    }                    // NCDBH_SQL_LOGD("%d,%d is FLOAT %lf", addedRows, i, value);                }                else if (type == SQLITE_BLOB) {                    // BLOB data                    dataTable->setColumnType(i, DBDataType_Blob);                    const void* blob = sqlite3_column_blob(stmt, i);                    size_t size = sqlite3_column_bytes(stmt, i);                    if (!dataTable->putBlob(addedRows, i, blob, size)) {                        // NCDBH_SQL_LOGD("Failed allocating %u bytes for blob at %d,%d", size, addedRows, i);                        break;                    }                    // NCDBH_SQL_LOGD("%d,%d is Blob with %u bytes", addedRows, i, size);                }                else if (type == SQLITE_NULL) {                    // NULL field                    dataTable->setColumnType(i, DBDataType_Null);                    if (!dataTable->putNull(addedRows, i)) {                        // NCDBH_SQL_LOGD("Failed allocating space for a null in column %d", i);                        break;                    }                    // NCDBH_SQL_LOGD("%d,%d is NULL", addedRows, i);                }                else {                    // Unknown data                    // NCDBH_SQL_LOGE("Unknown column type when filling database data table");                    std::cout << "Unknown column type when filling database data table";                    break;                }            }            addedRows++;        }        else if (err == SQLITE_DONE) {            // complete!            std::cout << "complete!/n";            break;        }        else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) {            // retry?            break;        }        else {            // exception?            std::cout << "query error with : " << err << "/n";            break;        }    }    return addedRows;}

DWORDSamDbGetObjectRecordInfoBySID_inlock(    PSAM_DIRECTORY_CONTEXT pDirectoryContext,    PCSTR                  pszObjectSID,    PLONG64                pllObjectRecordId,    SAMDB_OBJECT_CLASS*    pObjectClass    ){    DWORD dwError = 0;    sqlite3_stmt* pSqlStatement = NULL;    LONG64   llObjectRecordId = 0;    SAMDB_OBJECT_CLASS objectClass = SAMDB_OBJECT_CLASS_UNKNOWN;    BAIL_ON_INVALID_POINTER(pszObjectSID);    if (!pDirectoryContext->pDbContext->pQueryObjectRecordInfoStmt)    {        PCSTR pszQueryTemplate = "SELECT " SAM_DB_COL_RECORD_ID "," /                                           SAM_DB_COL_OBJECT_CLASS  /                                 "  FROM " SAM_DB_OBJECTS_TABLE     /                                 " WHERE " SAM_DB_COL_OBJECT_SID " = ?1";        dwError = sqlite3_prepare_v2(                        pDirectoryContext->pDbContext->pDbHandle,                        pszQueryTemplate,                        -1,                        &pDirectoryContext->pDbContext->pQueryObjectRecordInfoStmt,                        NULL);        BAIL_ON_SAMDB_SQLITE_ERROR_DB(                        dwError,                        pDirectoryContext->pDbContext->pDbHandle);    }    pSqlStatement = pDirectoryContext->pDbContext->pQueryObjectRecordInfoStmt;    dwError = sqlite3_bind_text(                    pSqlStatement,                    1,                    pszObjectSID,                    -1,                    SQLITE_TRANSIENT);    BAIL_ON_SAMDB_SQLITE_ERROR_STMT(dwError, pSqlStatement);    if ((dwError = sqlite3_step(pSqlStatement) == SQLITE_ROW))    {        if (sqlite3_column_count(pSqlStatement) != 2)        {            dwError = LW_ERROR_DATA_ERROR;            BAIL_ON_SAMDB_ERROR(dwError);        }        llObjectRecordId = sqlite3_column_int64(                                pSqlStatement,                                0);        objectClass = sqlite3_column_int(                                pSqlStatement,                                1);        dwError = LW_ERROR_SUCCESS;    }    else if (dwError == SQLITE_DONE)    {        dwError = LW_ERROR_NO_SUCH_OBJECT;    }    BAIL_ON_SAMDB_SQLITE_ERROR_STMT(dwError, pSqlStatement);    *pllObjectRecordId = llObjectRecordId;    *pObjectClass = objectClass;cleanup:    if (pDirectoryContext->pDbContext->pQueryObjectRecordInfoStmt)    {        sqlite3_reset(pDirectoryContext->pDbContext->pQueryObjectRecordInfoStmt);    }    return dwError;error:    *pllObjectRecordId = 0;    *pObjectClass = SAMDB_OBJECT_CLASS_UNKNOWN;    goto cleanup;}

/*!  /brief Load geometry from DB  /return true if geometry successfully loaded otherwise false*/bool VFKDataBlockSQLite::LoadGeometryFromDB(){    VFKReaderSQLite *poReader = (VFKReaderSQLite*) m_poReader;    if (!poReader->IsSpatial())   /* check if DB is spatial */        return false;    CPLString osSQL;    osSQL.Printf("SELECT num_geometries FROM %s WHERE table_name = '%s'",                 VFK_DB_TABLE, m_pszName);    sqlite3_stmt *hStmt = poReader->PrepareStatement(osSQL.c_str());    if (poReader->ExecuteSQL(hStmt) != OGRERR_NONE)        return false;    const int nGeometries = sqlite3_column_int(hStmt, 0);    sqlite3_finalize(hStmt);    if( nGeometries < 1 )        return false;    const bool bSkipInvalid =        EQUAL(m_pszName, "OB") ||        EQUAL(m_pszName, "OP") ||        EQUAL(m_pszName, "OBBP");    /* load geometry from DB */    osSQL.Printf("SELECT %s,rowid,%s FROM %s ",                 GEOM_COLUMN, FID_COLUMN, m_pszName);    if (EQUAL(m_pszName, "SBP"))        osSQL += "WHERE PORADOVE_CISLO_BODU = 1 ";    osSQL += "ORDER BY ";    osSQL += FID_COLUMN;    hStmt = poReader->PrepareStatement(osSQL.c_str());    int rowId = 0;    int nInvalid = 0;    int nGeometriesCount = 0;    while(poReader->ExecuteSQL(hStmt) == OGRERR_NONE) {        rowId++; // =sqlite3_column_int(hStmt, 1);#ifdef DEBUG        const GIntBig iFID = sqlite3_column_int64(hStmt, 2);#endif        VFKFeatureSQLite *poFeature = (VFKFeatureSQLite *) GetFeatureByIndex(rowId - 1);        CPLAssert(NULL != poFeature && poFeature->GetFID() == iFID);        // read geometry from DB        const int nBytes = sqlite3_column_bytes(hStmt, 0);        OGRGeometry *poGeometry = NULL;        if (nBytes > 0 &&            OGRGeometryFactory::createFromWkb((GByte*) sqlite3_column_blob(hStmt, 0),                                              NULL, &poGeometry, nBytes) == OGRERR_NONE) {            nGeometriesCount++;            if (!poFeature->SetGeometry(poGeometry)) {                nInvalid++;            }            delete poGeometry;        }        else {            nInvalid++;        }    }    CPLDebug("OGR-VFK", "%s: %d geometries loaded from DB",             m_pszName, nGeometriesCount);    if (nGeometriesCount != nGeometries) {        CPLError(CE_Warning, CPLE_AppDefined,                 "%s: %d geometries loaded (should be %d)",                 m_pszName, nGeometriesCount, nGeometries);    }    if (nInvalid > 0 && !bSkipInvalid) {        CPLError(CE_Warning, CPLE_AppDefined,                 "%s: %d features with invalid or empty geometry",                 m_pszName, nInvalid);    }    return true;}

const char *dbop3_first(DBOP *dbop, const char *name, regex_t *preg, int flags) {	int rc;	char *key;	STRBUF *sql = strbuf_open_tempbuf();	dbop->done = 0; 	/* This is turned on when it receives SQLITE_DONE. */	strbuf_puts(sql, "select rowid, * from ");	strbuf_puts(sql, dbop->tblname);	if (name) {		strbuf_puts(sql, " where key ");		if (dbop->ioflags & DBOP_PREFIX) {			/*			 * In sqlite3, 'like' ignores case. 'glob' does not ignore case.			 */			strbuf_puts(sql, "glob '");			strbuf_puts(sql, name);			strbuf_puts(sql, "*'");		} else {			strbuf_puts(sql, "= '");			strbuf_puts(sql, name);			strbuf_puts(sql, "'");		}		strlimcpy(dbop->key, name, sizeof(dbop->key));		dbop->keylen = strlen(name);	}	strbuf_puts(sql, " order by key");	if (dbop->stmt) {		rc = sqlite3_finalize(dbop->stmt);		if (rc != SQLITE_OK)			die("dbop3_finalize failed. (rc = %d)", rc);		dbop->stmt = NULL;	}	rc = sqlite3_prepare_v2(dbop->db3, strbuf_value(sql), -1, &dbop->stmt, NULL);	if (rc != SQLITE_OK)		die("dbop3_first: sqlite3_prepare_v2 failed. (rc = %d)", rc);	/*	 *	0: rowid	 *	1: key	 *	2: dat	 *	3: flags	 */	for (;;) {		/* Once it receives SQLITE_DONE, do not never return value */		if (dbop->done)			return NULL;		rc = sqlite3_step(dbop->stmt);		if (rc == SQLITE_DONE)			goto finish;		else if (rc == SQLITE_ROW) {			dbop->readcount++;			dbop->lastrowid = sqlite3_column_int64(dbop->stmt, 0);			key = (char *)sqlite3_column_text(dbop->stmt, 1);			if (name) {				if (dbop->ioflags & DBOP_PREFIX) {					if (strncmp(key, dbop->key, dbop->keylen))						goto finish;				} else {					if (strcmp(key, dbop->key)) 						goto finish;				}				if (dbop->preg && regexec(dbop->preg, key, 0, 0, 0) != 0)					continue;			} else {				/* skip meta records */				if (ismeta(key) && !(dbop->openflags & DBOP_RAW))					continue;				if (dbop->preg && regexec(dbop->preg, key, 0, 0, 0) != 0)					continue;			}			break;		} else {			die("dbop3_first: something is wrong (rc = %d).", rc);		}	}	strbuf_clear(dbop->sb);	strbuf_puts0(dbop->sb, (char *)sqlite3_column_text(dbop->stmt, 2));	dbop->lastsize = strbuf_getlen(dbop->sb) - 1;	dbop->lastflag = (char *)sqlite3_column_text(dbop->stmt, 3);	if (dbop->lastflag)		strbuf_puts(dbop->sb, dbop->lastflag);	dbop->lastdat = strbuf_value(dbop->sb);	if (dbop->lastflag)		dbop->lastflag = dbop->lastdat + dbop->lastsize + 1;	dbop->lastkey = key;	dbop->lastkeysize = strlen(dbop->lastkey);	strbuf_release_tempbuf(sql);	if (flags & DBOP_KEY) {		strlimcpy(dbop->prev, key, sizeof(dbop->prev));		return key;	}	return dbop->lastdat;finish:	strbuf_release_tempbuf(sql);	dbop->done = 1;	dbop->lastdat = NULL;	dbop->lastsize = 0;	dbop->lastflag = NULL;	return dbop->lastdat;}

/*** Check that the contents of the FTS index match that of the %_content** table. Return SQLITE_OK if they do, or SQLITE_CORRUPT if not. Return** some other SQLite error code if an error occurs while attempting to** determine this.*/int sqlite3Fts5StorageIntegrity(Fts5Storage *p){  Fts5Config *pConfig = p->pConfig;  int rc;                         /* Return code */  int *aColSize;                  /* Array of size pConfig->nCol */  i64 *aTotalSize;                /* Array of size pConfig->nCol */  Fts5IntegrityCtx ctx;  sqlite3_stmt *pScan;  memset(&ctx, 0, sizeof(Fts5IntegrityCtx));  ctx.pConfig = p->pConfig;  aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64)));  if( !aTotalSize ) return SQLITE_NOMEM;  aColSize = (int*)&aTotalSize[pConfig->nCol];  memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);  /* Generate the expected index checksum based on the contents of the  ** %_content table. This block stores the checksum in ctx.cksum. */  rc = fts5StorageGetStmt(p, FTS5_STMT_SCAN, &pScan, 0);  if( rc==SQLITE_OK ){    int rc2;    while( SQLITE_ROW==sqlite3_step(pScan) ){      int i;      ctx.iRowid = sqlite3_column_int64(pScan, 0);      ctx.szCol = 0;      if( pConfig->bColumnsize ){        rc = sqlite3Fts5StorageDocsize(p, ctx.iRowid, aColSize);      }      if( rc==SQLITE_OK && pConfig->eDetail==FTS5_DETAIL_NONE ){        rc = sqlite3Fts5TermsetNew(&ctx.pTermset);      }      for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){        if( pConfig->abUnindexed[i] ) continue;        ctx.iCol = i;        ctx.szCol = 0;        if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){          rc = sqlite3Fts5TermsetNew(&ctx.pTermset);        }        if( rc==SQLITE_OK ){          rc = sqlite3Fts5Tokenize(pConfig,               FTS5_TOKENIZE_DOCUMENT,              (const char*)sqlite3_column_text(pScan, i+1),              sqlite3_column_bytes(pScan, i+1),              (void*)&ctx,              fts5StorageIntegrityCallback          );        }        if( rc==SQLITE_OK && pConfig->bColumnsize && ctx.szCol!=aColSize[i] ){          rc = FTS5_CORRUPT;        }        aTotalSize[i] += ctx.szCol;        if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){          sqlite3Fts5TermsetFree(ctx.pTermset);          ctx.pTermset = 0;        }      }      sqlite3Fts5TermsetFree(ctx.pTermset);      ctx.pTermset = 0;      if( rc!=SQLITE_OK ) break;    }    rc2 = sqlite3_reset(pScan);    if( rc==SQLITE_OK ) rc = rc2;  }  /* Test that the "totals" (sometimes called "averages") record looks Ok */  if( rc==SQLITE_OK ){    int i;    rc = fts5StorageLoadTotals(p, 0);    for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){      if( p->aTotalSize[i]!=aTotalSize[i] ) rc = FTS5_CORRUPT;    }  }  /* Check that the %_docsize and %_content tables contain the expected  ** number of rows.  */  if( rc==SQLITE_OK && pConfig->eContent==FTS5_CONTENT_NORMAL ){    i64 nRow = 0;    rc = fts5StorageCount(p, "content", &nRow);    if( rc==SQLITE_OK && nRow!=p->nTotalRow ) rc = FTS5_CORRUPT;  }  if( rc==SQLITE_OK && pConfig->bColumnsize ){    i64 nRow = 0;    rc = fts5StorageCount(p, "docsize", &nRow);    if( rc==SQLITE_OK && nRow!=p->nTotalRow ) rc = FTS5_CORRUPT;  }  /* Pass the expected checksum down to the FTS index module. It will  ** verify, amongst other things, that it matches the checksum generated by  ** inspecting the index itself.  */  if( rc==SQLITE_OK ){    rc = sqlite3Fts5IndexIntegrityCheck(p->pIndex, ctx.cksum);  }  sqlite3_free(aTotalSize);//.........这里部分代码省略.........

const char *dbop3_next(DBOP *dbop) {	int rc;	char *key, *dat;	/*	 *	0: rowid	 *	1: key	 *	2: dat	 *	3: flags	 */	for (;;) {		/* Once it receives SQLITE_DONE, do not never return value */		if (dbop->done)			return NULL;		rc = sqlite3_step(dbop->stmt);		if (rc == SQLITE_DONE)			goto finish;		else if (rc == SQLITE_ROW) {			dbop->readcount++;			dbop->lastrowid = sqlite3_column_int64(dbop->stmt, 0);			key = (char *)sqlite3_column_text(dbop->stmt, 1);			dat = (char *)sqlite3_column_text(dbop->stmt, 2);			/* skip meta records */			if (!(dbop->openflags & DBOP_RAW)) {				if (dbop->ioflags & DBOP_KEY && ismeta(key))					continue;				else if (ismeta(dat))					continue;			}			if (dbop->ioflags & DBOP_KEY) {				if (!strcmp(dbop->prev, key))					continue;				if (strlen(key) > MAXKEYLEN)					die("primary key too long.");				strlimcpy(dbop->prev, key, sizeof(dbop->prev));			}			if (dbop->ioflags & DBOP_PREFIX) {				if (strncmp(key, dbop->key, dbop->keylen))					goto finish;			} else if (dbop->keylen) {				if (strcmp(key, dbop->key)) 					goto finish;			}			if (dbop->preg && regexec(dbop->preg, key, 0, 0, 0) != 0)				continue;			break;		} else {			die("dbop3_next: something is wrong (rc = %d).", rc);		}	}	strbuf_clear(dbop->sb);	strbuf_puts0(dbop->sb, (char *)sqlite3_column_text(dbop->stmt, 2));	dbop->lastsize = strbuf_getlen(dbop->sb) - 1;	dbop->lastflag = (char *)sqlite3_column_text(dbop->stmt, 3);	if (dbop->lastflag)		strbuf_puts(dbop->sb, dbop->lastflag);	dbop->lastdat = strbuf_value(dbop->sb);	if (dbop->lastflag)		dbop->lastflag = dbop->lastdat + dbop->lastsize + 1;	dbop->lastkey = key;	dbop->lastkeysize = strlen(dbop->lastkey);	if (dbop->ioflags & DBOP_KEY) {		strlimcpy(dbop->prev, key, sizeof(dbop->prev));		return key;	}	return dbop->lastdat;finish:	dbop->done = 1;	dbop->lastdat = NULL;	dbop->lastsize = 0;	return dbop->lastdat;}

intrspamd_sqlite3_run_prstmt (rspamd_mempool_t *pool, sqlite3 *db, GArray *stmts,		gint idx, ...){	gint retcode;	va_list ap;	sqlite3_stmt *stmt;	gint i, rowid, nargs, j;	gint64 len;	gpointer p;	struct rspamd_sqlite3_prstmt *nst;	const char *argtypes;	if (idx < 0 || idx >= (gint)stmts->len) {		return -1;	}	nst = &g_array_index (stmts, struct rspamd_sqlite3_prstmt, idx);	stmt = nst->stmt;	g_assert (nst != NULL);	msg_debug_pool ("executing `%s`", nst->sql);	argtypes = nst->args;	sqlite3_clear_bindings (stmt);	sqlite3_reset (stmt);	va_start (ap, idx);	nargs = 1;	for (i = 0, rowid = 1; argtypes[i] != '/0'; i ++) {		switch (argtypes[i]) {		case 'T':			for (j = 0; j < nargs; j ++, rowid ++) {				sqlite3_bind_text (stmt, rowid, va_arg (ap, const char*), -1,					SQLITE_STATIC);			}			nargs = 1;			break;		case 'V':		case 'B':			for (j = 0; j < nargs; j ++, rowid ++) {				len = va_arg (ap, gint64);				sqlite3_bind_text (stmt, rowid, va_arg (ap, const char*), len,						SQLITE_STATIC);			}			nargs = 1;			break;		case 'I':			for (j = 0; j < nargs; j ++, rowid ++) {				sqlite3_bind_int64 (stmt, rowid, va_arg (ap, gint64));			}			nargs = 1;			break;		case 'S':			for (j = 0; j < nargs; j ++, rowid ++) {				sqlite3_bind_int (stmt, rowid, va_arg (ap, gint));			}			nargs = 1;			break;		case '*':			nargs = va_arg (ap, gint);			break;		}	}	va_end (ap);	retcode = sqlite3_step (stmt);	if (retcode == nst->result) {		argtypes = nst->ret;		for (i = 0; argtypes != NULL && argtypes[i] != '/0'; i ++) {			switch (argtypes[i]) {			case 'T':				*va_arg (ap, char**) = g_strdup (sqlite3_column_text (stmt, i));				break;			case 'I':				*va_arg (ap, gint64*) = sqlite3_column_int64 (stmt, i);				break;			case 'S':				*va_arg (ap, int*) = sqlite3_column_int (stmt, i);				break;			case 'L':				*va_arg (ap, gint64*) = sqlite3_last_insert_rowid (db);				break;			case 'B':				len = sqlite3_column_bytes (stmt, i);				g_assert (len >= 0);				p = g_malloc (len);				memcpy (p, sqlite3_column_blob (stmt, i), len);				*va_arg (ap, gint64*) = len;//.........这里部分代码省略.........

result_t SQLite::execute(const char *sql, int sLen,                         obj_ptr<DBResult_base> &retVal){    if (!m_db)        return CHECK_ERROR(CALL_E_INVALID_CALL);    sqlite3_stmt *stmt = 0;    const char *pStr1;    if (sqlite3_prepare_v2(m_db, sql, sLen, &stmt, &pStr1))    {        result_t hr = CHECK_ERROR(Runtime::setError(sqlite3_errmsg(m_db)));        if (stmt)            sqlite3_finalize(stmt);        return hr;    }    if (!stmt)        return CHECK_ERROR(Runtime::setError("Query was empty"));    int columns = sqlite3_column_count(stmt);    obj_ptr<DBResult> res;    if (columns > 0)    {        int i;        res = new DBResult(columns);        for (i = 0; i < columns; i++)        {            std::string s = sqlite3_column_name(stmt, i);            res->setField(i, s);        }        while (true)        {            int r = sqlite3_step_sleep(stmt, SQLITE_SLEEP_TIME);            if (r == SQLITE_ROW)            {                res->beginRow();                for (i = 0; i < columns; i++)                {                    Variant v;                    switch (sqlite3_column_type(stmt, i))                    {                    case SQLITE_NULL:                        break;                    case SQLITE_INTEGER:                        v = (int64_t) sqlite3_column_int64(stmt, i);                        break;                    case SQLITE_FLOAT:                        v = sqlite3_column_double(stmt, i);                        break;                    default:                        const char *type = sqlite3_column_decltype(stmt, i);                        if (type                                && (!qstricmp(type, "blob")                                    || !qstricmp(type, "tinyblob")                                    || !qstricmp(type, "mediumblob")                                    || !qstricmp(type, "longblob")))                        {                            const char *data =                                (const char *) sqlite3_column_blob(stmt, i);                            int size = sqlite3_column_bytes(stmt, i);                            v = new Buffer(std::string(data, size));                        }                        else if (type                                 && (!qstricmp(type, "datetime")                                     || !qstricmp(type, "date")                                     || !qstricmp(type, "time")))                        {                            const char *data =                                (const char *) sqlite3_column_text(stmt, i);                            int size = sqlite3_column_bytes(stmt, i);                            v.parseDate(data, size);                        }                        else                        {                            const char *data =                                (const char *) sqlite3_column_text(stmt, i);                            int size = sqlite3_column_bytes(stmt, i);                            v = std::string(data, size);                        }                        break;                    }                    res->rowValue(i, v);                }                res->endRow();            }            else if (r == SQLITE_DONE)                break;//.........这里部分代码省略.........

static intcdb_get(struct custdb_handle *ch, const ChopstixPhone *phone,		ChopstixCustomer *cust){	char *phonestr;	int64_t cust_ID = 0;	sqlite3_stmt *q = NULL;	ChopstixCredit *cc;	int dupcount = 0;	CHECKSQL(ch);	/* get phonestr before zeroing, in case user sends same structure in */	if ((phonestr = phone2str(phone)) == NULL)		goto fail;	bzero(cust, sizeof(*cust));	/*	 * CUSTOMER	 */	q = SQLARG(ch)->q.cdb.get_cust;	/* 1 = first parameter in prepared query */	if (sqlite3_bind_text(q, 1, phonestr, strlen(phonestr), SQLITE_STATIC)) {		sql_err(SQLARG(ch), "cannot bind phone number to query");		goto fail;	}	while (sqlite3_step(q) == SQLITE_ROW) {		dupcount++;		/* start by freeing, incase multiple customers match the same phone */		free_ChopstixCustomer(cust);		/* ID, Phone, PhoneExt, Address, Intersection, Special */		cust_ID = sqlite3_column_int64(q, 0);		cust->name = sql_strdup(sqlite3_column_text(q, 1));		str2phone(sqlite3_column_text(q, 2), &cust->phone);		str2phoneext(sqlite3_column_text(q, 3), &cust->phone);		cust->addr.addr = sql_strdup(sqlite3_column_text(q, 4));		cust->addr.apt = sql_strdup(sqlite3_column_text(q, 5));		cust->addr.entry = sql_strdup(sqlite3_column_text(q, 6));		cust->isect.cross = sql_strdup(sqlite3_column_text(q, 7));		if ((cust->special = calloc(1, sizeof(cust->special))))			*cust->special = sql_strdup(sqlite3_column_text(q, 8));		cust->reps = sqlite3_column_int(q, 9);	}	sqlite3_reset(q);	if (dupcount > 1)		sql_warn(SQLARG(ch), "%d duplicate entries", dupcount);	if (cust_ID == 0) {		errno = ENOENT;		return -1;	}	/*	 * CREDITS	 */	q = SQLARG(ch)->q.cdb.get_cred;	/* 1 = first parameter in prepared query */	if (sqlite3_bind_int(q, 1, cust_ID)) {		sql_err(SQLARG(ch), "cannot bind customer ID to query");		goto fail;	}	if ((cust->credit = calloc(1, sizeof(*cust->credit))) == NULL)		goto fail;	cust->credit->len = 0;	while (sqlite3_step(q) == SQLITE_ROW) {		/* increase buffer */		if ((cc = realloc(cust->credit->val, (cust->credit->len + 1) *						sizeof(ChopstixCredit))) == NULL)			goto fail;		cust->credit->len++;		cust->credit->val = cc;		/* Credit, Remain, Reason */		cust->credit->val[cust->credit->len - 1].credit			= sqlite3_column_int(q, 0);		cust->credit->val[cust->credit->len - 1].remain			= sqlite3_column_int(q, 1);		cust->credit->val[cust->credit->len - 1].reason			= sql_strdup(sqlite3_column_text(q, 2));	}	sqlite3_reset(SQLARG(ch)->q.cdb.get_cred);	return 0;fail:	free_ChopstixCustomer(cust);	if (q)		sqlite3_reset(q);	return -1;}

apr_int64_tsvn_sqlite__column_int64(svn_sqlite__stmt_t *stmt, int column){  return sqlite3_column_int64(stmt->s3stmt, column);}

static void registerLogFile(sqlite3 *db,                            const char *filename){  sqlite3_stmt *statement;  int res;  const unsigned char *name;  int64 completed;  int64 file_size;  int64 file_modtime;  if (filename) {    struct stat st;    res = stat(filename, &st);    if (res != 0)      error("Couldn't stat() %s", filename);    file_size = st.st_size;    file_modtime = st.st_mtime;                            statement = prepareStatement(db,                                 "SELECT name, serial, completed FROM event_log"                                 " WHERE size = ? AND modtime = ?");    res = sqlite3_bind_int64(statement, 1, file_size);    if (res != SQLITE_OK)      sqlite_error(res, db, "event_log bind of size failed.");    res = sqlite3_bind_int64(statement, 2, file_modtime);    if (res != SQLITE_OK)      sqlite_error(res, db, "event_log bind of modtime failed.");    res = sqlite3_step(statement);     switch(res) {    case SQLITE_DONE:      evlog(LOG_SOMETIMES, "No log file matching '%s' found in database.", filename);      break;    case SQLITE_ROW:      name = sqlite3_column_text(statement, 0);      logSerial = sqlite3_column_int64(statement, 1);      completed = sqlite3_column_int64(statement, 2);      evlog(force ? LOG_OFTEN : LOG_ALWAYS, "Log file matching '%s' already in event_log, named /"%s/" (serial %lu, completed %lu).",            filename, name, logSerial, completed);      if (force) {        evlog(LOG_OFTEN, "Continuing anyway because -f specified.");      } else {        evlog(LOG_ALWAYS, "Exiting.  Specify -f to force events into SQL anyway.");        exit(0);      }      break;    default:      sqlite_error(res, db, "select from event_log failed.");    }    finalizeStatement(db, statement);  } else { /* stdin */    filename = "<stdin>";    file_size = 0;    file_modtime = 0;  }  statement = prepareStatement(db,                               "INSERT into event_log (name, size, modtime, completed)"                               " VALUES (?, ?, ?, 0)");  res = sqlite3_bind_text(statement, 1, filename, -1, SQLITE_STATIC);  if (res != SQLITE_OK)    sqlite_error(res, db, "event_log insert bind of name failed.");  res = sqlite3_bind_int64(statement, 2, file_size);  if (res != SQLITE_OK)    sqlite_error(res, db, "event_log insert bind of size failed.");  res = sqlite3_bind_int64(statement, 3, file_modtime);  if (res != SQLITE_OK)    sqlite_error(res, db, "event_log insert bind of modtime failed.");  res = sqlite3_step(statement);   if (res != SQLITE_DONE)    sqlite_error(res, db, "insert into event_log failed.");  logSerial = sqlite3_last_insert_rowid(db);  evlog(LOG_SOMETIMES, "Log file %s added to event_log with serial %lu",        filename, logSerial);  finalizeStatement(db, statement);}

int search(media_t* items, uint32_t* num_results, const char* terms) {  char buffer[1024];  sqlite3_stmt* query;  int retval;  uint32_t count;  if (terms == NULL) {    strcpy(buffer, "SELECT COUNT(*) FROM main");  }  else {    if ((sizeof(buffer)-50) < sizeof(terms)) {      log_debug(ERROR,"search(): terms exceeds buffer");      return MI_EXIT_ERROR;    }    strcpy(buffer, "SELECT COUNT(*) FROM main WHERE ");    strcat(buffer, terms);  }  log_debug(INFO,"search(): starting query");  log_debug(INFO,buffer);  if (sqlite3_prepare_v2(db_handle,buffer,-1,&query,NULL) != SQLITE_OK) {    log_debug(ERROR,"search(): error executing query");    log_debug(ERROR,sqlite3_errmsg(db_handle));    return MI_EXIT_ERROR;  }  retval = sqlite3_step(query);  if (retval == SQLITE_ROW)    *num_results = (uint32_t)sqlite3_column_int(query,0);  else if (retval == SQLITE_DONE) {    log_debug(INFO,"search(): no results for query");    sqlite3_finalize(query);    return MI_NO_RESULTS;  }  else {    log_debug(ERROR,"search(): unknown error");    log_debug(ERROR,sqlite3_errmsg(db_handle));    sqlite3_finalize(query);    return MI_EXIT_ERROR;  }  if (*num_results == 0) {    log_debug(INFO,"search(): no results for query");    sqlite3_finalize(query);    return MI_NO_RESULTS;  }  if (terms == NULL) {    strcpy(buffer, "SELECT * FROM main");  }  else {    strcpy(buffer, "SELECT * FROM main WHERE ");    strcat(buffer, terms);  }  log_debug(INFO,"search(): starting query");  log_debug(INFO,buffer);  if (sqlite3_prepare_v2(db_handle,buffer,-1,&query,NULL) != SQLITE_OK) {    log_debug(ERROR,"search(): error executing query");    log_debug(ERROR,sqlite3_errmsg(db_handle));    return MI_EXIT_ERROR;  }  items = malloc(sizeof(media_t)*(*num_results));  count = 0;  log_debug(INFO,"search(): staring row processing");  while (1) {    retval = sqlite3_step(query);    if (retval == SQLITE_ROW) {      items[count].code =          (uint32_t)sqlite3_column_int(query,0);      items[count].type =          (medium_t)sqlite3_column_int(query,1);      strcpy(items[count].name,    (char *)sqlite3_column_text(query,2));      strcpy(items[count].location,(char *)sqlite3_column_text(query,3));      items[count].update =        (time_t)sqlite3_column_int64(query,4);      count++;      sprintf(buffer,"search(): loaded row %u", count);      log_debug(INFO,buffer);    }    else if (retval == SQLITE_DONE) {      /* all done */      log_debug(INFO,"search(): row processing done");      sprintf(buffer,"%u rows processed out of %u rows actual",count,*num_results);      log_debug(INFO,buffer);      break;    }    else {      /* error of some sort */      log_debug(ERROR,"search(): error during row processing");      log_debug(ERROR,sqlite3_errmsg(db_handle));      sprintf(buffer,"%u rows processed out of %u rows actual",count,*num_results);      log_debug(INFO,buffer);      *num_results = 0;      free(items);      items = NULL;      sqlite3_finalize(query);//.........这里部分代码省略.........

boost::shared_ptr<RoutingNode> SQLiteDatabaseConnection::getNodeByID(boost::uint64_t id){    boost::shared_ptr<RoutingNode> retVal;    	int rc;	if(_getNodeByIDStatement == NULL)	{				rc = sqlite3_prepare_v2(_db, "SELECT ID, LAT, LON FROM NODES WHERE ID=?;",			-1, &_getNodeByIDStatement, NULL);		if (rc != SQLITE_OK)		{				std::cerr << "Failed to create getNodeByIDStatement." << " Resultcode: " << rc << std::endl;			return boost::shared_ptr<RoutingNode>();		}	}		// Parameter an das Statement binden    RoutingNode node;    node.setID(id);    if (node.isIDInLongFormat())    {        sqlite3_bind_int64(_getNodeByIDStatement, 1, RoutingNode::convertIDToShortFormat(id));    }    else    {        sqlite3_bind_int64(_getNodeByIDStatement, 1, id);    }		// Statement ausfuehren, in einer Schleife immer neue Zeilen holen	while ((rc = sqlite3_step(_getNodeByIDStatement)) != SQLITE_DONE)    {        //Es k
C++ sqlite3_column_name函数代码示例
C++ sqlite3_column_int函数代码示例