← Back to branch summary

~ubuntu-branches/ubuntu/vivid/akonadi/vivid

« back to all changes in this revision

Viewing changes to server/src/storage/datastore.cpp

  • Committer: Package Import Robot
  • Author(s): Rohan Garg, Rohan Garg, Philip Muškovac
  • Date: 2013-06-13 08:46:15 UTC
  • mfrom: (1.1.42)
  • Revision ID: package-import@ubuntu.com-20130613084615-e37v5pdoe2p2xu9d
Tags: 1.9.80-0ubuntu1
[ Rohan Garg ]
* New upstream release
  - Update symbols
  - Install asapcat with akonadi-server for now
  - Install notificationmessagev2_p.h with -dev package
  - Refresh disable_dbus_requiring_tests.diff

[ Philip Muškovac ]
* libkonadi-dev needs to depend on akonadi-server for the dbus service 

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/src/storage/datastore.cpp
163
163
 
164
164
/* --- ItemFlags ----------------------------------------------------- */
165
165
 
166
 
bool DataStore::setItemFlags( const PimItem &item, const QVector<Flag> &flags )
 
166
bool DataStore::setItemsFlags( const PimItem::List &items, const QVector<Flag> &flags )
167
167
{
168
168
  // first delete all old flags of this pim item
169
 
  if ( !item.clearFlags() )
170
 
    return false;
171
 
 
172
 
  // then add the new flags
173
 
  for ( int i = 0; i < flags.count(); ++i ) {
174
 
    if ( !item.addFlag( flags[i] ) )
175
 
      return false;
176
 
  }
177
 
 
178
 
  mNotificationCollector->itemChanged( item, QSet<QByteArray>() << "FLAGS" );
 
169
  QSet<QByteArray> removedFlags;
 
170
  QSet<QByteArray> addedFlags;
 
171
  QVariantList ids;
 
172
  QVariantList insIds;
 
173
  QVariantList insFlags;
 
174
 
 
175
  Q_FOREACH( const PimItem &item, items ) {
 
176
    Q_FOREACH( const Flag &flag, item.flags() ) {
 
177
      if ( !removedFlags.contains( flag.name().toLatin1() ) ) {
 
178
        removedFlags << flag.name().toLatin1();
 
179
      }
 
180
    }
 
181
 
 
182
    // create a bind values for the insert query - every item repeats exactly
 
183
    // flags.count()-times
 
184
    for ( int i = 0; i < flags.count(); ++i ) {
 
185
      insIds << item.id();
 
186
    }
 
187
 
 
188
    ids << item.id();
 
189
  }
 
190
 
 
191
  // Clear all flags of all given items at once
 
192
  QueryBuilder qb( PimItemFlagRelation::tableName(), QueryBuilder::Delete );
 
193
  Query::Condition cond;
 
194
  cond.addValueCondition( PimItemFlagRelation::leftFullColumnName(), Query::In, ids );
 
195
  qb.addCondition( cond );
 
196
  if ( !qb.exec() ) {
 
197
    return false;
 
198
  }
 
199
 
 
200
  // create bind values for the insert quest - every flags repeats exactly
 
201
  // items.count()-times
 
202
  Q_FOREACH( const Flag &flag, flags ) {
 
203
    for ( int i = 0; i < items.count(); ++i ) {
 
204
      insFlags << flag.id();
 
205
    }
 
206
 
 
207
    addedFlags << flag.name().toLatin1();
 
208
  }
 
209
 
 
210
  QueryBuilder qb2( PimItemFlagRelation::tableName(), QueryBuilder::Insert );
 
211
  qb2.setColumnValue( PimItemFlagRelation::leftFullColumnName(), insIds );
 
212
  qb2.setColumnValue( PimItemFlagRelation::rightFullColumnName(), insFlags );
 
213
  if ( !qb2.exec() ) {
 
214
    return false;
 
215
  }
 
216
 
 
217
  mNotificationCollector->itemsFlagsChanged( items, addedFlags, removedFlags );
179
218
  return true;
180
219
}
181
220
 
182
 
bool DataStore::appendItemFlags( const PimItem &item, const QVector<Flag> &flags,
 
221
bool DataStore::appendItemsFlags( const PimItem::List &items, const QVector<Flag> &flags,
183
222
                                 bool& flagsChanged, bool checkIfExists,
184
223
                                 const Collection &col )
185
224
{
186
 
  flagsChanged = false;
187
 
  if ( !item.isValid() )
 
225
  QSet<QByteArray> added;
 
226
  Q_FOREACH( const PimItem &item, items ) {
 
227
    flagsChanged = false;
 
228
    if ( !item.isValid() )
 
229
      return false;
 
230
    if ( flags.isEmpty() )
 
231
      return true;
 
232
 
 
233
    for ( int i = 0; i < flags.count(); ++i ) {
 
234
      if ( !checkIfExists || !item.relatesToFlag( flags[ i ] ) ) {
 
235
        flagsChanged = true;
 
236
        added << flags[ i ].name().toLatin1();
 
237
        if ( !item.addFlag( flags[i] ) )
 
238
          return false;
 
239
      }
 
240
    }
 
241
  }
 
242
 
 
243
  mNotificationCollector->itemsFlagsChanged( items, added, QSet<QByteArray>(), col );
 
244
  return true;
 
245
}
 
246
 
 
247
bool DataStore::removeItemsFlags( const PimItem::List &items, const QVector<Flag> &flags )
 
248
{
 
249
  QSet<QByteArray> removedFlags;
 
250
  QVariantList itemsIds;
 
251
  QVariantList flagsIds;
 
252
  Q_FOREACH ( const PimItem &item, items ) {
 
253
    itemsIds << item.id();
 
254
    for ( int i = 0; i < flags.count(); ++i ) {
 
255
      const QByteArray flagName = flags[ i ].name().toLatin1();
 
256
      if ( !flagsIds.contains( flagName ) ) {
 
257
        flagsIds << flags[ i ].id();
 
258
        removedFlags << flagName;
 
259
      }
 
260
    }
 
261
  }
 
262
 
 
263
  // Delete all given flags from all given items in one go
 
264
  QueryBuilder qb( PimItemFlagRelation::tableName(), QueryBuilder::Delete );
 
265
  Query::Condition cond( Query::And );
 
266
  cond.addValueCondition( PimItemFlagRelation::rightFullColumnName(), Query::In, flagsIds );
 
267
  cond.addValueCondition( PimItemFlagRelation::leftFullColumnName(), Query::In, itemsIds );
 
268
  qb.addCondition( cond );
 
269
  if ( !qb.exec() ) {
188
270
    return false;
189
 
  if ( flags.isEmpty() )
190
 
    return true;
191
 
 
192
 
  for ( int i = 0; i < flags.count(); ++i ) {
193
 
    if ( !checkIfExists || !item.relatesToFlag( flags[ i ] ) ) {
194
 
      flagsChanged = true;
195
 
      if ( !item.addFlag( flags[i] ) )
196
 
        return false;
197
 
    }
198
 
  }
199
 
  if ( flagsChanged )
200
 
    mNotificationCollector->itemChanged( item, QSet<QByteArray>() << "FLAGS", col );
201
 
  return true;
202
 
}
203
 
 
204
 
bool DataStore::removeItemFlags( const PimItem &item, const QVector<Flag> &flags )
205
 
{
206
 
  for ( int i = 0; i < flags.count(); ++i ) {
207
 
    if ( !item.removeFlag( flags[ i ] ) )
208
 
      return false;
209
 
  }
210
 
 
211
 
  mNotificationCollector->itemChanged( item, QSet<QByteArray>() << "FLAGS" );
 
271
  }
 
272
 
 
273
  mNotificationCollector->itemsFlagsChanged( items, QSet<QByteArray>(), removedFlags );
212
274
  return true;
213
275
}
214
276
 
274
336
  // collect item deletion notifications
275
337
  const PimItem::List items = collection.items();
276
338
  const QByteArray resource = collection.resource().name().toLatin1();
277
 
  Q_FOREACH ( const PimItem &item, items ) {
278
339
 
279
 
    // generate the notification before actually removing the data
280
 
    // TODO: we should try to get rid of this, requires client side changes to resources and Monitor though
281
 
    mNotificationCollector->itemRemoved( item, collection, QString(), resource );
282
 
  }
 
340
  // generate the notification before actually removing the data
 
341
  // TODO: we should try to get rid of this, requires client side changes to resources and Monitor though
 
342
  mNotificationCollector->itemsRemoved( items, collection, resource );
283
343
 
284
344
  // remove all external payload parts
285
345
  QueryBuilder qb( Part::tableName(), QueryBuilder::Select );
286
346
  qb.addColumn( Part::dataFullColumnName() );
287
 
  qb.addValueCondition( Part::externalFullColumnName(), Query::Equals, true );
288
 
  qb.addValueCondition( Part::dataFullColumnName(), Query::IsNot, QVariant() );
289
347
  qb.addJoin( QueryBuilder::InnerJoin, PimItem::tableName(), Part::pimItemIdFullColumnName(), PimItem::idFullColumnName() );
290
348
  qb.addJoin( QueryBuilder::InnerJoin, Collection::tableName(), PimItem::collectionIdFullColumnName(), Collection::idFullColumnName() );
 
349
  qb.addValueCondition( Collection::idFullColumnName(), Query::Equals, collection.id() );
 
350
  qb.addValueCondition( Part::externalFullColumnName(), Query::Equals, true );
 
351
  qb.addValueCondition( Part::dataFullColumnName(), Query::IsNot, QVariant() );
291
352
  if ( !qb.exec() )
292
353
    return false;
293
354
 
311
372
  // delete the content
312
373
  const PimItem::List items = collection.items();
313
374
  const QByteArray resource = collection.resource().name().toLatin1();
 
375
  mNotificationCollector->itemsRemoved( items, collection, resource );
 
376
 
314
377
  Q_FOREACH ( const PimItem &item, items ) {
315
 
 
316
 
    // generate the notification before actually removing the data
317
 
    mNotificationCollector->itemRemoved( item, collection, QString(), resource );
318
 
 
319
378
    if ( !item.clearFlags() ) // TODO: move out of loop and use only a single query
320
379
      return false;
321
380
    if ( !PartHelper::remove( Part::pimItemIdColumn(), item.id() ) ) // TODO: reduce to single query
484
543
  return Collection::extractResult( qb.query() );
485
544
}
486
545
 
 
546
QMap<Entity::Id,PimItem> DataStore::virtualCollections( const PimItem::List &items )
 
547
{
 
548
  QueryBuilder qb( CollectionPimItemRelation::tableName(), QueryBuilder::Select );
 
549
  qb.addJoin( QueryBuilder::InnerJoin, Collection::tableName(),
 
550
              Collection::idFullColumnName(), CollectionPimItemRelation::leftFullColumnName() );
 
551
  qb.addJoin( QueryBuilder::InnerJoin, PimItem::tableName(),
 
552
              PimItem::idFullColumnName(), CollectionPimItemRelation::rightFullColumnName() );
 
553
  qb.addColumn( Collection::idFullColumnName() );
 
554
  qb.addColumns( QStringList() << PimItem::idFullColumnName()
 
555
                               << PimItem::remoteIdFullColumnName()
 
556
                               << PimItem::remoteRevisionFullColumnName() );
 
557
 
 
558
  Query::Condition condition( Query::Or );
 
559
  QStringList ids;
 
560
  Q_FOREACH( const PimItem &item, items ) {
 
561
    ids << QString::number( item.id() );
 
562
  }
 
563
  qb.addValueCondition( CollectionPimItemRelation::rightFullColumnName(), Query::In, ids );
 
564
 
 
565
  if ( !qb.exec() ) {
 
566
    akDebug() << "Error during selection of records from table CollectionPimItemRelation"
 
567
      << qb.query().lastError().text();
 
568
    return QMap<Entity::Id,PimItem>();
 
569
  }
 
570
 
 
571
  QSqlQuery query = qb.query();
 
572
  QMap<Entity::Id,PimItem> map;
 
573
  while ( query.next() ) {
 
574
    PimItem item;
 
575
    item.setId( query.value( 1 ).toLongLong() );
 
576
    item.setRemoteId( query.value( 2 ).toString() );
 
577
    item.setRemoteRevision( query.value( 3 ).toString() );
 
578
    map.insertMulti( query.value( 0 ).toLongLong(), item );
 
579
  }
 
580
 
 
581
  return map;
 
582
}
 
583
 
487
584
 
488
585
/* --- MimeType ------------------------------------------------------ */
489
586
bool DataStore::appendMimeType( const QString & mimetype, qint64 *insertId )
544
641
 
545
642
//   akDebug() << "appendPimItem: " << pimItem;
546
643
 
547
 
  mNotificationCollector->itemAdded( pimItem, collection, mimetype.name() );
 
644
  mNotificationCollector->itemAdded( pimItem, collection );
548
645
  return true;
549
646
}
550
647
 
572
669
  return PartHelper::remove( Part::nameFullColumnName(), QLatin1String( "ATR:HIDDEN" ) );
573
670
}
574
671
 
575
 
bool DataStore::cleanupPimItem( const PimItem &item )
 
672
bool DataStore::cleanupPimItems( const PimItem::List &items )
576
673
{
577
 
  if ( !item.isValid() )
578
 
    return false;
579
 
 
580
674
  // generate the notification before actually removing the data
581
 
  mNotificationCollector->itemRemoved( item );
582
 
 
583
 
  if ( !item.clearFlags() )
584
 
    return false;
585
 
  if ( !PartHelper::remove( Part::pimItemIdColumn(), item.id() ) )
586
 
    return false;
587
 
  if ( !PimItem::remove( PimItem::idColumn(), item.id() ) )
588
 
    return false;
589
 
 
590
 
  if ( !Entity::clearRelation<CollectionPimItemRelation>( item.id(), Entity::Right ) )
591
 
    return false;
 
675
  mNotificationCollector->itemsRemoved( items );
 
676
 
 
677
  // FIXME: Create a single query to do this
 
678
  Q_FOREACH( const PimItem &item, items ) {
 
679
    if ( !item.clearFlags() )
 
680
      return false;
 
681
    if ( !PartHelper::remove( Part::pimItemIdColumn(), item.id() ) )
 
682
      return false;
 
683
    if ( !PimItem::remove( PimItem::idColumn(), item.id() ) )
 
684
      return false;
 
685
 
 
686
    if ( !Entity::clearRelation<CollectionPimItemRelation>( item.id(), Entity::Right ) )
 
687
      return false;
 
688
  }
592
689
 
593
690
  return true;
594
691
}