File indexing completed on 2024-10-06 12:46:17

 /* This file is part of the KDE project
    Copyright (C) 2004-2015 Jarosław Staniek <staniek@kde.org>
    Copyright (c) 2006, 2007 Thomas Braxton <kde.braxton@gmail.com>
    Copyright (c) 1999 Preston Brown <pbrown@kde.org>
    Copyright (c) 1997 Matthias Kalle Dalheimer <kalle@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 "KDbTableOrQuerySchema.h"
 #include "KDbConnection.h"
 #include "KDbQuerySchema.h"
 #include "kdb_debug.h"
 
 class Q_DECL_HIDDEN KDbTableOrQuerySchema::Private
 {
 public:
     Private() {}
     //! The name is kept here because m_table and m_table can be 0
     //! and we still want name() and acptionOrName() work.
     QByteArray name;
 
     KDbTableSchema* table;
 
     KDbQuerySchema* query;
 private:
     Q_DISABLE_COPY(Private)
 };
 
 KDbTableOrQuerySchema::KDbTableOrQuerySchema(KDbConnection *conn, const QByteArray& name)
         : d(new Private)
 {
     d->name = name;
     d->table = conn->tableSchema(QLatin1String(name));
     d->query = d->table ? nullptr : conn->querySchema(QLatin1String(name));
     if (!d->table && !d->query) {
         kdbWarning() << "tableOrQuery is neither table nor query!";
     }
 }
 
 KDbTableOrQuerySchema::KDbTableOrQuerySchema(KDbConnection *conn, const QByteArray& name, Type type)
         : d(new Private)
 {
     d->name = name;
     d->table = type == Type::Table ? conn->tableSchema(QLatin1String(name)) : nullptr;
     d->query = type == Type::Query ? conn->querySchema(QLatin1String(name)) : nullptr;
     if (type == Type::Table && !d->table) {
         kdbWarning() << "no table specified!";
     }
     if (type == Type::Query && !d->query) {
         kdbWarning() << "no query specified!";
     }
 }
 
 KDbTableOrQuerySchema::KDbTableOrQuerySchema(KDbFieldList *tableOrQuery)
     : d(new Private)
 {
     d->table = dynamic_cast<KDbTableSchema*>(tableOrQuery);
     d->query = dynamic_cast<KDbQuerySchema*>(tableOrQuery);
     if (!d->table && !d->query) {
         kdbWarning() << "tableOrQuery is neither table nor query!";
     }
 }
 
 KDbTableOrQuerySchema::KDbTableOrQuerySchema(KDbConnection *conn, int id)
     : d(new Private)
 {
     d->table = conn->tableSchema(id);
     d->query = d->table ? nullptr : conn->querySchema(id);
     if (!d->table && !d->query) {
         kdbWarning() << "no table or query found for id==" << id;
     }
 }
 
 KDbTableOrQuerySchema::KDbTableOrQuerySchema(KDbTableSchema* table)
     : d(new Private)
 {
     d->table = table;
     d->query = nullptr;
     if (!d->table) {
         kdbWarning() << "no table specified!";
     }
 }
 
 KDbTableOrQuerySchema::KDbTableOrQuerySchema(KDbQuerySchema* query)
     : d(new Private)
 {
     d->table = nullptr;
     d->query = query;
     if (!d->query) {
         kdbWarning() << "no query specified!";
     }
 }
 
 KDbTableOrQuerySchema::~KDbTableOrQuerySchema()
 {
     delete d;
 }
 
 int KDbTableOrQuerySchema::fieldCount(KDbConnection *conn) const
 {
     if (d->table)
         return d->table->fieldCount();
     if (d->query && conn)
         return d->query->fieldsExpanded(conn).size();
     return -1;
 }
 
 const KDbQueryColumnInfo::Vector KDbTableOrQuerySchema::columns(KDbConnection * conn, ColumnsMode mode)
 {
     if (d->table) {
         return d->table->query()->fieldsExpanded(conn, mode == ColumnsMode::Unique
                                                      ? KDbQuerySchema::FieldsExpandedMode::Unique
                                                      : KDbQuerySchema::FieldsExpandedMode::Default);
     }
     if (d->query) {
         return d->query->fieldsExpanded(conn, mode == ColumnsMode::Unique
                                             ? KDbQuerySchema::FieldsExpandedMode::Unique
                                             : KDbQuerySchema::FieldsExpandedMode::Default);
     }
     kdbWarning() << "no query or table specified!";
     return KDbQueryColumnInfo::Vector();
 }
 
 QByteArray KDbTableOrQuerySchema::name() const
 {
     if (d->table)
         return d->table->name().toLatin1();
     if (d->query)
         return d->query->name().toLatin1();
     return d->name;
 }
 
 QString KDbTableOrQuerySchema::captionOrName() const
 {
     KDbObject *object = d->table ? static_cast<KDbObject *>(d->table) : static_cast<KDbObject *>(d->query);
     if (!object)
         return QLatin1String(d->name);
     return object->caption().isEmpty() ? object->name() : object->caption();
 }
 
 KDbField* KDbTableOrQuerySchema::field(const QString& name)
 {
     if (d->table)
         return d->table->field(name);
     if (d->query)
         return d->query->field(name);
 
     return nullptr;
 }
 
 KDbQueryColumnInfo* KDbTableOrQuerySchema::columnInfo(KDbConnection *conn, const QString& name)
 {
     if (d->table)
         return d->table->query()->columnInfo(conn, name);
 
     if (d->query)
         return d->query->columnInfo(conn, name);
 
     return nullptr;
 }
 
 //! Sends information about table or query schema @a schema to debug output @a dbg.
 QDebug operator<<(QDebug dbg, const KDbConnectionAndSchema &connectionAndSchema)
 {
     if (std::get<1>(connectionAndSchema).table()) {
         dbg.nospace() << *std::get<1>(connectionAndSchema).table();
     } else if (std::get<1>(connectionAndSchema).query()) {
         dbg.nospace() << KDbConnectionAndQuerySchema(std::get<0>(connectionAndSchema),
                                                      *std::get<1>(connectionAndSchema).query());
     }
     return dbg.space();
 }
 
 KDbQuerySchema* KDbTableOrQuerySchema::query() const
 {
     return d->query;
 }
 
 KDbTableSchema* KDbTableOrQuerySchema::table() const
 {
     return d->table;
 }