path: root/src/sql/qsqlfield.cpp

/****************************************************************************
**
** Implementation of QSqlField class
**
** Created : 2000-11-03
**
** Copyright (C) 2005-2008 Trolltech ASA.  All rights reserved.
**
** This file is part of the sql module of the Qt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free Qt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at [email protected].
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.QPL
** included in the packaging of this file.  Licensees holding valid Qt
** Commercial licenses may use this file in accordance with the Qt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/

#include "qsqlfield.h"

#ifndef QT_NO_SQL


/*!
    \class QSqlField qsqlfield.h
    \brief The QSqlField class manipulates the fields in SQL database tables
    and views.

    \ingroup database
    \module sql

    QSqlField represents the characteristics of a single column in a
    database table or view, such as the data type and column name. A
    field also contains the value of the database column, which can be
    viewed or changed.

    Field data values are stored as QVariants. Using an incompatible
    type is not permitted. For example:

    \code
    QSqlField f( "myfield", QVariant::Int );
    f.setValue( QPixmap() );  // will not work
    \endcode

    However, the field will attempt to cast certain data types to the
    field data type where possible:

    \code
    QSqlField f( "myfield", QVariant::Int );
    f.setValue( QString("123") ); // casts QString to int
    \endcode

    QSqlField objects are rarely created explicitly in application
    code. They are usually accessed indirectly through \l QSqlRecord
    or \l QSqlCursor which already contain a list of fields. For
    example:

    \code
    QSqlCursor cur( "Employee" );        // create cursor using the 'Employee' table
    QSqlField* f = cur.field( "name" );  // use the 'name' field
    f->setValue( "Dave" );               // set field value
    ...
    \endcode

    In practice we rarely need to extract a pointer to a field at all.
    The previous example would normally be written:

    \code
    QSqlCursor cur( "Employee" );
    cur.setValue( "name", "Dave" );
    ...
    \endcode
*/

/*!
    Constructs an empty field called \a fieldName of type \a type.
*/

QSqlField::QSqlField( const QString& fieldName, QVariant::Type type )
    : nm(fieldName), ro(FALSE), nul(FALSE)
{
    d = new QSqlFieldPrivate();
    d->type = type;
    val.cast( type );
}

/*!
    Constructs a copy of \a other.
*/

QSqlField::QSqlField( const QSqlField& other )
    : nm( other.nm ), val( other.val ), ro( other.ro ), nul( other.nul )
{
    d = new QSqlFieldPrivate();
    d->type = other.d->type;
}

/*!
    Sets the field equal to \a other.
*/

QSqlField& QSqlField::operator=( const QSqlField& other )
{
    nm = other.nm;
    val = other.val;
    ro = other.ro;
    nul = other.nul;
    d->type = other.d->type;
    return *this;    
}

/*!
    Returns TRUE if the field is equal to \a other; otherwise returns
    FALSE. Fields are considered equal when the following field
    properties are the same:

    \list
    \i \c name()
    \i \c isNull()
    \i \c value()
    \i \c isReadOnly()
    \endlist

*/
bool QSqlField::operator==(const QSqlField& other) const
{
    return ( nm == other.nm &&
	     val == other.val &&
	     ro == other.ro &&
	     nul == other.nul &&
	     d->type == other.d->type );
}

/*!
    Destroys the object and frees any allocated resources.
*/

QSqlField::~QSqlField()
{
    delete d;
}


/*!
    \fn QVariant QSqlField::value() const

    Returns the value of the field as a QVariant.
*/

/*!
    Sets the value of the field to \a value. If the field is read-only
    (isReadOnly() returns TRUE), nothing happens. If the data type of
    \a value differs from the field's current data type, an attempt is
    made to cast it to the proper type. This preserves the data type
    of the field in the case of assignment, e.g. a QString to an
    integer data type. For example:

    \code
    QSqlCursor cur( "Employee" );                 // 'Employee' table
    QSqlField* f = cur.field( "student_count" );  // an integer field
    ...
    f->setValue( myLineEdit->text() );		  // cast the line edit text to an integer
    \endcode

    \sa isReadOnly()
*/

void QSqlField::setValue( const QVariant& value )
{
    if ( isReadOnly() )
	return;
    if ( value.type() != d->type ) {
	if ( !val.canCast( d->type ) )
	     qWarning("QSqlField::setValue: %s cannot cast from %s to %s",
		      nm.local8Bit().data(), value.typeName(), QVariant::typeToName( d->type ) );
    }
    val = value;

    if ( value.isNull() )
	nul = TRUE;
    else
	nul = val.type() == QVariant::Invalid;
}

/*!
    Clears the value of the field. If the field is read-only, nothing
    happens. If \a nullify is TRUE (the default), the field is set to
    NULL.
*/

void QSqlField::clear( bool nullify )
{
    if ( isReadOnly() )
	return;
    QVariant v;
    v.cast( type() );
    val = v;
    if ( nullify )
	nul = TRUE;
}

/*!
    \fn void QSqlField::setName( const QString& name )

    Sets the name of the field to \a name.
*/

void QSqlField::setName( const QString& name )
{
    nm = name;
}

/*!
    \fn void QSqlField::setNull()

    Sets the field to NULL and clears the value using clear(). If the
    field is read-only, nothing happens.

    \sa isReadOnly() clear()
*/

void QSqlField::setNull()
{
    clear( TRUE );
}

/*!
    \fn void QSqlField::setReadOnly( bool readOnly )

    Sets the read only flag of the field's value to \a readOnly.

    \sa setValue()
*/
void QSqlField::setReadOnly( bool readOnly )
{
    ro = readOnly;
}

/*!
    \fn QString QSqlField::name() const

    Returns the name of the field.
*/

/*!
    \fn QVariant::Type QSqlField::type() const

    Returns the field's type as stored in the database.
    Note that the actual value might have a different type,
    Numerical values that are too large to store in a long
    int or double are usually stored as strings to prevent
    precision loss.
*/

/*!
    \fn bool QSqlField::isReadOnly() const

    Returns TRUE if the field's value is read only; otherwise returns
    FALSE.
*/

/*!
    \fn bool QSqlField::isNull() const

    Returns TRUE if the field is currently NULL; otherwise returns
    FALSE.
*/


/******************************************/
/*******     QSqlFieldInfo Impl      ******/
/******************************************/

struct QSqlFieldInfoPrivate
{
    int required, len, prec, typeID;
    uint generated: 1;
    uint trim: 1;
    uint calculated: 1;
    QString name;
    QString typeName;
    QVariant::Type typ;
    QVariant defValue;
};

/*!
    \class QSqlFieldInfo qsqlfield.h
    \brief The QSqlFieldInfo class stores meta data associated with a SQL field.

    \ingroup database
    \module sql

    QSqlFieldInfo objects only store meta data; field values are
    stored in QSqlField objects.

    All values must be set in the constructor, and may be retrieved
    using isRequired(), type(), length(), precision(), defaultValue(),
    name(), isGenerated() and typeID().
*/

/*!
    Constructs a QSqlFieldInfo with the following parameters:
    \table
    \row \i \a name  \i the name of the field.
    \row \i \a typ   \i the field's type in a QVariant.
    \row \i \a required  \i greater than 0 if the field is required, 0
    if its value can be NULL and less than 0 if it cannot be
    determined whether the field is required or not.
    \row \i \a len  \i the length of the field. Note that for
    non-character types some databases return either the length in
    bytes or the number of digits. -1 signifies that the length cannot
    be determined.
    \row \i \a prec  \i the precision of the field, or -1 if the field
    has no precision or it cannot be determined.
    \row \i \a defValue  \i the default value that is inserted into
    the table if none is specified by the user. QVariant() if there is
    no default value or it cannot be determined.
    \row \i \a typeID  \i the internal typeID of the database system
    (only useful for low-level programming). 0 if unknown.
    \row \i \a generated  \i TRUE indicates that this field should be
    included in auto-generated SQL statments, e.g. in QSqlCursor.
    \row \i \a trim  \i TRUE indicates that widgets should remove
    trailing whitespace from character fields. This does not affect
    the field value but only its representation inside widgets.
    \row \i \a calculated  \i TRUE indicates that the value of this
    field is calculated. The value of calculated fields can by
    modified by subclassing QSqlCursor and overriding
    QSqlCursor::calculateField().
    \endtable
*/
QSqlFieldInfo::QSqlFieldInfo( const QString& name,
		   QVariant::Type typ,
		   int required,
		   int len,
		   int prec,
		   const QVariant& defValue,
		   int typeID,
		   bool generated,
		   bool trim,
		   bool calculated )
{
    d = new QSqlFieldInfoPrivate();
    d->name = name;
    d->typ = typ;
    d->required = required;
    d->len = len;
    d->prec = prec;
    d->defValue = defValue;
    d->typeID = typeID;
    d->generated = generated;
    d->trim = trim;
    d->calculated = calculated;
}

/*!
    Constructs a copy of \a other.
*/
QSqlFieldInfo::QSqlFieldInfo( const QSqlFieldInfo & other )
{
    d = new QSqlFieldInfoPrivate( *(other.d) );
}

/*!
    Creates a QSqlFieldInfo object with the type and the name of the
    QSqlField \a other. If \a generated is TRUE this field will be
    included in auto-generated SQL statments, e.g. in QSqlCursor.
*/
QSqlFieldInfo::QSqlFieldInfo( const QSqlField & other, bool generated )
{
    d = new QSqlFieldInfoPrivate();
    d->name = other.name();
    d->typ = other.type();
    d->required = -1;
    d->len = -1;
    d->prec = -1;
    d->typeID = 0;
    d->generated = generated;
    d->trim = FALSE;
    d->calculated = FALSE;
}

/*!
    Destroys the object and frees any allocated resources.
*/
QSqlFieldInfo::~QSqlFieldInfo()
{
    delete d;
}

/*!
    Assigns \a other to this field info and returns a reference to it.
*/
QSqlFieldInfo& QSqlFieldInfo::operator=( const QSqlFieldInfo& other )
{
    delete d;
    d = new QSqlFieldInfoPrivate( *(other.d) );
    return *this;
}

/*!
    Returns TRUE if this fieldinfo is equal to \a f; otherwise returns
    FALSE.

    Two field infos are considered equal if all their attributes
    match.
*/
bool QSqlFieldInfo::operator==( const QSqlFieldInfo& f ) const
{
    return ( d->name == f.d->name &&
		d->typ == f.d->typ &&
		d->required == f.d->required &&
		d->len == f.d->len &&
		d->prec == f.d->prec &&
		d->defValue == f.d->defValue &&
		d->typeID == f.d->typeID &&
		d->generated == f.d->generated &&
		d->trim == f.d->trim &&
		d->calculated == f.d->calculated );
}

/*!
    Returns an empty QSqlField based on the information in this
    QSqlFieldInfo.
*/
QSqlField QSqlFieldInfo::toField() const
{ return QSqlField( d->name, d->typ ); }

/*!
    Returns a value greater than 0 if the field is required (NULL
    values are not allowed), 0 if it isn't required (NULL values are
    allowed) or less than 0 if it cannot be determined whether the
    field is required or not.
*/
int QSqlFieldInfo::isRequired() const
{ return d->required; }

/*!
    Returns the field's type or QVariant::Invalid if the type is
    unknown.
*/
QVariant::Type QSqlFieldInfo::type() const
{ return d->typ; }

/*!
    Returns the field's length. For fields storing text the return
    value is the maximum number of characters the field can hold. For
    non-character fields some database systems return the number of
    bytes needed or the number of digits allowed. If the length cannot
    be determined -1 is returned.
*/
int QSqlFieldInfo::length() const
{ return d->len; }

/*!
    Returns the field's precision or -1 if the field has no precision
    or it cannot be determined.
*/
int QSqlFieldInfo::precision() const
{ return d->prec; }

/*!
    Returns the field's default value or an empty QVariant if the
    field has no default value or the value couldn't be determined.
    The default value is the value inserted in the database when it
    is not explicitly specified by the user.
*/
QVariant QSqlFieldInfo::defaultValue() const
{ return d->defValue; }

/*!
    Returns the name of the field in the SQL table.
*/
QString QSqlFieldInfo::name() const
{ return d->name; }

/*!
    Returns the internal type identifier as returned from the database
    system. The return value is 0 if the type is unknown.

    \warning This information is only useful for low-level database
    programming and is \e not database independent.
*/
int QSqlFieldInfo::typeID() const
{ return d->typeID; }

/*!
    Returns TRUE if the field should be included in auto-generated
    SQL statments, e.g. in QSqlCursor; otherwise returns FALSE.

    \sa setGenerated()
*/
bool QSqlFieldInfo::isGenerated() const
{ return d->generated; }

/*!
    Returns TRUE if trailing whitespace should be removed from
    character fields; otherwise returns FALSE.

    \sa setTrim()
*/
bool QSqlFieldInfo::isTrim() const
{ return d->trim; }

/*!
    Returns TRUE if the field is calculated; otherwise returns FALSE.

    \sa setCalculated()
*/
bool QSqlFieldInfo::isCalculated() const
{ return d->calculated; }

/*!
    If \a trim is TRUE widgets should remove trailing whitespace from
    character fields. This does not affect the field value but only
    its representation inside widgets.

    \sa isTrim()
*/
void QSqlFieldInfo::setTrim( bool trim )
{ d->trim = trim; }

/*!
    \a gen set to FALSE indicates that this field should not appear
    in auto-generated SQL statements (for example in QSqlCursor).

    \sa isGenerated()
*/
void QSqlFieldInfo::setGenerated( bool gen )
{ d->generated = gen; }

/*!
    \a calc set to TRUE indicates that this field is a calculated
    field. The value of calculated fields can by modified by subclassing
    QSqlCursor and overriding QSqlCursor::calculateField().

    \sa isCalculated()
*/
void QSqlFieldInfo::setCalculated( bool calc )
{ d->calculated = calc; }

#endif