← Back to branch summary

~ubuntu-branches/ubuntu/trusty/digikam/trusty

« back to all changes in this revision

Viewing changes to core/libs/database/albumdb.cpp

  • Committer: Package Import Robot
  • Author(s): Rohan Garg
  • Date: 2012-11-26 18:24:20 UTC
  • mfrom: (1.9.1) (3.1.23 experimental)
  • Revision ID: package-import@ubuntu.com-20121126182420-qoy6z0nx4ai0wzcl
Tags: 4:3.0.0~beta3-0ubuntu1
https://launchpad.net/bugs/890059
https://launchpad.net/bugs/1011211
https://launchpad.net/bugs/658047
* New upstream release
  - Add build-deps :  libhupnp-dev, libqtgstreamer-dev, libmagickcore-dev
* Merge from debian, remaining changes:
  - Make sure libqt4-opengl-dev, libgl1-mesa-dev and libglu1-mesa-dev only
    install on i386,amd64 and powerpc
  - Depend on libtiff-dev instead of libtiff4-dev
  - Drop digikam breaks/replaces kipi-plugins-common since we're past the
    LTS release now
  - digikam to recommend mplayerthumbs | ffmpegthumbs. We currently only
    have latter in the archives, even though former is also supposed to
    be part of kdemultimedia. (LP: #890059)
  - kipi-plugins to recommend www-browser rather than konqueror directly
    since 2.8 no direct usage of konqueror is present in the flickr
    plugin anymore (LP: #1011211)
  - Keep kubuntu_mysqld_executable_name.diff
  - Don't install libkipi translations
  - Keep deps on libcv-dev, libcvaux-dev
  - Keep split packaging of libraries
  - Replace icons from KDE 3 time in debian/xpm.d/*.xpm with the new
    versions (LP: #658047)
* Update debian/not-installed

Show diffs side-by-side

added added

removed removed

Lines of Context:
core/libs/database/albumdb.cpp
6
6
 * Date        : 2004-06-18
7
7
 * Description :database album interface.
8
8
 *
9
 
 * Copyright (C) 2004-2005 by Renchi Raju <renchi@pooh.tam.uiuc.edu>
10
 
 * Copyright (C) 2006-2010 by Gilles Caulier <caulier dot gilles at gmail dot com>
11
 
 * Copyright (C) 2006-2010 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
12
 
 * Copyright (C) 2012 by Andi Clemens <andi dot clemens at googlemail dot com>
 
9
 * Copyright (C) 2004-2005 by Renchi Raju <renchi dot raju at gmail dot com>
 
10
 * Copyright (C) 2006-2012 by Gilles Caulier <caulier dot gilles at gmail dot com>
 
11
 * Copyright (C) 2006-2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 
12
 * Copyright (C) 2012      by Andi Clemens <andi dot clemens at gmail dot com>
13
13
 *
14
14
 * This program is free software; you can redistribute it
15
15
 * and/or modify it under the terms of the GNU General
63
63
namespace Digikam
64
64
{
65
65
 
66
 
class AlbumDB::AlbumDBPriv
 
66
class AlbumDB::Private
67
67
{
68
68
 
69
69
public:
70
70
 
71
 
    AlbumDBPriv() :
 
71
    Private() :
72
72
        db(0),
73
73
        uniqueHashVersion(-1)
74
74
    {
88
88
    QList<qlonglong> execRelatedImagesQuery(SqlQuery& query, qlonglong id, DatabaseRelation::Type type);
89
89
};
90
90
 
91
 
const QString AlbumDB::AlbumDBPriv::configGroupName("AlbumDB Settings");
92
 
const QString AlbumDB::AlbumDBPriv::configRecentlyUsedTags("Recently Used Tags");
 
91
const QString AlbumDB::Private::configGroupName("AlbumDB Settings");
 
92
const QString AlbumDB::Private::configRecentlyUsedTags("Recently Used Tags");
 
93
 
 
94
QString AlbumDB::Private::constructRelatedImagesSQL(bool fromOrTo, DatabaseRelation::Type type, bool boolean)
 
95
{
 
96
    QString sql;
 
97
 
 
98
    if (fromOrTo)
 
99
    {
 
100
        sql = "SELECT object FROM ImageRelations "
 
101
              "INNER JOIN Images ON ImageRelations.object=Images.id "
 
102
              "WHERE subject=? %1 AND status!=3 %2;";
 
103
    }
 
104
    else
 
105
    {
 
106
        sql = "SELECT subject FROM ImageRelations "
 
107
              "INNER JOIN Images ON ImageRelations.subject=Images.id "
 
108
              "WHERE object=? %1 AND status!=3 %2;";
 
109
    }
 
110
 
 
111
    if (type != DatabaseRelation::UndefinedType)
 
112
    {
 
113
        sql = sql.arg(QString("AND type=?"));
 
114
    }
 
115
    else
 
116
    {
 
117
        sql = sql.arg(QString());
 
118
    }
 
119
 
 
120
    if (boolean)
 
121
    {
 
122
        sql = sql.arg(QString("LIMIT 1"));
 
123
    }
 
124
    else
 
125
    {
 
126
        sql = sql.arg(QString());
 
127
    }
 
128
 
 
129
    return sql;
 
130
}
 
131
 
 
132
QList<qlonglong> AlbumDB::Private::execRelatedImagesQuery(SqlQuery& query, qlonglong id, DatabaseRelation::Type type)
 
133
{
 
134
    QVariantList values;
 
135
 
 
136
    if (type == DatabaseRelation::UndefinedType)
 
137
    {
 
138
        db->execSql(query, id, &values);
 
139
    }
 
140
    else
 
141
    {
 
142
        db->execSql(query, id, type, &values);
 
143
    }
 
144
 
 
145
    QList<qlonglong> imageIds;
 
146
 
 
147
    if (values.isEmpty())
 
148
    {
 
149
        return imageIds;
 
150
    }
 
151
 
 
152
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd(); ++it)
 
153
    {
 
154
        imageIds << (*it).toInt();
 
155
    }
 
156
 
 
157
    return imageIds;
 
158
}
93
159
 
94
160
// --------------------------------------------------------
95
161
 
96
 
AlbumDB::AlbumDB(DatabaseBackend* backend)
97
 
    : d(new AlbumDBPriv)
 
162
AlbumDB::AlbumDB(DatabaseBackend* const backend)
 
163
    : d(new Private)
98
164
{
99
165
    d->db = backend;
100
166
    readSettings();
109
175
QList<AlbumRootInfo> AlbumDB::getAlbumRoots()
110
176
{
111
177
    QList<AlbumRootInfo> list;
 
178
    QList<QVariant>      values;
112
179
 
113
 
    QList<QVariant> values;
114
180
    d->db->execSql("SELECT id, label, status, type, identifier, specificPath FROM AlbumRoots;", &values);
115
181
 
116
182
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd();)
289
355
                   tagId, &values);
290
356
 
291
357
    QString iconName, iconKDE, albumURL;
292
 
    int iconAlbumRootId;
 
358
    int     iconAlbumRootId;
293
359
 
294
360
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd();)
295
361
    {
329
395
SearchInfo::List AlbumDB::scanSearches()
330
396
{
331
397
    SearchInfo::List searchList;
 
398
    QList<QVariant>  values;
332
399
 
333
 
    QList<QVariant> values;
334
400
    d->db->execSql("SELECT id, type, name, query FROM Searches;", &values);
335
401
 
336
402
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd();)
355
421
QList<AlbumShortInfo> AlbumDB::getAlbumShortInfos()
356
422
{
357
423
    QList<QVariant> values;
 
424
 
358
425
    d->db->execSql(QString("SELECT Albums.id, Albums.relativePath, Albums.albumRoot from Albums ORDER BY Albums.id; "),
359
426
                   &values);
360
427
 
380
447
QList<TagShortInfo> AlbumDB::getTagShortInfos()
381
448
{
382
449
    QList<QVariant> values;
383
 
    d->db->execSql(QString("SELECT id, pid, name FROM Tags ORDER BY id;"),
384
 
                   &values);
 
450
 
 
451
    d->db->execSql(QString("SELECT id, pid, name FROM Tags ORDER BY id;"), &values);
385
452
 
386
453
    QList<TagShortInfo> tagList;
387
454
 
459
526
                      const QString& caption,
460
527
                      const QDate& date, const QString& collection)
461
528
{
462
 
    QVariant id;
 
529
    QVariant        id;
463
530
    QList<QVariant> boundValues;
 
531
 
464
532
    boundValues << albumRootId << relativePath << date.toString(Qt::ISODate) << caption << collection;
465
533
 
466
534
    d->db->execSql(QString("REPLACE INTO Albums (albumRoot, relativePath, date, caption, collection) "
505
573
bool AlbumDB::getAlbumIcon(int albumID, int* albumRootId, QString* iconRelativePath)
506
574
{
507
575
    QList<QVariant> values;
 
576
 
508
577
    d->db->execSql(QString("SELECT B.relativePath, I.name, B.albumRoot \n "
509
578
                           "FROM Albums AS A \n "
510
579
                           "  LEFT JOIN Images AS I ON I.id=A.icon \n "
518
587
    }
519
588
 
520
589
    QList<QVariant>::const_iterator it = values.constBegin();
521
 
    QString album     = (*it).toString();
522
 
    ++it;
523
 
    QString iconName  = (*it).toString();
524
 
    ++it;
525
 
    *albumRootId = (*it).toInt();
 
590
    QString album                      = (*it).toString();
 
591
    ++it;
 
592
    QString iconName                   = (*it).toString();
 
593
    ++it;
 
594
    *albumRootId                       = (*it).toInt();
526
595
 
527
 
    *iconRelativePath = album + '/' + iconName;
 
596
    *iconRelativePath                  = album + '/' + iconName;
528
597
 
529
598
    return !iconName.isEmpty();
530
599
}
594
663
int AlbumDB::addTag(int parentTagID, const QString& name, const QString& iconKDE,
595
664
                    qlonglong iconID)
596
665
{
597
 
    QVariant id;
 
666
    QVariant                id;
598
667
    QMap<QString, QVariant> parameters;
 
668
 
599
669
    parameters.insert(":tagPID", parentTagID);
600
670
    parameters.insert(":tagname", name);
601
671
 
624
694
void AlbumDB::deleteTag(int tagID)
625
695
{
626
696
    /*
627
 
    QString("DELETE FROM Tags WHERE id=?;"),
628
 
                    tagID */
 
697
    QString("DELETE FROM Tags WHERE id=?;"), tagID
 
698
    */
629
699
 
630
700
    QMap<QString, QVariant> bindingMap;
631
701
    bindingMap.insert(QString(":tagID"), tagID);
776
846
    return tagIds;
777
847
}
778
848
 
779
 
 
780
849
void AlbumDB::addTagProperty(int tagId, const QString& property, const QString& value)
781
850
{
782
851
    d->db->execSql("INSERT INTO TagProperties (tagid, property, value) VALUES(?, ?, ?);",
915
984
static QStringList joinMainAndUserFilterString(const QString& filter, const QString& userFilter)
916
985
{
917
986
    QSet<QString> filterSet;
918
 
    QStringList userFilterList;
919
 
    QStringList sortedList;
 
987
    QStringList   userFilterList;
 
988
    QStringList   sortedList;
920
989
 
921
 
    filterSet = filter.split(';', QString::SkipEmptyParts).toSet();
 
990
    filterSet      = filter.split(';', QString::SkipEmptyParts).toSet();
922
991
    userFilterList = userFilter.split(';', QString::SkipEmptyParts);
 
992
 
923
993
    foreach(const QString& userFormat, userFilterList)
924
994
    {
925
995
        if (userFormat.startsWith('-'))
1007
1077
    }
1008
1078
 
1009
1079
    QStringList sepList = filterString.split(sep, QString::SkipEmptyParts);
 
1080
 
1010
1081
    foreach(const QString& f, sepList)
1011
1082
    {
1012
1083
        if (f.startsWith(wildcard))
1033
1104
    return filterList;
1034
1105
}
1035
1106
 
1036
 
void AlbumDB::setUserFilterSettings(const QString& imageFilterString, const QString& videoFilterString, const QString& audioFilterString)
 
1107
void AlbumDB::setUserFilterSettings(const QString& imageFilterString, const QString& videoFilterString,
 
1108
                                    const QString& audioFilterString)
1037
1109
{
1038
1110
    setUserFilterSettings(cleanUserFilterString(imageFilterString),
1039
1111
                          cleanUserFilterString(videoFilterString),
1049
1121
 
1050
1122
void AlbumDB::addToUserImageFilterSettings(const QString& filterString)
1051
1123
{
1052
 
    QStringList addList = cleanUserFilterString(filterString);
1053
 
 
 
1124
    QStringList addList     = cleanUserFilterString(filterString);
1054
1125
    QStringList currentList = getSetting("databaseUserImageFormats").split(';', QString::SkipEmptyParts);
1055
1126
 
1056
1127
    // merge lists
1068
1139
QUuid AlbumDB::databaseUuid()
1069
1140
{
1070
1141
    QString uuidString = getSetting("databaseUUID");
1071
 
    QUuid uuid = QUuid(uuidString);
 
1142
    QUuid uuid         = QUuid(uuidString);
1072
1143
 
1073
1144
    if (uuidString.isNull() || uuid.isNull())
1074
1145
    {
1245
1316
    }
1246
1317
 
1247
1318
    QVector<QList<int> > results(imageIds.size());
1248
 
 
1249
 
    SqlQuery query = d->db->prepareQuery("SELECT tagid FROM ImageTags WHERE imageID=?;");
1250
 
 
1251
 
    QVariantList values;
 
1319
    SqlQuery             query = d->db->prepareQuery("SELECT tagid FROM ImageTags WHERE imageID=?;");
 
1320
    QVariantList         values;
1252
1321
 
1253
1322
    for (int i = 0; i < imageIds.size(); i++)
1254
1323
    {
1255
1324
        d->db->execSql(query, imageIds[i], &values);
1256
1325
        QList<int>& tagIds = results[i];
 
1326
 
1257
1327
        foreach(const QVariant& v, values)
1258
1328
        {
1259
1329
            tagIds << v.toInt();
1293
1363
    {
1294
1364
        ImageTagProperty property;
1295
1365
 
1296
 
        property.imageId = imageId;
 
1366
        property.imageId  = imageId;
1297
1367
 
1298
1368
        property.tagId    = (*it).toInt();
1299
1369
        ++it;
1495
1565
    return ids;
1496
1566
}
1497
1567
 
1498
 
 
1499
 
 
1500
1568
QVariantList AlbumDB::getImagesFields(qlonglong imageID, DatabaseFields::Images fields)
1501
1569
{
1502
1570
    QVariantList values;
1540
1608
        {
1541
1609
            int index = fieldNames.indexOf("creationDate");
1542
1610
            values[index] = (values.at(index).isNull() ? QDateTime()
1543
 
                             : QDateTime::fromString(values.at(index).toString(), Qt::ISODate));
 
1611
                                                       : QDateTime::fromString(values.at(index).toString(), Qt::ISODate));
1544
1612
        }
1545
1613
 
1546
1614
        if ((fields & DatabaseFields::DigitizationDate) && !values.isEmpty())
1547
1615
        {
1548
1616
            int index = fieldNames.indexOf("digitizationDate");
1549
1617
            values[index] = (values.at(index).isNull() ? QDateTime()
1550
 
                             : QDateTime::fromString(values.at(index).toString(), Qt::ISODate));
 
1618
                                                       : QDateTime::fromString(values.at(index).toString(), Qt::ISODate));
1551
1619
        }
1552
1620
    }
1553
1621
 
1567
1635
 
1568
1636
        d->db->execSql(query, imageID, &values);
1569
1637
 
 
1638
        // For some reason, if REAL values may be required from variables stored as QString QVariants. Convert code will come here.
 
1639
    }
 
1640
 
 
1641
    return values;
 
1642
}
 
1643
 
 
1644
QVariantList AlbumDB::getVideoMetadata(qlonglong imageID, DatabaseFields::VideoMetadata fields)
 
1645
{
 
1646
    QVariantList values;
 
1647
 
 
1648
    if (fields != DatabaseFields::VideoMetadataNone)
 
1649
    {
 
1650
        QString query("SELECT ");
 
1651
        QStringList fieldNames = videoMetadataFieldList(fields);
 
1652
        query += fieldNames.join(", ");
 
1653
        query += (" FROM VideoMetadata WHERE imageid=?;");
 
1654
 
 
1655
        d->db->execSql(query, imageID, &values);
 
1656
 
1570
1657
        // For some reason REAL values may come as QString QVariants. Convert here.
1571
1658
        if (values.size() == fieldNames.size() &&
1572
1659
            ((fields & DatabaseFields::Aperture) ||
1602
1689
    if (fields != DatabaseFields::ImagePositionsNone)
1603
1690
    {
1604
1691
        QString query("SELECT ");
1605
 
        QStringList fieldNames = imagePositionsFieldList(fields);
1606
 
        query += fieldNames.join(", ");
1607
 
        query += (" FROM ImagePositions WHERE imageid=?;");
 
1692
        QStringList fieldNames =  imagePositionsFieldList(fields);
 
1693
        query                  += fieldNames.join(", ");
 
1694
        query                  += (" FROM ImagePositions WHERE imageid=?;");
1608
1695
 
1609
1696
        d->db->execSql(query, imageID, &values);
1610
1697
 
1611
1698
        // For some reason REAL values may come as QString QVariants. Convert here.
1612
1699
        if (values.size() == fieldNames.size() &&
1613
 
            ((fields & DatabaseFields::LatitudeNumber) ||
1614
 
             (fields & DatabaseFields::LongitudeNumber) ||
1615
 
             (fields & DatabaseFields::Altitude) ||
 
1700
            ((fields & DatabaseFields::LatitudeNumber)      ||
 
1701
             (fields & DatabaseFields::LongitudeNumber)     ||
 
1702
             (fields & DatabaseFields::Altitude)            ||
1616
1703
             (fields & DatabaseFields::PositionOrientation) ||
1617
 
             (fields & DatabaseFields::PositionTilt) ||
1618
 
             (fields & DatabaseFields::PositionRoll) ||
 
1704
             (fields & DatabaseFields::PositionTilt)        ||
 
1705
             (fields & DatabaseFields::PositionRoll)        ||
1619
1706
             (fields & DatabaseFields::PositionAccuracy))
1620
1707
           )
1621
1708
        {
1622
1709
            for (int i = 0; i < values.size(); ++i)
1623
1710
            {
1624
1711
                if (values.at(i).type() == QVariant::String &&
1625
 
                    (fieldNames.at(i) == "latitudeNumber" ||
 
1712
                    (fieldNames.at(i) == "latitudeNumber"  ||
1626
1713
                     fieldNames.at(i) == "longitudeNumber" ||
1627
 
                     fieldNames.at(i) == "altitude" ||
1628
 
                     fieldNames.at(i) == "orientation" ||
1629
 
                     fieldNames.at(i) == "tilt" ||
1630
 
                     fieldNames.at(i) == "roll" ||
 
1714
                     fieldNames.at(i) == "altitude"        ||
 
1715
                     fieldNames.at(i) == "orientation"     ||
 
1716
                     fieldNames.at(i) == "tilt"            ||
 
1717
                     fieldNames.at(i) == "roll"            ||
1631
1718
                     fieldNames.at(i) == "accuracy")
1632
1719
                   )
1633
1720
                {
1647
1734
    if (fields != DatabaseFields::ImagePositionsNone)
1648
1735
    {
1649
1736
        QString sql("SELECT ");
1650
 
        QStringList fieldNames = imagePositionsFieldList(fields);
1651
 
        sql += fieldNames.join(", ");
1652
 
        sql += (" FROM ImagePositions WHERE imageid=?;");
 
1737
        QStringList fieldNames =  imagePositionsFieldList(fields);
 
1738
        sql                    += fieldNames.join(", ");
 
1739
        sql                    += (" FROM ImagePositions WHERE imageid=?;");
1653
1740
 
1654
1741
        SqlQuery query = d->db->prepareQuery(sql);
1655
1742
 
1662
1749
 
1663
1750
        // For some reason REAL values may come as QString QVariants. Convert here.
1664
1751
        if (values.size() == fieldNames.size() &&
1665
 
            (fields & DatabaseFields::LatitudeNumber ||
1666
 
             fields & DatabaseFields::LongitudeNumber ||
1667
 
             fields & DatabaseFields::Altitude ||
 
1752
            (fields & DatabaseFields::LatitudeNumber      ||
 
1753
             fields & DatabaseFields::LongitudeNumber     ||
 
1754
             fields & DatabaseFields::Altitude            ||
1668
1755
             fields & DatabaseFields::PositionOrientation ||
1669
 
             fields & DatabaseFields::PositionTilt ||
1670
 
             fields & DatabaseFields::PositionRoll ||
 
1756
             fields & DatabaseFields::PositionTilt        ||
 
1757
             fields & DatabaseFields::PositionRoll        ||
1671
1758
             fields & DatabaseFields::PositionAccuracy)
1672
1759
           )
1673
1760
        {
1674
1761
            for (int i = 0; i < values.size(); ++i)
1675
1762
            {
1676
1763
                if (values.at(i).type() == QVariant::String &&
1677
 
                    (fieldNames.at(i) == "latitudeNumber" ||
 
1764
                    (fieldNames.at(i) == "latitudeNumber"  ||
1678
1765
                     fieldNames.at(i) == "longitudeNumber" ||
1679
 
                     fieldNames.at(i) == "altitude" ||
1680
 
                     fieldNames.at(i) == "orientation" ||
1681
 
                     fieldNames.at(i) == "tilt" ||
1682
 
                     fieldNames.at(i) == "roll" ||
 
1766
                     fieldNames.at(i) == "altitude"        ||
 
1767
                     fieldNames.at(i) == "orientation"     ||
 
1768
                     fieldNames.at(i) == "tilt"            ||
 
1769
                     fieldNames.at(i) == "roll"            ||
1683
1770
                     fieldNames.at(i) == "accuracy")
1684
1771
                   )
1685
1772
                {
1702
1789
    QString query("REPLACE INTO ImageInformation ( imageid, ");
1703
1790
 
1704
1791
    QStringList fieldNames = imageInformationFieldList(fields);
 
1792
 
1705
1793
    Q_ASSERT(fieldNames.size() == infos.size());
 
1794
 
1706
1795
    query += fieldNames.join(", ");
1707
 
 
1708
1796
    query += " ) VALUES (";
1709
1797
    addBoundValuePlaceholders(query, infos.size() + 1);
1710
1798
    query += ");";
1773
1861
    }
1774
1862
 
1775
1863
    QString query("REPLACE INTO ImageMetadata ( imageid, ");
1776
 
 
1777
1864
    QStringList fieldNames = imageMetadataFieldList(fields);
 
1865
 
1778
1866
    Q_ASSERT(fieldNames.size() == infos.size());
 
1867
 
1779
1868
    query += fieldNames.join(", ");
1780
 
 
1781
1869
    query += " ) VALUES (";
1782
1870
    addBoundValuePlaceholders(query, infos.size() + 1);
1783
1871
    query += ");";
1800
1888
    QString query("UPDATE ImageMetadata SET ");
1801
1889
 
1802
1890
    QStringList fieldNames = imageMetadataFieldList(fields);
1803
 
    Q_ASSERT(fieldNames.size() == infos.size());
1804
 
    query += fieldNames.join("=?,");
1805
 
 
 
1891
 
 
1892
    Q_ASSERT(fieldNames.size() == infos.size());
 
1893
 
 
1894
    query += fieldNames.join("=?,");
 
1895
    query += "=? WHERE imageid=?;";
 
1896
 
 
1897
    QVariantList boundValues;
 
1898
    boundValues << infos << imageId;
 
1899
 
 
1900
    d->db->execSql(query, boundValues);
 
1901
    d->db->recordChangeset(ImageChangeset(imageId, fields));
 
1902
}
 
1903
 
 
1904
void AlbumDB::addVideoMetadata(qlonglong imageID, const QVariantList& infos, DatabaseFields::VideoMetadata fields)
 
1905
{
 
1906
    if (fields == DatabaseFields::VideoMetadataNone)
 
1907
    {
 
1908
        return;
 
1909
    }
 
1910
 
 
1911
    QString query("REPLACE INTO VideoMetadata ( imageid, "); //need to create this database
 
1912
    QStringList fieldNames = videoMetadataFieldList(fields);
 
1913
 
 
1914
    Q_ASSERT(fieldNames.size() == infos.size());
 
1915
 
 
1916
    query += fieldNames.join(", ");
 
1917
    query += " ) VALUES (";
 
1918
    addBoundValuePlaceholders(query, infos.size() + 1);
 
1919
    query += ");";
 
1920
 
 
1921
    QVariantList boundValues;
 
1922
    boundValues << imageID << infos;
 
1923
 
 
1924
    d->db->execSql(query, boundValues);
 
1925
    d->db->recordChangeset(ImageChangeset(imageID, fields));
 
1926
}
 
1927
 
 
1928
void AlbumDB::changeVideoMetadata(qlonglong imageId, const QVariantList& infos,
 
1929
                                  DatabaseFields::VideoMetadata fields)
 
1930
{
 
1931
    if (fields == DatabaseFields::VideoMetadataNone)
 
1932
    {
 
1933
        return;
 
1934
    }
 
1935
 
 
1936
    QString query("UPDATE VideoMetadata SET ");
 
1937
    QStringList fieldNames = videoMetadataFieldList(fields);
 
1938
 
 
1939
    Q_ASSERT(fieldNames.size() == infos.size());
 
1940
 
 
1941
    query += fieldNames.join("=?,");
1806
1942
    query += "=? WHERE imageid=?;";
1807
1943
 
1808
1944
    QVariantList boundValues;
1820
1956
    }
1821
1957
 
1822
1958
    QString query("REPLACE INTO ImagePositions ( imageid, ");
1823
 
 
1824
1959
    QStringList fieldNames = imagePositionsFieldList(fields);
 
1960
 
1825
1961
    Q_ASSERT(fieldNames.size() == infos.size());
 
1962
 
1826
1963
    query += fieldNames.join(", ");
1827
 
 
1828
1964
    query += " ) VALUES (";
1829
1965
    addBoundValuePlaceholders(query, infos.size() + 1);
1830
1966
    query += ");";
1845
1981
    }
1846
1982
 
1847
1983
    QString query("UPDATE ImagePositions SET ");
1848
 
 
1849
1984
    QStringList fieldNames = imagePositionsFieldList(fields);
 
1985
 
1850
1986
    Q_ASSERT(fieldNames.size() == infos.size());
 
1987
 
1851
1988
    query += fieldNames.join("=?,");
1852
 
 
1853
1989
    query += "=? WHERE imageid=?;";
1854
1990
 
1855
1991
    QVariantList boundValues;
1924
2060
    }
1925
2061
 
1926
2062
    QString query("UPDATE ImageComments SET ");
1927
 
 
1928
2063
    QStringList fieldNames = imageCommentsFieldList(fields);
 
2064
 
1929
2065
    Q_ASSERT(fieldNames.size() == infos.size());
 
2066
 
1930
2067
    query += fieldNames.join("=?,");
1931
2068
    query += "=? WHERE id=?;";
1932
2069
 
1981
2118
QList<CopyrightInfo> AlbumDB::getImageCopyright(qlonglong imageID, const QString& property)
1982
2119
{
1983
2120
    QList<CopyrightInfo> list;
1984
 
 
1985
 
    QList<QVariant> values;
 
2121
    QList<QVariant>      values;
1986
2122
 
1987
2123
    if (property.isNull())
1988
2124
    {
2303
2439
    return !getRelatedImages(objectId, false, type, true).isEmpty();
2304
2440
}
2305
2441
 
2306
 
QString AlbumDB::AlbumDBPriv::constructRelatedImagesSQL(bool fromOrTo, DatabaseRelation::Type type, bool boolean)
2307
 
{
2308
 
    QString sql;
2309
 
 
2310
 
    if (fromOrTo)
2311
 
    {
2312
 
        sql = "SELECT object FROM ImageRelations "
2313
 
              "INNER JOIN Images ON ImageRelations.object=Images.id "
2314
 
              "WHERE subject=? %1 AND status!=3 %2;";
2315
 
    }
2316
 
    else
2317
 
    {
2318
 
        sql = "SELECT subject FROM ImageRelations "
2319
 
              "INNER JOIN Images ON ImageRelations.subject=Images.id "
2320
 
              "WHERE object=? %1 AND status!=3 %2;";
2321
 
    }
2322
 
 
2323
 
    if (type != DatabaseRelation::UndefinedType)
2324
 
    {
2325
 
        sql = sql.arg(QString("AND type=?"));
2326
 
    }
2327
 
    else
2328
 
    {
2329
 
        sql = sql.arg(QString());
2330
 
    }
2331
 
 
2332
 
    if (boolean)
2333
 
    {
2334
 
        sql = sql.arg(QString("LIMIT 1"));
2335
 
    }
2336
 
    else
2337
 
    {
2338
 
        sql = sql.arg(QString());
2339
 
    }
2340
 
 
2341
 
    return sql;
2342
 
}
2343
 
 
2344
 
QList<qlonglong> AlbumDB::AlbumDBPriv::execRelatedImagesQuery(SqlQuery& query, qlonglong id, DatabaseRelation::Type type)
2345
 
{
2346
 
    QVariantList values;
2347
 
 
2348
 
    if (type == DatabaseRelation::UndefinedType)
2349
 
    {
2350
 
        db->execSql(query, id, &values);
2351
 
    }
2352
 
    else
2353
 
    {
2354
 
        db->execSql(query, id, type, &values);
2355
 
    }
2356
 
 
2357
 
    QList<qlonglong> imageIds;
2358
 
 
2359
 
    if (values.isEmpty())
2360
 
    {
2361
 
        return imageIds;
2362
 
    }
2363
 
 
2364
 
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd(); ++it)
2365
 
    {
2366
 
        imageIds << (*it).toInt();
2367
 
    }
2368
 
 
2369
 
    return imageIds;
2370
 
}
2371
 
 
2372
2442
QList<qlonglong> AlbumDB::getRelatedImages(qlonglong id, bool fromOrTo, DatabaseRelation::Type type, bool boolean)
2373
2443
{
2374
2444
    QString sql = d->constructRelatedImagesSQL(fromOrTo, type, boolean);
2479
2549
        sql = sql.arg("AND type=?");
2480
2550
    }
2481
2551
 
2482
 
    SqlQuery query = d->db->prepareQuery(sql);
2483
 
 
 
2552
    SqlQuery        query = d->db->prepareQuery(sql);
2484
2553
    QSet<qlonglong> result;
2485
2554
    QList<QVariant> values;
 
2555
 
2486
2556
    foreach(qlonglong id, ids)
2487
2557
    {
2488
2558
        if (type == DatabaseRelation::UndefinedType)
2528
2598
QList<qlonglong> AlbumDB::getDirtyOrMissingFingerprints()
2529
2599
{
2530
2600
    QList<qlonglong> itemIDs;
2531
 
    QList<QVariant> values;
 
2601
    QList<QVariant>  values;
2532
2602
 
2533
2603
    d->db->execSql(QString("SELECT id FROM Images "
2534
2604
                           "LEFT JOIN ImageHaarMatrix ON Images.id=ImageHaarMatrix.imageid "
2560
2630
                   &values);
2561
2631
 
2562
2632
    QStringList urls;
2563
 
    QString albumRootPath, relativePath, name;
 
2633
    QString     albumRootPath, relativePath, name;
2564
2634
 
2565
2635
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd();)
2566
2636
    {
2598
2668
                   &values);
2599
2669
 
2600
2670
    QStringList urls;
2601
 
    QString albumRootPath, relativePath, name;
 
2671
    QString     albumRootPath, relativePath, name;
2602
2672
 
2603
2673
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd();)
2604
2674
    {
2796
2866
    return list;
2797
2867
}
2798
2868
 
 
2869
QStringList AlbumDB::videoMetadataFieldList(DatabaseFields::VideoMetadata fields)
 
2870
{
 
2871
    // adds no spaces at beginning or end
 
2872
    QStringList list;
 
2873
 
 
2874
    if (fields & DatabaseFields::AspectRatio)
 
2875
    {
 
2876
        list << "aspectRatio";
 
2877
    }
 
2878
 
 
2879
    if (fields & DatabaseFields::AudioBitRate)
 
2880
    {
 
2881
        list << "audioBitRate";
 
2882
    }
 
2883
 
 
2884
    if (fields & DatabaseFields::AudioChannelType)
 
2885
    {
 
2886
        list << "audioChannelType";
 
2887
    }
 
2888
 
 
2889
    if (fields & DatabaseFields::AudioCompressor)
 
2890
    {
 
2891
        list << "audioCompressor";
 
2892
    }
 
2893
 
 
2894
    if (fields & DatabaseFields::Duration)
 
2895
    {
 
2896
        list << "duration";
 
2897
    }
 
2898
 
 
2899
    if (fields & DatabaseFields::FrameRate)
 
2900
    {
 
2901
        list << "frameRate";
 
2902
    }
 
2903
 
 
2904
    if (fields & DatabaseFields::VideoCodec)
 
2905
    {
 
2906
        list << "videoCodec";
 
2907
    }
 
2908
 
 
2909
    return list;
 
2910
}
 
2911
 
2799
2912
QStringList AlbumDB::imageMetadataFieldList(DatabaseFields::ImageMetadata fields)
2800
2913
{
2801
2914
    // adds no spaces at beginning or end
2975
3088
    return list;
2976
3089
}
2977
3090
 
2978
 
 
2979
3091
void AlbumDB::addBoundValuePlaceholders(QString& query, int count)
2980
3092
{
2981
3093
    // adds no spaces at beginning or end
3020
3132
    return id.toInt();
3021
3133
}
3022
3134
 
3023
 
 
3024
 
 
3025
3135
/*
3026
3136
void AlbumDB::setItemCaption(qlonglong imageID,const QString& caption)
3027
3137
{
3098
3208
        return;
3099
3209
    }
3100
3210
 
3101
 
    SqlQuery query = d->db->prepareQuery("REPLACE INTO ImageTags (imageid, tagid) VALUES(?, ?);");
3102
 
 
 
3211
    SqlQuery     query = d->db->prepareQuery("REPLACE INTO ImageTags (imageid, tagid) VALUES(?, ?);");
3103
3212
    QVariantList images;
3104
3213
    QVariantList tags;
3105
3214
 
3149
3258
        return;
3150
3259
    }
3151
3260
 
3152
 
    SqlQuery query = d->db->prepareQuery("DELETE FROM ImageTags WHERE imageID=? AND tagid=?;");
3153
 
 
 
3261
    SqlQuery     query = d->db->prepareQuery("DELETE FROM ImageTags WHERE imageID=? AND tagid=?;");
3154
3262
    QVariantList images;
3155
3263
    QVariantList tags;
3156
3264
 
3229
3337
                   " WHERE Images.status=1;", &values);
3230
3338
 
3231
3339
    QList<QDateTime> list;
 
3340
 
3232
3341
    foreach(const QVariant& value, values)
3233
3342
    {
3234
3343
        if (!value.isNull())
3247
3356
                   " WHERE Images.status=1;", &values);
3248
3357
 
3249
3358
    QMap<QDateTime, int> datesStatMap;
 
3359
 
3250
3360
    foreach(const QVariant& value, values)
3251
3361
    {
3252
3362
        if (!value.isNull())
3890
4000
    }
3891
4001
 
3892
4002
    QStringList urls;
3893
 
    QString relativePath, name;
 
4003
    QString     relativePath, name;
3894
4004
 
3895
4005
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd();)
3896
4006
    {
3915
4025
QList<qlonglong> AlbumDB::getItemIDsInAlbum(int albumID)
3916
4026
{
3917
4027
    QList<qlonglong> itemIDs;
3918
 
    QList<QVariant> values;
 
4028
    QList<QVariant>  values;
3919
4029
 
3920
4030
    d->db->execSql(QString("SELECT id FROM Images WHERE album=?;"),
3921
4031
                   albumID, &values);
3954
4064
 
3955
4065
    QString   path;
3956
4066
    qlonglong id;
3957
 
    QString relativePath, name;
 
4067
    QString   relativePath, name;
3958
4068
 
3959
4069
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd();)
3960
4070
    {
4058
4168
 
4059
4169
QStringList AlbumDB::getItemURLsInTag(int tagID, bool recursive)
4060
4170
{
4061
 
    QList<QVariant> values;
4062
 
 
4063
 
    QString imagesIdClause;
4064
 
 
 
4171
    QList<QVariant>         values;
 
4172
    QString                 imagesIdClause;
4065
4173
    QMap<QString, QVariant> bindingMap;
 
4174
 
4066
4175
    bindingMap.insert(QString(":tagID"), tagID);
4067
4176
    bindingMap.insert(QString(":tagID2"), tagID);
4068
4177
 
4076
4185
    }
4077
4186
 
4078
4187
    QStringList urls;
4079
 
    QString albumRootPath, relativePath, name;
 
4188
    QString     albumRootPath, relativePath, name;
4080
4189
 
4081
4190
    for (QList<QVariant>::const_iterator it = values.constBegin(); it != values.constEnd();)
4082
4191
    {
4102
4211
 
4103
4212
QList<qlonglong> AlbumDB::getItemIDsInTag(int tagID, bool recursive)
4104
4213
{
4105
 
    QList<qlonglong> itemIDs;
4106
 
    QList<QVariant> values;
 
4214
    QList<qlonglong>        itemIDs;
 
4215
    QList<QVariant>         values;
 
4216
    QMap<QString, QVariant> parameters;
4107
4217
 
4108
 
    QMap<QString, QVariant> parameters;
4109
4218
    parameters.insert(":tagPID", tagID);
4110
4219
    parameters.insert(":tagID",  tagID);
4111
4220
 
4235
4344
    }
4236
4345
 
4237
4346
    qint64 julianDays = 0;
 
4347
 
4238
4348
    foreach(const QDate& date, dates)
4239
4349
    {
4240
4350
        julianDays += date.toJulianDay();
4267
4377
 
4268
4378
    QVariantList imageIds;
4269
4379
    QVariantList status;
 
4380
 
4270
4381
    foreach(const qlonglong& id, itemIDs)
4271
4382
    {
4272
4383
        status << (int)DatabaseItem::Removed;
4465
4576
                   dstId, srcId);
4466
4577
    fields |= DatabaseFields::ImageMetadataAll;
4467
4578
 
 
4579
    d->db->execSql(QString("INSERT INTO VideoMetadata "
 
4580
                           " (imageid, aspectRatio, audioBitRate, audioChannelType, audioCompressor, duration, frameRate, "
 
4581
                           "  videoCodec) "
 
4582
                           "SELECT ?, aspectRatio, audioBitRate, audioChannelType, audioCompressor, duration, frameRate, "
 
4583
                           "  videoCodec "
 
4584
                           "FROM VideoMetadata WHERE imageid=?;"),
 
4585
                   dstId, srcId);
 
4586
    fields |= DatabaseFields::VideoMetadataAll;
 
4587
 
4468
4588
    d->db->execSql(QString("INSERT INTO ImagePositions "
4469
4589
                           " (imageid, latitude, latitudeNumber, longitude, longitudeNumber, "
4470
4590
                           "  altitude, orientation, tilt, roll, accuracy, description) "
4573
4693
    return true;
4574
4694
}
4575
4695
 
4576
 
QList<QVariant> AlbumDB::getImageIdsFromArea(qreal lat1, qreal lat2, qreal lng1, qreal lng2, int /*sortMode*/, const QString& /*sortBy*/)
 
4696
QList<QVariant> AlbumDB::getImageIdsFromArea(qreal lat1, qreal lat2, qreal lng1, qreal lng2, int /*sortMode*/,
 
4697
                                             const QString& /*sortBy*/)
4577
4698
{
4578
4699
    QList<QVariant> values;
4579
4700
    QList<QVariant> boundValues;