field.h

/* This file is part of the KDE project
   Copyright (C) 2002 Lucijan Busch <lucijan@gmx.at>
   Copyright (C) 2002 Joseph Wenninger <jowenn@kde.org>
   Copyright (C) 2003-2006 Jaroslaw Staniek <js@iidea.pl>
 
   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.
 */
 
#ifndef KEXIDB_FIELD_H
#define KEXIDB_FIELD_H
 
#include <tqvariant.h>
#include <tqstring.h>
#include <tqpair.h>
#include <tqvaluevector.h>
#include <tqptrvector.h>
#include "kexidb/kexidb_export.h"
namespace KexiDB {
 
class TableSchema;
class QuerySchema;
class FieldList;
class BaseExpr;


class KEXI_DB_EXPORT Field
{
    public:
        typedef TQPtrList<Field> List; 
        typedef TQPtrVector<Field> Vector; 
        typedef TQPtrListIterator<Field> ListIterator; 
        typedef TQPair<Field*,Field*> Pair; 
        typedef TQPtrList<Pair> PairList; 

        enum Type
        {
            InvalidType = 0, 
            Byte = 1,        
            ShortInteger = 2,
            Integer = 3,     
            BigInteger = 4,  
            Boolean = 5,     
            Date = 6,        
            DateTime = 7,      
            Time = 8,        
            Float = 9,       
            Double = 10,     
            Text = 11,       
            LongText = 12,   
            BLOB = 13,       
 
            LastType = 13,   
 
            Null = 64,       

            Asterisk = 128,  
            Enum = 129,      
            Map = 130        
        };
 
//TODO: make this configurable
        static uint defaultTextLength() { return 200; }

        enum TypeGroup
        {
            InvalidGroup = 0,
            TextGroup = 1,
            IntegerGroup = 2,
            FloatGroup = 3,
            BooleanGroup = 4,
            DateTimeGroup = 5,
            BLOBGroup = 6, /* large binary object */
 
            LastTypeGroup = 6 // This line should be at the end of the enum!
        };

        enum Constraints
        {
            NoConstraints = 0,
            AutoInc = 1,
            Unique = 2,
            PrimaryKey = 4,
            ForeignKey = 8,
            NotNull = 16,
            NotEmpty = 32, 
            Indexed = 64
        };

        enum Options
        {
            NoOptions = 0,
            Unsigned = 1
        };

        Field(TableSchema *tableSchema);

        Field();

        Field(const TQString& name, Type ctype,
            uint cconst=NoConstraints,
            uint options = NoOptions,
            uint length=0, uint precision=0,
            TQVariant defaultValue=TQVariant(),
            const TQString& caption = TQString(),
            const TQString& description = TQString(),
            uint width = 0);

        Field(const Field& f);
 
        virtual ~Field();

        static TQVariant::Type variantType(uint type);

        static TQString typeName(uint type);

        static TQString typeString(uint type);

        static Type typeForString(const TQString& typeString);

        static TypeGroup typeGroupForString(const TQString& typeGroupString);

        static TypeGroup typeGroup(uint type);

        static TQString typeGroupName(uint typeGroup);

        static TQString typeGroupString(uint typeGroup);
 
        /* ! \return the name of this field */
        inline TQString name() const { return m_name; }
        
        virtual TableSchema* table() const;

        virtual void setTable(TableSchema *table);

        QuerySchema* query() const;

        void setQuery(QuerySchema *query);

        inline bool isAutoIncrement() const { return constraints() & AutoInc; }

        inline bool isPrimaryKey() const { return constraints() & PrimaryKey; }

        inline bool isUniqueKey() const { return constraints() & Unique; }

        inline bool isForeignKey() const { return constraints() & ForeignKey; }

        inline bool isNotNull() const { return constraints() & NotNull; }

        inline bool isNotEmpty() const { return constraints() & NotEmpty; }

        inline bool isIndexed() const { return constraints() & Indexed; }

        inline bool isNumericType() const { return Field::isNumericType(type()); }
        
        static bool isNumericType(uint type);

        inline bool isIntegerType() const { return Field::isIntegerType(type()); }
        
        static bool isIntegerType(uint type);
        
        inline bool isFPNumericType() const { return Field::isFPNumericType(type()); }
        
        static bool isFPNumericType(uint type);

        inline bool isDateTimeType() const { return Field::isDateTimeType(type()); }
        
        static bool isDateTimeType(uint type);

        inline bool isTextType() const { return Field::isTextType(type()); }
        
        static bool isTextType(uint type);
 
        uint options() const { return m_options; }
 
        void setOptions(uint options) { m_options = options; }

        inline TQVariant::Type variantType() const { return variantType(type()); }

        Type type() const;

        inline TQString typeName() const { return Field::typeName(type()); }

        inline TypeGroup typeGroup() const { return Field::typeGroup(type()); }

        inline TQString typeGroupName() const { return Field::typeGroupName(type()); }

        inline TQString typeString() const { return Field::typeString(type()); }

        inline TQString typeGroupString() const { return Field::typeGroupString(type()); }

        inline TQString subType() const { return m_subType; }

        inline void setSubType(const TQString& subType) { m_subType = subType; }

        inline TQVariant defaultValue() const { return m_defaultValue; }
        
        inline uint length() const { return m_length; }

        inline uint precision() const { return m_precision; } 

        inline uint scale() const { return m_length; }


        inline int visibleDecimalPlaces() const { return m_visibleDecimalPlaces; }

        inline uint constraints() const { return m_constraints; }

        inline int order() const { return m_order; }

        inline TQString caption() const { return m_caption; }

        inline TQString captionOrName() const { return m_caption.isEmpty() ? m_name : m_caption; }

        inline TQString description() const { return m_desc; }

        inline uint width() const { return m_width; }
        
        inline bool isUnsigned() const { return m_options & Unsigned; }

        inline bool hasEmptyProperty() const { return Field::hasEmptyProperty(type()); }

        static bool hasEmptyProperty(uint type);

        inline bool isAutoIncrementAllowed() const { return Field::isAutoIncrementAllowed(type()); }

        static bool isAutoIncrementAllowed(uint type);

        void setType(Type t);

        void setName(const TQString& name);

        void setConstraints(uint c);

        void setLength(uint l);

        void setScale(uint s);

        void setVisibleDecimalPlaces(int p);

        void setPrecision(uint p);

        void setUnsigned(bool u);

        void setDefaultValue(const TQVariant& def);

        bool setDefaultValue(const TQCString& def);

        void setAutoIncrement(bool a);

        void setPrimaryKey(bool p);

        void setUniqueKey(bool u);

        void setForeignKey(bool f);

        void setNotNull(bool n);

        void setNotEmpty(bool n);

        void setIndexed(bool s);

        void setCaption(const TQString& caption) { m_caption=caption; }

        void setDescription(const TQString& description) { m_desc=description; }
        
        void setWidth(uint w) { m_width=w; }

        virtual bool isQueryAsterisk() const { return false; }
        
        virtual TQString debugString() const;

        void debug();

        inline KexiDB::BaseExpr *expression() { return m_expr; }

        void setExpression(KexiDB::BaseExpr *expr);

        inline bool isExpression() const { return m_expr!=NULL; }
 
//<TMP>
        TQValueVector<TQString> enumHints() const { return m_hints; }
        TQString enumHint(uint num) { return (num < m_hints.size()) ? m_hints.at(num) : TQString(); }
        void setEnumHints(const TQValueVector<TQString> &l) { m_hints = l; }
//</TMP>

        TQVariant customProperty(const TQCString& propertyName,
            const TQVariant& defaultValue = TQVariant()) const;

        void setCustomProperty(const TQCString& propertyName, const TQVariant& value);

        typedef TQMap<TQCString,TQVariant> CustomPropertiesMap;

        inline const CustomPropertiesMap customProperties() const {
            return m_customProperties ? *m_customProperties : CustomPropertiesMap(); }
 
    protected:
        Field(QuerySchema *querySchema, BaseExpr* expr = 0);

        void init();

        virtual Field* copy() const;
 
        FieldList *m_parent; 
        TQString m_name;
        TQString m_subType;
        uint m_constraints;
        uint m_length; 
        uint m_precision;
        int m_visibleDecimalPlaces; 
        uint m_options;
        TQVariant m_defaultValue;
        int m_order;
        TQString m_caption;
        TQString m_desc;
        uint m_width;
        TQValueVector<TQString> m_hints;
 
        KexiDB::BaseExpr *m_expr;
        CustomPropertiesMap* m_customProperties;

        class KEXI_DB_EXPORT FieldTypeNames : public TQValueVector<TQString> {
            public:
                FieldTypeNames();
                void init();
            TQMap<TQString,Type> str2num;
            protected:
                bool m_initialized : 1;
        };

        class KEXI_DB_EXPORT FieldTypeGroupNames : public TQValueVector<TQString> {
            public: 
                FieldTypeGroupNames();
                void init();
            TQMap<TQString,TypeGroup> str2num;
            protected:
                bool m_initialized : 1;
        };

        static FieldTypeNames m_typeNames;

        static FieldTypeGroupNames m_typeGroupNames;
 
    private:
        Type m_type;
 
    friend class Connection;
    friend class FieldList;
    friend class TableSchema;
    friend class QuerySchema;
};
 
} //namespace KexiDB
 
#endif