keximigrate.h

/* This file is part of the KDE project
   Copyright (C) 2004 Adam Pigg <adam@piggz.co.uk>
   Copyright (C) 2004-2006 Jaroslaw Staniek <js@iidea.pl>
   Copyright (C) 2005 Martin Ellis <martin.ellis@kdemail.net>
 
   This program 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 program 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 program; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#ifndef KEXI_MIGRATE_H
#define KEXI_MIGRATE_H
 
 
#include "kexidb/tableschema.h"
#include "kexidb/connection.h"
#include "keximigratedata.h"
 
#include <kgenericfactory.h>
#include <tqstringlist.h>
#include <tqguardedptr.h>
 
class KexiProject;
namespace Kexi
{
    class ObjectStatus;
}
 
#define KEXI_MIGRATION_VERSION_MAJOR 1
#define KEXI_MIGRATION_VERSION_MINOR 1
 
namespace KexiMigration 
{
 
KEXIMIGR_EXPORT int versionMajor();
 
KEXIMIGR_EXPORT int versionMinor();
 
 
 
class KEXIMIGR_EXPORT KexiMigrate : public TQObject, public KexiDB::Object
{
    TQ_OBJECT
  
 
    public:
        virtual ~KexiMigrate();
 
        KexiMigration::Data* data() const { return m_migrateData; }
 
        void setData(KexiMigration::Data* migrateData);
 
        bool checkIfDestinationDatabaseOverwritingNeedsAccepting(Kexi::ObjectStatus* result,
            bool& acceptingNeeded);
 
        bool isSourceAndDestinationDataSourceTheSame() const;
 
        bool performImport(Kexi::ObjectStatus* result = 0);
 
        bool performExport(Kexi::ObjectStatus* result = 0);
 
        inline bool progressSupported() { return drv_progressSupported(); }
 
        virtual int versionMajor() const = 0;
        virtual int versionMinor() const = 0;
 
        virtual TQVariant propertyValue( const TQCString& propName );
 
        void setPropertyValue( const TQCString& propName, const TQVariant& value );
 
        TQString propertyCaption( const TQCString& propName ) const;
 
        TQValueList<TQCString> propertyNames() const;
 
        virtual bool isValid();
 
    signals:
        void progressPercent(int percent);
 
    protected:
        KexiMigrate(TQObject *parent, const char *name, const TQStringList &args = TQStringList());
 
        virtual bool drv_connect() = 0;
        virtual bool drv_disconnect() = 0;
 
        virtual bool drv_tableNames(TQStringList& tablenames) = 0;
 
        virtual bool drv_readTableSchema(
            const TQString& originalName, KexiDB::TableSchema& tableSchema) = 0;
 
        virtual bool drv_queryMaxNumber(const TQString& tableName, 
            const TQString& columnName, int& result);
 
        virtual tristate drv_queryStringListFromSQL(
            const TQString& sqlStatement, uint columnNumber, TQStringList& stringList, 
            int numRecords = -1)
         { Q_UNUSED(sqlStatement); Q_UNUSED(columnNumber); Q_UNUSED(stringList);
           Q_UNUSED(numRecords); 
           return cancelled; }
 
        virtual tristate drv_querySingleStringFromSQL(const TQString& sqlStatement, 
            uint columnNumber, TQString& string);
 
        virtual tristate drv_fetchRecordFromSQL(const TQString& sqlStatement, 
            KexiDB::RowData& data, bool &firstRecord)
         { Q_UNUSED(sqlStatement); Q_UNUSED(data); Q_UNUSED(firstRecord);
           return cancelled; }
 
        virtual bool drv_copyTable(const TQString& srcTable, KexiDB::Connection *destConn, 
            KexiDB::TableSchema* dstTable) = 0;
 
        virtual bool drv_progressSupported() { return false; }
 
        virtual bool drv_getTableSize(const TQString&, TQ_ULLONG&)
        { return false; }
 
        void updateProgress(TQ_ULLONG step = 1ULL);
 
        KexiDB::Field::Type userType(const TQString& fname);
 
        virtual TQString drv_escapeIdentifier( const TQString& str ) const {
            return m_kexiDBDriver ? m_kexiDBDriver->escapeIdentifier(str) : str; }
 
        KexiMigration::Data* m_migrateData;
 
//          // Temporary values used during import (set by driver specific methods)
//          KexiDB::Field* m_f;
 
        TQMap<TQCString,TQVariant> m_properties;
 
        TQMap<TQCString,TQString> m_propertyCaptions;
 
        TQGuardedPtr<KexiDB::Driver> m_kexiDBDriver;
 
    private:
        bool tableNames(TQStringList& tablenames);
 
        TQPtrList<KexiDB::TableSchema> m_tableSchemas;
 
        TQPtrList<KexiDB::TableSchema> m_kexiDBCompatibleTableSchemasToRemoveFromMemoryAfterImport;
 
        bool progressInitialise();
 
        KexiProject *m_destPrj;
 
        TQ_ULLONG m_progressTotal;
 
        TQ_ULLONG m_progressDone;
 
        TQ_ULLONG m_progressNextReport;
 
        friend class MigrateManager;
};
 
} //namespace KexiMigration
 
#define KEXIMIGRATE_DRIVER_INFO( class_name, internal_name ) \
    int class_name::versionMajor() const { return KEXI_MIGRATION_VERSION_MAJOR; } \
    int class_name::versionMinor() const { return KEXI_MIGRATION_VERSION_MINOR; } \
    K_EXPORT_COMPONENT_FACTORY(keximigrate_ ## internal_name, \
      KGenericFactory<KexiMigration::class_name>( "keximigrate_" #internal_name ))
 
#define KEXIMIGRATION_DRIVER \
    public: \
    virtual int versionMajor() const; \
    virtual int versionMinor() const;
 
#endif