alter.h

/* This file is part of the KDE project
   Copyright (C) 2006-2007 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_ALTER_H
#define KEXIDB_ALTER_H
 
#include "connection.h"
 
#include <tqvaluelist.h>
#include <tqasciidict.h>
 
#include <kdebug.h>
 
namespace KexiDB
{
class Connection;
class ConnectionData;
 
 
class KEXI_DB_EXPORT AlterTableHandler : public Object
{
    public:
        class ChangeFieldPropertyAction;
        class RemoveFieldAction;
        class InsertFieldAction;
        class MoveFieldPositionAction;
 
        enum AlteringRequirements {
            PhysicalAlteringRequired = 1,
 
            DataConversionRequired = 2,
 
            /* Changes to the main table schema (in kexi__fields) required,
             this does not require physical changes for the table; 
             e.g. changing value of the "caption" or "description" property. */
            MainSchemaAlteringRequired = 4,
 
            /* Only changes to extended table schema required,
             this does not require physical changes for the table; 
             e.g. changing value of the "visibleDecimalPlaces" property
             or any of the custom properties. */
            ExtendedSchemaAlteringRequired = 8,
 
            SchemaAlteringRequired = ExtendedSchemaAlteringRequired | MainSchemaAlteringRequired
        };
 
        class ActionBase;
        typedef TQAsciiDict<ActionBase> ActionDict; 
        typedef TQIntDict<ActionDict> ActionDictDict; 
        typedef TQAsciiDictIterator<ActionBase> ActionDictIterator;
        typedef TQIntDictIterator<ActionDict> ActionDictDictIterator;
        typedef TQPtrVector<ActionBase> ActionVector; 
 
        typedef TQPtrList<ActionBase> ActionList;
 
        typedef TQPtrListIterator<ActionBase> ActionListIterator;
 
        class KEXI_DB_EXPORT ActionBase {
            public:
                ActionBase(bool null = false);
                virtual ~ActionBase();
 
                ChangeFieldPropertyAction& toChangeFieldPropertyAction();
                RemoveFieldAction& toRemoveFieldAction();
                InsertFieldAction& toInsertFieldAction();
                MoveFieldPositionAction& toMoveFieldPositionAction();
                
                bool isNull() const { return m_null; }
 
                class DebugOptions
                {
                    public:
                        DebugOptions() : showUID(true), showFieldDebug(false) {}
 
                        bool showUID : 1;
 
                        bool showFieldDebug : 1;
                };
 
                virtual TQString debugString(const DebugOptions& debugOptions = DebugOptions()) { 
                    Q_UNUSED(debugOptions); return "ActionBase"; }
                void debug(const DebugOptions& debugOptions = DebugOptions()) { 
                    KexiDBDbg << debugString(debugOptions) 
                        << " (req = " << alteringRequirements() << ")" << endl; }
 
            protected:
                void setAlteringRequirements( int alteringRequirements )
                    { m_alteringRequirements = alteringRequirements; }
 
                int alteringRequirements() const { return m_alteringRequirements; }
 
                virtual void updateAlteringRequirements() {};
 
                virtual void simplifyActions(ActionDictDict &fieldActions) { Q_UNUSED(fieldActions); }
 
                virtual bool shouldBeRemoved(ActionDictDict &fieldActions) { 
                    Q_UNUSED(fieldActions); return false; }
 
                virtual tristate updateTableSchema(TableSchema &table, Field* field, 
                    TQMap<TQString, TQString>& fieldMap) 
                    { Q_UNUSED(table); Q_UNUSED(field); Q_UNUSED(fieldMap); return true; }
 
            private:
                virtual tristate execute(Connection& /*conn*/, TableSchema& /*table*/) { return true; }
 
                int m_alteringRequirements;
 
                int m_order;
 
                bool m_null : 1;
 
            friend class AlterTableHandler;
        };
 
        class KEXI_DB_EXPORT FieldActionBase : public ActionBase {
            public:
                FieldActionBase(const TQString& fieldName, int uid);
                FieldActionBase(bool);
                virtual ~FieldActionBase();
 
                TQString fieldName() const { return m_fieldName; }
 
                int uid() const { return m_fieldUID; }
 
                void setFieldName(const TQString& fieldName) { m_fieldName = fieldName; }
 
            protected:
 
                int m_fieldUID;
            private:
                TQString m_fieldName;
        };
 
        class KEXI_DB_EXPORT ChangeFieldPropertyAction : public FieldActionBase {
            public:
                ChangeFieldPropertyAction(const TQString& fieldName, 
                    const TQString& propertyName, const TQVariant& newValue, int uid);
                ChangeFieldPropertyAction(bool null);
                virtual ~ChangeFieldPropertyAction();
 
                TQString propertyName() const { return m_propertyName; }
                TQVariant newValue() const { return m_newValue; }
                virtual TQString debugString(const DebugOptions& debugOptions = DebugOptions());
 
                virtual void simplifyActions(ActionDictDict &fieldActions);
 
                virtual bool shouldBeRemoved(ActionDictDict &fieldActions);
 
                virtual tristate updateTableSchema(TableSchema &table, Field* field, 
                    TQMap<TQString, TQString>& fieldMap);
 
            protected:
                virtual void updateAlteringRequirements();
 
                virtual tristate execute(Connection &conn, TableSchema &table);
 
                TQString m_propertyName;
                TQVariant m_newValue;
        };
 
        class KEXI_DB_EXPORT RemoveFieldAction : public FieldActionBase {
            public:
                RemoveFieldAction(const TQString& fieldName, int uid);
                RemoveFieldAction(bool);
                virtual ~RemoveFieldAction();
 
                virtual TQString debugString(const DebugOptions& debugOptions = DebugOptions());
 
                virtual void simplifyActions(ActionDictDict &fieldActions);
 
                virtual tristate updateTableSchema(TableSchema &table, Field* field, 
                    TQMap<TQString, TQString>& fieldMap);
 
            protected:
                virtual void updateAlteringRequirements();
 
                virtual tristate execute(Connection &conn, TableSchema &table);
        };
 
        class KEXI_DB_EXPORT InsertFieldAction : public FieldActionBase {
            public:
                InsertFieldAction(int fieldIndex, KexiDB::Field *newField, int uid);
                //copy ctor
                InsertFieldAction(const InsertFieldAction& action);
                InsertFieldAction(bool);
                virtual ~InsertFieldAction();
 
                int index() const { return m_index; }
                void setIndex( int index ) { m_index = index; }
                KexiDB::Field& field() const { return *m_field; }
                void setField(KexiDB::Field* field);
                virtual TQString debugString(const DebugOptions& debugOptions = DebugOptions());
 
                virtual void simplifyActions(ActionDictDict &fieldActions);
 
                virtual tristate updateTableSchema(TableSchema &table, Field* field, 
                    TQMap<TQString, TQString>& fieldMap);
 
            protected:
                virtual void updateAlteringRequirements();
 
                virtual tristate execute(Connection &conn, TableSchema &table);
 
                int m_index;
 
            private:
                KexiDB::Field *m_field;
        };
 
        class KEXI_DB_EXPORT MoveFieldPositionAction : public FieldActionBase {
            public:
                MoveFieldPositionAction(int fieldIndex, const TQString& fieldName, int uid);
                MoveFieldPositionAction(bool);
                virtual ~MoveFieldPositionAction();
 
                int index() const { return m_index; }
                virtual TQString debugString(const DebugOptions& debugOptions = DebugOptions());
 
                virtual void simplifyActions(ActionDictDict &fieldActions);
 
            protected:
                virtual void updateAlteringRequirements();
 
                virtual tristate execute(Connection &conn, TableSchema &table);
 
                int m_index;
        };
 
        AlterTableHandler(Connection &conn);
 
        virtual ~AlterTableHandler();
 
        void addAction(ActionBase* action);
 
        AlterTableHandler& operator<< ( ActionBase* action );
 
        void removeAction(int index);
 
        void clear();
 
        void setActions(const ActionList& actions);
 
        const ActionList& actions() const;
 
        class ExecutionArguments {
            public:
                ExecutionArguments()
                 : debugString(0)
                 , requirements(0)
                 , result(false)
                 , simulate(false)
                 , onlyComputeRequirements(false)
                {
                }
            TQString* debugString;
            int requirements;
            tristate result;
            bool simulate : 1;
            bool onlyComputeRequirements;
        };
 
        TableSchema* execute(const TQString& tableName, ExecutionArguments & args);
 
        void debug();
 
//      tristate simulateExecution(const TQString& tableName, TQString& debugString);
 
        static int alteringTypeForProperty(const TQCString& propertyName);
 
    protected:
//      TableSchema* executeInternal(const TQString& tableName, tristate& result, bool simulate = false,
//          TQString* debugString = 0);
 
        class Private;
        Private *d;
};
}
 
#endif