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

/* creates a new dir_info from that statement passed */static inline struct mp3_info* create_from_stmt( sqlite3_stmt* res ) {	struct mp3_info* tmp = malloc(sizeof(struct mp3_info));	memset( tmp, 0, sizeof(struct dir_info));	/* set the data */	tmp->oid = sqlite3_column_int ( res, 0 );	/* have to use strdup so the pointers		are not deleted on finalize */	tmp->title  = strdup( (char*)sqlite3_column_text( res, 1 ) );	tmp->artist = strdup( (char*)sqlite3_column_text( res, 2 ) );	tmp->album  = strdup( (char*)sqlite3_column_text( res, 3 ) );		const void* blob = sqlite3_column_blob( res, 4 );	size_t blob_bytes = sqlite3_column_bytes( res, 4 );	tmp->metadata = malloc( tmp->metadata_blob_len = blob_bytes );	memcpy( tmp->metadata, blob, blob_bytes );	return tmp;	}

/*  * Gather the results into list_entry format. Each row has page, number, len, * value. Look at queries in attr_get_attr attr_get_attr_page.  See page 163. * * -EINVAL: invalid argument * -EOVERFLOW: error, if not enough room to even start the entry * >0: success. returns number of bytes copied into outbuf. */static int attr_gather_attr(sqlite3_stmt *stmt, void *buf, uint32_t buflen,			    uint64_t oid, uint8_t listfmt){	uint32_t page = sqlite3_column_int(stmt, 0);	uint32_t number = sqlite3_column_int(stmt, 1);	uint16_t len = sqlite3_column_bytes(stmt, 2);	const void *val = sqlite3_column_blob(stmt, 2);	if (listfmt == RTRVD_SET_ATTR_LIST) {		return le_pack_attr(buf, buflen, page, number, len, val);	} else if (listfmt == RTRVD_MULTIOBJ_LIST) {		return le_multiobj_pack_attr(buf, buflen, oid, page, number,					     len, val);	} else if (listfmt == RTRVD_CREATE_MULTIOBJ_LIST) {		return le_create_multiobj_pack_attr(buf, buflen, oid, page,						    number, len, val);	} else {		return -EINVAL;	}}

/*! * * @param field * @return */QString Address::searchDB(const char* field) const{    ostringstream sqlCmmd;    sqlCmmd << "SELECT "            << field            << " FROM ics_addresses WHERE a_customer='"            << customer.toStdString()            << "';";        sqlite3_stmt* stmt;    int rc = sqlite3_prepare_v2(db, sqlCmmd.str().c_str(), -1, &stmt, NULL);        rc = sqlite3_step(stmt);        if(rc != SQLITE_DONE){        return QString(static_cast<const char*>(sqlite3_column_blob(stmt, 0)));    }    else{        return "";    }}

/*** Print the content of a segment or of the root of a segdir.  The segment** or root is identified by azExtra[0].  If the first character of azExtra[0]** is 'r' then the remainder is the integer rowid of the %_segdir entry.** If the first character of azExtra[0] is not 'r' then, then all of** azExtra[0] is an integer which is the block number.**** If the --raw option is present in azExtra, then a hex dump is provided.** Otherwise a decoding is shown.*/static void showSegment(sqlite3 *db, const char *zTab) {    const unsigned char *aData;    int nData;    sqlite3_stmt *pStmt;    pStmt = prepareToGetSegment(db, zTab, azExtra[0]);    if( sqlite3_step(pStmt)!=SQLITE_ROW ) {        sqlite3_finalize(pStmt);        return;    }    nData = sqlite3_column_bytes(pStmt, 0);    aData = sqlite3_column_blob(pStmt, 0);    printf("Segment %s of size %d bytes:/n", azExtra[0], nData);    if( findOption("raw", 0, 0)!=0 ) {        printBlob(aData, nData);    } else {        decodeSegment(aData, nData);    }    sqlite3_finalize(pStmt);}

/* * packs contents of an attribute of dir page. Note that even though the * query selects 'page', the resultant rows are actually rows 'numbers' * within directory page. *  * returns: * -EINVAL: invalid argument, or length(attribute value) != 40 * -EOVERFLOW: outlen too small * >0: success, number of bytes copied into outdata */static int attr_gather_dir_page(sqlite3_stmt *stmt, uint32_t outlen,				void *outdata, uint64_t oid, uint32_t page,				uint8_t listfmt){	uint32_t number = sqlite3_column_int(stmt, 0);	uint16_t len = sqlite3_column_bytes(stmt, 1);	const void *val = sqlite3_column_blob(stmt, 1);	if (len != ATTR_PAGE_ID_LEN) 		return -EINVAL;	if (listfmt == RTRVD_SET_ATTR_LIST) {		return le_pack_attr(outdata, outlen, page, number, len, val);	} else if (listfmt == RTRVD_CREATE_MULTIOBJ_LIST) {		return le_multiobj_pack_attr(outdata, outlen, oid, page, 					     number, len, val);	} else {		return -EINVAL;	}}

void MapDatabaseSQLite3::loadBlock(const v3s16 &pos, std::string *block){	verifyDatabase();	bindPos(m_stmt_read, pos);	if (sqlite3_step(m_stmt_read) != SQLITE_ROW) {		sqlite3_reset(m_stmt_read);		return;	}	const char *data = (const char *) sqlite3_column_blob(m_stmt_read, 0);	size_t len = sqlite3_column_bytes(m_stmt_read, 0);	*block = (data) ? std::string(data, len) : "";	sqlite3_step(m_stmt_read);	// We should never get more than 1 row, so ok to reset	sqlite3_reset(m_stmt_read);}

bool DBBrowserDB::getRow(const QString& sTableName, int rowid, QList<QByteArray>& rowdata){    QString sQuery = QString("SELECT * from %1 WHERE rowid=%2;").arg(sTableName).arg(rowid);    QByteArray utf8Query = sQuery.toUtf8();    sqlite3_stmt *stmt;    int status = sqlite3_prepare_v2(_db, utf8Query, utf8Query.size(), &stmt, NULL);    if(SQLITE_OK == status)    {        // even this is a while loop, the statement should always only return 1 row        while(sqlite3_step(stmt) == SQLITE_ROW)        {            for (int i = 0; i < sqlite3_column_count(stmt); ++i)                rowdata.append(QByteArray(static_cast<const char*>(sqlite3_column_blob(stmt, i)), sqlite3_column_bytes(stmt, i)));        }    }    sqlite3_finalize(stmt);    return status == SQLITE_OK;}

// ================================// gbDB_GetNextRowFromMassTileRead:// ================================//// Unused / deprecated.//int gbDB_GetNextRowFromMassTileRead(sqlite3*      database,                                    sqlite3_stmt* selStmt,                                    void**        tileData,                                    size_t*       tileDataBytes,                                    int*          dataCount,                                    uint32_t*     x,                                    uint32_t*     y){    int      sqliteStepResult = sqlite3_step(selStmt);    uint32_t _x               = -1;    uint32_t _y               = -1;    int      _dataCount       = 0;    void*    _tileData        = NULL;    size_t   _tileDataBytes   = 0;        // -- 1. read row with tile, store in temp vector --    if (sqliteStepResult == SQLITE_ROW)    {        _x                    = (uint32_t)sqlite3_column_int(selStmt, 0);        _y                    = (uint32_t)sqlite3_column_int(selStmt, 1);        _dataCount            =           sqlite3_column_int(selStmt, 2);        const void *blobBytes =          sqlite3_column_blob(selStmt, 3);        int blobLen           =         sqlite3_column_bytes(selStmt, 3);                if (blobLen > 0)        {            _tileDataBytes = blobLen;            _tileData      = malloc(_tileDataBytes);                        memcpy(_tileData, blobBytes, _tileDataBytes);        }//if    }//if        *tileData      = _tileData;    *tileDataBytes = _tileDataBytes;    *x             = _x;    *y             = _y;    *dataCount     = _dataCount;        return sqliteStepResult;}//gbDB_GetNextRowFromMassTileRead

BYTE * CSQLite::ReadScorcoData(const char * SQL, const char * param, BOOL * pSqlError, int * size){    int rc;    const void* pBlob;    if (strcmp(param, "FETCHMODE") != 0) {        finalizeStatement();        rc = sqlite3_prepare(sdb, SQL, -1, &pStmt, NULL);        if (rc != SQLITE_OK) {            strcpy(lastError, sqlite3_errmsg(sdb));            finalizeStatement();            *pSqlError = true;            return NULL;        }    }    // execute step    rc = sqlite3_step(pStmt);    if (rc == SQLITE_ERROR) {        strcpy(lastError, sqlite3_errmsg(sdb));        *pSqlError = true;        finalizeStatement();        return NULL;    }    *pSqlError = false;    if (rc == SQLITE_ROW) {        unsigned long length = sqlite3_column_bytes(pStmt, 0);        *size = length;        if (length == 0) return NULL;        char* buf = new char[length];        if (buf == NULL) return NULL;        pBlob = sqlite3_column_blob(pStmt, 0);        if (pBlob == NULL) { delete [] buf; return NULL; }        memcpy(buf, pBlob, length);        return (BYTE*)buf; // NWN VM will delete this block of memory    } else if (rc == SQLITE_DONE) {        finalizeStatement();    }    return NULL;}

/* *  stack_res_get *  --------------------------------------------------------------------------------------------- *  Accesses the details and/or data of the resource with the specified ID and type. *  Returns STACK_YES on success, STACK_NO otherwise. * *  Only returns the arguments for which a non-NULL pointer is supplied. * *  The result string and data remain valid until the next call, the stack is closed or  *  stack_res_type_n() is invoked. * *  An error can occur because the resource cannot be found or because of an I/O error. */int stack_res_get(Stack *in_stack, int in_id, char const *in_type, char **out_name, void **out_data, long *out_size){    assert(IS_STACK(in_stack));    assert(in_id >= 1);        if (in_stack->_returned_res_str) _stack_free(in_stack->_returned_res_str);    in_stack->_returned_res_str = NULL;    if (in_stack->_returned_res_data) _stack_free(in_stack->_returned_res_data);    in_stack->_returned_res_data = NULL;    long data_size = 0;        sqlite3_stmt *stmt;    sqlite3_prepare_v2(in_stack->db, "SELECT resourcename,data FROM resource WHERE resourceid=?1 AND resourcetype=?2", -1, &stmt, NULL);    sqlite3_bind_int(stmt, 1, in_id);    sqlite3_bind_text(stmt, 2, in_type, -1, SQLITE_STATIC);    int err = sqlite3_step(stmt);    if (err == SQLITE_ROW) {        in_stack->_returned_res_str = _stack_clone_cstr((char*)sqlite3_column_text(stmt, 0));        data_size = sqlite3_column_bytes(stmt, 1);        in_stack->_returned_res_data = _stack_malloc(data_size);        if (!in_stack->_returned_res_data)        {            _stack_panic_void(in_stack, STACK_ERR_MEMORY);            sqlite3_finalize(stmt);            return STACK_NO;        }        else            memcpy(in_stack->_returned_res_data, sqlite3_column_blob(stmt, 1), data_size);    }    sqlite3_finalize(stmt);        if (err == SQLITE_ROW)    {        if (out_name) *out_name = in_stack->_returned_res_str;        if (out_data) *out_data = in_stack->_returned_res_data;        if (out_size) *out_size = data_size;        return STACK_YES;    }    else        return STACK_NO;}

bool getAvatar(const std::string &db_path, const std::string &name, std::string &photo) {	bool ret = false;	sqlite3 *db;	LOG4CXX_INFO(logger, "Opening database " << db_path);	if (sqlite3_open(db_path.c_str(), &db)) {		sqlite3_close(db);		LOG4CXX_ERROR(logger, "Can't open database");	}	else {		sqlite3_stmt *stmt;		PREP_STMT(stmt, "SELECT avatar_image FROM Contacts WHERE skypename=?");		if (stmt) {			BEGIN(stmt);			BIND_STR(stmt, name);			if(sqlite3_step(stmt) == SQLITE_ROW) {				int size = sqlite3_column_bytes(stmt, 0);				if (size > 0) {				    const void *data = sqlite3_column_blob(stmt, 0);				    photo = std::string((const char *)data + 1, size - 1);				    ret = true;				} else {				    ret = false;				}			}			else {				LOG4CXX_ERROR(logger, (sqlite3_errmsg(db) == NULL ? "" : sqlite3_errmsg(db)));			}			int ret;			while((ret = sqlite3_step(stmt)) == SQLITE_ROW) {			}			FINALIZE_STMT(stmt);		}		else {			LOG4CXX_ERROR(logger, "Can't create prepared statement");			LOG4CXX_ERROR(logger, (sqlite3_errmsg(db) == NULL ? "" : sqlite3_errmsg(db)));		}		sqlite3_close(db);	}	return ret;}

int print_col(sqlite3_stmt * pTableInfo, int col){	int fd;	static int ct = 0;	char outfile[50];	switch (sqlite3_column_type(pTableInfo, col)) {	case SQLITE_INTEGER:		printf("%d ", sqlite3_column_int(pTableInfo, col));		break;	case SQLITE_FLOAT:		printf("%f ", sqlite3_column_double(pTableInfo, col));		break;	case SQLITE_TEXT:		printf("%s ", sqlite3_column_text(pTableInfo, col));		break;	case SQLITE_BLOB:	//printf("%s",sqlite3_column_blob(pTableInfo, col));		/* fprintf(stderr, "IN BLOB bytes %d/n",		   sqlite3_column_bytes(pTableInfo, col)); */		snprintf(outfile, 20, "outdata.%d.png", ct++);		if ((fd = open(outfile, O_RDWR | O_CREAT, 0600)) == -1) {			fprintf(stderr, "Can't open data: %s/n",				strerror(errno));			return 1;		}		write(fd, sqlite3_column_blob(pTableInfo, col),		      sqlite3_column_bytes(pTableInfo, col));		close(fd);		break;	case SQLITE_NULL:		printf("Null ");		break;	default:		printf(" *Cannot determine SQLITE TYPE* col=%d ", col);	}	return 0;}

void db_query_value(struct db_query *query, uint8_t **value, size_t *size, 		int *raw, int *id) {	const void *data;	int n;		*raw = sqlite3_column_int(query->stmt, 1);	*id = sqlite3_column_int(query->stmt, 2);	if(value == NULL)		return;	if( (data = sqlite3_column_blob(query->stmt, 0)) == NULL)		err_panic(0, "column data is NULL: %s", sqlite3_errmsg(g.handle));	if( (n = sqlite3_column_bytes(query->stmt, 0)) < 0)		err_panic(0, "value size is negative");	*size = n;	if(*size > 0) {		*value = talloc_array(NULL, uint8_t, *size);		memcpy(*value, data, *size);	}}

/*! * * @param username * @param password * @return */Customer* Database::loginAsCustomer(QString username, QString password){    unsigned* digest = encryptPassword(password);    Customer* customer;    if(validateCustomerLogin(username, digest)){        ostringstream sqlCmmd;        sqlCmmd << "SELECT cl_customer FROM ics_customer_logins WHERE cl_username = '"                << username.toStdString() << "'";        sqlite3_stmt* stmt;        sqlite3_prepare_v2(connection, sqlCmmd.str().c_str(), -1, &stmt, NULL);        sqlite3_step(stmt);        customer = new Customer(connection, QString(static_cast<const char*>(sqlite3_column_blob(stmt, 0))));    }    else{        ostringstream ex;        ex << "Invalid login by " << username.toStdString();        throw new InvalidLoginException(ex.str().c_str());    }    return customer;}

//============================================================================//		NDBResult::GetValueData : Get a data value.//----------------------------------------------------------------------------NData NDBResult::GetValueData(NIndex theIndex) const{	NData			theResult;	const void		*thePtr;	NIndex			theSize;	// Validate our parameters	NN_ASSERT(theIndex < GetSize());	// Get the value	thePtr  = (const void *) sqlite3_column_blob( (sqlite3_stmt *) mResult, theIndex);	theSize = (NIndex      ) sqlite3_column_bytes((sqlite3_stmt *) mResult, theIndex);		if (thePtr != NULL && theSize != 0)		theResult.AppendData(theSize, thePtr);		return(theResult);}

String SQLiteStatement::getColumnBlobAsString(int col){    ASSERT(col >= 0);    if (!m_statement && prepareAndStep() != SQLITE_ROW)        return String();    if (columnCount() <= col)        return String();    const void* blob = sqlite3_column_blob(m_statement, col);    if (!blob)        return String();    int size = sqlite3_column_bytes(m_statement, col);    if (size < 0)        return String();    ASSERT(!(size % sizeof(UChar)));    return String(static_cast<const UChar*>(blob), size / sizeof(UChar));}

void QgsSpatiaLiteFeatureIterator::getFeatureGeometry( sqlite3_stmt* stmt, int ic, QgsFeature& feature ){  if ( sqlite3_column_type( stmt, ic ) == SQLITE_BLOB )  {    unsigned char *featureGeom = NULL;    size_t geom_size = 0;    const void *blob = sqlite3_column_blob( stmt, ic );    size_t blob_size = sqlite3_column_bytes( stmt, ic );    QgsSpatiaLiteProvider::convertToGeosWKB(( const unsigned char * )blob, blob_size,                                            &featureGeom, &geom_size );    if ( featureGeom )      feature.setGeometryAndOwnership( featureGeom, geom_size );    else      feature.setGeometryAndOwnership( 0, 0 );  }  else  {    // NULL geometry    feature.setGeometryAndOwnership( 0, 0 );  }}

float zDBBinaryReader::ToSingle(int offset){	int						cb = sizeof(float);		// Number of bytes to alloc/copy	const unsigned char*	puData;					// Pointer into raw data	array<System::Byte>^	rg;						// Managed byte array of data	PinnedBytePtr			pinRg;					// Pinned pointer into rg[]	CHECK_DISPOSED(m_disposed);	if(offset < 0) throw gcnew ArgumentException();	if(offset > (m_cb - cb)) throw gcnew ArgumentOutOfRangeException();	rg = gcnew array<System::Byte>(cb);		// Allocate the local buffer	pinRg = &rg[0];							// Pin it down for memcpy_s	// Copy only the amount of data we specifically need from SQLite, and attempt	// to convert it using a standard binary conversion mechanism	puData = reinterpret_cast<const unsigned char*>(sqlite3_column_blob(m_pStatement->Handle, m_ordinal));	memcpy_s(pinRg, cb, puData + offset, cb);	return BitConverter::ToSingle(rg, 0);}

/*** Load a list of Blob objects from the database*/static void blobListLoadFromDb(  sqlite3 *db,             /* Read from this database */  const char *zSql,        /* Query used to extract the blobs */  int onlyId,              /* Only load where id is this value */  int *pN,                 /* OUT: Write number of blobs loaded here */  Blob **ppList            /* OUT: Write the head of the blob list here */){  Blob head;  Blob *p;  sqlite3_stmt *pStmt;  int n = 0;  int rc;  char *z2;  if( onlyId>0 ){    z2 = sqlite3_mprintf("%s WHERE rowid=%d", zSql, onlyId);  }else{    z2 = sqlite3_mprintf("%s", zSql);  }  rc = sqlite3_prepare_v2(db, z2, -1, &pStmt, 0);  sqlite3_free(z2);  if( rc ) fatalError("%s", sqlite3_errmsg(db));  head.pNext = 0;  p = &head;  while( SQLITE_ROW==sqlite3_step(pStmt) ){    int sz = sqlite3_column_bytes(pStmt, 1);    Blob *pNew = safe_realloc(0, sizeof(*pNew)+sz );    pNew->id = sqlite3_column_int(pStmt, 0);    pNew->sz = sz;    pNew->seq = n++;    pNew->pNext = 0;    memcpy(pNew->a, sqlite3_column_blob(pStmt,1), sz);    pNew->a[sz] = 0;    p->pNext = pNew;    p = pNew;  }  sqlite3_finalize(pStmt);  *pN = n;  *ppList = head.pNext;}

static bool read_chunk_sqlite(unsigned char *chunk, const unsigned char *digest,		void *db_info_ptr){	static const char sql[] = "SELECT data FROM chunk WHERE hash = ?";	struct db_info *db_info = db_info_ptr;	sqlite3_stmt *stmt;	int err;	bool status = false;	lock_db(db_info);	err = sqlite3_prepare(db_info->db, sql, -1, &stmt, 0);	if (err != SQLITE_OK) {		ERROR("sqlite3_prepare failed: %d/n",				sqlite3_errmsg(db_info->db));		unlock_db(db_info);		return false;	}	TRACE("%s/n", digest_string(digest));	sqlite3_bind_text(stmt, 1, digest_string(digest), -1, SQLITE_STATIC);	err = sqlite3_step(stmt);	if (err != SQLITE_ROW) {		ERROR("sqlite3_step failed: %s/n",				sqlite3_errmsg(db_info->db));	} else if (sqlite3_column_bytes(stmt, 0) != CHUNK_SIZE) {		ERROR("sqlite3 query returned %d bytes instead of %d./n",				sqlite3_column_bytes(stmt, 0), CHUNK_SIZE);	} else {		TRACE("sqlite3 query got chunk./n");		memcpy(chunk, sqlite3_column_blob(stmt, 0), CHUNK_SIZE);		status = true;	}	sqlite3_finalize(stmt);	unlock_db(db_info);	return status;}

sf::SoundBuffer* ResourceManager::getSoundBuffer(std::string filename) {    if (mSoundBuffers.count(filename) > 0) {        return mSoundBuffers.at(filename);    }    int rc;    std::string query = "SELECT bytes FROM files "                        "WHERE  name='" + filename + "';";    sqlite3_stmt *stmt;    rc = sqlite3_prepare_v2(mDB, query.c_str(), -1, &stmt, NULL);    if(rc != SQLITE_OK){        std::cerr << "Could not prepare query: " << sqlite3_errmsg(mDB) << std::endl;        sqlite3_finalize(stmt);        throw ErrorCode(EC_DB_FAILURE);    }    rc = sqlite3_step(stmt);    if(rc != SQLITE_ROW){        std::cerr << "Could not execute query: " << sqlite3_errmsg(mDB) << std::endl;        sqlite3_finalize(stmt);        throw ErrorCode(EC_DB_FAILURE);    }    const void* data = sqlite3_column_blob(stmt, 0);    size_t data_size = sqlite3_column_bytes(stmt, 0);    sf::SoundBuffer* soundBuffer = new sf::SoundBuffer();    if (!soundBuffer->loadFromMemory(data, data_size)) {        throw ErrorCode(EC_AUDIO_FAILURE);    }    mSoundBuffers[filename] = soundBuffer;    sqlite3_finalize(stmt);    return soundBuffer;}

voidO2DatDB::get_columns(sqlite3_stmt* stmt, wstrarray &cols){	__int64 t_int;	double	t_float;	wstring	t_text;	byte	*t_byte;	int		size;	wchar_t tmp[1024];	int column_count = sqlite3_column_count(stmt);	for (int i = 0; i < column_count; i++) {		switch (sqlite3_column_type(stmt, i)) {			case SQLITE_INTEGER:				t_int = sqlite3_column_int64 (stmt, i);				swprintf_s(tmp, 1024, L"%I64u", t_int);				cols.push_back(tmp);				break;			case SQLITE_FLOAT:				t_float = sqlite3_column_double(stmt, i);				swprintf_s(tmp, 1024, L"%lf", t_float);				cols.push_back(tmp);				break;			case SQLITE_TEXT:				t_text = (wchar_t*)sqlite3_column_text16(stmt, i);				cols.push_back(t_text);				break;			case SQLITE_BLOB:				size = sqlite3_column_bytes(stmt, i);				t_byte = new byte[size];				memcpy(t_byte, (byte*)sqlite3_column_blob(stmt, i), size);				byte2whex(t_byte, size, t_text);				cols.push_back(t_text);				delete [] t_byte;				break;		}	}}

/*** Print the content of a doclist.  The segment or segdir-root is** identified by azExtra[0].  If the first character of azExtra[0]** is 'r' then the remainder is the integer rowid of the %_segdir entry.** If the first character of azExtra[0] is not 'r' then, then all of** azExtra[0] is an integer which is the block number.  The offset** into the segment is identified by azExtra[1].  The size of the doclist** is azExtra[2].**** If the --raw option is present in azExtra, then a hex dump is provided.** Otherwise a decoding is shown.*/static void showDoclist(sqlite3 *db, const char *zTab){  const unsigned char *aData;  sqlite3_int64 offset, nData;  sqlite3_stmt *pStmt;  offset = atoi64(azExtra[1]);  nData = atoi64(azExtra[2]);  pStmt = prepareToGetSegment(db, zTab, azExtra[0]);  if( sqlite3_step(pStmt)!=SQLITE_ROW ){    sqlite3_finalize(pStmt);    return;  }  aData = sqlite3_column_blob(pStmt, 0);  printf("Doclist at %s offset %lld of size %lld bytes:/n",         azExtra[0], offset, nData);  if( findOption("raw", 0, 0)!=0 ){    printBlob(aData+offset, nData);  }else{    decodeDoclist(aData+offset, nData);  }  sqlite3_finalize(pStmt);}

static mrb_valuerow_to_value(mrb_state* mrb, sqlite3_stmt* stmt) {  int i;  int count = sqlite3_column_count(stmt);  mrb_value a = mrb_ary_new(mrb);  for (i = 0; i < count; i++) {    switch (sqlite3_column_type(stmt, i)) {    case SQLITE_INTEGER:      {        sqlite3_int64 value = sqlite3_column_int64(stmt, i);        mrb_ary_push(mrb, a, mrb_fixnum_value((mrb_int) value));      }      break;    case SQLITE_FLOAT:      {        double value = sqlite3_column_double(stmt, i);        mrb_ary_push(mrb, a, mrb_float_value(mrb, value));      }      break;    case SQLITE_BLOB:      {        int size = sqlite3_column_bytes(stmt, i);        const char* ptr = sqlite3_column_blob(stmt, i);        mrb_ary_push(mrb, a, mrb_str_new(mrb, ptr, size));      }      break;    case SQLITE_NULL:      mrb_ary_push(mrb, a, mrb_nil_value());      break;    case SQLITE_TEXT:      {        const char* value = (const char*) sqlite3_column_text(stmt, i);        mrb_ary_push(mrb, a, mrb_str_new_cstr(mrb, value));      }      break;    }  }  return a;}

// Retrieve an arbitrary binary value from INI file or registry.BOOL  SQLITE3::GetProfileBinary(LPCTSTR lpszSection, LPCTSTR lpszEntry,                                LPBYTE* ppData, UINT* pBytes, bool fallofftoreg){    CString szSQL;    szSQL.Format(_T("SELECT vdata FROM settingbin2 WHERE skey = /"%s/" AND sect = /"%s/" ") , lpszSection, lpszEntry);    int iDestLen;    char* buff = svpTool.CStringToUTF8(szSQL, &iDestLen);    char *tail;    sqlite3_stmt *stmt=0;    int err = 1;    if(sqlite3_prepare_v2(db, buff, strlen(buff), &stmt, 0) == SQLITE_OK)    {        //printf("Could not prepare statement./n");        //return;        rc = sqlite3_step(stmt);        if( rc==SQLITE_ROW )        {            int newBlobSize = sqlite3_column_bytes(stmt, 0);            if(newBlobSize > 0){                void* buffx = malloc(newBlobSize);                *pBytes = newBlobSize;                    memcpy(buffx, sqlite3_column_blob(stmt, 0), newBlobSize);                *ppData = (LPBYTE)buffx;                //SVP_LogMsg6("lalalax got bin %d", newBlobSize);                err = 0;            }        }         sqlite3_finalize(stmt);     }    free(buff);    if(!err){        return true;    }else if (fallofftoreg){        //SVP_LogMsg6("lalalax");        return AfxGetApp()->GetProfileBinary(lpszSection,lpszEntry,ppData,pBytes);    }    else        return false;}

static Value cursor_get_sub(sqlite3_stmt *stmt, int i){    switch (sqlite3_column_type(stmt, i)) {    case SQLITE_INTEGER:        return fs->int64_Value(sqlite3_column_int64(stmt, i));    case SQLITE_FLOAT:        return fs->float_Value(fs->cls_float, sqlite3_column_double(stmt, i));    case SQLITE_TEXT: {        const char *p = (const char*)sqlite3_column_text(stmt, i);        int len = sqlite3_column_bytes(stmt, i);        return fs->cstr_Value(NULL, p, len);    }    case SQLITE_BLOB: {        const char *p = (const char*)sqlite3_column_blob(stmt, i);        int len = sqlite3_column_bytes(stmt, i);        return fs->cstr_Value(fs->cls_bytes, p, len);    }    default:        break;    }    return VALUE_NULL;}

// id integer primary key,source text,title text,link text,description blob,read integerbool CSQLite::GetCaches(std::vector<CCache*>* caches, const char* source, int read){	std::stringstream ss;	std::string sql;	std::string tsource;	if(WrapApostrophe(source, &tsource))		source = tsource.c_str();	ss << "select * from " << kCachesTableName << " where source='" << source << "'";	if(read == 1) ss << " and read=1;";	else if(read == 0) ss << " and read=0;";	else ss << ";";	sql = ss.str();	sqlite3_stmt* stmt;	if(sqlite3_prepare(m_db, sql.c_str(),-1,&stmt,nullptr) == SQLITE_OK){		int rv;		while((rv = sqlite3_step(stmt)) == SQLITE_ROW){			auto pCache = new CCache;			pCache->id = sqlite3_column_int(stmt, 0);			pCache->source = (const char*)sqlite3_column_text(stmt, 1);			pCache->title = (const char*)sqlite3_column_text(stmt, 2);			pCache->link = (const char*)sqlite3_column_text(stmt, 3);			pCache->description = (const char*)sqlite3_column_blob(stmt, 4);			pCache->read = !!sqlite3_column_int(stmt, 5);			caches->push_back(pCache);		}		if(rv != SQLITE_DONE){			throw "未能取得缓存数据!";		}		sqlite3_finalize(stmt);		return true;	}	else{		throw "sqlite3错误!";	}	return false;}

static gchar*get_active_preset_name(dt_lib_module_info_t *minfo){  sqlite3_stmt *stmt;  DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params, writeprotect from presets where operation=?1 and op_version=?2", -1, &stmt, NULL);  DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, minfo->plugin_name, strlen(minfo->plugin_name), SQLITE_TRANSIENT);  DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, minfo->version);  gchar *name = NULL;  // collect all presets for op from db  while(sqlite3_step(stmt) == SQLITE_ROW)  {    void *op_params = (void *)sqlite3_column_blob(stmt, 1);    int32_t op_params_size = sqlite3_column_bytes(stmt, 1);    if(op_params_size == minfo->params_size && !memcmp(minfo->params, op_params, op_params_size))    {      name = g_strdup((char *)sqlite3_column_text(stmt, 0));      break;    }  }  sqlite3_finalize(stmt);  return name;}

void SqliteTableModel::fetchData(unsigned int from, unsigned to){    int currentsize = m_data.size();    QString sLimitQuery;    if(m_sQuery.startsWith("PRAGMA", Qt::CaseInsensitive) || m_sQuery.startsWith("EXPLAIN", Qt::CaseInsensitive))    {        sLimitQuery = m_sQuery;    } else {        // Remove trailing trailing semicolon        QString queryTemp = rtrimChar(m_sQuery, ';');        // If the query ends with a LIMIT statement take it as it is, if not append our own LIMIT part for lazy population        if(queryTemp.contains(QRegExp("LIMIT//s+//d+//s*(,//s*//d+//s*)?$", Qt::CaseInsensitive)))            sLimitQuery = queryTemp;        else            sLimitQuery = QString("%1 LIMIT %2, %3;").arg(queryTemp).arg(from).arg(to-from);    }    m_db->logSQL(sLimitQuery, kLogMsg_App);    QByteArray utf8Query = sLimitQuery.toUtf8();    sqlite3_stmt *stmt;    int status = sqlite3_prepare_v2(m_db->_db, utf8Query, utf8Query.size(), &stmt, NULL);    if(SQLITE_OK == status)    {        while(sqlite3_step(stmt) == SQLITE_ROW)        {            QByteArrayList rowdata;            for (int i = 0; i < m_headers.size(); ++i)                rowdata.append(QByteArray(static_cast<const char*>(sqlite3_column_blob(stmt, i)), sqlite3_column_bytes(stmt, i)));            m_data.push_back(rowdata);        }    }    sqlite3_finalize(stmt);    beginInsertRows(QModelIndex(), currentsize, m_data.size()-1);    endInsertRows();}