← Back to branch summary

~ubuntu-branches/ubuntu/saucy/digikam/saucy

« back to all changes in this revision

Viewing changes to libs/database/databaseaccess.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-12-21 23:19:11 UTC
  • mfrom: (1.2.33 upstream) (3.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20101221231911-z9jip7s5aht1jqn9
Tags: 2:1.7.0-1ubuntu1
* Merge from Debian Experimental. Remaining Ubuntu changes:
  - Export .pot name and copy to plugins in debian/rules
  - Version build-depends on kipi-plugins-dev to ensure build is against the
    same version on all archs
* Drop debian/patches/kubuntu_01_linker.diff, incoporated upstream
* Remove patches directory and unused patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/database/databaseaccess.cpp
62
62
    };
63
63
    ~DatabaseAccessStaticPriv() {};
64
64
 
65
 
    DatabaseBackend    *backend;
66
 
    AlbumDB            *db;
67
 
    ImageInfoCache     *infoCache;
68
 
    DatabaseWatch      *databaseWatch;
 
65
    DatabaseBackend*    backend;
 
66
    AlbumDB*            db;
 
67
    ImageInfoCache*     infoCache;
 
68
    DatabaseWatch*      databaseWatch;
69
69
    DatabaseParameters  parameters;
70
70
    DatabaseLocking     lock;
71
71
    QString             lastError;
78
78
{
79
79
public:
80
80
 
81
 
    DatabaseAccessMutexLocker(DatabaseAccessStaticPriv *d)
 
81
    DatabaseAccessMutexLocker(DatabaseAccessStaticPriv* d)
82
82
        : QMutexLocker(&d->lock.mutex), d(d)
83
83
    {
84
84
        d->lock.lockCount++;
92
92
    DatabaseAccessStaticPriv* const d;
93
93
};
94
94
 
95
 
DatabaseAccessStaticPriv *DatabaseAccess::d = 0;
 
95
DatabaseAccessStaticPriv* DatabaseAccess::d = 0;
96
96
 
97
97
DatabaseAccess::DatabaseAccess()
98
98
{
99
99
    Q_ASSERT(d/*You will want to call setParameters before constructing DatabaseAccess*/);
100
100
    d->lock.mutex.lock();
101
101
    d->lock.lockCount++;
 
102
 
102
103
    if (!d->backend->isOpen() && !d->initializing)
103
104
    {
104
105
        // avoid endless loops (e.g. recursing from CollectionManager)
126
127
    d->lock.lockCount++;
127
128
}
128
129
 
129
 
AlbumDB *DatabaseAccess::db() const
 
130
AlbumDB* DatabaseAccess::db() const
130
131
{
131
132
    return d->db;
132
133
}
133
134
 
134
 
DatabaseBackend *DatabaseAccess::backend() const
 
135
DatabaseBackend* DatabaseAccess::backend() const
135
136
{
136
137
    return d->backend;
137
138
}
138
139
 
139
 
ImageInfoCache *DatabaseAccess::imageInfoCache() const
 
140
ImageInfoCache* DatabaseAccess::imageInfoCache() const
140
141
{
141
142
    return d->infoCache;
142
143
}
143
144
 
144
 
DatabaseWatch *DatabaseAccess::databaseWatch()
 
145
DatabaseWatch* DatabaseAccess::databaseWatch()
145
146
{
146
147
    if (d)
 
148
    {
147
149
        return d->databaseWatch;
 
150
    }
 
151
 
148
152
    return 0;
149
153
}
150
154
 
151
 
void DatabaseAccess::initDatabaseErrorHandler(DatabaseErrorHandler *errorhandler){
 
155
void DatabaseAccess::initDatabaseErrorHandler(DatabaseErrorHandler* errorhandler)
 
156
{
152
157
    if (!d)
153
 
        {
154
 
            d = new DatabaseAccessStaticPriv();
155
 
        }
 
158
    {
 
159
        d = new DatabaseAccessStaticPriv();
 
160
    }
 
161
 
156
162
    //DatabaseErrorHandler *errorhandler = new DatabaseGUIErrorHandler(d->parameters);
157
163
    d->backend->setDatabaseErrorHandler(errorhandler);
158
164
}
160
166
DatabaseParameters DatabaseAccess::parameters()
161
167
{
162
168
    if (d)
 
169
    {
163
170
        return d->parameters;
 
171
    }
 
172
 
164
173
    return DatabaseParameters();
165
174
}
166
175
 
168
177
{
169
178
    //TODO 0.11: Refine API
170
179
    setParameters(parameters, DatabaseSlave);
 
180
 
171
181
    if (d->databaseWatch)
 
182
    {
172
183
        d->databaseWatch->doAnyProcessing();
 
184
    }
173
185
}
174
186
 
175
187
void DatabaseAccess::setParameters(const DatabaseParameters& parameters, ApplicationStatus status)
182
194
    DatabaseAccessMutexLocker lock(d);
183
195
 
184
196
    if (d->parameters == parameters)
 
197
    {
185
198
        return;
 
199
    }
186
200
 
187
201
    if (d->backend && d->backend->isOpen())
 
202
    {
188
203
        d->backend->close();
 
204
    }
189
205
 
190
206
    // Kill the old database error handler
191
207
    if (d->backend)
 
208
    {
192
209
        d->backend->setDatabaseErrorHandler(0);
 
210
    }
193
211
 
194
212
    d->parameters = parameters;
195
213
 
197
215
    {
198
216
        d->databaseWatch = new DatabaseWatch();
199
217
        d->databaseWatch->setApplicationIdentifier(d->applicationIdentifier);
 
218
 
200
219
        if (status == MainApplication)
 
220
        {
201
221
            d->databaseWatch->initializeRemote(DatabaseWatch::DatabaseMaster);
 
222
        }
202
223
        else
 
224
        {
203
225
            d->databaseWatch->initializeRemote(DatabaseWatch::DatabaseSlave);
 
226
        }
204
227
    }
205
228
 
206
229
    if (!d->backend || !d->backend->isCompatible(parameters))
219
242
    CollectionManager::instance()->clear_locked();
220
243
}
221
244
 
222
 
bool DatabaseAccess::checkReadyForUse(InitializationObserver *observer)
 
245
bool DatabaseAccess::checkReadyForUse(InitializationObserver* observer)
223
246
{
224
247
    QStringList drivers = QSqlDatabase::drivers();
 
248
 
225
249
    if (!drivers.contains("QSQLITE"))
226
250
    {
227
251
        kError() << "No SQLite3 driver available. List of QSqlDatabase drivers: " << drivers;
236
260
    if (!d->backend)
237
261
    {
238
262
        kWarning() << "No database backend available in checkReadyForUse. "
239
 
                           "Did you call setParameters before?";
 
263
                   "Did you call setParameters before?";
240
264
        return false;
241
265
    }
 
266
 
242
267
    if (d->backend->isReady())
 
268
    {
243
269
        return true;
 
270
    }
244
271
 
245
 
//TODO: Implement a method to wait until the database is open
 
272
    //TODO: Implement a method to wait until the database is open
246
273
    if (!d->backend->isOpen())
247
274
    {
248
275
        if (!d->backend->open(d->parameters))
261
288
    updater.setDatabaseAccess(&access);
262
289
 
263
290
    updater.setObserver(observer);
 
291
 
264
292
    if (!d->backend->initSchema(&updater))
265
293
    {
266
294
        access.setLastError(updater.getLastErrorMessage());
298
326
        delete d->db;
299
327
        delete d->backend;
300
328
    }
 
329
 
301
330
    delete d;
302
331
    d = 0;
303
332
}
312
341
    count = DatabaseAccess::d->lock.lockCount;
313
342
    // set lock count to 0
314
343
    DatabaseAccess::d->lock.lockCount = 0;
 
344
 
315
345
    // unlock
316
346
    for (int i=0; i<count; ++i)
 
347
    {
317
348
        DatabaseAccess::d->lock.mutex.unlock();
 
349
    }
 
350
 
318
351
    // drop lock acquired in first line. Mutex is now free.
319
352
    DatabaseAccess::d->lock.mutex.unlock();
320
353
}
321
354
 
322
 
DatabaseAccessUnlock::DatabaseAccessUnlock(DatabaseAccess *)
 
355
DatabaseAccessUnlock::DatabaseAccessUnlock(DatabaseAccess*)
323
356
{
324
357
    // With the passed pointer, we have assured that the mutex is acquired
325
358
    // Store lock count
326
359
    count = DatabaseAccess::d->lock.lockCount;
327
360
    // set lock count to 0
328
361
    DatabaseAccess::d->lock.lockCount = 0;
 
362
 
329
363
    // unlock
330
364
    for (int i=0; i<count; ++i)
 
365
    {
331
366
        DatabaseAccess::d->lock.mutex.unlock();
 
367
    }
 
368
 
332
369
    // Mutex is now free
333
370
}
334
371
 
336
373
{
337
374
    // lock as often as it was locked before
338
375
    for (int i=0; i<count; ++i)
 
376
    {
339
377
        DatabaseAccess::d->lock.mutex.lock();
 
378
    }
 
379
 
340
380
    // update lock count
341
381
    DatabaseAccess::d->lock.lockCount = count;
342
382
}