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