qsqlfield.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 "qsqlfield.h"
#include "qdebug.h"
 
QT_BEGIN_NAMESPACE
 
class QSqlFieldPrivate : public QSharedData
{
public:
    QSqlFieldPrivate(const QString &name,
                     QMetaType type, const QString &tableName) :
        nm(name), table(tableName), def(QVariant()), type(type),
        req(QSqlField::Unknown), len(-1), prec(-1), tp(-1),
        ro(false), gen(true), autoval(false)
    {}
 
    bool operator==(const QSqlFieldPrivate& other) const
    {
        return (nm == other.nm
                && table == other.table
                && def == other.def
                && type == other.type
                && req == other.req
                && len == other.len
                && prec == other.prec
                && ro == other.ro
                && gen == other.gen
                && autoval == other.autoval);
    }
 
    QString nm;
    QString table;
    QVariant def;
    QMetaType type;
    QSqlField::RequiredStatus req;
    int len;
    int prec;
    int tp;
    bool ro: 1;
    bool gen: 1;
    bool autoval: 1;
};
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QSqlFieldPrivate)
 
 
 
QSqlField::QSqlField(const QString &fieldName, QMetaType type, const QString &table)
    : val(QVariant(type, nullptr)),
      d(new QSqlFieldPrivate(fieldName, type, table))
{
}
 
QSqlField::QSqlField(const QSqlField &other)
    = default;
 
QSqlField& QSqlField::operator=(const QSqlField& other)
    = default;
 
bool QSqlField::operator==(const QSqlField& other) const
{
    return ((d == other.d || *d == *other.d)
            && val == other.val);
}
 
QSqlField::~QSqlField()
    = default;
 
void QSqlField::setRequiredStatus(RequiredStatus required)
{
    detach();
    d->req = required;
}
 
void QSqlField::setLength(int fieldLength)
{
    detach();
    d->len = fieldLength;
}
 
void QSqlField::setPrecision(int precision)
{
    detach();
    d->prec = precision;
}
 
void QSqlField::setDefaultValue(const QVariant &value)
{
    detach();
    d->def = value;
}
 
#if QT_DEPRECATED_SINCE(6, 8)
void QSqlField::setSqlType(int type)
{
    detach();
    d->tp = type;
}
#endif
 
void QSqlField::setGenerated(bool gen)
{
    detach();
    d->gen = gen;
}
 
 
void QSqlField::setValue(const QVariant& value)
{
    if (isReadOnly())
        return;
    val = value;
}
 
void QSqlField::clear()
{
    if (isReadOnly())
        return;
    val = QVariant(d->type, nullptr);
}
 
 
void QSqlField::setName(const QString& name)
{
    detach();
    d->nm = name;
}
 
void QSqlField::setReadOnly(bool readOnly)
{
    detach();
    d->ro = readOnly;
}
 
QString QSqlField::name() const
{
    return d->nm;
}
 
QMetaType QSqlField::metaType() const
{
    return d->type;
}
 
void QSqlField::setMetaType(QMetaType type)
{
    detach();
    d->type = type;
    if (!val.isValid())
        val = QVariant(type, nullptr);
}
 
bool QSqlField::isReadOnly() const
{
    return d->ro;
}
 
bool QSqlField::isNull() const
{
    return val.isNull();
}
 
void QSqlField::detach()
{
    d.detach();
}
 
QSqlField::RequiredStatus QSqlField::requiredStatus() const
{
    return d->req;
}
 
int QSqlField::length() const
{
    return d->len;
}
 
int QSqlField::precision() const
{
    return d->prec;
}
 
QVariant QSqlField::defaultValue() const
{
    return d->def;
}
 
#if QT_DEPRECATED_SINCE(6, 8)
int QSqlField::typeID() const
{
    return d->tp;
}
#endif
 
bool QSqlField::isGenerated() const
{
    return d->gen;
}
 
bool QSqlField::isValid() const
{
    return d->type.isValid();
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QSqlField &f)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace();
    dbg << "QSqlField(" << f.name() << ", " << f.metaType().name();
    dbg << ", tableName: " << (f.tableName().isEmpty() ? QStringLiteral("(not specified)") : f.tableName());
    if (f.length() >= 0)
        dbg << ", length: " << f.length();
    if (f.precision() >= 0)
        dbg << ", precision: " << f.precision();
    if (f.requiredStatus() != QSqlField::Unknown)
        dbg << ", required: "
            << (f.requiredStatus() == QSqlField::Required ? "yes" : "no");
    dbg  << ", generated: " << (f.isGenerated() ? "yes" : "no");
    if (!f.defaultValue().isNull())
        dbg << ", defaultValue: \"" << f.defaultValue() << '\"';
    dbg << ", autoValue: " << f.isAutoValue()
        << ", readOnly: " << f.isReadOnly() << ')';
    return dbg;
}
#endif
 
bool QSqlField::isAutoValue() const
{
    return d->autoval;
}
 
void QSqlField::setAutoValue(bool autoVal)
{
    detach();
    d->autoval = autoVal;
}
 
void QSqlField::setTableName(const QString &tableName)
{
    detach();
    d->table = tableName;
}
 
QString QSqlField::tableName() const
{
    return d->table;
}
 
QT_END_NAMESPACE
 
#include "moc_qsqlfield.cpp"