C++ CppSQLite3Query::getBlobField方法代码示例

BOOL CCP_MainApp::GetClipData(long lID, CClipFormat &Clip)
{
	BOOL bRet = FALSE;

	try
	{
		CppSQLite3Query q = theApp.m_db.execQueryEx(_T("SELECT ooData FROM Data WHERE lParentID = %d AND strClipboardFormat = '%s'"), lID, GetFormatName(Clip.m_cfType));
		if(q.eof() == false)
		{
			int nDataLen = 0;
			const unsigned char *cData = q.getBlobField(_T("ooData"), nDataLen);
			if(cData != NULL)
			{
				Clip.m_hgData = NewGlobal(nDataLen);

				::CopyToGlobalHP(Clip.m_hgData, (LPVOID)cData, nDataLen);

				bRet = TRUE;
			}
		}
	}
	CATCH_SQLITE_EXCEPTION

	return bRet;
}

bool CThumbIndex::AbstractFromGUID(const CString& guid, WIZABSTRACT &abstract,const CString& type)
{
    if(!m_dbThumb.IsOpened())
        return false;

    CString sql = CString("select ") + FIELD_LIST_ABSTRACT + " from " + TABLE_NAME_ABSTRACT +" where ABSTRACT_GUID='"
                    + guid + ("' AND ABSTRACT_TYPE=")
                    + STR2SQL(type)
                    + (";");
    try
    {
        CppSQLite3Query query = m_dbThumb.execQuery(sql);

        while (!query.eof())
        {
            abstract.guid = query.getStringField(0);
            abstract.text = query.getStringField(2);
            int length;
            const unsigned char * imageData = query.getBlobField(3, length);
            if (imageData && length)
            {
                abstract.image.loadFromData(imageData, length);
            }
            return true;
        }
		return false;
	}
	catch (const CppSQLite3Exception& e)
	{
		TOLOG(e.errorMessage());
        TOLOG(sql);
		return false;
	}
	catch (...) {
		TOLOG("Unknown exception while close DB");
		return false;
	}
}

/** Message 조회
 *
 * @param szId target device id
 * @param nMessageType 0 이라면 Message 전체
 * @param pWrapper 응답을 전해 줄 IF4Wrapper
 */
BOOL CMessageHelper::Select(const char *szId, BYTE nMessageType, IF4Wrapper *pWrapper)
{
    if(!CheckDB()) return FALSE;

    CppSQLite3Query result;
    char timeString[32];
    TIMESTAMP issueTime;
    unsigned char * pPayload;
    int idx=0, nPayloadLen;
    int year, mon, day, hour, min, sec;

    if(pWrapper == NULL) return FALSE;

    if(!Open()) return FALSE;
    try
    {
        CppSQLite3Statement stmt;
        
        if (nMessageType > 0) {
            stmt = m_SqliteHelper.compileStatement(
                "SELECT "
                "messageId, issueTime, userData, payload, "
                "duration, errorHandler, preHandler, postHandler "
                "FROM MessageTbl "
                "WHERE targetId = ? and messageType = ? ; ");

            stmt.bind(1, szId);
            stmt.bind(2, nMessageType);
        } else {
            stmt = m_SqliteHelper.compileStatement(
                "SELECT "
                "messageId, issueTime, userData, payload, "
                "duration, errorHandler, preHandler, postHandler "
                "FROM MessageTbl "
                "WHERE targetId = ? ; ");

            stmt.bind(1, szId);
        }

        result = stmt.execQuery();
        while(!result.eof())
        {
            memset(timeString, 0, sizeof(timeString));
            memset(&issueTime, 0, sizeof(TIMESTAMP));
            pPayload = NULL; nPayloadLen = 0; idx = 0;

            IF4API_AddResultNumber(pWrapper, "1.6", VARSMI_UINT, result.getIntField(idx));  idx++;
            strcat(timeString, result.getStringField(idx));                                 idx++;
            sscanf(timeString,"%04d-%02d-%02d %02d:%02d:%02d",
                    &year, &mon, &day, &hour, &min, &sec);
            issueTime.year = year; issueTime.mon = mon;
            issueTime.day = day; issueTime.hour = hour;
            issueTime.min = min; issueTime.sec = sec;
            /*
            XDEBUG(" %04d/%02d/%02d %02d:%02d:%02d\r\n",
                    issueTime.year, issueTime.mon, issueTime.day, issueTime.hour, issueTime.min, issueTime.sec);
                    */
	        IF4API_AddResultFormat(pWrapper, "1.16", VARSMI_TIMESTAMP, &issueTime, sizeof(TIMESTAMP));
            IF4API_AddResultNumber(pWrapper, "1.6", VARSMI_UINT, result.getIntField(idx));  idx++;
            pPayload = const_cast<unsigned char *>(result.getBlobField(idx, nPayloadLen));  idx++;
	        IF4API_AddResultFormat(pWrapper, "1.12", VARSMI_STREAM, pPayload, nPayloadLen);

            result.nextRow();
        }
        stmt.finalize();
        Close();
    }
	catch ( CppSQLite3Exception& e )
	{
        Close();
		XDEBUG(ANSI_COLOR_RED "MessageTbl DB ERROR SELECT: %d %s\r\n" ANSI_NORMAL, e.errorCode(), e.errorMessage());
        return FALSE;
	}
    return TRUE;
}

//必须在task 加载之后
int CPersistencManager::LoadBlockMap(CB_MAP &block_map,CT_MAP &task_map){
	
	if(m_useLevelDB)
	{
		for(CT_MAP::iterator it = task_map.begin(); it != task_map.end(); it++)
		{
			const char* guid = it->first.c_str();
			CCrackTask* pCT = it->second;
			leveldb::ReadOptions ro;
			leveldb::Status s;
			string value;
			int actual_num = 0;
			//连在一起申请，不然在deleteTask函数释放时会出错
			CCrackBlock* pCBs = new (std::nothrow)CCrackBlock[pCT->m_split_num];
			if (!pCBs){
				CLog::Log(LOG_LEVEL_ERROR, "Alloc object %d CCrackBlock Error\n", pCT->m_split_num);
				return -2;
			}

			for(int i = 0; i < pCT->m_split_num; i++)
			{
				s = m_LevelDB->Get(ro, BLOCK_IDX(guid, i), &value);
				if(!s.ok()) continue;

				s = m_LevelDB->Get(ro, value, &value);
				if(!s.ok()) continue;

				actual_num ++;
				CCrackBlock* item = (CCrackBlock*) value.data();
				CCrackBlock *pCB = pCBs + i;
				*pCB = *item;
				pCB->task = pCT;
	
				pCT->m_crackblock_map.insert(CB_MAP::value_type(pCB->guid,pCB));
				block_map.insert(CB_MAP::value_type(pCB->guid, pCB));
			}

			pCT->m_split_num = actual_num;
		}

		return 0;
	}
	
	int ret = 0;

	CT_MAP::iterator cur_iter ;
	CT_MAP::iterator end_iter  = task_map.end();
	CCrackTask *pCT = NULL;

	for(cur_iter = task_map.begin(); cur_iter != end_iter; cur_iter++)
	{
		const char* guid = cur_iter->first.c_str();
		pCT = cur_iter->second;
		
		//连在一起申请，不然在deleteTask函数释放时会出错
		CCrackBlock* pCBs = new (std::nothrow)CCrackBlock[pCT->m_split_num];
		if (!pCBs){
			CLog::Log(LOG_LEVEL_ERROR, "Alloc object %d CCrackBlock Error\n", pCT->m_split_num);
			return -2;
		}

		char cmd[1024];
		_snprintf(cmd, sizeof(cmd), "select * from Block where taskid='%s'", guid);
		CppSQLite3Query query = m_SQLite3DB.execQuery(cmd);
		int idx = 0;
		while (!query.eof())
		{
			CCrackBlock *pCB = pCBs + idx;
			idx ++;

			memset(pCB->john,0,sizeof(pCB->john));
			memset(pCB->m_comp_guid,0,sizeof(pCB->m_comp_guid));
			memset(pCB->guid,0,sizeof(pCB->guid));
		
			memcpy(pCB->m_comp_guid,query.fieldValue("compip"),strlen(query.fieldValue("compip")));
			memcpy(pCB->guid,query.fieldValue("blockid"),strlen(query.fieldValue("blockid")));
					
			pCB->algo = pCT->algo;
			pCB->charset = pCT->charset;
			pCB->type = query.getIntField("type");
			int len;
			const unsigned char* info = query.getBlobField("info", len);
			memcpy(&(pCB->start), info, len);

			int tmpIndex = query.getIntField("index0");
			pCB->hash_idx = tmpIndex;
			memcpy(pCB->john,pCT->m_crackhash_list[pCB->hash_idx]->m_john,sizeof(pCT->m_crackhash_list[pCB->hash_idx]->m_john));

			pCB->special = pCT->special;
			pCB->task = pCT;
			pCB->m_progress = query.getFloatField("progress");
			pCB->m_speed = query.getFloatField("speed");

			pCB->m_status = query.getIntField("status");
			pCB->m_remaintime = query.getIntField("remaintime");

			
			cur_iter->second->m_crackblock_map.insert(CB_MAP::value_type(pCB->guid,pCB));		
					
//.........这里部分代码省略.........

int CPersistencManager::LoadTaskMap(CT_MAP &task_map){

	if(m_useLevelDB)
	{
		string value;
		vector<string> allguids;
		leveldb::ReadOptions ro;
		leveldb::Status s;
		int task_count = 0;

		s = m_LevelDB->Get(ro, TASK_COUNT, &value);
		if(s.ok())
			task_count = *(int*)value.data();
		CLog::Log(LOG_LEVEL_DEBUG, "LoadTaskMap: count=%d\n", task_count);

		for(int i = 1; i <= task_count; i++)
		{
			s = m_LevelDB->Get(ro, TASK_IDX(TASK_KEY, i), &value);
			if(s.ok())
			{
				allguids.push_back(value);
			}
		}

		for(int i = 0; i < allguids.size(); i++)
		{
			s = m_LevelDB->Get(ro, allguids[i], &value);
			if(!s.ok()) continue;

			//CCrackTask类里面有类，不能直接拷贝构造函数将内存按字节拷贝，咳!
			CCrackTask* task = (CCrackTask*)value.data();
			CCrackTask* pCT = new CCrackTask();

#ifndef USE_PLACEMANT_NEW
			memcpy(pCT, (crack_task*)task, sizeof(crack_task));
			memcpy(pCT->m_owner, task->m_owner, sizeof(task->m_owner));
			int len = (char*)&task->m_filelen - (char*)&task->m_status + sizeof(task->m_filelen);
			memcpy(&pCT->m_status, &task->m_status, len);
#else
			memcpy(pCT, task, sizeof(CCrackTask));
			//调用placement new对类成员进行初始化
			new (&pCT->m_crackblock_map) CB_MAP();
			new (&pCT->cur_crack_block) CB_MAP::iterator();
			new (&pCT->m_crackhash_list) CRACK_HASH_LIST();
#endif

			task_map.insert(CT_MAP::value_type(pCT->guid,pCT));
		}

		return 0;
	}

	int ret = 0;
	
	CppSQLite3Query query = m_SQLite3DB.execQuery("select * from Task order by 1;");

    while (!query.eof())
    {
        CCrackTask *pCT = new CCrackTask();
		if (!pCT){

			CLog::Log(LOG_LEVEL_ERROR,"Alloc object CCrackTask Error\n");
			return -1;
		}

		memset(pCT->guid,0,sizeof(pCT->guid));
		memcpy(pCT->guid,query.fieldValue("taskid"),strlen(query.fieldValue("taskid")));


		pCT->algo = query.getIntField("algo");
		pCT->charset = query.getIntField("charset");
		pCT->type = query.getIntField("type");
		pCT->special = query.getIntField("filetag");
		pCT->single = query.getIntField("single");
		int len;
		const unsigned char* info = query.getBlobField("info", len);
		memcpy(&(pCT->startLength), info, len);
		memset(pCT->m_owner,0,sizeof(pCT->m_owner));
		memcpy(pCT->m_owner,query.fieldValue("owner"),strlen(query.fieldValue("owner")));

		pCT->m_status = query.getIntField("status");
		pCT->m_split_num = query.getIntField("splitnum");
		pCT->m_finish_num = query.getIntField("finishnum");
		pCT->m_bsuccess = (strcmp(query.fieldValue("success"),"1") == 0)? true : false;
		pCT->m_progress = query.getFloatField("progress");

		pCT->m_speed = query.getFloatField("speed");
		pCT->m_start_time = query.getIntField("starttime");
		pCT->m_running_time = query.getIntField("runtime");
		pCT->m_remain_time = query.getIntField("remaintime");

		pCT->count = query.getIntField("count");

		if(pCT->type == bruteforce)
			CLog::Log(LOG_LEVEL_NOMAL, "[%d %d] %d\n", pCT->startLength, pCT->endLength, pCT->count);
		else if(pCT->type == dict)
			CLog::Log(LOG_LEVEL_NOMAL, "[dict=%d] %d\n", pCT->dict_idx, pCT->count);
		else if(pCT->type == mask)
			CLog::Log(LOG_LEVEL_NOMAL, "[mask=%s] %d\n", pCT->masks, pCT->count);
		
//.........这里部分代码省略.........

//.........这里部分代码省略.........
		// ANy data can be stored in any column
		////////////////////////////////////////////////////////////////////////////////
        cout << endl << "Data types and BLOBs()" << endl;
        db.execDML("create table types(no int, "
				"name char(20), qty float, dat blob);");
        db.execDML("insert into types values(null, null, null, null);");
        db.execDML("insert into types values(1, 2, 3, 4);");
        db.execDML("insert into types values(1.1, 2.2, 3.3, 4.4);");
        db.execDML("insert into types values('a', 'b', 'c', 'd');");

        CppSQLite3Statement stmt = db.compileStatement("insert into types values(?,?,?,?);");
        unsigned char buf[256];
		memset(buf, 1, 1); stmt.bind(1, buf, 1);
		memset(buf, 2, 2); stmt.bind(2, buf, 2);
		memset(buf, 3, 3); stmt.bind(3, buf, 3);
		memset(buf, 4, 4); stmt.bind(4, buf, 4);
		stmt.execDML();
        cout << db.execScalar("select count(*) from types;") << " rows in types table" << endl;

        q = db.execQuery("select * from types;");
        while (!q.eof())
        {
			for (int i = 0; i < q.numFields(); i++)
			{
				switch (q.fieldDataType(i))
				{
				case SQLITE_INTEGER  : cout << "SQLITE_INTEGER|"; break;
				case SQLITE_FLOAT    : cout << "SQLITE_FLOAT  |"; break;
				case SQLITE_TEXT     : cout << "SQLITE_TEXT   |"; break;
				case SQLITE_BLOB     : cout << "SQLITE_BLOB   |"; break;
				case SQLITE_NULL     : cout << "SQLITE_NULL   |"; break;
				default: cout << "***UNKNOWN TYPE***"; break;
				}
			}
            q.nextRow();
			cout << endl;
        }

        nRows = db.execDML("delete from types where no = 1 or no = 1.1 or no = 'a' or no is null;");
		cout << endl << nRows << " rows deleted, leaving binary row only" << endl;

        q = db.execQuery("select * from types;");
		const unsigned char* pBlob;
		int nLen;
		pBlob = q.getBlobField(0, nLen);
		cout << "Field 1 BLOB length: " << nLen << endl;
		pBlob = q.getBlobField(1, nLen);
		cout << "Field 2 BLOB length: " << nLen << endl;
		pBlob = q.getBlobField(2, nLen);
		cout << "Field 3 BLOB length: " << nLen << endl;
		pBlob = q.getBlobField(3, nLen);
		cout << "Field 4 BLOB length: " << nLen << endl;

		q.finalize();

        nRows = db.execDML("delete from types;");
		cout << endl << nRows << " rows deleted, leaving empty table" << endl;
        unsigned char bin[256];

        for (int i = 0; i < sizeof bin; i++)
        {
            bin[i] = i;
        }

        stmt = db.compileStatement("insert into types values(?,0,0,0);");
		stmt.bind(1, bin, sizeof bin);
		stmt.execDML();

        cout << "Stored binary Length: " << sizeof bin << endl;

        q = db.execQuery("select * from types;");

		pBlob = q.getBlobField(0, nLen);
		cout << "Field 1 BLOB length: " << nLen << endl;

        for (i = 0; i < sizeof bin; i++)
        {
            if (pBlob[i] != i)
            {
				cout << "Problem: i: ," << i << " BLOB[i]: " << pBlob[i] << endl;
            }
        }
	}
    catch (CppSQLite3Exception& e)
    {
        cerr << e.errorCode() << ":" << e.errorMessage() << endl;
    }

	////////////////////////////////////////////////////////////////////////////////
    // Loop until user enters q or Q
    ////////////////////////////////////////////////////////////////////////////////
    char c(' ');

    while (c != 'q' && c != 'Q')
    {
        cout << "Press q then enter to quit: ";
        cin >> c;
    }
    return 0;
}

BOOL Maxthon3PlugIn::ExportFavoriteData( PFAVORITELINEDATA pData, int32& nDataNum )
{
	CCRCHash ojbCrcHash;

	if (pData == NULL || nDataNum == 0)
	{
		return FALSE;
	}

	if (m_pMemFavoriteDB != NULL)
	{
		CppSQLite3DB  m_SqliteDatabase;

		m_SqliteDatabase.openmem(m_pMemFavoriteDB, "");
		CppSQLite3Query Query = m_SqliteDatabase.execQuery("select * from MyFavNodes where parent_id <> ''");
		int i = 0;
		unsigned char szParentNode[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
		unsigned char szRecycle[16] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
		unsigned char szGroup[16] = {2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
		unsigned char szStartPageFav[16] = {3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

		while(!Query.eof() && i < nDataNum)
		{
			const unsigned char *pTemp = NULL;
			int nBlobLen = 0;
			pTemp = Query.getBlobField("parent_id", nBlobLen);

			if (memcmp(pTemp, szParentNode, 16) == 0)
			{
				pData[i].nPid = 0;
			}
			else if(memcmp(pTemp, szRecycle, 16) == 0)
			{
				int i = 0;
			}
			else if(memcmp(pTemp, szGroup, 16) == 0)
			{
				int j = 0;
			}
			else if(memcmp(pTemp, szStartPageFav, 16) == 0)
			{
				pData[i].nPid = 0;
				int m = 0;
			}
			else
			{
				ojbCrcHash.GetHash((BYTE *)pTemp, nBlobLen, (BYTE *)&pData[i].nPid, sizeof(uint32));
			}
			

			pTemp = Query.getBlobField("id", nBlobLen);

			if (pTemp == NULL)
			{
				continue;
			}

			ojbCrcHash.GetHash((BYTE *)pTemp, nBlobLen, (BYTE *)&pData[i].nId, sizeof(uint32));

			pTemp = Query.getBlobField("title", nBlobLen);

			if (nBlobLen != 0)
			{
				memcpy(pData[i].szTitle, pTemp, nBlobLen);

				ojbCrcHash.GetHash((BYTE *)pData[i].szTitle, wcslen(pData[i].szTitle) * sizeof(wchar_t), (BYTE *)&pData[i].nHashId, sizeof(uint32));
			}
			else
			{
				pData[i].szTitle[0] = 0;
			}

			pTemp = Query.getBlobField("url", nBlobLen);

			if (nBlobLen != 0)
			{
				memcpy(pData[i].szUrl, pTemp, nBlobLen);
			}
			else
			{
				pData[i].szUrl[0] = 0;
			}

			pData[i].bFolder = Query.getIntField("type", 1) == IT_FOLDER ? true : false;

			pData[i].nAddTimes = Query.getIntField("add_date", 0);
			pData[i].nClickTimes = Query.getIntField("visit_count", 0);
			pData[i].nLastModifyTime = Query.getIntField("last_modified", 0);
			pData[i].bDelete = false;
			pData[i].nOrder = Query.getIntField("norder", 0);

			Query.nextRow();
			i++;
		}

		nDataNum = i;

		for (int i = 0; i < nDataNum; i++)
		{
			//如果该结点的nId不是数组下标+1,则需要修正
//.........这里部分代码省略.........

//##ModelId=474D307602FF
bool CClip_ImportExport::ImportFromSqliteV1(CppSQLite3DB &db, CppSQLite3Query &qMain)
{
	try
	{
		//Load the Main Table
		m_Desc = qMain.getStringField(_T("mText"));
		long lID = qMain.getIntField(_T("lID"));

		//Load the data Table
		CClipFormat cf;
		HGLOBAL hGlobal = 0;
		m_Formats.RemoveAll();

		CString csSQL;
		csSQL.Format(
			_T("SELECT Data.* FROM Data ")
			_T("INNER JOIN Main ON Main.lID = Data.lParentID ")
			_T("WHERE Main.lID = %d ORDER BY Data.lID desc"), lID);

		CppSQLite3Query qData = db.execQuery(csSQL);
		while(qData.eof() == false)
		{
			cf.m_cfType = GetFormatID(qData.getStringField(_T("strClipBoardFormat")));
			long lOriginalSize = qData.getIntField(_T("lOriginalSize"));

			int nDataLen = 0;
			const unsigned char *cData = qData.getBlobField(_T("ooData"), nDataLen);
			if(cData != NULL)
			{
				Bytef *pUnZippedData = new Bytef[lOriginalSize];
				if(pUnZippedData)
				{
					//the data in the exported file is compressed so uncompress it now
					int nRet = uncompress(pUnZippedData, (uLongf *)&lOriginalSize, (Bytef *)cData, nDataLen);
					if(nRet == Z_OK)
					{
						cf.m_hgData = NewGlobalP(pUnZippedData, lOriginalSize);
						if(cf.m_hgData)
						{
							m_Formats.Add(cf);
							cf.m_hgData = NULL; //m_format owns m_hgData now
						}
						else
						{
							Log(StrF(_T("Error allocating NewGlobalP size = %d"), lOriginalSize));
							ASSERT(FALSE);
						}
					}
					else
					{
						Log(_T("Error uncompressing data from zlib"));
						ASSERT(FALSE);
					}

					delete []pUnZippedData;
					pUnZippedData = NULL;
				}
				else
				{
					Log(StrF(_T("Error allocating memory to unzip size = %d"), lOriginalSize));
					ASSERT(FALSE);
				}
			}

			qData.nextRow();
		}
	}
	CATCH_SQLITE_EXCEPTION_AND_RETURN(false)

	return m_Formats.GetSize() > 0;
}