|
1 /* |
|
2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Responsible for interation with the Artist table |
|
15 * |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 // INCLUDE FILES |
|
21 #include <sqldb.h> |
|
22 |
|
23 #include <mpxlog.h> |
|
24 |
|
25 #include "mpxdbcommonutil.h" |
|
26 #include "mpxdbcommondef.h" |
|
27 #include "mpxmediamusicdefs.h" |
|
28 #include "mpxdbmanager.h" |
|
29 |
|
30 #include "mpxcollectiondbdef.h" |
|
31 #include "mpxdbpluginqueries.h" |
|
32 #include "mpxdbutil.h" |
|
33 #include "mpxdbartist.h" |
|
34 |
|
35 // CONSTANTS |
|
36 |
|
37 // ============================ MEMBER FUNCTIONS ============================== |
|
38 |
|
39 // ---------------------------------------------------------------------------- |
|
40 // Two-phased constructor. |
|
41 // ---------------------------------------------------------------------------- |
|
42 // |
|
43 CMPXDbArtist* CMPXDbArtist::NewL( |
|
44 CMPXDbManager& aDbManager, |
|
45 TMPXGeneralCategory aCategory) |
|
46 { |
|
47 MPX_FUNC("CMPXDbArtist::NewL"); |
|
48 |
|
49 CMPXDbArtist* self = CMPXDbArtist::NewLC(aDbManager, aCategory); |
|
50 CleanupStack::Pop(self); |
|
51 return self; |
|
52 } |
|
53 |
|
54 // ---------------------------------------------------------------------------- |
|
55 // Two-phased constructor. |
|
56 // ---------------------------------------------------------------------------- |
|
57 // |
|
58 CMPXDbArtist* CMPXDbArtist::NewLC( |
|
59 CMPXDbManager& aDbManager, |
|
60 TMPXGeneralCategory aCategory) |
|
61 { |
|
62 MPX_FUNC("CMPXDbArtist::NewLC"); |
|
63 |
|
64 CMPXDbArtist* self = new (ELeave) CMPXDbArtist(aDbManager, aCategory); |
|
65 CleanupStack::PushL(self); |
|
66 self->ConstructL(); |
|
67 return self; |
|
68 } |
|
69 |
|
70 // ---------------------------------------------------------------------------- |
|
71 // Destructor |
|
72 // ---------------------------------------------------------------------------- |
|
73 // |
|
74 CMPXDbArtist::~CMPXDbArtist() |
|
75 { |
|
76 MPX_FUNC("CMPXDbArtist::~CMPXDbArtist"); |
|
77 } |
|
78 |
|
79 // ---------------------------------------------------------------------------- |
|
80 // Constructor |
|
81 // ---------------------------------------------------------------------------- |
|
82 // |
|
83 CMPXDbArtist::CMPXDbArtist( |
|
84 CMPXDbManager& aDbManager, |
|
85 TMPXGeneralCategory aCategory) : |
|
86 CMPXDbCategory(aDbManager, aCategory) |
|
87 { |
|
88 MPX_FUNC("CMPXDbArtist::CMPXDbArtist"); |
|
89 } |
|
90 |
|
91 // ---------------------------------------------------------------------------- |
|
92 // Second phase constructor. |
|
93 // ---------------------------------------------------------------------------- |
|
94 // |
|
95 void CMPXDbArtist::ConstructL() |
|
96 { |
|
97 MPX_FUNC("CMPXDbArtist::ConstructL"); |
|
98 |
|
99 BaseConstructL(); |
|
100 } |
|
101 |
|
102 // ---------------------------------------------------------------------------- |
|
103 // CMPXDbArtist::AddItemL |
|
104 // ---------------------------------------------------------------------------- |
|
105 // |
|
106 TUint32 CMPXDbArtist::AddItemL( |
|
107 TMPXGeneralCategory /*aCategory*/, |
|
108 const CMPXMedia& aMedia, |
|
109 TInt aDriveId, |
|
110 TBool& aNewRecord, |
|
111 TBool aCaseSensitive) |
|
112 { |
|
113 MPX_FUNC("CMPXDbArtist::AddItemL"); |
|
114 |
|
115 TPtrC artist(KNullDesC); |
|
116 TPtrC albumArt(KNullDesC); |
|
117 |
|
118 if (aMedia.IsSupported(KMPXMediaMusicArtist)) |
|
119 { |
|
120 artist.Set(aMedia.ValueText(KMPXMediaMusicArtist).Left(KMCMaxTextLen)); |
|
121 } |
|
122 |
|
123 if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName)) |
|
124 { |
|
125 albumArt.Set(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen)); |
|
126 } |
|
127 |
|
128 // try to find the item first |
|
129 TUint32 rowId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), iCategory, |
|
130 artist, aCaseSensitive)); |
|
131 |
|
132 HBufC* query = PreProcessStringLC(KQueryCategoryItem); |
|
133 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aDriveId, *query, rowId)); |
|
134 CleanupStack::PopAndDestroy(query); |
|
135 CleanupClosePushL(recordset); |
|
136 |
|
137 TInt result(recordset.Next()); |
|
138 if (result == KSqlAtEnd) |
|
139 { |
|
140 aNewRecord = result; |
|
141 |
|
142 // insert new |
|
143 HBufC* name = MPXDbCommonUtil::ProcessSingleQuotesLC(artist); |
|
144 HBufC* art = MPXDbCommonUtil::ProcessSingleQuotesLC(albumArt); |
|
145 |
|
146 iDbManager.ExecuteQueryL(aDriveId, KQueryArtistInsert, rowId, name, 1, 0, art); |
|
147 |
|
148 CleanupStack::PopAndDestroy(art); |
|
149 CleanupStack::PopAndDestroy(name); |
|
150 } |
|
151 else if (result == KSqlAtRow) |
|
152 { |
|
153 // retrieve Art from Artist table |
|
154 TPtrC art(KNullDesC); |
|
155 art.Set(MPXDbCommonUtil::GetColumnTextL(recordset, EArtistArt)); |
|
156 |
|
157 // the current one is Unknown and the new one is Not Unknown |
|
158 if ( art == KNullDesC && albumArt != KNullDesC ) |
|
159 { |
|
160 HBufC* artReplaceSingleQuote = |
|
161 MPXDbCommonUtil::ProcessSingleQuotesLC( albumArt ); |
|
162 _LIT( KFormatArt, "Art=\'%S\'" ); |
|
163 HBufC* setStr = HBufC::NewLC(KMaxFileName); |
|
164 setStr->Des().Format( KFormatArt, artReplaceSingleQuote ); |
|
165 |
|
166 iDbManager.ExecuteQueryL(aDriveId, KQueryArtistUpdate, setStr, rowId); |
|
167 CleanupStack::PopAndDestroy(setStr); |
|
168 CleanupStack::PopAndDestroy(artReplaceSingleQuote); |
|
169 } |
|
170 |
|
171 // increment the number of songs for the category |
|
172 query = PreProcessStringLC(KQueryCategoryIncrementSongCount); |
|
173 iDbManager.ExecuteQueryL(aDriveId, *query, rowId); |
|
174 CleanupStack::PopAndDestroy(query); |
|
175 } |
|
176 else |
|
177 { |
|
178 MPX_DEBUG2("SQL error %d", result); |
|
179 User::Leave(result); |
|
180 } |
|
181 |
|
182 CleanupStack::PopAndDestroy(&recordset); |
|
183 |
|
184 return rowId; |
|
185 } |
|
186 |
|
187 // ---------------------------------------------------------------------------- |
|
188 // CMPXDbArtist::DecrementSongsForCategoryL |
|
189 // ---------------------------------------------------------------------------- |
|
190 // |
|
191 void CMPXDbArtist::DecrementSongsForCategoryL( |
|
192 const TUint32 aId, |
|
193 TInt aDriveId, |
|
194 CMPXMessageArray* aItemChangedMessages, |
|
195 TBool& aItemExist |
|
196 #ifdef ABSTRACTAUDIOALBUM_INCLUDED |
|
197 , |
|
198 TBool /*aMTPInUse*/ |
|
199 #endif //ABSTRACTAUDIOALBUM_INCLUDED |
|
200 ) |
|
201 { |
|
202 MPX_FUNC("CMPXDbArtist::DecrementSongsForCategoryL"); |
|
203 |
|
204 TInt songsCount(0); |
|
205 TInt albumsCount(0); |
|
206 |
|
207 GetSongsAndAlbumsCountL(aDriveId, aId, songsCount, albumsCount); |
|
208 |
|
209 MPX_DEBUG4("id %d, songsCount %d, albumsCount %d", aId, songsCount, albumsCount); |
|
210 |
|
211 // if just one song uses this category. Use <= just in case |
|
212 if (songsCount <= 1 && albumsCount == 0) |
|
213 { |
|
214 aItemExist = EFalse; |
|
215 // delete the category |
|
216 DeleteCategoryL(aId, aDriveId); |
|
217 |
|
218 if (aItemChangedMessages) |
|
219 { |
|
220 // add the item changed message |
|
221 MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aId, EMPXItemDeleted, |
|
222 iCategory, KDBPluginUid); |
|
223 } |
|
224 } |
|
225 else if (songsCount > 0) |
|
226 { |
|
227 aItemExist = ETrue; |
|
228 // decrement the number of songs for the category |
|
229 HBufC* query = PreProcessStringLC(KQueryCategoryDecrementSongCount); |
|
230 iDbManager.ExecuteQueryL(aDriveId, *query, aId); |
|
231 CleanupStack::PopAndDestroy(query); |
|
232 } |
|
233 } |
|
234 |
|
235 // ---------------------------------------------------------------------------- |
|
236 // CMPXDbArtist::UpdateMediaL |
|
237 // ---------------------------------------------------------------------------- |
|
238 // |
|
239 void CMPXDbArtist::UpdateMediaL( |
|
240 RSqlStatement& aRecord, |
|
241 const TArray<TMPXAttribute>& aAttrs, |
|
242 CMPXMedia& aMedia) |
|
243 { |
|
244 MPX_FUNC("CMPXDbArtist::UpdateMediaL"); |
|
245 |
|
246 TInt count(aAttrs.Count()); |
|
247 for (TInt i = 0; i < count; ++i) |
|
248 { |
|
249 TInt contentId(aAttrs[i].ContentId()); |
|
250 TUint attributeId(aAttrs[i].AttributeId()); |
|
251 |
|
252 if (contentId == KMPXMediaIdGeneral) |
|
253 { |
|
254 if (attributeId & EMPXMediaGeneralId) |
|
255 { |
|
256 MPX_DEBUG1(" EMPXMediaGeneralId"); |
|
257 |
|
258 aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, |
|
259 aRecord.ColumnInt64(EArtistUniqueId)); |
|
260 MPX_DEBUG2(" Id[%d]", aRecord.ColumnInt64(EArtistUniqueId)); |
|
261 } |
|
262 if (attributeId & EMPXMediaGeneralTitle) |
|
263 { |
|
264 MPX_DEBUG1(" EMPXMediaGeneralTitle"); |
|
265 |
|
266 TPtrC artist( MPXDbCommonUtil::GetColumnTextL(aRecord, EArtistName) ); |
|
267 aMedia.SetTextValueL(KMPXMediaGeneralTitle, |
|
268 MPXDbCommonUtil::GetColumnTextL(aRecord, EArtistName)); |
|
269 |
|
270 MPX_DEBUG2(" Artist[%S]", &artist); |
|
271 } |
|
272 if (attributeId & EMPXMediaGeneralCount) |
|
273 { |
|
274 // get songs count from all drives |
|
275 TInt songCount = GetSongsCountL( KDbManagerAllDrives, |
|
276 aRecord.ColumnInt64( EArtistUniqueId ) ); |
|
277 aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralCount, songCount); // mod by anjokela |
|
278 |
|
279 MPX_DEBUG1(" EMPXMediaGeneralCount"); |
|
280 MPX_DEBUG2(" SongCount[%d]", songCount); |
|
281 } |
|
282 } // end if contentId == KMPXMediaIdGeneral |
|
283 else if ( contentId == KMPXMediaIdMusic ) |
|
284 { |
|
285 if (attributeId & EMPXMediaMusicAlbumArtFileName) |
|
286 { |
|
287 MPX_DEBUG1(" EMPXMediaMusicAlbumArtFileName"); |
|
288 TPtrC art(KNullDesC); |
|
289 art.Set(MPXDbCommonUtil::GetColumnTextL(aRecord, EArtistArt)); |
|
290 aMedia.SetTextValueL(KMPXMediaMusicAlbumArtFileName, art); |
|
291 MPX_DEBUG2(" Art[%S]", &art); |
|
292 } |
|
293 } |
|
294 } // end for |
|
295 |
|
296 aMedia.SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXItem); |
|
297 aMedia.SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, iCategory); |
|
298 } |
|
299 |
|
300 // ---------------------------------------------------------------------------- |
|
301 // CMPXDbArtist::GenerateArtistFieldsValuesL |
|
302 // ---------------------------------------------------------------------------- |
|
303 // |
|
304 void CMPXDbArtist::GenerateArtistFieldsValuesL(const CMPXMedia& aMedia, CDesCArray& aFields, CDesCArray& aValues) |
|
305 { |
|
306 if (aMedia.IsSupported(KMPXMediaMusicAlbumArtFileName)) |
|
307 { |
|
308 const TDesC& albumArtFilename = aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen); |
|
309 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCMusicArt, albumArtFilename); |
|
310 } |
|
311 } |
|
312 |
|
313 // ---------------------------------------------------------------------------- |
|
314 // CMPXDbArtist::GetAllCategoryItemsL |
|
315 // ---------------------------------------------------------------------------- |
|
316 // |
|
317 void CMPXDbArtist::GetAllCategoryItemsL( |
|
318 const TArray<TMPXAttribute>& aAttrs, |
|
319 CMPXMediaArray& aMediaArray) |
|
320 { |
|
321 MPX_FUNC("CMPXDbArtist::GetAllCategoryItemsL"); |
|
322 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryArtistAll())); |
|
323 CleanupClosePushL(recordset); |
|
324 ProcessRecordsetL(aAttrs, recordset, aMediaArray); |
|
325 CleanupStack::PopAndDestroy(&recordset); |
|
326 } |
|
327 |
|
328 // ---------------------------------------------------------------------------- |
|
329 // CMPXDbArtist::UpdateItemL |
|
330 // ---------------------------------------------------------------------------- |
|
331 // |
|
332 void CMPXDbArtist::UpdateItemL( |
|
333 TUint32 aId, |
|
334 const CMPXMedia& aMedia, |
|
335 TInt aDriveId, |
|
336 CMPXMessageArray* aItemChangedMessages) |
|
337 { |
|
338 MPX_FUNC("CMPXDbAlbum::UpdateItemL"); |
|
339 |
|
340 CDesCArrayFlat* fields = new (ELeave) CDesCArrayFlat(EArtistFieldCount); |
|
341 CleanupStack::PushL(fields); |
|
342 CDesCArrayFlat* values = new (ELeave) CDesCArrayFlat(EArtistFieldCount); |
|
343 CleanupStack::PushL(values); |
|
344 |
|
345 // process the media parameter and construct the fields and values array |
|
346 GenerateArtistFieldsValuesL(aMedia, *fields, *values); |
|
347 |
|
348 // construct the SET string |
|
349 HBufC* setStr = MPXDbCommonUtil::StringFromArraysLC(*fields, *values, KMCEqualSign, KMCCommaSign); |
|
350 |
|
351 if (setStr->Length()) |
|
352 { |
|
353 // execute the query |
|
354 iDbManager.ExecuteQueryL(aDriveId, KQueryArtistUpdate, setStr, aId); |
|
355 MPXDbCommonUtil::AddItemAlbumChangedMessageL(*aItemChangedMessages, aId, EMPXItemModified, |
|
356 EMPXArtist, KDBPluginUid, ETrue, 0 ); |
|
357 } |
|
358 |
|
359 CleanupStack::PopAndDestroy(setStr); |
|
360 CleanupStack::PopAndDestroy(values); |
|
361 CleanupStack::PopAndDestroy(fields); |
|
362 } |
|
363 |
|
364 // ---------------------------------------------------------------------------- |
|
365 // CMPXDbArtist::AddAlbumArtistL |
|
366 // ---------------------------------------------------------------------------- |
|
367 // |
|
368 TUint32 CMPXDbArtist::AddAlbumArtistL( |
|
369 const TDesC& aName, |
|
370 const TDesC& aArt, |
|
371 TInt aDriveId) |
|
372 { |
|
373 MPX_FUNC("CMPXDbArtist::AddAlbumArtistL"); |
|
374 |
|
375 // try to find the item first |
|
376 TUint32 rowId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), iCategory, |
|
377 aName, ETrue)); |
|
378 HBufC* query = PreProcessStringLC(KQueryCategoryItem); |
|
379 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aDriveId, *query, rowId)); |
|
380 CleanupStack::PopAndDestroy(query); |
|
381 CleanupClosePushL(recordset); |
|
382 |
|
383 TInt result(recordset.Next()); |
|
384 if (result == KSqlAtEnd) |
|
385 { |
|
386 // insert new |
|
387 HBufC* name = MPXDbCommonUtil::ProcessSingleQuotesLC(aName); |
|
388 HBufC* art = MPXDbCommonUtil::ProcessSingleQuotesLC(aArt); |
|
389 |
|
390 iDbManager.ExecuteQueryL(aDriveId, KQueryArtistInsert, rowId, name, 0, 1, art); |
|
391 |
|
392 CleanupStack::PopAndDestroy(art); |
|
393 CleanupStack::PopAndDestroy(name); |
|
394 } |
|
395 else if (result == KSqlAtRow) |
|
396 { |
|
397 // retrieve Art from Artist table |
|
398 TPtrC art(KNullDesC); |
|
399 art.Set(MPXDbCommonUtil::GetColumnTextL(recordset, EArtistArt)); |
|
400 |
|
401 // the current one is Unknown and the new one is Not Unknown |
|
402 if ( art == KNullDesC && aArt != KNullDesC ) |
|
403 { |
|
404 HBufC* artReplaceSingleQuote = |
|
405 MPXDbCommonUtil::ProcessSingleQuotesLC( aArt ); |
|
406 _LIT( KFormatArt, "Art=\'%S\'" ); |
|
407 HBufC* setStr = HBufC::NewLC(KMaxFileName); |
|
408 setStr->Des().Format( KFormatArt, artReplaceSingleQuote ); |
|
409 |
|
410 iDbManager.ExecuteQueryL(aDriveId, KQueryArtistUpdate, setStr, rowId); |
|
411 CleanupStack::PopAndDestroy(setStr); |
|
412 CleanupStack::PopAndDestroy(artReplaceSingleQuote); |
|
413 } |
|
414 |
|
415 // increment the number of songs for the category |
|
416 iDbManager.ExecuteQueryL(aDriveId, KQueryArtistIncrementAlbumCount, rowId); |
|
417 } |
|
418 else |
|
419 { |
|
420 MPX_DEBUG2("SQL error %d", result); |
|
421 User::Leave(result); |
|
422 } |
|
423 |
|
424 CleanupStack::PopAndDestroy(&recordset); |
|
425 |
|
426 return rowId; |
|
427 } |
|
428 |
|
429 // ---------------------------------------------------------------------------- |
|
430 // CMPXDbArtist::DecrementAlbumsForArtistL |
|
431 // ---------------------------------------------------------------------------- |
|
432 // |
|
433 void CMPXDbArtist::DecrementAlbumsForArtistL( |
|
434 const TUint32 aId, |
|
435 TInt aDriveId, |
|
436 CMPXMessageArray* aItemChangedMessages |
|
437 ) |
|
438 { |
|
439 MPX_FUNC("CMPXDbArtist::DecrementAlbumsForCategoryL"); |
|
440 |
|
441 TInt songsCount(0); |
|
442 TInt albumsCount(0); |
|
443 |
|
444 GetSongsAndAlbumsCountL(aDriveId, aId, songsCount, albumsCount); |
|
445 |
|
446 MPX_DEBUG4("id %d, songsCount %d, albumsCount %d", aId, songsCount, albumsCount); |
|
447 |
|
448 // if just one album uses this category. Use <= just in case |
|
449 if (songsCount == 0 && albumsCount <= 1) |
|
450 { |
|
451 // delete the category |
|
452 DeleteCategoryL(aId, aDriveId); |
|
453 |
|
454 if (aItemChangedMessages) |
|
455 { |
|
456 // add the item changed message |
|
457 MPXDbCommonUtil::AddItemChangedMessageL(*aItemChangedMessages, aId, EMPXItemDeleted, |
|
458 iCategory, KDBPluginUid); |
|
459 } |
|
460 } |
|
461 else if (albumsCount > 0) |
|
462 { |
|
463 // decrement the number of albums for the category |
|
464 iDbManager.ExecuteQueryL(aDriveId, KQueryArtistDecrementAlbumCount, aId); |
|
465 } |
|
466 } |
|
467 |
|
468 // ---------------------------------------------------------------------------- |
|
469 // CMPXDbArtist::GetSongsAndAlbumsCountL |
|
470 // ---------------------------------------------------------------------------- |
|
471 // |
|
472 void CMPXDbArtist::GetSongsAndAlbumsCountL( |
|
473 TInt aDriveId, |
|
474 TUint32 aId, |
|
475 TInt& aSongCount, |
|
476 TInt& aAlbumCount) |
|
477 { |
|
478 MPX_FUNC("CMPXDbArtist::GetSongsAndAlbumsCountL"); |
|
479 |
|
480 RSqlStatement recordset( |
|
481 iDbManager.ExecuteSelectQueryL(aDriveId, KQueryArtistGetSongCountAndAlbumCount, aId)); |
|
482 CleanupClosePushL(recordset); |
|
483 |
|
484 TInt err(KErrNone); |
|
485 while ((err = recordset.Next()) == KSqlAtRow) |
|
486 { |
|
487 aSongCount += recordset.ColumnInt(KMPXTableDefaultIndex); |
|
488 aAlbumCount += recordset.ColumnInt(KMPXTableDefaultIndex+1); |
|
489 } |
|
490 |
|
491 if (err != KSqlAtEnd) |
|
492 { |
|
493 User::Leave(err); |
|
494 } |
|
495 |
|
496 CleanupStack::PopAndDestroy(&recordset); |
|
497 } |
|
498 |
|
499 // ---------------------------------------------------------------------------- |
|
500 // CMPXDbArtist::CreateTableL |
|
501 // ---------------------------------------------------------------------------- |
|
502 // |
|
503 void CMPXDbArtist::CreateTableL( |
|
504 RSqlDatabase& aDatabase, |
|
505 TBool /* aCorruptTable */) |
|
506 { |
|
507 MPX_FUNC("CMPXDbArtist::CreateTableL"); |
|
508 |
|
509 // create the table |
|
510 User::LeaveIfError(aDatabase.Exec(KArtistCreateTable)); |
|
511 |
|
512 // do not create an index on the Name field |
|
513 // as it only slows down the insert/update queries overall |
|
514 } |
|
515 |
|
516 // ---------------------------------------------------------------------------- |
|
517 // CMPXDbArtist::CheckTableL |
|
518 // ---------------------------------------------------------------------------- |
|
519 // |
|
520 TBool CMPXDbArtist::CheckTableL( |
|
521 RSqlDatabase& aDatabase) |
|
522 { |
|
523 MPX_FUNC("CMPXDbArtist::CheckTableL"); |
|
524 |
|
525 TBool check(DoCheckTable(aDatabase, KArtistCheckTable)); |
|
526 |
|
527 return check; |
|
528 } |
|
529 |
|
530 // End of File |