browserutilities/recenturlstore/RecentUrlSrc/RecentUrlStore.cpp
changeset 10 a359256acfc6
parent 0 dd21522fd290
child 25 0ed94ceaa377
equal deleted inserted replaced
5:10e98eab6f85 10:a359256acfc6
   138 // Returns matching urls.
   138 // Returns matching urls.
   139 //-----------------------------------------------------------------------------
   139 //-----------------------------------------------------------------------------
   140 void CRecentUrlStore::GetDataL (RDbNamedDatabase& aDataBase, 
   140 void CRecentUrlStore::GetDataL (RDbNamedDatabase& aDataBase, 
   141 			CDesCArray& aUrls, CDesCArray& aTitles, const TDesC& aUrl)
   141 			CDesCArray& aUrls, CDesCArray& aTitles, const TDesC& aUrl)
   142     {
   142     {
   143 	
   143     // shouldn't happen but if it's too long just skip it!
   144     TInt rowCount(0);
   144     if ( aUrl.Length() <= KUrlSize)
   145 
   145 		{	
   146 	// select values from the database filtered by url
   146 		TInt rowCount(0);
   147 	if (aUrl.Length())
   147 
   148 		{
   148 		// select values from the database filtered by url
   149 		HBufC* domain = aUrl.AllocLC();
   149 		if (aUrl.Length())
   150 		domain->Des().LowerCase();
   150 			{
   151 		iSQLStatement.Format(KSQLSelect, domain, domain);
   151 			HBufC* domain = aUrl.AllocLC();
   152 		CleanupStack::PopAndDestroy();
   152 			domain->Des().LowerCase();
   153 		}
   153 			iSQLStatement.Format(KSQLSelect, domain, domain);
   154 	else
   154 			CleanupStack::PopAndDestroy();
   155 		{
   155 			}
   156 		iSQLStatement.Format(KSQLSelectAll);
   156 		else
   157 		}
   157 			{
   158 	
   158 			iSQLStatement.Format(KSQLSelectAll);
   159 
   159 			}
   160     RDbView view;
   160 		
   161     
   161 		RDbView view;    
   162     TInt err = view.Prepare(aDataBase, TDbQuery(iSQLStatement));
   162 		CleanupClosePushL( view );
   163     if (err == KErrNone)
   163 		User::LeaveIfError( view.Prepare(aDataBase, TDbQuery(iSQLStatement)) );
   164     	{
   164 		User::LeaveIfError( view.EvaluateAll() ); 
   165     	err = view.EvaluateAll();
   165 		view.FirstL();
   166     	if (err == KErrNone)
   166 			// loop through rows and build the list
   167     		{
   167 		while (view.AtRow() && rowCount++ < KMaxRows)
   168     		view.FirstL();
   168 			{
   169     		// loop through rows and build the list
   169 			view.GetL();
   170     		while (view.AtRow() && rowCount++ < KMaxRows)
   170 			aUrls.AppendL(view.ColDes(KUrlCol));
   171     			{
   171 			aTitles.AppendL(view.ColDes(KTitleCol));
   172     			view.GetL();
   172 			view.NextL();
   173 				aUrls.AppendL(view.ColDes(KUrlCol));
   173 			}
   174 				aTitles.AppendL(view.ColDes(KTitleCol));
   174 		/*
   175     			view.NextL();
   175 		* This loop will keep the number of rows in the database at a reasonable size by
   176     			}
   176 		* deleting old rows (deletes rows beyond KMaxRows).  Should be at most 1 row deleted.
   177     		/*
   177 		* Its more efficiant to delete it here than in the SaveData because in this function
   178     		* This loop will keep the number of rows in the database at a reasonable size by
   178 		* we already have the list and know its size
   179     		* deleting old rows (deletes rows beyond KMaxRows).  Should be at most 1 row deleted.
   179 		*/
   180     		* Its more efficiant to delete it here than in the SaveData because in this function
   180 		while (view.AtRow())
   181     		* we already have the list and know its size
   181 			{
   182     		*/
   182 			view.GetL();
   183     		while (view.AtRow())
   183 			iSQLStatement.Format(KSQLDelete, &aUrl);
   184     			{
   184 			aDataBase.Execute(iSQLStatement);
   185     			view.GetL();
   185 			view.NextL();
   186     			iSQLStatement.Format(KSQLDelete, &aUrl);
   186 			}
   187 				aDataBase.Execute(iSQLStatement);
   187 		CleanupStack::PopAndDestroy( &view );
   188     			view.NextL();
   188 		}
   189     			}
       
   190        		}
       
   191     	}
       
   192     view.Close();
       
   193     }
   189     }
   194 
   190 
   195 //-----------------------------------------------------------------------------
   191 //-----------------------------------------------------------------------------
   196 // CRecentUrlStore::DeleteData
   192 // CRecentUrlStore::DeleteData
   197 // Deletes a single row from the database.
   193 // Deletes a single row from the database.
   198 //-----------------------------------------------------------------------------
   194 //-----------------------------------------------------------------------------
   199 EXPORT_C void CRecentUrlStore::DeleteData (const TDesC& aUrl)
   195 EXPORT_C void CRecentUrlStore::DeleteData (const TDesC& aUrl)
   200     {
   196     {  
   201     RDbNamedDatabase dataBase;
   197     // shouldn't happen but if it's too long just skip it!
   202     if (OpenDatabase(dataBase) == KErrNone)
   198      if ( aUrl.Length() <= KUrlSize)
   203     	{
   199 		{		
   204 		iSQLStatement.Format(KSQLDelete, &aUrl);
   200 		RDbNamedDatabase dataBase;
   205 		dataBase.Execute(iSQLStatement);
   201 		if (OpenDatabase(dataBase) == KErrNone)
   206     	dataBase.Close();
   202 			{
   207     	}
   203 			iSQLStatement.Format(KSQLDelete, &aUrl);
   208     }
   204 			dataBase.Execute(iSQLStatement);
       
   205 			dataBase.Close();
       
   206 			}
       
   207 		}
       
   208 	}
   209 
   209 
   210 //-----------------------------------------------------------------------------
   210 //-----------------------------------------------------------------------------
   211 // CRecentUrlStore::SaveDataL
   211 // CRecentUrlStore::SaveDataL
   212 // Save the url in store.
   212 // Save the url in store.
   213 //-----------------------------------------------------------------------------
   213 //-----------------------------------------------------------------------------
   214 EXPORT_C void CRecentUrlStore::SaveData (const TDesC& aUrl, const TDesC& aTitle)
   214 EXPORT_C void CRecentUrlStore::SaveDataL (const TDesC& aUrl, const TDesC& aTitle)
   215 	{
   215 	{
   216 	RDbNamedDatabase dataBase;
   216 	TInt urlLength (aUrl.Length());	
   217 	TInt urlLength (aUrl.Length());
       
   218 	
       
   219 	// shouldn't happen but if it's too long for the data store just skip it!
   217 	// shouldn't happen but if it's too long for the data store just skip it!
   220 	if (urlLength > KUrlSize)
   218 	if (urlLength <= KUrlSize)
   221 		{
   219 		{
   222 		return;
   220 		RDbNamedDatabase dataBase;
   223 		}
   221 		CleanupClosePushL( dataBase );
   224 	
   222 		if (OpenDatabase(dataBase) == KErrNone)
   225 	if (OpenDatabase(dataBase) == KErrNone)
   223 			{
   226 		{
   224 			// find the point where the domain starts and ends
   227 		// find the point where the domain starts and ends
   225 			TInt domainLength(urlLength);
   228 		TInt domainLength(urlLength);
   226 			TInt domainStart(0);
   229 		TInt domainStart(0);
   227 			
   230 		
   228 			TInt startPos = aUrl.Find(KDomainDelim);
   231 		TInt startPos = aUrl.Find(KDomainDelim);
   229 			if (startPos != KErrNotFound)
   232 		if (startPos != KErrNotFound)
       
   233 			{
       
   234 			domainStart = startPos + (KDomainDelim().Length()); // first char after delim
       
   235 			TInt len = aUrl.Right(urlLength - domainStart).Find(KDomainDelim);
       
   236 			if (len > 0) // ignore delim following delim.  we don't want an empty string
       
   237 				{
   230 				{
   238 				domainLength = len;
   231 				domainStart = startPos + (KDomainDelim().Length()); // first char after delim
       
   232 				TInt len = aUrl.Right(urlLength - domainStart).Find(KDomainDelim);
       
   233 				if (len > 0) // ignore delim following delim.  we don't want an empty string
       
   234 					{
       
   235 					domainLength = len;
       
   236 					}
       
   237 				else
       
   238 					{
       
   239 					domainLength -= domainStart;
       
   240 					}
   239 				}
   241 				}
   240 			else
   242 				
   241 				{
   243 			// make sure it's not too big for the data store
   242 				domainLength -= domainStart;
   244 			domainLength = (domainLength > KDomainSize) ? KDomainSize : domainLength;
   243 				}
   245 			TInt titleLength = (aTitle.Length() > KTitleSize) ? KTitleSize : aTitle.Length();
   244 			}
   246 				
       
   247 			HBufC* domain = aUrl.Mid(domainStart,domainLength).AllocLC();
       
   248 			domain->Des().LowerCase();
       
   249 			HBufC* title = aTitle.Left(titleLength).AllocLC();
       
   250 	
       
   251 			// delete and re-insert
       
   252 			iSQLStatement.Format(KSQLDelete, &aUrl);
       
   253 			dataBase.Execute(iSQLStatement);
       
   254 			iSQLStatement.Format(KSQLInsert, domain, &aUrl, title);
       
   255 			dataBase.Execute(iSQLStatement);
   245 			
   256 			
   246 		// make sure it's not too big for the data store
   257 			CleanupStack::PopAndDestroy(3, &dataBase );
   247 		domainLength = (domainLength > KDomainSize) ? KDomainSize : domainLength;
   258 			}
   248 		TInt titleLength = (aTitle.Length() > KTitleSize) ? KTitleSize : aTitle.Length();
       
   249 			
       
   250 		HBufC* domain = aUrl.Mid(domainStart,domainLength).AllocLC();
       
   251 		domain->Des().LowerCase();
       
   252 		HBufC* title = aTitle.Left(titleLength).AllocLC();
       
   253 
       
   254 		// delete and re-insert
       
   255 		iSQLStatement.Format(KSQLDelete, &aUrl);
       
   256 		dataBase.Execute(iSQLStatement);
       
   257 		iSQLStatement.Format(KSQLInsert, domain, &aUrl, title);
       
   258 		CleanupStack::PopAndDestroy(2); // domain, title
       
   259 		
       
   260 		dataBase.Execute(iSQLStatement);
       
   261 		dataBase.Close();
       
   262 		}
   259 		}
   263 	}
   260 	}
   264 	
   261 	
   265 //-----------------------------------------------------------------------------
   262 //-----------------------------------------------------------------------------
   266 // CRecentUrlStore::ClearData
   263 // CRecentUrlStore::ClearData
   277 //-----------------------------------------------------------------------------
   274 //-----------------------------------------------------------------------------
   278 // CRecentUrlStore::DeleteOldRowsL
   275 // CRecentUrlStore::DeleteOldRowsL
   279 //-----------------------------------------------------------------------------
   276 //-----------------------------------------------------------------------------
   280 void CRecentUrlStore::DeleteOldRowsL (RDbNamedDatabase& aDataBase)
   277 void CRecentUrlStore::DeleteOldRowsL (RDbNamedDatabase& aDataBase)
   281     {
   278     {
   282 	
       
   283     TInt rowCount(0);
   279     TInt rowCount(0);
   284 
       
   285 	iSQLStatement.Format(KSQLSelectAll);
   280 	iSQLStatement.Format(KSQLSelectAll);
   286 	
   281 	
   287     RDbView view;
   282     RDbView view;
   288     
   283     CleanupClosePushL( view );
   289     TInt err = view.Prepare(aDataBase, TDbQuery(iSQLStatement));
   284     
   290     if (err == KErrNone)
   285     User::LeaveIfError( view.Prepare(aDataBase, TDbQuery(iSQLStatement)));
   291     	{
   286     User::LeaveIfError(  view.EvaluateAll() );
   292     	err = view.EvaluateAll();
   287 	view.FirstL();
   293     	if (err == KErrNone)
   288 	// loop through rows we want to keep
   294     		{
   289 	while (view.AtRow() && rowCount++ < KMaxRows)
   295     		view.FirstL();
   290 		{
   296     		// loop through rows we want to keep
   291 		view.NextL();
   297     		while (view.AtRow() && rowCount++ < KMaxRows)
   292 		}
   298     			{
   293 	// delete the rows that are old
   299     			view.NextL();
   294 	while (view.AtRow())
   300     			}
   295 		{
   301     		// delete the rows that are old
   296 		view.DeleteL();
   302     		while (view.AtRow())
   297 		view.NextL();
   303     			{
   298 		}
   304     			view.DeleteL();
   299     CleanupStack::PopAndDestroy( &view );	
   305     			view.NextL();
       
   306     			}
       
   307        		}
       
   308     	}
       
   309     view.Close();
       
   310     }
   300     }
   311 
   301 
   312 //-----------------------------------------------------------------------------
   302 //-----------------------------------------------------------------------------
   313 // CRecentUrlStore::OpenDatabase
   303 // CRecentUrlStore::OpenDatabase
   314 // Open the data store.
   304 // Open the data store.