eiendb_common.hpp

浏览该文件的文档.

#ifndef __EIENDB_COMMON_HPP__
#define __EIENDB_COMMON_HPP__

#include "eiendb_base.hpp"

namespace eiendb
{

class EIENDB_DLL MemoryResult : public IDBResult
{
public:
    MemoryResult( winux::StringArray const & fields );

    #if defined(__GNUC__) || _MSC_VER > 1200
    template < winux::uint n >
    MemoryResult( winux::String (&fields)[n] ) : _curRowIndex(0), _fieldNames( fields, fields + n )
    {
    }
    #endif

    virtual ~MemoryResult();

    template < typename _Ty >
    int addRow( std::vector<_Ty> const & values )
    {
        winux::MixedArray newRow;
        typename std::vector<_Ty>::const_iterator it;
        for ( it = values.begin(); it != values.end(); ++it )
        {
            newRow.push_back(*it);
        }
        int index = _dataRows.size();
        _dataRows.push_back(newRow);
        return index;
    }

    #if defined(__GNUC__) || _MSC_VER > 1200
    template < typename _Ty, winux::uint n >
    int addRow( _Ty (&values)[n] )
    {
        winux::MixedArray newRow;
        int i;
        for ( i = 0; i < (int)n; ++i )
        {
            newRow.push_back(values[i]);
        }
        int index = _dataRows.size();
        _dataRows.push_back(newRow);
        return index;
    }
    #endif

    virtual bool dataSeek( int index );
    virtual bool fetchRow( winux::Mixed * fields, int type = 0 );
    virtual bool fetchRow( winux::MixedArray * fields );
    virtual bool fetchRow( winux::StringMixedMap * fields );
    virtual winux::String fieldName( int fieldIndex ) { return _fieldNames[fieldIndex]; }
    virtual bool free() { return true; }
    virtual winux::ulong fieldsCount() { return (int)_fieldNames.size(); }
    virtual winux::ulong rowsCount() { return (int)_dataRows.size(); }
    virtual winux::String fieldType( int fieldIndex );

private:
    MemoryResult( MemoryResult const & );
    MemoryResult & operator = ( MemoryResult const & );

    int _curRowIndex; // 当前行索引
    winux::StringArray _fieldNames; // 字段名称信息
    std::vector<winux::MixedArray> _dataRows;// 作为内部数据
};

class EIENDB_DLL SQLScript
{
private:
    winux::StringArray _sqlArr;
    winux::StringArray _errArr;
    //std::vector< winux::SharedPointer<IDBResult> > _resArr;
    IDBConnection * _cnn;

public:
    SQLScript( IDBConnection * cnn );

    winux::ulong loadSql( winux::String const & sqlText );

    winux::ulong load( winux::IFile * sqlFile );

    typedef bool (* ProgressCallback)( SQLScript * script, winux::ulong iCurSql, winux::String const & errStr, void * param );

    winux::ulong exec(
        bool onErrorNext = false,
        bool storeError = true,
        ProgressCallback progress = NULL,
        void * param = NULL
    );

    winux::StringArray const & sqls() { return this->_sqlArr; }
    winux::StringArray const & errors() { return this->_errArr; }
};

class EIENDB_DLL SQLBackup
{
private:
    IDBConnection * _cnn;
    IDBConnection * _compatible;
    winux::IFile * _file;

    winux::StringArray _tableNames;
public:
    SQLBackup( IDBConnection * cnn, winux::IFile * file, IDBConnection * compatible = NULL );

    enum BackupProgressType
    {
        bptNone, bptBackupData, bptBackupStruct
    };
    struct BackupProgressData
    {
        enum BackupProgressType type;
        winux::String tblName;
        int tblIndex;
        int tblsCount;
        int rowIndex;  
        int rowsCount; 
        BackupProgressData() : type(bptNone), tblIndex(0), tblsCount(0), rowIndex(0), rowsCount(0) { }
    };
    typedef bool (* ProgressCallback)( SQLBackup * backup, BackupProgressData * data, void * param );

    void backupTableStructure( winux::String const & tableName );

    void backupTableData( winux::String const & tableName, bool noDeleteFrom = false, ProgressCallback progress = NULL, void * param = NULL );

    void backupDb( bool backupStructure = true, bool noDeleteFrom = false, ProgressCallback progress = NULL, void * param = NULL );
    bool resumeDb( bool onErrorNext = false, SQLScript::ProgressCallback progress = NULL, void * param = NULL );
};

class EIENDB_DLL Database
{
public:
    Database( winux::Mixed const & configParams );
    virtual ~Database();
    operator bool() const { return (bool)_cnn && (bool)*_cnn.get(); }
    IDBConnection * cnn() { return this->_cnn.get(); }
    IDBConnection * operator -> () { return this->_cnn.get(); }
    winux::SharedPointer<IDBModifier> mdf( winux::String const & tableName );
    winux::Mixed const & config() const { return _configParams; }
    //winux::Mixed & config() { return _configParams; }
private:
    void _doCreateConnection();
    winux::Mixed _configParams;
    winux::SimplePointer<IDBConnection> _cnn;
};

}

#endif // __EIENDB_COMMON_HPP__