tableschema.h

/* This file is part of the KDE project
   Copyright (C) 2003 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_TABLE_H
#define KEXIDB_TABLE_H
 
#include <tqvaluelist.h>
#include <tqptrlist.h>
#include <tqstring.h>
#include <tqguardedptr.h>
 
#include <kexidb/fieldlist.h>
#include <kexidb/schemadata.h>
#include <kexidb/indexschema.h>
#include <kexidb/relationship.h>
 
namespace KexiDB {
 
class Connection;
class LookupFieldSchema;

class KEXI_DB_EXPORT TableSchema : public FieldList, public SchemaData
{
    public:
        typedef TQPtrList<TableSchema> List; 
        typedef TQPtrListIterator<TableSchema> ListIterator; 
 
        TableSchema(const TQString & name);
        TableSchema(const SchemaData& sdata);
        TableSchema();

        TableSchema(const TableSchema& ts, bool copyId = true);

        TableSchema(const TableSchema& ts, int setId);
 
        virtual ~TableSchema();
        
        virtual FieldList& insertField(uint index, Field *field);

        virtual void removeField(KexiDB::Field *field);

        IndexSchema* primaryKey() const { return m_pkey; }

        void setPrimaryKey(IndexSchema *pkey);
 
        const IndexSchema::ListIterator indicesIterator() const 
            { return IndexSchema::ListIterator(m_indices); }
 
        const IndexSchema::List* indices() { return &m_indices; }

        virtual void clear();

        TQString debugString(bool includeTableName);

        virtual TQString debugString();

        Connection* connection() const { return m_conn; }

        bool isKexiDBSystem() const { return m_isKexiDBSystem; }

        void setKexiDBSystem(bool set);

        virtual bool isNative() const { return m_native || m_isKexiDBSystem; }
        
        /* Sets native flag. Does not allow to set this off for system KexiDB table. */
        virtual void setNative(bool set);

        QuerySchema* query();

        Field* anyNonPKField();

        bool setLookupFieldSchema( const TQString& fieldName, LookupFieldSchema *lookupFieldSchema );

        LookupFieldSchema *lookupFieldSchema( const Field& field ) const;

        LookupFieldSchema *lookupFieldSchema( const TQString& fieldName );

        const TQPtrVector<LookupFieldSchema>& lookupFieldsList();
 
    protected:
        TableSchema(Connection *conn, const TQString & name = TQString());
 
        IndexSchema::List m_indices;
 
        TQGuardedPtr<Connection> m_conn;
        
        IndexSchema *m_pkey;
 
        QuerySchema *m_query; 
 
        class Private;
        Private *d;
 
    private:
        void init();

        void init(const TableSchema& ts, bool copyId);
 
        bool m_isKexiDBSystem : 1;
 
    friend class Connection;
};

class KEXI_DB_EXPORT InternalTableSchema : public TableSchema
{
    public:
        InternalTableSchema(const TQString& name);
        InternalTableSchema(const TableSchema& ts);
        virtual ~InternalTableSchema();
};
 
} //namespace KexiDB
 
#endif