File indexing completed on 2024-04-14 14:53:34

 /* This file is part of the KDE project
    Copyright (C) 2003 Joseph Wenninger <jowenn@kde.org>
    Copyright (C) 2003-2016 Jarosław Staniek <staniek@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KDbTableSchema.h"
 #include "KDbDriver.h"
 #include "KDbConnection.h"
 #include "KDbLookupFieldSchema.h"
 #include "KDbQuerySchema.h"
 #include "kdb_debug.h"
 
 //! @internal
 class Q_DECL_HIDDEN KDbTableSchema::Private
 {
 public:
     Private(KDbTableSchema *t)
             : q(t)
             , anyNonPKField(nullptr)
             , conn(nullptr)
             , pkey(nullptr)
             , query(nullptr)
     {
     }
 
     ~Private() {
         clearLookupFields();
         qDeleteAll(indices);
         delete query;
     }
 
     void clearLookupFields() {
         qDeleteAll(lookupFields);
         lookupFields.clear();
     }
 
     void addIndex(KDbIndexSchema *index) {
         indices.append(index);
         index->setTable(q);
     }
 
     KDbTableSchema * const q;
     KDbField *anyNonPKField;
     QHash<const KDbField*, KDbLookupFieldSchema*> lookupFields;
     QVector<KDbLookupFieldSchema*> lookupFieldsList;
     QList<KDbIndexSchema*> indices;
     //! @todo IMPORTANT: use something like QPointer<KDbConnection> conn
     KDbConnection *conn;
     KDbIndexSchema *pkey;
     KDbQuerySchema *query; //!< cached query schema that is defined by "select * from <this_table_name>"
 private:
     Q_DISABLE_COPY(Private)
 };
 
 //-------------------------------------
 
 KDbTableSchema::KDbTableSchema(const QString& name)
         : KDbFieldList(true)
         , KDbObject(KDb::TableObjectType)
         , d(new Private(this))
 {
     setName(name);
     init(nullptr);
 }
 
 KDbTableSchema::KDbTableSchema(const KDbObject& other)
         : KDbFieldList(true)
         , KDbObject(other)
         , d(new Private(this))
 {
     init(nullptr);
 }
 
 KDbTableSchema::KDbTableSchema()
         : KDbFieldList(true)
         , KDbObject(KDb::TableObjectType)
         , d(new Private(this))
 {
     init(nullptr);
 }
 
 KDbTableSchema::KDbTableSchema(const KDbTableSchema& ts, bool copyId)
         : KDbFieldList(static_cast<const KDbFieldList&>(ts))
         , KDbObject(static_cast<const KDbObject&>(ts))
         , d(new Private(this))
 {
     init(ts, copyId);
 }
 
 KDbTableSchema::KDbTableSchema(const KDbTableSchema& ts, int id)
         : KDbFieldList(static_cast<const KDbFieldList&>(ts))
         , KDbObject(static_cast<const KDbObject&>(ts))
         , d(new Private(this))
 {
     init(ts, false);
     setId(id);
 }
 
 // used by KDbConnection
 KDbTableSchema::KDbTableSchema(KDbConnection *conn, const QString & name)
         : KDbFieldList(true)
         , KDbObject(KDb::TableObjectType)
         , d(new Private(this))
 {
     setName(name);
     init(conn);
 }
 
 KDbTableSchema::~KDbTableSchema()
 {
     if (d->conn) {
         d->conn->removeMe(this);
     }
     delete d;
 }
 
 void KDbTableSchema::init(KDbConnection* conn)
 {
     d->conn = conn;
     d->pkey = new KDbIndexSchema;
     d->addIndex(d->pkey);
 }
 
 void KDbTableSchema::init(const KDbTableSchema& ts, bool copyId)
 {
     d->conn = ts.connection();
     setName(ts.name());
     d->pkey = nullptr; //will be copied
     if (!copyId)
         setId(-1);
 
     //deep copy all members
     foreach(KDbIndexSchema* otherIdx, *ts.indices()) {
         // fields from _this_ table will be assigned to the index
         KDbIndexSchema *idx = copyIndexFrom(*otherIdx);
         if (idx->isPrimaryKey()) {//assign pkey
             d->pkey = idx;
         }
     }
 
     KDbField::ListIterator tsIter(ts.fieldsIterator());
     KDbField::ListIterator iter(fieldsIterator());
     for (; iter != fieldsIteratorConstEnd(); ++tsIter, ++iter) {
         const KDbLookupFieldSchema *lookup = ts.lookupFieldSchema(**tsIter);
         if (lookup) {
             d->lookupFields.insert(*iter, new KDbLookupFieldSchema(*lookup));
         }
     }
 }
 
 KDbIndexSchema* KDbTableSchema::primaryKey()
 {
     return d->pkey;
 }
 
 const KDbIndexSchema* KDbTableSchema::primaryKey() const
 {
     return d->pkey;
 }
 
 const QList<KDbIndexSchema*>::ConstIterator KDbTableSchema::indicesIterator() const
 {
     return QList<KDbIndexSchema*>::ConstIterator (d->indices.constBegin());
 }
 
 const QList<KDbIndexSchema*>* KDbTableSchema::indices() const
 {
     return &d->indices;
 }
 
 bool KDbTableSchema::addIndex(KDbIndexSchema *index)
 {
     if (index && !d->indices.contains(index)) {
         d->addIndex(index);
         return true;
     }
     return false;
 }
 
 bool KDbTableSchema::removeIndex(KDbIndexSchema *index)
 {
     if (index) {
         d->indices.removeOne(index);
         return true;
     }
     return false;
 }
 
 KDbIndexSchema* KDbTableSchema::copyIndexFrom(const KDbIndexSchema& index)
 {
     KDbIndexSchema *newIndex = new KDbIndexSchema(index, this);
     addIndex(newIndex);
     return newIndex;
 }
 
 bool KDbTableSchema::isInternal() const
 {
     return dynamic_cast<const KDbInternalTableSchema*>(this);
 }
 
 void KDbTableSchema::setPrimaryKey(KDbIndexSchema *pkey)
 {
     if (pkey && !d->indices.contains(pkey)) {
         kdbWarning() << *pkey << "index can't be made primary key because it does not belong "
                                  "to table schema" << name();
         return;
     }
     if (d->pkey && d->pkey != pkey) {
         if (d->pkey->fieldCount() == 0) {//this is empty key, probably default - remove it
             d->indices.removeOne(d->pkey);
             delete d->pkey;
         }
         else {
             d->pkey->setPrimaryKey(false); //there can be only one pkey..
             //that's ok, the old pkey is still on indices list, if not empty
         }
     }
 
     if (!pkey) {//clearing - set empty pkey
         pkey = new KDbIndexSchema;
         d->addIndex(pkey);
     }
     d->pkey = pkey; //!< @todo
     d->pkey->setPrimaryKey(true);
     d->anyNonPKField = nullptr; //for safety
 }
 
 bool KDbTableSchema::insertField(int index, KDbField *field)
 {
     if (!field) {
         return false;
     }
     KDbField::List *fieldsList = fields();
     KDbFieldList::insertField(index, field);
     if (!field || index > fieldsList->count()) {
         return false;
     }
     field->setTable(this);
     field->setOrder(index);
     //update order for next next fields
     const int fieldCount = fieldsList->count();
     for (int i = index + 1; i < fieldCount; i++) {
         fieldsList->at(i)->setOrder(i);
     }
 
     //Check for auto-generated indices:
     KDbIndexSchema *idx = nullptr;
     if (field->isPrimaryKey()) {// this is auto-generated single-field unique index
         idx = new KDbIndexSchema;
         d->addIndex(idx);
         idx->setAutoGenerated(true);
         const bool ok = idx->addField(field);
         Q_ASSERT(ok);
         setPrimaryKey(idx);
     }
     if (field->isUniqueKey()) {
         if (!idx) {
             idx = new KDbIndexSchema;
             d->addIndex(idx);
             idx->setAutoGenerated(true);
             const bool ok = idx->addField(field);
             Q_ASSERT(ok);
         }
         idx->setUnique(true);
     }
     if (field->isIndexed()) {// this is auto-generated single-field
         if (!idx) {
             idx = new KDbIndexSchema;
             d->addIndex(idx);
             idx->setAutoGenerated(true);
             const bool ok = idx->addField(field);
             Q_ASSERT(ok);
         }
     }
     return true;
 }
 
 bool KDbTableSchema::removeField(KDbField *field)
 {
     KDbLookupFieldSchema* lookup = d->lookupFields.take(field);
     if (!KDbFieldList::removeField(field)) {
         return false;
     }
     if (d->anyNonPKField && field == d->anyNonPKField) //d->anyNonPKField will be removed!
         d->anyNonPKField = nullptr;
     delete lookup;
     return true;
 }
 
 void KDbTableSchema::clear()
 {
     d->indices.clear();
     d->clearLookupFields();
     KDbFieldList::clear();
     KDbObject::clear();
     d->conn = nullptr;
 }
 
 QDebug KDbTableSchema::debugFields(QDebug dbg) const
 {
     dbg.nospace() << static_cast<const KDbFieldList&>(*this);
     for (const KDbField *f : *fields()) {
         const KDbLookupFieldSchema *lookupSchema = lookupFieldSchema(*f);
         if (lookupSchema)
             dbg.nospace() << '\n' << f->name() << *lookupSchema;
     }
     return dbg.space();
 }
 
 QDebug operator<<(QDebug dbg, const KDbTableSchema& table)
 {
     dbg.nospace() << "TABLE";
     dbg.space() << static_cast<const KDbObject&>(table) << '\n';
     table.debugFields(dbg);
     return dbg.space();
 }
 
 QDebug operator<<(QDebug dbg, const KDbInternalTableSchema& table)
 {
     dbg.nospace() << "INTERNAL_TABLE";
     dbg.space() << static_cast<const KDbObject&>(table) << '\n';
     table.debugFields(dbg);
     return dbg.space();
 }
 
 KDbConnection* KDbTableSchema::connection() const
 {
     return d->conn;
 }
 
 void KDbTableSchema::setConnection(KDbConnection* conn)
 {
     d->conn = conn;
 }
 
 KDbQuerySchema* KDbTableSchema::query()
 {
     if (d->query)
         return d->query;
     d->query = new KDbQuerySchema(this);   //it's owned by me
     return d->query;
 }
 
 KDbField* KDbTableSchema::anyNonPKField()
 {
     if (!d->anyNonPKField) {
         KDbField *f = nullptr;
         for (QListIterator<KDbField*> it(*fields()); it.hasPrevious();) {
             f = it.previous();
             if (!f->isPrimaryKey() && (!d->pkey || !d->pkey->hasField(*f)))
                 break;
         }
         d->anyNonPKField = f;
     }
     return d->anyNonPKField;
 }
 
 bool KDbTableSchema::setLookupFieldSchema(const QString& fieldName, KDbLookupFieldSchema *lookupFieldSchema)
 {
     KDbField *f = field(fieldName);
     if (!f) {
         kdbWarning() << "no such field" << fieldName << "in table" << name();
         return false;
     }
     delete d->lookupFields.take(f);
     if (lookupFieldSchema) {
         d->lookupFields.insert(f, lookupFieldSchema);
     }
     d->lookupFieldsList.clear(); //this will force to rebuid the internal cache
     return true;
 }
 
 KDbLookupFieldSchema *KDbTableSchema::lookupFieldSchema(const KDbField& field)
 {
     return d->lookupFields.value(&field);
 }
 
 const KDbLookupFieldSchema *KDbTableSchema::lookupFieldSchema(const KDbField& field) const
 {
     return d->lookupFields.value(&field);
 }
 
 KDbLookupFieldSchema *KDbTableSchema::lookupFieldSchema(const QString& fieldName)
 {
     KDbField *f = KDbTableSchema::field(fieldName);
     if (!f)
         return nullptr;
     return lookupFieldSchema(*f);
 }
 
 QVector<KDbLookupFieldSchema*> KDbTableSchema::lookupFields() const
 {
     if (d->lookupFields.isEmpty())
         return QVector<KDbLookupFieldSchema*>();
     if (!d->lookupFields.isEmpty() && !d->lookupFieldsList.isEmpty())
         return d->lookupFieldsList; //already updated
     //update
     d->lookupFieldsList.clear();
     d->lookupFieldsList.resize(d->lookupFields.count());
     int i = 0;
     for (KDbField* f : *fields()) {
         QHash<const KDbField*, KDbLookupFieldSchema*>::ConstIterator itMap = d->lookupFields.constFind(f);
         if (itMap != d->lookupFields.constEnd()) {
             d->lookupFieldsList[i] = itMap.value();
             i++;
         }
     }
     return d->lookupFieldsList;
 }
 
 //--------------------------------------
 
 class Q_DECL_HIDDEN KDbInternalTableSchema::Private
 {
 public:
     Private() {}
     bool dummy = false;
 };
 
 KDbInternalTableSchema::KDbInternalTableSchema(const QString& name)
         : KDbTableSchema(name)
         , d(new Private)
 {
 }
 
 KDbInternalTableSchema::KDbInternalTableSchema(const KDbTableSchema& ts)
         : KDbTableSchema(ts, false)
         , d(new Private)
 {
 }
 
 KDbInternalTableSchema::KDbInternalTableSchema(const KDbInternalTableSchema& ts)
         : KDbTableSchema(ts, false)
         , d(new Private)
 {
 }
 
 KDbInternalTableSchema::~KDbInternalTableSchema()
 {
     delete d;
 }