|
1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include "pltables.h" |
|
17 #include "dbsqlconstants.h" |
|
18 |
|
19 |
|
20 const TInt KArrayGranularity = 4; |
|
21 |
|
22 /** |
|
23 @param aDatabase A handle to the database. |
|
24 |
|
25 @return A pointer to a new CPplGroupsTable object. |
|
26 */ |
|
27 CPplGroupsTable* CPplGroupsTable::NewL(RSqlDatabase& aDatabase) |
|
28 { |
|
29 CPplGroupsTable* self = CPplGroupsTable::NewLC(aDatabase); |
|
30 CleanupStack::Pop(self); |
|
31 return self; |
|
32 } |
|
33 |
|
34 /** |
|
35 @param aDatabase A handle to the database. |
|
36 |
|
37 @return A pointer to a new CPplGroupsTable object. |
|
38 */ |
|
39 CPplGroupsTable* CPplGroupsTable::NewLC(RSqlDatabase& aDatabase) |
|
40 { |
|
41 CPplGroupsTable* self = new (ELeave) CPplGroupsTable(aDatabase); |
|
42 CleanupStack::PushL(self); |
|
43 self->ConstructL(); |
|
44 return self; |
|
45 } |
|
46 |
|
47 /** |
|
48 Set up the CCntSqlStatement objects held by the class. |
|
49 */ |
|
50 void CPplGroupsTable::ConstructL() |
|
51 { |
|
52 // Statement types |
|
53 TCntSqlStatementType insertType(EInsert, KSqlContactGroupTableName); |
|
54 TCntSqlStatementType selectType(ESelect, KSqlContactGroupTableName); |
|
55 TCntSqlStatementType updateType(EUpdate, KSqlContactGroupTableName); |
|
56 TCntSqlStatementType deleteType(EDelete, KSqlContactGroupTableName); |
|
57 TCntSqlStatementType countContactsType(ESelect, KSqlContactTableName); |
|
58 |
|
59 // Where clauses |
|
60 |
|
61 // sizes of the clauses |
|
62 const TInt KWhereGroupClauseBufSize(KGroupContactGroupId().Size() + |
|
63 KWhereStringEqualsStringFormatText().Size() + KGroupContactGroupIdParam().Size() ); |
|
64 const TInt KWhereMemberClauseBufSize(KGroupContactGroupMemberId().Size() + |
|
65 KWhereStringEqualsStringFormatText().Size() + KGroupContactGroupMemberIdParam().Size() ); |
|
66 const TInt KWhereOrClauseBufSize(KWhereGroupClauseBufSize + KSqlOr().Size() + KWhereMemberClauseBufSize); |
|
67 |
|
68 // for WHERE contact_group_id = [contact id value] |
|
69 HBufC* whereGroupIdClause = HBufC::NewLC(KWhereGroupClauseBufSize); |
|
70 whereGroupIdClause->Des().AppendFormat(KWhereStringEqualsStringFormatText, |
|
71 &KGroupContactGroupId, &KGroupContactGroupIdParam ); |
|
72 |
|
73 // for WHERE contact_group_member_id = [contact id value] |
|
74 HBufC* whereMemberIdClause = HBufC::NewLC(KWhereMemberClauseBufSize); |
|
75 whereMemberIdClause->Des().AppendFormat(KWhereStringEqualsStringFormatText, |
|
76 &KGroupContactGroupMemberId, &KGroupContactGroupMemberIdParam ); |
|
77 |
|
78 // for WHERE contact_group_id = [contact id value] |
|
79 // OR contact_group_member_id = [contact id value] |
|
80 HBufC* whereGroupOrMemberIdClause = HBufC::NewLC(KWhereOrClauseBufSize); |
|
81 TPtr whereGroupOrMemberIdClausePtr = whereGroupOrMemberIdClause->Des(); |
|
82 whereGroupOrMemberIdClausePtr.AppendFormat(KWhereStringEqualsStringFormatText, |
|
83 &KGroupContactGroupId, &KGroupContactGroupIdParam); |
|
84 whereGroupOrMemberIdClausePtr.Append(KSqlOr); |
|
85 whereGroupOrMemberIdClausePtr.AppendFormat(KWhereStringEqualsStringFormatText, |
|
86 &KGroupContactGroupMemberId, &KGroupContactGroupMemberIdParam); |
|
87 |
|
88 // for WHERE contact_id = [contact_id] |
|
89 HBufC* whereContactIdClause = HBufC::NewLC(KWhereGroupClauseBufSize); |
|
90 whereContactIdClause->Des().AppendFormat(KWhereStringEqualsStringFormatText, |
|
91 &KContactId, &KContactIdParam ); |
|
92 |
|
93 // INSERT |
|
94 |
|
95 // insert group-member relationships |
|
96 // For a statement in the following format: |
|
97 // INSERT INTO groups |
|
98 // (group_id, contact_group_id, contact_group_member_id) |
|
99 // VALUES (NULL, [contact group id value], [contact group member id value]); |
|
100 // |
|
101 iInsertStmnt = TSqlProvider::GetSqlStatementL(insertType); |
|
102 iInsertStmnt->SetParamL(KGroupContactGroupId(), KGroupContactGroupIdParam()); |
|
103 iInsertStmnt->SetParamL(KGroupContactGroupMemberId(), KGroupContactGroupMemberIdParam()); |
|
104 |
|
105 // SELECT |
|
106 |
|
107 // select group id |
|
108 // For a statement in the following format: |
|
109 // SELECT contact_group_id FROM groups |
|
110 // WHERE contact_group_member_id = [contact id value]; |
|
111 // |
|
112 iSelectGroupsStmnt = TSqlProvider::GetSqlStatementL(selectType); |
|
113 iSelectGroupsStmnt->SetParamL(KGroupContactGroupId(), KNullDesC() ); |
|
114 iSelectGroupsStmnt->SetConditionL(*whereMemberIdClause); |
|
115 |
|
116 // select member id |
|
117 // For a statement in the following format: |
|
118 // SELECT contact_group_member_id FROM groups |
|
119 // WHERE contact_group_id = [contact id value]; |
|
120 // |
|
121 iSelectMembersStmnt = TSqlProvider::GetSqlStatementL(selectType); |
|
122 iSelectMembersStmnt->SetParamL(KGroupContactGroupMemberId(), KNullDesC() ); |
|
123 iSelectMembersStmnt->SetConditionL(*whereGroupIdClause); |
|
124 |
|
125 // DELETE |
|
126 |
|
127 // delete all where group or member equals id |
|
128 // For a statement in the following format: |
|
129 // DELETE FROM groups WHERE contact_group_id = [contact id value] |
|
130 // OR contact_group_member_id = [contact id value]; |
|
131 // |
|
132 iDeleteStmnt = TSqlProvider::GetSqlStatementL(deleteType); |
|
133 iDeleteStmnt->SetConditionL(*whereGroupOrMemberIdClause); |
|
134 |
|
135 // SELECT |
|
136 |
|
137 // SELECt count(*) FROM contact WHERE contact_id = [contact_id] |
|
138 iCountContactsStmnt = TSqlProvider::GetSqlStatementL(countContactsType); |
|
139 iCountContactsStmnt->SetParamL(KSqlCount, KSpace); |
|
140 iCountContactsStmnt->SetConditionL(*whereContactIdClause); |
|
141 |
|
142 CleanupStack::PopAndDestroy(4, whereGroupIdClause); // and whereContactIdClause, whereMemberIdClause, whereGroupOrMemberIdClause |
|
143 } |
|
144 |
|
145 |
|
146 /** |
|
147 Destructor |
|
148 |
|
149 Tidy up CCntSqlStatement objects |
|
150 */ |
|
151 CPplGroupsTable::~CPplGroupsTable() |
|
152 { |
|
153 delete iInsertStmnt; |
|
154 delete iSelectGroupsStmnt; |
|
155 delete iSelectMembersStmnt; |
|
156 delete iDeleteStmnt; |
|
157 delete iCountContactsStmnt; |
|
158 } |
|
159 |
|
160 |
|
161 /** |
|
162 Does nothing. An empty implementation to override the pure virtual method in the base class. |
|
163 */ |
|
164 void CPplGroupsTable::CreateInDbL(CContactItem& /*aItem*/) |
|
165 { |
|
166 // Do nothing. |
|
167 |
|
168 // Inserting new records in the groups table is done through the UpdateL() method. |
|
169 } |
|
170 |
|
171 |
|
172 /** |
|
173 ReadL has a dual functionality. If passed parameter is a group, will be filled to contacts |
|
174 bellonging to that group. Otherwirse, the contact item will be filed with all groups to which |
|
175 it belongs |
|
176 |
|
177 @param aItem Reference to contact item. |
|
178 */ |
|
179 void CPplGroupsTable::ReadL(CContactItem& aItem) |
|
180 { |
|
181 const TContactItemId KItemId(aItem.Id() ); |
|
182 const TUid KType(aItem.Type() ); |
|
183 if (KType == KUidContactGroup) |
|
184 { |
|
185 CContactGroup& group = static_cast<CContactGroup&>(aItem); |
|
186 group.ResetItems(); |
|
187 group.SetItems(GetListForItemL(KItemId, ETrue)); |
|
188 } |
|
189 |
|
190 |
|
191 if (KType == KUidContactCard || KType == KUidContactOwnCard || KType == KUidContactICCEntry || KType == KUidContactGroup) |
|
192 { |
|
193 CContactItemPlusGroup& item = static_cast<CContactItemPlusGroup&>(aItem); |
|
194 item.ResetGroups(); |
|
195 item.SetGroups(GetListForItemL(KItemId, EFalse)); |
|
196 } |
|
197 } |
|
198 |
|
199 |
|
200 /** |
|
201 Updates informations related to passed contact item within group table |
|
202 |
|
203 @param aItem Reference to contact item. |
|
204 */ |
|
205 void CPplGroupsTable::UpdateL(const CContactItem& aItem) |
|
206 { |
|
207 // Only write to the table if it's a group. If we add the relationship from both sides |
|
208 // (i.e. once for the group and once for the item) we will have duplicate records. |
|
209 if (aItem.Type() == KUidContactGroup) |
|
210 { |
|
211 WriteGroupMembersL(aItem); |
|
212 } |
|
213 } |
|
214 |
|
215 |
|
216 /** |
|
217 Deletes group informations related to passed contact item from group table |
|
218 |
|
219 @param aItem Reference to contact item. |
|
220 @param aLowDiskErrorOccurred out parameter; will be set to ETrue if there was an attempt to delete |
|
221 in low disk condition |
|
222 */ |
|
223 void CPplGroupsTable::DeleteL(const CContactItem& aItem, TBool& aLowDiskErrorOccurred) |
|
224 { |
|
225 DeleteItemL(aItem.Id(), aLowDiskErrorOccurred); |
|
226 } |
|
227 |
|
228 |
|
229 /** |
|
230 Creates the groups table and its indexes in the database. |
|
231 */ |
|
232 void CPplGroupsTable::CreateTableL() |
|
233 { |
|
234 User::LeaveIfError(iDatabase.Exec(KGroupsCreateStmnt() ) ); |
|
235 } |
|
236 |
|
237 |
|
238 /** |
|
239 CPplGroupsTable constructor |
|
240 |
|
241 @param aDatabase reference to contact database |
|
242 */ |
|
243 CPplGroupsTable::CPplGroupsTable(RSqlDatabase& aDatabase) : |
|
244 iDatabase(aDatabase) |
|
245 { |
|
246 } |
|
247 |
|
248 |
|
249 /** |
|
250 GetListForItemL has a dual nature. If aIsGroup is ETrue, a list of contact items belonging to |
|
251 specified group is returned. Otherwise a list of group ids to which contact id belongs is returned. |
|
252 |
|
253 @param aItemId contact item id |
|
254 @param aIsGroup ETrue if the method will fill a group. |
|
255 */ |
|
256 CContactIdArray* CPplGroupsTable::GetListForItemL(TContactItemId aItemId, TBool aIsGroup) |
|
257 { |
|
258 /* |
|
259 // Check if group membership information was not requested or if the item |
|
260 // is not derived from CContactItemPlusGroup. |
|
261 if (!(aType == KUidContactGroup || aType == KUidContactCard || |
|
262 aType == KUidContactOwnCard || aType == KUidContactICCEntry) ) |
|
263 { |
|
264 return NULL; |
|
265 } |
|
266 */ |
|
267 |
|
268 // build the RSqlStatement |
|
269 RSqlStatement stmnt; |
|
270 CleanupClosePushL(stmnt); |
|
271 TInt idIndex; |
|
272 |
|
273 // build the CCntSqlStatement statement |
|
274 const TInt KWhereParamIndex(KFirstIndex); // only one parameter in the query |
|
275 if (aIsGroup) |
|
276 { |
|
277 // group -> select members |
|
278 stmnt.PrepareL(iDatabase, iSelectMembersStmnt->SqlStringL() ); |
|
279 User::LeaveIfError(stmnt.BindInt(KWhereParamIndex, aItemId ) ); |
|
280 idIndex = stmnt.ColumnIndex(KGroupContactGroupMemberId() ); |
|
281 } |
|
282 else |
|
283 { |
|
284 // member -> select groups |
|
285 stmnt.PrepareL(iDatabase, iSelectGroupsStmnt->SqlStringL() ); |
|
286 User::LeaveIfError(stmnt.BindInt(KWhereParamIndex, aItemId ) ); |
|
287 idIndex = stmnt.ColumnIndex(KGroupContactGroupId() ); |
|
288 } |
|
289 User::LeaveIfError(idIndex); |
|
290 // fetch the list of any matching ids |
|
291 CContactIdArray* items = CContactIdArray::NewLC(); |
|
292 TInt err(KErrNone); |
|
293 while ((err = stmnt.Next() ) == KSqlAtRow) |
|
294 { |
|
295 items->AddL(stmnt.ColumnInt(idIndex) ); |
|
296 } |
|
297 |
|
298 // leave if we didn't complete going through the results properly |
|
299 if(err != KSqlAtEnd) |
|
300 { |
|
301 User::Leave(err); |
|
302 } |
|
303 |
|
304 CleanupStack::Pop(items); |
|
305 CleanupStack::PopAndDestroy(&stmnt); |
|
306 return items; |
|
307 } |
|
308 |
|
309 |
|
310 /** |
|
311 Persist the items belonging to curent group into group table |
|
312 |
|
313 @param aGroup referece to a contact group |
|
314 */ |
|
315 void CPplGroupsTable::WriteGroupMembersL(const CContactItem& aGroup) |
|
316 { |
|
317 if (aGroup.Type() != KUidContactGroup) |
|
318 { |
|
319 return; |
|
320 } |
|
321 |
|
322 const TContactItemId KGroupId(aGroup.Id() ); |
|
323 |
|
324 // make sure we clear out any previous, out-of-date data |
|
325 TBool lowDiskErr(EFalse); |
|
326 DeleteItemL(KGroupId, lowDiskErr); |
|
327 if (lowDiskErr) |
|
328 { |
|
329 User::Leave(KErrDiskFull); |
|
330 } |
|
331 |
|
332 // build the RSqlStatement |
|
333 RSqlStatement stmnt; |
|
334 CleanupClosePushL(stmnt); |
|
335 stmnt.PrepareL(iDatabase, iInsertStmnt->SqlStringL() ); |
|
336 const TInt KGroupIdIndex(KFirstIndex); // first parameter in query... |
|
337 const TInt KMemberIdIndex(KGroupIdIndex + 1); // ...and the second parameter |
|
338 |
|
339 // copy and sort the member id array so we can see if there are duplicates |
|
340 const CContactIdArray* contactIdArray = static_cast<const CContactGroup&>(aGroup).ItemsContained(); //does not take the ownership |
|
341 |
|
342 const TInt arrayCount = contactIdArray->Count(); |
|
343 CArrayFixFlat<TContactItemId>* sortedList = new(ELeave) CArrayFixFlat<TContactItemId>(KArrayGranularity); |
|
344 CleanupStack::PushL(sortedList); |
|
345 for(TInt loop = 0;loop < arrayCount; ++loop) |
|
346 { |
|
347 sortedList->AppendL((*contactIdArray)[loop]); |
|
348 } |
|
349 TKeyArrayFix key(0,ECmpTInt); |
|
350 sortedList->Sort(key); |
|
351 |
|
352 // insert the group-member relationships |
|
353 const TInt KCountStmntParamIndex(KFirstIndex); // first and only parameter in query |
|
354 const TInt listLen(sortedList->Count() ); |
|
355 TInt lastId(0); |
|
356 for (TInt i = 0; i < listLen; ++i) |
|
357 { |
|
358 TInt itemId((*sortedList)[i]); |
|
359 |
|
360 //check if a contact item with itemId id really exists in contact database |
|
361 RSqlStatement countStmnt; |
|
362 CleanupClosePushL(countStmnt); |
|
363 countStmnt.PrepareL(iDatabase, iCountContactsStmnt->SqlStringL() ); |
|
364 User::LeaveIfError(countStmnt.BindInt(KCountStmntParamIndex, itemId) ); |
|
365 TInt count = 0; |
|
366 TInt err = KErrNone; |
|
367 if((err = countStmnt.Next() ) == KSqlAtRow) |
|
368 { |
|
369 count = countStmnt.ColumnInt(iCountContactsStmnt->ParameterIndex(KSqlCount) ); |
|
370 } |
|
371 else |
|
372 { |
|
373 User::LeaveIfError(err); |
|
374 } |
|
375 |
|
376 if(count == 0) |
|
377 { |
|
378 User::Leave(KErrNotFound); |
|
379 } |
|
380 CleanupStack::PopAndDestroy(&countStmnt); |
|
381 |
|
382 // only insert this if we haven't already seen it |
|
383 if (itemId != lastId || i == 0) |
|
384 { |
|
385 User::LeaveIfError(stmnt.BindInt(KGroupIdIndex, KGroupId) ); |
|
386 User::LeaveIfError(stmnt.BindInt(KMemberIdIndex, itemId) ); |
|
387 User::LeaveIfError(stmnt.Exec() ); |
|
388 User::LeaveIfError(stmnt.Reset() ); |
|
389 } |
|
390 lastId = itemId; |
|
391 } |
|
392 |
|
393 CleanupStack::PopAndDestroy(2, &stmnt); // and sortedList |
|
394 } |
|
395 |
|
396 |
|
397 /** |
|
398 Deletes information about group for the passed contact item id |
|
399 |
|
400 @param aItemId contact item id |
|
401 @param aLowDiskErrorOccurred out parameter; will be set to ETrue if there was a deletion in |
|
402 low disk condition |
|
403 */ |
|
404 void CPplGroupsTable::DeleteItemL(TContactItemId aItemId, TBool& aLowDiskErrorOccurred) |
|
405 { |
|
406 RSqlStatement stmnt; |
|
407 CleanupClosePushL(stmnt); |
|
408 stmnt.PrepareL(iDatabase, iDeleteStmnt->SqlStringL() ); |
|
409 |
|
410 const TInt KGroupIdIndex(KFirstIndex); // first parameter in query... |
|
411 const TInt KMemberIdIndex(KGroupIdIndex + 1); // ...and the second parameter |
|
412 User::LeaveIfError(stmnt.BindInt(KGroupIdIndex, aItemId) ); |
|
413 User::LeaveIfError(stmnt.BindInt(KMemberIdIndex, aItemId) ); |
|
414 TInt err = stmnt.Exec(); |
|
415 CleanupStack::PopAndDestroy(&stmnt); |
|
416 |
|
417 if (err == KErrDiskFull) |
|
418 { |
|
419 aLowDiskErrorOccurred = ETrue; |
|
420 } |
|
421 else |
|
422 { |
|
423 User::LeaveIfError(err); |
|
424 } |
|
425 } |