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 < size_t _N >
    MemoryResult( winux::String (&fields)[_N] ) : _curRowIndex(0), _fieldNames( fields, fields + _N )
    {
    }
    #endif

    virtual ~MemoryResult();

    template < typename _Ty >
    size_t 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);
        }
        size_t index = _dataRows.size();
        _dataRows.push_back(newRow);
        return index;
    }

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

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

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

    DISABLE_OBJECT_COPY(MemoryResult)
};

class EIENDB_DLL SqlScript
{
public:
    SqlScript( IDbConnection * cnn );

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

    size_t load( winux::IFile * sqlFile );

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

    size_t 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; }

private:
    winux::StringArray _sqlArr;
    winux::StringArray _errArr;
    //std::vector< winux::SharedPointer<IDbResult> > _resArr;
    IDbConnection * _cnn;
};

class EIENDB_DLL SqlBackup
{
public:
    SqlBackup( IDbConnection * cnn, winux::IFile * file, IDbConnection * compatible = NULL );

    enum BackupProgressType
    {
        bptNone, 
        bptBackupData, 
        bptBackupStruct 
    };

    struct BackupProgressData
    {
        enum BackupProgressType type; 
        winux::String tblName; 
        size_t tblIndex; 
        size_t tblsCount; 
        size_t rowIndex;  
        size_t 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 );

private:
    IDbConnection * _cnn;
    IDbConnection * _compatible;
    winux::IFile * _file;
    winux::StringArray _tableNames;
};

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__