qsqlrecord.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsqlrecord.h"
 
#include "qatomic.h"
#include "qdebug.h"
#include "qlist.h"
#include "qsqlfield.h"
#include "qstring.h"
 
QT_BEGIN_NAMESPACE
 
class QSqlRecordPrivate : public QSharedData
{
public:
    inline bool contains(qsizetype index) const
    {
      return index >= 0 && index < fields.size();
    }
 
    QList<QSqlField> fields;
};
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QSqlRecordPrivate)
 
 
QSqlRecord::QSqlRecord()
  : d(new QSqlRecordPrivate)
{
}
 
QSqlRecord::QSqlRecord(const QSqlRecord &other)
    = default;
 
QSqlRecord& QSqlRecord::operator=(const QSqlRecord &other)
    = default;
 
QSqlRecord::~QSqlRecord()
    = default;
 
 
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(QStringView(name));
}
 
QVariant QSqlRecord::value(QStringView 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
{
    return indexOf(QStringView(name));
}
 
int QSqlRecord::indexOf(QStringView name) const
{
    QStringView tableName;
    QStringView fieldName(name);
    const qsizetype idx = name.indexOf(u'.');
    if (idx != -1) {
        tableName = fieldName.left(idx);
        fieldName = fieldName.mid(idx + 1);
    }
    const int cnt = count();
    for (int i = 0; i < cnt; ++i) {
        // Check the passed in name first in case it is an alias using a dot.
        // Then check if both the table and field match when there is a table name specified.
        const auto &currentField = d->fields.at(i);
        const auto &currentFieldName = currentField.name();
        if (currentFieldName.compare(name, Qt::CaseInsensitive) == 0
            || (idx != -1 && currentFieldName.compare(fieldName, Qt::CaseInsensitive) == 0
                && currentField.tableName().compare(tableName, Qt::CaseInsensitive) == 0)) {
            return i;
        }
    }
    return -1;
}
 
QSqlField QSqlRecord::field(int index) const
{
    return d->fields.value(index);
}
 
QSqlField QSqlRecord::field(const QString &name) const
{
    return field(QStringView(name));
}
 
QSqlField QSqlRecord::field(QStringView 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 contains(QStringView(name));
}
 
bool QSqlRecord::contains(QStringView name) const
{
    return indexOf(name) >= 0;
}
 
void QSqlRecord::clearValues()
{
    detach();
    for (QSqlField &f : d->fields)
        f.clear();
}
 
void QSqlRecord::setGenerated(const QString &name, bool generated)
{
    setGenerated(QStringView(name), generated);
}
void QSqlRecord::setGenerated(QStringView 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(QStringView(name));
}
 
bool QSqlRecord::isNull(QStringView 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(QStringView(name));
}
 
void QSqlRecord::setNull(QStringView name)
{
    setNull(indexOf(name));
}
 
bool QSqlRecord::isGenerated(const QString &name) const
{
    return isGenerated(QStringView(name));
}
 
bool QSqlRecord::isGenerated(QStringView name) const
{
    return isGenerated(indexOf(name));
}
 
bool QSqlRecord::isGenerated(int index) const
{
    return d->fields.value(index).isGenerated();
}
 
int QSqlRecord::count() const
{
    return d->fields.size();
}
 
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(QStringView(name), val);
}
void QSqlRecord::setValue(QStringView name, const QVariant &val)
{
    setValue(indexOf(name), val);
}
 
 
void QSqlRecord::detach()
{
    d.detach();
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QSqlRecord &r)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace();
    const int count = r.count();
    dbg << "QSqlRecord(" << count << ')';
    for (int i = 0; i < count; ++i) {
        dbg.nospace();
        dbg << '\n' << qSetFieldWidth(2) << Qt::right << i << Qt::left << qSetFieldWidth(0) << ':';
        dbg.space();
        dbg << r.field(i) << r.value(i).toString();
    }
    return dbg;
}
#endif
 
QSqlRecord QSqlRecord::keyValues(const QSqlRecord &keyFields) const
{
    QSqlRecord retValues(keyFields);
 
    for (int i = retValues.count() - 1; i >= 0; --i)
        retValues.setValue(i, value(retValues.fieldName(i)));
 
    return retValues;
}
 
QT_END_NAMESPACE