qsqlrecord.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtSql module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qsqlrecord.h"

#include "qdebug.h"
#include "qstringlist.h"
#include "qatomic.h"
#include "qsqlfield.h"
#include "qstring.h"
#include "qvector.h"

QT_BEGIN_NAMESPACE

class QSqlRecordPrivate
{
public:
    QSqlRecordPrivate();
    QSqlRecordPrivate(const QSqlRecordPrivate &other);

    inline bool contains(int index) { return index >= 0 && index < fields.count(); }
    QString createField(int index, const QString &prefix) const;

    QVector<QSqlField> fields;
    QAtomicInt ref;
};

QSqlRecordPrivate::QSqlRecordPrivate()
{
    ref = 1;
}

QSqlRecordPrivate::QSqlRecordPrivate(const QSqlRecordPrivate &other): fields(other.fields)
{
    ref = 1;
}

QString QSqlRecordPrivate::createField(int index, const QString &prefix) const
{
    QString f;
    if (!prefix.isEmpty())
        f = prefix + QLatin1Char('.');
    f += fields.at(index).name();
    return f;
}

QSqlRecord::QSqlRecord()
{
    d = new QSqlRecordPrivate();
}

QSqlRecord::QSqlRecord(const QSqlRecord& other)
{
    d = other.d;
    d->ref.ref();
}

QSqlRecord& QSqlRecord::operator=(const QSqlRecord& other)
{
    qAtomicAssign(d, other.d);
    return *this;
}

QSqlRecord::~QSqlRecord()
{
    if (!d->ref.deref())
        delete d;
}

bool QSqlRecord::operator==(const QSqlRecord &other) const
{
    return d->fields == other.d->fields;
}

QVariant QSqlRecord::value(int index) const
{
    return d->fields.value(index).value();
}

QVariant QSqlRecord::value(const QString& name) const
{
    return value(indexOf(name));
}

QString QSqlRecord::fieldName(int index) const
{
    return d->fields.value(index).name();
}

int QSqlRecord::indexOf(const QString& name) const
{
    QString nm = name.toUpper();
    for (int i = 0; i < count(); ++i) {
        if (d->fields.at(i).name().toUpper() == nm) // TODO: case-insensitive comparison
            return i;
    }
    return -1;
}

#ifdef QT3_SUPPORT

const QSqlField* QSqlRecord::fieldPtr(int index) const
{
    if (!d->contains(index))
        return 0;

    return &d->fields.at(index);
}

const QSqlField* QSqlRecord::fieldPtr(const QString& name) const
{
    int i = indexOf(name);
    if (!d->contains(i))
        return 0;

    return &d->fields.at(i);
}
#endif //QT3_SUPPORT

QSqlField QSqlRecord::field(int index) const
{
    return d->fields.value(index);
}

QSqlField QSqlRecord::field(const QString &name) const
{
    return field(indexOf(name));
}


void QSqlRecord::append(const QSqlField& field)
{
    detach();
    d->fields.append(field);
}

void QSqlRecord::insert(int pos, const QSqlField& field)
{
   detach();
   d->fields.insert(pos, field);
}

void QSqlRecord::replace(int pos, const QSqlField& field)
{
    if (!d->contains(pos))
        return;

    detach();
    d->fields[pos] = field;
}

void QSqlRecord::remove(int pos)
{
    if (!d->contains(pos))
        return;

    detach();
    d->fields.remove(pos);
}

void QSqlRecord::clear()
{
    detach();
    d->fields.clear();
}

bool QSqlRecord::isEmpty() const
{
    return d->fields.isEmpty();
}


bool QSqlRecord::contains(const QString& name) const
{
    return indexOf(name) >= 0;
}

void QSqlRecord::clearValues()
{
    detach();
    int count = d->fields.count();
    for (int i = 0; i < count; ++i)
        d->fields[i].clear();
}

void QSqlRecord::setGenerated(const QString& name, bool generated)
{
    setGenerated(indexOf(name), generated);
}

void QSqlRecord::setGenerated(int index, bool generated)
{
    if (!d->contains(index))
        return;
    detach();
    d->fields[index].setGenerated(generated);
}

bool QSqlRecord::isNull(int index) const
{
    return d->fields.value(index).isNull();
}

bool QSqlRecord::isNull(const QString& name) const
{
    return isNull(indexOf(name));
}

void QSqlRecord::setNull(int index)
{
    if (!d->contains(index))
        return;
    detach();
    d->fields[index].clear();
}

void QSqlRecord::setNull(const QString& name)
{
    setNull(indexOf(name));
}


bool QSqlRecord::isGenerated(const QString& name) const
{
    return isGenerated(indexOf(name));
}

bool QSqlRecord::isGenerated(int index) const
{
    return d->fields.value(index).isGenerated();
}

#ifdef QT3_SUPPORT

QString QSqlRecord::toString(const QString& prefix, const QString& sep) const
{
    QString pflist;
    bool comma = false;
    for (int i = 0; i < count(); ++i) {
        if (!d->fields.value(i).isGenerated()) {
            if (comma)
                pflist += sep + QLatin1Char(' ');
            pflist += d->createField(i, prefix);
            comma = true;
        }
    }
    return pflist;
}

QStringList QSqlRecord::toStringList(const QString& prefix) const
{
    QStringList s;
    for (int i = 0; i < count(); ++i) {
        if (!d->fields.value(i).isGenerated())
            s += d->createField(i, prefix);
    }
    return s;
}
#endif // QT3_SUPPORT

int QSqlRecord::count() const
{
    return d->fields.count();
}

void QSqlRecord::setValue(int index, const QVariant& val)
{
    if (!d->contains(index))
        return;
    detach();
    d->fields[index].setValue(val);
}


void QSqlRecord::setValue(const QString& name, const QVariant& val)
{
    setValue(indexOf(name), val);
}


void QSqlRecord::detach()
{
    qAtomicDetach(d);
}

#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QSqlRecord &r)
{
    dbg << "QSqlRecord(" << r.count() << ')';
    for (int i = 0; i < r.count(); ++i)
        dbg << '\n' << QString::fromLatin1("%1:").arg(i, 2) << r.field(i) << r.value(i).toString();
    return dbg;
}
#endif

QT_END_NAMESPACE