Ｃ３Ｌａｂ研究室

Back to Title Page(OpenLab)タイトルページへ戻る

最終更新日： 1998年 12月 14日 月曜日

JET Database 「CDAODB」 DAO Access class Rel 5 (ver 1.60.102)


　MFC・CDaoDatabaseオブジェクトを利用すると簡単にＤａｔａＢａｓｅが利用可能です。

　ファイルの使用はＶＣ＋＋のサンプルソースと共にＬＨＡ形式でアーカイブされ含まれていますので、ダウンロード 後展開してください。

使用法など拡張された機能について

・メインとなる部分はＲ４までとおなじためそちらを参照してください。
・リリース版のパフォーマンス向上のために、デバッグ用チェックコードの一部をＡＳＳＥＲＴ分に変更しました。
・CDAOCash4クラスを拡張しました。
・同一タイプの複数のフィールドを一括して作成する関数の追加

　

クラスのヘッダー定義は次のようになっています。

//-------------------------------------------
// DAO Database access class for MFC CDaoXXX
//    Programmed & Copyright (c) by kitaro 1998
// Revision 1.60.102

#ifndef __CDAODB_CLASS__
#define __CDAODB_CLASS__

#include <afxdao.h>
#include "CStrObj.h"

class CDAODB ;

VOID CompactDAODB(void);

class CDAODBCash : public CStrObj {// CObject {
        typedef struct {
            char         data[40];
            char         data1[40];
            char         data2[20];
        }CashTree,*LPCashTree;
    public:
        long nMaxCount; // max cash buffers
        long nCount;
    public :
        CashTree *root;
        long sCount;
        CDAODBCash();
        virtual ~CDAODBCash();
        int         GetCount    (void);
        int         GetMaxCount    (void);

    public:    // tree control
        void    Push     (LPSTR s,LPSTR d,LPSTR d2 = ""); // s,d(d2)の値を登録する
        void    PushNE     (LPSTR s,LPSTR d,LPSTR d2 = ""); // s の値で２重登録を検査する
        void    PushNE1     (LPSTR s,LPSTR d,LPSTR d2 = ""); // d の値で２重登録を検査する
        void    PushNE2     (LPSTR s,LPSTR d,LPSTR d2 = ""); // d2 の値で２重登録を検査する
        LPSTR    GetStr     (long n);
        LPSTR    GetStr1     (long n);
        LPSTR    GetStr2     (long n);
        void    SetStr     (long n,LPSTR p);
        void    SetStr1     (long n,LPSTR p);
        void    SetStr2     (long n,LPSTR p);
        void SortOneBegin(void);
        BOOL    SortOne         (void);
        BOOL    SortOne1     (void);
        BOOL    SortOne2     (void);
        long    Search     (LPSTR szText);
        BOOL    Create         (long nMaxCount);    // Create and Initialize
        BOOL    Load         (LPSTR filename);    // Status Load
        BOOL    Save         (LPSTR filename);    // Status Save
    private :
        long StructSize(void);
};
//----------------------------------------------
class CDAODBCash2 : public CDAODBCash {
    public:
            typedef struct {
            char         data[10];
            char         data1[40];
        }CashTree2,*LPCashTree2;
    public :
        CashTree2 *root;
        long sCount;
        CDAODBCash2();
        virtual ~CDAODBCash2();
    public:    // tree control
        void    Push     (LPSTR s,LPSTR d);
        void    Push2     (LPSTR s,LPSTR d);
        void    PushNE     (LPSTR s,LPSTR d);
        void    PushNE1     (LPSTR s,LPSTR d);
        LPSTR    GetStr     (long n);
        LPSTR    GetStr1     (long n);
        void    SetStr     (long n,LPSTR p);
        void    SetStr1     (long n,LPSTR p);
        void SortOneBegin(void);
        BOOL    SortOne         (void);
        BOOL    SortOne1     (void);
        long    Search         (LPSTR szText);

        BOOL    Create         (long nMaxCount);    // Create and Initialize
        BOOL    Load         (LPSTR filename);    // Status Load
        BOOL    Save         (LPSTR filename);    // Status Save
    private :
        long StructSize(void);
};
//----------------------------------------------
class CDAODBCash3 : public CDAODBCash {
    public:
            typedef struct {
            char         data[10];
            char         data1[10];
        }CashTree2,*LPCashTree2;
    public :
        CashTree2 *root;
        long sCount;
        CDAODBCash3();
        virtual ~CDAODBCash3();
    public:    // tree control
        void    Push         (LPSTR s,LPSTR d);
        void    PushNE         (LPSTR s,LPSTR d);
        void    PushNE1         (LPSTR s,LPSTR d);
        LPSTR    GetStr         (long n);
        LPSTR    GetStr1         (long n);
        void    SetStr         (long n,LPSTR p);
        void    SetStr1         (long n,LPSTR p);
        void SortOneBegin(void);
        BOOL    SortOne         (void);
        BOOL    SortOne1     (void);
        long    Search         (LPSTR szText);

        BOOL    Create         (long nMaxCount);    // Create and Initialize
        BOOL    Load         (LPSTR filename);    // Status Load
        BOOL    Save         (LPSTR filename);    // Status Save
    private :
        long StructSize(void);
};
//----------------------------------------------
class CDAODBCash4 : public CDAODBCash {
    public:
            typedef struct {
            char         data[10];
            char         data1[128];
        }CashTree2,*LPCashTree2;
    public :
        CashTree2 *root;
        long sCount;
        CDAODBCash4();
        virtual ~CDAODBCash4();
    public:    // tree control
        void    Push     (LPSTR s,LPSTR d);
        void    Push2     (LPSTR s,LPSTR d);
        void    PushNE     (LPSTR s,LPSTR d);
        void    PushNE1     (LPSTR s,LPSTR d);
        LPSTR    GetStr     (long n);
        LPSTR    GetStr1     (long n);
        void    SetStr     (long n,LPSTR p);
        void    SetStr1     (long n,LPSTR p);
        void SortOneBegin(void);
        BOOL    SortOne         (void);
        BOOL    SortOne1     (void);
        long    Search         (LPSTR szText);

        BOOL    Create         (long nMaxCount);    // Create and Initialize
        BOOL    Load         (LPSTR filename);    // Status Load
        BOOL    Save         (LPSTR filename);    // Status Save
    private :
        long StructSize(void);
};
//----------------------------------------------
class CDAODB : public CStrObj //CObject
{
    private : // CDaoDatabase Object
        CDaoWorkspace *m_ws;
        CDaoDatabase *m_cdao;
        CDaoTableDef *m_tbl;
        CDaoRecordset *m_rs;
        char szOrgFileName[_MAX_PATH];
        char szPassword[_MAX_PATH];
    private : //
        BOOL bAppend;    // Field Create and need append function flg
    public : // constructor / destructor
        CDAODB();
        ~CDAODB();

    public : // Workspace Function （ＣＤａｏＷｏｒｋｓｐａｃｅ）
        void CreateWorkspace    (void);
        BOOL CreateWS    (LPCTSTR lpszName = "", LPCTSTR lpszUserName = "", LPCTSTR lpszPassword = "");    // CDaoWorkspaceを作成します
        BOOL OpenWS         (LPCTSTR lpszName = NULL );     // CDaoWorkspaceを開きます
        void CloseWS    (void);     //    CDaoWorkspaceを終了します
        BOOL SetDefaultPassword( LPCTSTR lpszPassword);
        BOOL SetDefaultPassword( long dwPassword);

    public : // commondlg32 file
        LPSTR File2Load( CWnd *lpcWnd );     // 読み込み用ファイルの指定をコモンダイアログを使用して修得する
        LPSTR File2Save( CWnd *lpcWnd );     // 書き込み用ファイルの指定をコモンダイアログを使用して修得する
        LPSTR File2Load( HWND hWnd );         // 読み込み用ファイルの指定をコモンダイアログを使用して修得する
        LPSTR File2Save( HWND hWnd );         // 書き込み用ファイルの指定をコモンダイアログを使用して修得する
    public : // Macro function
        long Search    (int     nFieldIndex ,LPCSTR szData);    // 現在オープンしているレコードセット内のデータを検索する
        long Search    (LPCSTR     szFieldIndex,LPCSTR szData);    // 現在オープンしているレコードセット内のデータを検索する
        long SearchI(int    nFieldIndex ,LPCSTR szData);    // 現在オープンしているレコードセット内のデータを検索する
        long SearchI(LPCSTR     szFieldIndex,LPCSTR szData);    // 現在オープンしているレコードセット内のデータを検索する
        //
        long Search    (int     nFieldIndex ,int    nFieldIndex2,LPCSTR szData,LPCSTR szData2);    // 現在オープンしているレコードセット内のデータを検索する
        long Search    (LPCSTR     szFieldIndex,LPCSTR    szFieldIndex2,LPCSTR szData,LPCSTR szData2);    // 現在オープンしているレコードセット内のデータを検索する
        long SearchI(int    nFieldIndex ,int    nFieldIndex2,LPCSTR szData,LPCSTR szData2);    // 現在オープンしているレコードセット内のデータを検索する
        long SearchI(LPCSTR     szFieldIndex,LPCSTR    szFieldIndex2,LPCSTR szData,LPCSTR szData2);    // 現在オープンしているレコードセット内のデータを検索する

        long GetCurrentRecords     (void);
        BOOL CkUpdateField         (LPSTR szFieldName,COleVariant c); // フィールドがアップデート可能かどうか調べる

    public : // CDaoDataBase
        void SetOpenPassword(LPCTSTR lpszPassword); // ファイルを開く時のパスワードを設定する
        BOOL Create    (LPCSTR filename, LPCTSTR lpszLocale = dbLangGeneral, int dwOptions = 0 );    // データベースファイルを作成する
        BOOL Open    ( LPCTSTR lpszName, BOOL bExclusive = FALSE, BOOL bReadOnly = FALSE, LPCTSTR lpszConnect = _T("") );     // データベースファイルを開く
        BOOL Open    ( LPCTSTR lpszName, LPCTSTR lpszConnect,BOOL bExclusive = FALSE, BOOL bReadOnly = FALSE );     // データベースファイルを開く
        BOOL ReOpen    ( BOOL bExclusive = FALSE, BOOL bReadOnly = FALSE, LPCTSTR lpszConnect = _T("") );     // いったん終了し再度同一ファイルをオープンしなおす
        void Close    (void);     // データベースの使用を終了する
        CDaoTableDef*     GetTable(void){return m_tbl;};    // 現在使用しているＤＡＯテーブルクラスのポインターを返す
        CDaoRecordset*     GetRecord(void){return m_rs;};    // 現在使用しているＤＡＯレコードセットクラスのポインターを返す
        CString         GetVersion(void);    // Jet Database Engine のバージョンを修得(3.5の場合は 3.0になる)
    //------------------------------------------
        short GetTableDefCount( void );     //    テーブルの数を修得
        BOOL GetTableDefInfo( int nIndex, CDaoTableDefInfo& tabledefinfo, DWORD dwInfoOptions = AFX_DAO_PRIMARY_INFO );     // テーブルの情報を修得
        BOOL GetTableDefInfo( LPCTSTR lpszName, CDaoTableDefInfo& tabledefinfo, DWORD dwInfoOptions = AFX_DAO_PRIMARY_INFO );     // テーブルの情報を修得
        BOOL DeleteTableDef    ( LPCTSTR lpszName );    // テーブルを消去
        BOOL IsTableDef         (LPSTR szTableName);    // 指定名がテーブル名かどうか検査する
    //------------------------------------------
        BOOL CreateTable    (LPCSTR szTableName);    // テーブルを作成する
        BOOL OpenTable         (LPCSTR szTableName);    // テーブルを開く
        BOOL CloseTable         (void);    // テーブルをクローズする
        BOOL AppendField    (void);     // フィールドを追加する
        // create reguler field functions
        BOOL CreateField         (LPSTR lpszName,short nType , long lSize , long lAttributes = 0); // フィールドを作成
        BOOL CreateFieldStr         (LPSTR lpszName,long lSize = 255, long lAttributes = dbVariableField); // String型フィールドを作成
        BOOL CreateFieldStr         (int count,...); // String 型フィールドを指定個数標準型で作成
        BOOL CreateFieldDate    (LPSTR lpszName,long lAttributes = dbFixedField);    // Date型フィールドを作成
        BOOL CreateFieldCurrency(LPSTR lpszName,long lAttributes = dbFixedField);    // Currency型フィールドを作成
        BOOL CreateFieldBool    (LPSTR lpszName,long lAttributes = dbFixedField);    // Bool型フィールドを作成
        BOOL CreateFieldByte    (LPSTR lpszName,long lAttributes = dbFixedField);    // Byte型フィールドを作成
        BOOL CreateFieldInt         (LPSTR lpszName,long lAttributes = dbFixedField);    // Int型フィールドを作成
        BOOL CreateFieldInt         (int count,...); // int 型フィールドを指定個数標準型で作成
        BOOL CreateFieldLong    (LPSTR lpszName,long lAttributes = dbFixedField);    // Long型フィールドを作成
        BOOL CreateFieldLong    (int count,...); // long 型フィールドを指定個数標準型で作成
        BOOL CreateFieldSingle    (LPSTR lpszName,long lAttributes = dbFixedField);    // Single型フィールドを作成
        BOOL CreateFieldSingle    (int count,...); // single 型フィールドを指定個数標準型で作成
        BOOL CreateFieldDouble    (LPSTR lpszName,long lAttributes = dbFixedField);    // Double型フィールドを作成
        BOOL CreateFieldDouble    (int count,...); // double 型フィールドを指定個数標準型で作成
        BOOL CreateFieldLB         (LPSTR lpszName,long lAttributes = dbFixedField);
        BOOL CreateFieldMemo    (LPSTR lpszName,long lAttributes = dbFixedField);    // メモ型フィールドを作成
        short FieldCount(void);         // フィールド数を修得
        BOOL FieldInfo( int nIndex, CDaoFieldInfo& fieldinfo, DWORD dwInfoOptions = AFX_DAO_PRIMARY_INFO ); // フィールドの情報を修得
        BOOL FieldInfo( LPCTSTR lpszName, CDaoFieldInfo& fieldinfo, DWORD dwInfoOptions = AFX_DAO_PRIMARY_INFO ); // フィールドの情報を修得
        BOOL IsFieldName(LPSTR szFieldName);     //     フィールドに指定の名前が存在するかどうかチェック
        LPCTSTR    GetFieldName(int nIndex);

        // create index
        BOOL CreateIndex( CDaoIndexInfo& indexinfo );    // インデックス作成
        BOOL DeleteIndex( LPCTSTR lpszName);             // インデックス消去
        BOOL DeleteIndex( int index);                     // インデックス消去
        BOOL CanUpdateTbl(void);                         // テーブルが更新可能かどうかチェック

        BOOL GetIndexInfo( int nIndex, CDaoIndexInfo& indexinfo, DWORD dwInfoOptions = AFX_DAO_PRIMARY_INFO );     // インデックス情報を修得
        BOOL GetIndexInfo( LPCTSTR lpszName, CDaoIndexInfo& indexinfo, DWORD dwInfoOptions = AFX_DAO_PRIMARY_INFO );     // インデックス情報を修得


    //------------------------------------------
    // CDaoRecordset
        BOOL OpenRecord(int nOpenType = dbOpenDynaset, int nOptions = 0);
        BOOL CloseRecord(void);
        BOOL AddNew         (void); // pare w/Update function
        BOOL AddNew         (CWnd *lpcWnd); // pare w/Update function
            // ページロックできない時に再施行します。またユーザーに問い合わせも行います
        BOOL Update         (void);
        BOOL CancelUpdate(void);
        long GetCount    (void);     // Get Record Count
        BOOL Delete         (void);    // current delete and move first record automatically
        BOOL Delete         (long n); // delete n position
        BOOL Edit         (void);
        BOOL Edit         (CWnd *lpcWnd); // ページロックできない時に再施行します。またユーザーに問い合わせも行います
        COleDateTime GetDateCreated(void);
        COleDateTime GetDateLastUpdated(void);
        // position function
        long GetPos         (void);             // 現在のカーソル位置を修得。Absolute Position
        BOOL SetPos         (long lPos);    // カーソル位置を設定absolute position
        float GetPerPos    (void);             // カーソル位置を修得Percent Position
        // move function
        BOOL Move         (long n);    // カーソル位置を設定
        BOOL MoveLast    (void);         // カーソルを最後の位置に設定
        BOOL MoveFirst    (void);         // カーソルを最初のレコードに設定
        BOOL MovePrev    (void);         // カーソルを一つ前に移動
        BOOL MoveNext    (void);         // カーソルを次に移動
        // status function
        BOOL IsBOF         (void);         // カーソルが現在初めの位置にあるかどうかとチェック
        BOOL IsEOF         (void);         // カーソルが最終位置にあるかどうかチェック
        BOOL IsDeleted    (void);
        BOOL IsOpen         (void);
        // Get field value function レコードの情報を修得する
        BOOL    Get             (LPCTSTR lpszName, COleVariant& varValue );
        BOOL    Get             (int nIndex, COleVariant& varValue );
        short    GetInt         (LPCSTR lpszName);
        short    GetInt         (int nIndex);
        long    GetLong         (LPCSTR lpszName);
        long    GetLong         (int nIndex);
        float    GetSingle     (LPCSTR lpszName);
        float    GetSingle     (int nIndex);
        double    GetDouble     (LPCSTR lpszName);
        double    GetDouble     (int nIndex);
        LPSTR    GetStr         (LPCSTR lpszName);
        LPSTR    GetStr         (int nIndex);

        // Set field value function レコードに情報を設定する
        BOOL Set    (LPCTSTR lpszName, const COleVariant& varValue);
        BOOL Set    (int nOrdinal, const COleVariant& varValue);
        BOOL Set    (LPCTSTR lpszName, LPCTSTR lpszValue );
        BOOL Set    (int nOrdinal, LPCTSTR lpszValue );
        BOOL Set    (LPCTSTR lpszName, short n );
        BOOL Set    (int nOrdinal, short n );
        BOOL Set    (LPCTSTR lpszName, long n );
        BOOL Set    (int nOrdinal, long n );
        BOOL Set    (LPCTSTR lpszName, float n );
        BOOL Set    (int nOrdinal, float n );
        BOOL Set    (LPCTSTR lpszName, double n );
        BOOL Set    (int nOrdinal, double n );

        BOOL SetNull    (LPCTSTR lpszName);    // レコードをＮＵＬＬに設定する
        BOOL SetNull    (int nOrdinal);         // レコードをＮＵＬＬに設定する

        BOOL SetToday    (LPCTSTR lpszName);    // レコードに現在時間を設定する
        BOOL SetToday    (int nOrdinal);         // レコードに現在時間を設定する
        BOOL SetDate    (int nOrdinal     ,int nY,int nM,int nD);        // レコードに指定日設定する
        BOOL SetDate    (LPCTSTR lpszName,int nY,int nM,int nD);    // レコードに指定日設定する
        BOOL SetDateOffset    (int nOrdinal    ,int nY,int nM,int nD);    // レコードに指定日設定する
        BOOL SetDateOffset    (LPCTSTR lpszName,int nY,int nM,int nD);    // レコードに指定日設定する

        // Field Infomation
        BOOL GetInfo(int nIndex, CDaoFieldInfo& fieldinfo, DWORD dwInfoOptions = AFX_DAO_PRIMARY_INFO);             // フィールドの情報を修得する
        BOOL GetInfo(LPCTSTR lpszName, CDaoFieldInfo& fieldinfo, DWORD dwInfoOptions = AFX_DAO_PRIMARY_INFO);     // フィールドの情報を修得する
        //


};
#endif // __CDAODB_CLASS__
// EOF
//-------------------------------------------

　

クラスの本体定義は次のようになっています

//-------------------------------------------
// DAO Database access class for MFC CDaoXXX
//    programmed Copyright (c) by kitaro 1998
// Cash program for DAODB class
//
#include "CDAODB.h"

VOID CompactDAODB(void){
    CDaoWorkspace cw;
    cw.Open(NULL);
    cw.CompactDatabase ("ZipCode.mdb",
        "temp.mdb");
    cw.Close();
}
//--------------------------------------
// CDAODB Memory Cash class
BOOL CDAODBCash::Save(LPSTR filename){
    CFile cf;
    if( cf.Open(filename,CFile::modeCreate | CFile::modeWrite ) == FALSE) return FALSE;
    cf.Write(&nCount,sizeof(nCount));
    cf.Write( root,StructSize()*nCount );
    cf.Close();
    return TRUE;
};
BOOL CDAODBCash::Load(LPSTR filename){
    CFile cf;
    int n;
    if( cf.Open(filename,CFile::modeRead)== FALSE) return FALSE;
    cf.Read(&n,sizeof(n)); nMaxCount = n;
    if(root != NULL) free(root); root=NULL;
    Create(n); nCount = n;
    cf.Read( root,StructSize()*nCount );
    cf.Close();
    return TRUE;
};
BOOL CDAODBCash::Create(long n){
    nMaxCount = n;
    root = (CashTree*)malloc (StructSize()*nMaxCount) ;
    if(root == NULL){
        ::MessageBox(NULL,"メモリー不足です","ERROR",MB_OK);
    }
    ZeroMemory(root,StructSize()*nMaxCount );
    nCount = 0;
    return TRUE;
};
CDAODBCash::CDAODBCash(){    root = NULL;};
CDAODBCash::~CDAODBCash(){
    if( root != NULL) free( root); root=NULL;
};
void CDAODBCash::PushNE(LPSTR s,LPSTR d,LPSTR d2){
    int i;
    for(i=0;i<nCount;i++){
        if(strcmp(root[i].data,s)==0) return;
    }
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    strcpy(root[nCount].data2,d2);
    nCount++;
};
void CDAODBCash::PushNE1(LPSTR s,LPSTR d,LPSTR d2){
    int i;
    for(i=0;i<nCount;i++){
        if(strcmp(root[i].data1,d)==0) return;
    }
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    strcpy(root[nCount].data2,d2);
    nCount++;
};
void CDAODBCash::PushNE2(LPSTR s,LPSTR d,LPSTR d2){
    int i;
    for(i=0;i<nCount;i++){
        if(strcmp(root[i].data2,d2)==0) return;
    }
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    strcpy(root[nCount].data2,d2);
    nCount++;
};
void CDAODBCash::Push(LPSTR s,LPSTR d,LPSTR d2){
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    strcpy(root[nCount].data2,d2);
    nCount++;
};
long    CDAODBCash::Search    (LPSTR szText){
    long i;
    for(i=0;i<nCount;i++){
        if( strcmp(root[i].data ,szText)==0) return (i);
    }return -1;
};
int        CDAODBCash::GetCount     (void) {return nCount;};
int        CDAODBCash::GetMaxCount     (void) {return nMaxCount;};
LPSTR    CDAODBCash::GetStr        (long n){return root[n].data;};
LPSTR    CDAODBCash::GetStr1         (long n){return root[n].data1;};
LPSTR    CDAODBCash::GetStr2         (long n){return root[n].data2;};
void    CDAODBCash::SetStr        (long n,LPSTR p){strcpy( root[n].data ,p);};
void    CDAODBCash::SetStr1        (long n,LPSTR p){strcpy( root[n].data1,p);};
void    CDAODBCash::SetStr2        (long n,LPSTR p){strcpy( root[n].data2,p);};
long    CDAODBCash::StructSize    (void) {return(sizeof(CashTree));};
void    CDAODBCash::SortOneBegin(void){
    sCount=0;
};
BOOL    CDAODBCash::SortOne(void){
    BOOL bx;
    int j,k;
    static CashTree *a,*top,px;
    {
        bx = TRUE;
        a = root + sCount;
        j = sCount;
        k = nCount;
        top = a;
        _asm{
            mov eax,k
            mov ebx,j
            sub eax,ebx
            mov ecx,eax
loop1:
            push ecx
        }
        {
            if(strcmp(top->data,a->data)>0)
                top=a;
            a++;
        }
        _asm{
            pop ecx
            loop loop1
        }
        memcpy(&px,&root [ sCount ],sizeof(CashTree));
        memcpy(&root [ sCount ],top,sizeof(CashTree));
        memcpy(top,&px,sizeof(CashTree));
        sCount++;
        return bx;
    }
};
BOOL    CDAODBCash::SortOne1(void){
    BOOL bx;
    int j,k;
    static CashTree *a,*top,px;
    {
        bx = TRUE;
        a = root + sCount;
        j = sCount;
        k = nCount;
        top = a;
        _asm{
            mov eax,k
            mov ebx,j
            sub eax,ebx
            mov ecx,eax
loop1:
            push ecx
        }
        {
            if(strcmp(top->data1,a->data1)>0)
                top=a;
            a++;
        }
        _asm{
            pop ecx
            loop loop1
        }
        memcpy(&px,&root [ sCount ],sizeof(CashTree));
        memcpy(&root [ sCount ],top,sizeof(CashTree));
        memcpy(top,&px,sizeof(CashTree));
        sCount++;
        return bx;
    }
};
BOOL    CDAODBCash::SortOne2(void){
    BOOL bx;
    int j,k;
    static CashTree *a,*top,px;
    {
        bx = TRUE;
        a = root + sCount;
        j = sCount;
        k = nCount;
        top = a;
        _asm{
            mov eax,k
            mov ebx,j
            sub eax,ebx
            mov ecx,eax
loop1:
            push ecx
        }
        {
            if(strcmp(top->data2,a->data2)>0)
                top=a;
            a++;
        }
        _asm{
            pop ecx
            loop loop1
        }
        memcpy(&px,&root [ sCount ],sizeof(CashTree));
        memcpy(&root [ sCount ],top,sizeof(CashTree));
        memcpy(top,&px,sizeof(CashTree));
        sCount++;
        return bx;
    }
};
//--------------------------------------
// CDAODB Memory Cash class Cache2
BOOL CDAODBCash2::Save(LPSTR filename){
    CFile cf;
    if( cf.Open(filename,CFile::modeCreate | CFile::modeWrite )==FALSE)return FALSE;
    cf.Write(&nCount,sizeof(nCount));
    cf.Write( root,StructSize()*nCount );
    cf.Close();
    return TRUE;
};
BOOL CDAODBCash2::Load(LPSTR filename){
    CFile cf;
    int n;
    if( cf.Open(filename,CFile::modeRead)==FALSE)return FALSE;
    cf.Read(&n,sizeof(n)); nMaxCount = n;
    if(root != NULL) free(root); root=NULL;
    Create(n); nCount = n;
    cf.Read( root,StructSize()*nCount );
    cf.Close();
    return TRUE;
};
BOOL CDAODBCash2::Create(long n){
    nMaxCount = n;
    root = (CashTree2*)malloc (StructSize()*nMaxCount) ;
    if(root == NULL){
        ::MessageBox(NULL,"メモリー不足です","ERROR",MB_OK);
    }
    ZeroMemory(root,StructSize()*nMaxCount );
    nCount = 0;
    return TRUE;
};
CDAODBCash2::CDAODBCash2(){
    root = NULL;
};
CDAODBCash2::~CDAODBCash2(){
    if( root != NULL) free( root); root=NULL;
};
void CDAODBCash2::PushNE(LPSTR s,LPSTR d){
    int i;
    for(i=0;i<nCount;i++){
        if(strcmp(root[i].data,s)==0) return;
    }
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    nCount++;
};
void CDAODBCash2::PushNE1(LPSTR s,LPSTR d){
    int i;
    for(i=0;i<nCount;i++){
        if(strcmp(root[i].data1,d)==0) return;
    }
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    nCount++;
};
void CDAODBCash2::Push(LPSTR s,LPSTR d){
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    nCount++;
};
long    CDAODBCash2::Search    (LPSTR szText){
    long i;
    for(i=0;i<nCount;i++){
        if( strcmp(root[i].data ,szText)==0) return (i);
    }return -1;
};
LPSTR    CDAODBCash2::GetStr         (long n){return root[n].data;};
LPSTR    CDAODBCash2::GetStr1    (long n){return root[n].data1;};
void    CDAODBCash2::SetStr        (long n,LPSTR p){strcpy( root[n].data ,p);};
void    CDAODBCash2::SetStr1    (long n,LPSTR p){strcpy( root[n].data1,p);};
long    CDAODBCash2::StructSize     (void){return(sizeof(CashTree2));};
void    CDAODBCash2::SortOneBegin(void){
    sCount=0;
};

BOOL    CDAODBCash2::SortOne(void){
    BOOL bx;
    int j,k;
    static CashTree2 *a,*top,px;
    {
        bx = TRUE;
        a = root + sCount;
        j = sCount;
        k = nCount;
        top = a;
        _asm{
            mov eax,k
            mov ebx,j
            sub eax,ebx
            mov ecx,eax
loop1:
            push ecx
        }
        {
            if(strcmp(top->data,a->data)>0)
                top=a;
            a++;
        }
        _asm{
            pop ecx
            loop loop1
        }
        memcpy(&px,&root [ sCount ],sizeof(CashTree));
        memcpy(&root [ sCount ],top,sizeof(CashTree));
        memcpy(top,&px,sizeof(CashTree));
        sCount++;
        return bx;
    }
};
BOOL    CDAODBCash2::SortOne1(void){
    BOOL bx;
    int j,k;
    static CashTree2 *a,*top,px;
    {
        bx = TRUE;
        a = root + sCount;
        j = sCount;
        k = nCount;
        top = a;
        _asm{
            mov eax,k
            mov ebx,j
            sub eax,ebx
            mov ecx,eax
loop1:
            push ecx
        }
        {
            if(strcmp(top->data1,a->data1)>0)
                top=a;
            a++;
        }
        _asm{
            pop ecx
            loop loop1
        }
        memcpy(&px,&root [ sCount ],sizeof(CashTree));
        memcpy(&root [ sCount ],top,sizeof(CashTree));
        memcpy(top,&px,sizeof(CashTree));
        sCount++;
        return bx;
    }
};
//--------------------------------------
// CDAODB Memory Cash class 3
CDAODBCash3::Save(LPSTR filename){
    CFile cf;
    if(cf.Open(filename,CFile::modeCreate | CFile::modeWrite )==FALSE)return FALSE;
    cf.Write(&nCount,sizeof(nCount));
    cf.Write( root,StructSize()*nCount );
    cf.Close();
    return TRUE;
};
CDAODBCash3::Load(LPSTR filename){
    CFile cf;
    int n;
    if( cf.Open(filename,CFile::modeRead)==FALSE)return FALSE;
    cf.Read(&n,sizeof(n)); nMaxCount = n;
    if(root != NULL) free(root); root=NULL;
    Create(n); nCount = n;
    cf.Read( root,StructSize()*nCount );
    cf.Close();
    return TRUE;
};
BOOL CDAODBCash3::Create(long n){
    nMaxCount = n;
    root = (CashTree2*)malloc (StructSize()*nMaxCount) ;
    if(root == NULL){
        ::MessageBox(NULL,"メモリー不足です","ERROR",MB_OK);
    }
    ZeroMemory(root,StructSize()*nMaxCount );
    nCount = 0;
    return TRUE;
};
CDAODBCash3::CDAODBCash3(){
    root = NULL;
};
CDAODBCash3::~CDAODBCash3(){
    if( root != NULL) free( root); root=NULL;
};
void CDAODBCash3::PushNE(LPSTR s,LPSTR d){
    int i;
    for(i=0;i<nCount;i++){
        if(strcmp(root[i].data,s)==0) return;
    }
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    nCount++;
};
void CDAODBCash3::PushNE1(LPSTR s,LPSTR d){
    int i;
    for(i=0;i<nCount;i++){
        if(strcmp(root[i].data1,d)==0) return;
    }
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    nCount++;
};
void CDAODBCash3::Push(LPSTR s,LPSTR d){
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    nCount++;
};
long    CDAODBCash3::Search    (LPSTR szText){
    long i;
    for(i=0;i<nCount;i++){
        if( strcmp(root[i].data ,szText)==0) return (i);
    }return -1;
};
LPSTR    CDAODBCash3::GetStr         (long n){return root[n].data;};
LPSTR    CDAODBCash3::GetStr1    (long n){return root[n].data1;};
void    CDAODBCash3::SetStr        (long n,LPSTR p){strcpy( root[n].data ,p);};
void    CDAODBCash3::SetStr1    (long n,LPSTR p){strcpy( root[n].data1,p);};
long    CDAODBCash3::StructSize     (void){return(sizeof(CashTree2));};
void    CDAODBCash3::SortOneBegin(void){
    sCount=0;
};

BOOL    CDAODBCash3::SortOne(void){
    BOOL bx;
    int j,k;
    static CashTree2 *a,*top,px;
    {
        bx = TRUE;
        a = root + sCount;
        j = sCount;
        k = nCount;
        top = a;
        _asm{
            mov eax,k
            mov ebx,j
            sub eax,ebx
            mov ecx,eax
loop1:
            push ecx
        }
        {
            if(strcmp(top->data,a->data)>0)
                top=a;
            a++;
        }
        _asm{
            pop ecx
            loop loop1
        }
        memcpy(&px,&root [ sCount ],sizeof(CashTree));
        memcpy(&root [ sCount ],top,sizeof(CashTree));
        memcpy(top,&px,sizeof(CashTree));
        sCount++;
        return bx;
    }
};
BOOL    CDAODBCash3::SortOne1(void){
    BOOL bx;
    int j,k;
    static CashTree2 *a,*top,px;
    {
        bx = TRUE;
        a = root + sCount;
        j = sCount;
        k = nCount;
        top = a;
        _asm{
            mov eax,k
            mov ebx,j
            sub eax,ebx
            mov ecx,eax
loop1:
            push ecx
        }
        {
            if(strcmp(top->data1,a->data1)>0)
                top=a;
            a++;
        }
        _asm{
            pop ecx
            loop loop1
        }
        memcpy(&px,&root [ sCount ],sizeof(CashTree));
        memcpy(&root [ sCount ],top,sizeof(CashTree));
        memcpy(top,&px,sizeof(CashTree));
        sCount++;
        return bx;
    }
};
//--------------------------------------
// CDAODB Memory Cash class Cache4
BOOL CDAODBCash4::Save(LPSTR filename){
    CFile cf;
    if( cf.Open(filename,CFile::modeCreate | CFile::modeWrite )==FALSE)return FALSE;
    cf.Write(&nCount,sizeof(nCount));
    cf.Write( root,StructSize()*nCount );
    cf.Close();
    return TRUE;
};
BOOL CDAODBCash4::Load(LPSTR filename){
    CFile cf;
    int n;
    if( cf.Open(filename,CFile::modeRead)==FALSE)return FALSE;
    cf.Read(&n,sizeof(n)); nMaxCount = n;
    if(root != NULL) free(root); root=NULL;
    Create(n); nCount = n;
    cf.Read( root,StructSize()*nCount );
    cf.Close();
    return TRUE;
};
BOOL CDAODBCash4::Create(long n){
    nMaxCount = n;
    root = (CashTree2*)malloc (StructSize()*nMaxCount) ;
    if(root == NULL){
        ::MessageBox(NULL,"メモリー不足です","ERROR",MB_OK);
    }
    ZeroMemory(root,StructSize()*nMaxCount );
    nCount = 0;
    return TRUE;
};
CDAODBCash4::CDAODBCash4(){
    root = NULL;
};
CDAODBCash4::~CDAODBCash4(){
    if( root != NULL) free( root); root=NULL;
};
void CDAODBCash4::PushNE(LPSTR s,LPSTR d){
    int i;
    for(i=0;i<nCount;i++){
        if(strcmp(root[i].data,s)==0) return;
    }
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    nCount++;
};
void CDAODBCash4::PushNE1(LPSTR s,LPSTR d){
    int i;
    for(i=0;i<nCount;i++){
        if(strcmp(root[i].data1,d)==0) return;
    }
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    nCount++;
};
void CDAODBCash4::Push(LPSTR s,LPSTR d){
    if(nCount >= nMaxCount)return;
    strcpy(root[nCount].data ,s);
    strcpy(root[nCount].data1,d);
    nCount++;
};
long    CDAODBCash4::Search    (LPSTR szText){
    long i;
    for(i=0;i<nCount;i++){
        if( strcmp(root[i].data ,szText)==0) return (i);
    }return -1;
};
LPSTR    CDAODBCash4::GetStr         (long n){return root[n].data;};
LPSTR    CDAODBCash4::GetStr1    (long n){return root[n].data1;};
void    CDAODBCash4::SetStr        (long n,LPSTR p){strcpy( root[n].data ,p);};
void    CDAODBCash4::SetStr1    (long n,LPSTR p){strcpy( root[n].data1,p);};
long    CDAODBCash4::StructSize     (void){return(sizeof(CashTree2));};
void    CDAODBCash4::SortOneBegin(void){
    sCount=0;
};

BOOL    CDAODBCash4::SortOne(void){
    BOOL bx;
    int j,k;
    static CashTree2 *a,*top,px;
    {
        bx = TRUE;
        a = root + sCount;
        j = sCount;
        k = nCount;
        top = a;
        _asm{
            mov eax,k
            mov ebx,j
            sub eax,ebx
            mov ecx,eax
loop1:
            push ecx
        }
        {
            if(strcmp(top->data,a->data)>0)
                top=a;
            a++;
        }
        _asm{
            pop ecx
            loop loop1
        }
        memcpy(&px,&root [ sCount ],sizeof(CashTree));
        memcpy(&root [ sCount ],top,sizeof(CashTree));
        memcpy(top,&px,sizeof(CashTree));
        sCount++;
        return bx;
    }
};
BOOL    CDAODBCash4::SortOne1(void){
    BOOL bx;
    int j,k;
    static CashTree2 *a,*top,px;
    {
        bx = TRUE;
        a = root + sCount;
        j = sCount;
        k = nCount;
        top = a;
        _asm{
            mov eax,k
            mov ebx,j
            sub eax,ebx
            mov ecx,eax
loop1:
            push ecx
        }
        {
            if(strcmp(top->data1,a->data1)>0)
                top=a;
            a++;
        }
        _asm{
            pop ecx
            loop loop1
        }
        memcpy(&px,&root [ sCount ],sizeof(CashTree));
        memcpy(&root [ sCount ],top,sizeof(CashTree));
        memcpy(top,&px,sizeof(CashTree));
        sCount++;
        return bx;
    }
};
//-------------------------------------------
//
CDAODB::CDAODB(){
    strcpy(szPassword,"");
    m_ws    = NULL;
    m_cdao    = NULL;
    m_tbl    = NULL;
    m_rs    = NULL;
    bAppend = FALSE;
};
CDAODB::~CDAODB(){
    Close();
};
//-------------------------------------------
void CDAODB::Close(void){
    //
    if(m_ws        !=NULL){CloseWS();}
    if(m_rs        !=NULL){m_rs ->Close(); delete(m_rs); } // delete recordset object
    if(m_tbl    !=NULL){m_tbl ->Close(); delete(m_tbl); } // delete table object
    if(m_cdao    !=NULL){m_cdao->Close(); delete(m_cdao); }
    m_cdao    = NULL;
    m_tbl    = NULL;
    m_rs    = NULL;
};
BOOL CDAODB::GetTableDefInfo( int nIndex, CDaoTableDefInfo& tabledefinfo, DWORD dwInfoOptions ){
    ASSERT(m_cdao);
    try{
        m_cdao->GetTableDefInfo(nIndex, tabledefinfo, dwInfoOptions );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::GetTableDefInfo( LPCTSTR lpszName, CDaoTableDefInfo& tabledefinfo, DWORD dwInfoOptions ){
    ASSERT(m_cdao);
    try{
        m_cdao->GetTableDefInfo(lpszName, tabledefinfo, dwInfoOptions );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
short CDAODB::GetTableDefCount( void ){
    ASSERT(m_cdao);
    short n;
    try{
        n = m_cdao->GetTableDefCount();
    }
    catch(CDaoException* e)        { e->Delete(); return -1;    }
    catch(CMemoryException* e)    { e->Delete(); return -1;    }
    return n;
};
BOOL CDAODB::IsTableDef(LPSTR szTableName){
    short i,n;
    CDaoTableDefInfo tabledefinfo;
    n = GetTableDefCount();
    for(i=0;i<n;i++){
        GetTableDefInfo(i,tabledefinfo);
        if(strcmp(szTableName,LPCTSTR( tabledefinfo.m_strName) )==0) break;
    }
    if(i==n)return FALSE;
    return TRUE;
};

BOOL CDAODB::GetIndexInfo( int nIndex, CDaoIndexInfo& indexinfo, DWORD dwInfoOptions ){
    ASSERT(m_tbl);
    try{
        m_tbl->GetIndexInfo( nIndex, indexinfo, dwInfoOptions );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}

BOOL CDAODB::GetIndexInfo( LPCTSTR lpszName, CDaoIndexInfo& indexinfo, DWORD dwInfoOptions ){
    ASSERT(m_tbl);
    try{
        m_tbl->GetIndexInfo( lpszName, indexinfo, dwInfoOptions );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::CanUpdateTbl( void){
    ASSERT(m_tbl);
    try{
        return(m_tbl->CanUpdate());
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}

BOOL CDAODB::DeleteIndex( int nIndex){
    ASSERT(m_tbl);
    try{
        if(CanUpdateTbl()==TRUE)
            m_tbl->DeleteIndex( nIndex );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::DeleteIndex( LPCTSTR lpszName){
    ASSERT(m_tbl);
    try{
        if(CanUpdateTbl()==TRUE)
            m_tbl->DeleteIndex( lpszName );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::CreateTable(LPCSTR szTableName){
    ASSERT(m_tbl);
    try{
        CloseTable();
        m_tbl->Create( szTableName );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::OpenTable(LPCSTR szTableName){
    ASSERT(m_tbl);
    try{
        CloseTable();
        m_tbl->Open( szTableName );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::CloseTable(void){
    ASSERT(m_tbl);
    try{
        if(bAppend == TRUE)m_tbl->Append(); bAppend = FALSE;
        if(m_tbl->IsOpen()==TRUE)
            m_tbl->Close();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}

BOOL CDAODB::DeleteTableDef( LPCTSTR lpszName ){
    ASSERT(m_cdao);
    try{
        m_cdao->DeleteTableDef( lpszName );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
//----------------------------------------------------------------------------
// Create Index Function
BOOL CDAODB::CreateIndex( CDaoIndexInfo& indexinfo ){
    ASSERT(m_tbl);
    try{
        m_tbl->CreateIndex( indexinfo );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};

//----------------------------------------------------------------------------
// Table Field object
BOOL CDAODB::FieldInfo( int nIndex, CDaoFieldInfo& fieldinfo, DWORD dwInfoOptions ){
    ASSERT(m_tbl);
    try{
        m_tbl->GetFieldInfo(nIndex,fieldinfo,dwInfoOptions );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::FieldInfo( LPCTSTR lpszName, CDaoFieldInfo& fieldinfo, DWORD dwInfoOptions ){
    ASSERT(m_tbl);
    try{
        m_tbl->GetFieldInfo(lpszName,fieldinfo,dwInfoOptions );
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
short CDAODB::FieldCount( void ){
    ASSERT(m_tbl);
    try{
        return(m_tbl->GetFieldCount());
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return FALSE;
};
LPCTSTR    CDAODB::GetFieldName(int nIndex){
    static CDaoFieldInfo fieldinfo;
    if( FieldInfo( nIndex, fieldinfo)== FALSE) return NULL;
    return LPCTSTR(fieldinfo.m_strName);
}

BOOL CDAODB::IsFieldName(LPSTR szFieldName){
    short i,n;
    CDaoFieldInfo fieldinfo;
    n = FieldCount();
    for(i=0;i<n;i++){
        if( FieldInfo( i, fieldinfo)== FALSE) return FALSE;
        if(strcmp(szFieldName,LPCTSTR(fieldinfo.m_strName))==0)break;
    }
    if(i==n)return FALSE;
    return TRUE;
};
BOOL CDAODB::AppendField( void ){
    ASSERT(m_tbl);
    try{
        if(bAppend == TRUE)m_tbl->Append(); bAppend = FALSE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateField(LPSTR lpszName,short nType , long lSize , long lAttributes ){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,nType,lSize,lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};

//---------------------------------------------------------------------
BOOL CDAODB::CreateFieldStr    (int count,...){
    BOOL b=FALSE;
    va_list argList;
    va_start(argList, count);
    int i;
    for(i=0;i<count;i++){
        LPSTR p;
        p = va_arg(argList, LPSTR );
        b = CreateFieldStr(p);
        if(b==FALSE)break;
    }
    va_end(argList);
    return b;
};
BOOL CDAODB::CreateFieldInt    (int count,...){
    BOOL b=FALSE;
    va_list argList;
    va_start(argList, count);
    int i;
    for(i=0;i<count;i++){
        LPSTR p;
        p = va_arg(argList, LPSTR );
        b = CreateFieldInt(p);
        if(b==FALSE)break;
    }
    va_end(argList);
    return b;
};
BOOL CDAODB::CreateFieldLong    (int count,...){
    BOOL b=FALSE;
    va_list argList;
    va_start(argList, count);
    int i;
    for(i=0;i<count;i++){
        LPSTR p;
        p = va_arg(argList, LPSTR );
        b = CreateFieldLong(p);
        if(b==FALSE)break;
    }
    va_end(argList);
    return b;
};
BOOL CDAODB::CreateFieldSingle    (int count,...){
    BOOL b=FALSE;
    va_list argList;
    va_start(argList, count);
    int i;
    for(i=0;i<count;i++){
        LPSTR p;
        p = va_arg(argList, LPSTR );
        b = CreateFieldSingle(p);
        if(b==FALSE)break;
    }
    va_end(argList);
    return b;
};
BOOL CDAODB::CreateFieldDouble    (int count,...){
    BOOL b=FALSE;
    va_list argList;
    va_start(argList, count);
    int i;
    for(i=0;i<count;i++){
        LPSTR p;
        p = va_arg(argList, LPSTR );
        b = CreateFieldDouble(p);
        if(b==FALSE)break;
    }
    va_end(argList);
    return b;
};

//---------------------------------------------------------------------
BOOL CDAODB::CreateFieldStr(LPSTR lpszName,long lSize,long lAttributes ){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbText,lSize,lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldDate(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbDate,8,dbFixedField | lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldInt(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbInteger,2,dbFixedField | lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldLong(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbLong,4,dbFixedField | lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldSingle(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbSingle,4,dbFixedField | lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldDouble(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbDouble,8,dbFixedField |lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldCurrency(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbCurrency,8,dbFixedField | lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldBool(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbBoolean,1,dbFixedField | lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldByte(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbByte,1,dbFixedField | lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldLB(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbLongBinary,0,lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::CreateFieldMemo(LPSTR lpszName,long lAttributes){
    ASSERT(m_tbl);
    try{
        if(m_tbl->IsOpen()==TRUE) return FALSE; //table is not open error
        m_tbl->CreateField( lpszName ,dbMemo,0,lAttributes);
        bAppend = TRUE;
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};

//----------------------------------------------------------------------------
BOOL CDAODB::Move(long n){
    ASSERT(m_rs);
    try{
        m_rs->Move(n);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::MoveNext(void){
    ASSERT(m_rs);
    try{
        m_rs->MoveNext();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::MovePrev(void){
    ASSERT(m_rs);
    try{
        m_rs->MovePrev();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::MoveFirst(void){
    ASSERT(m_rs);
    try{
        m_rs->MoveFirst();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::MoveLast(void){
    ASSERT(m_rs);
    try{
        m_rs->MoveLast();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}

//-------------------------------------
LPSTR CDAODB::GetStr(LPCSTR lpszName){
    static COleVariant c; Get(lpszName,c); if(c.vt==VT_BSTR) return (LPSTR)c.pbVal;
    return NULL;
}
LPSTR CDAODB::GetStr(int nIndex){
    static COleVariant c; Get(nIndex,c); if(c.vt==VT_BSTR) return (LPSTR)c.pbVal;
    return NULL;
}
BOOL CDAODB::Get( LPCTSTR lpszName, COleVariant& varValue ){
    ASSERT(m_rs);
    try{
        m_rs->GetFieldValue(lpszName,varValue);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::Get( int nIndex, COleVariant& varValue ){
    ASSERT(m_rs);
    try{
        m_rs->GetFieldValue(nIndex,varValue);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
short CDAODB::GetInt(LPCSTR lpszName){
    COleVariant c; Get(lpszName,c); return c.iVal;
}
short CDAODB::GetInt(int nIndex){
    COleVariant c; Get(nIndex,c); return c.iVal;
}
long CDAODB::GetLong(LPCSTR lpszName){
    COleVariant c; Get(lpszName,c); return c.lVal;
}
long CDAODB::GetLong(int nIndex){
    COleVariant c; Get(nIndex,c); return c.lVal;
}
float CDAODB::GetSingle(LPCSTR lpszName){
    COleVariant c; Get(lpszName,c); return c.fltVal;
}
float CDAODB::GetSingle(int nIndex){
    COleVariant c; Get(nIndex,c); return c.fltVal;
}
double CDAODB::GetDouble(LPCSTR lpszName){
    COleVariant c; Get(lpszName,c); return c.dblVal;
}
double CDAODB::GetDouble(int nIndex){
    COleVariant c; Get(nIndex,c); return c.dblVal;
}
//-------------------------------------
// SetFieldValue
BOOL CDAODB::SetDateOffset(int nOrdinal,int nY,int nM,int nD){
    ASSERT(m_rs);
    COleDateTime ct=COleDateTime::GetCurrentTime();
    nY = nY + ct.GetYear();
    nM = nM + ct.GetMonth();
    nD = nD + ct.GetDay();
    ct.SetDate(nY,nM,nD);
    try{
        m_rs->SetFieldValue(nOrdinal,(COleVariant)ct);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::SetDateOffset(LPCTSTR lpszName,int nY,int nM,int nD){
    ASSERT(m_rs);
    COleDateTime ct=COleDateTime::GetCurrentTime();
    nY = nY + ct.GetYear();
    nM = nM + ct.GetMonth();
    nD = nD + ct.GetDay();
    ct.SetDate(nY,nM,nD);
    try{
        m_rs->SetFieldValue(lpszName,(COleVariant)ct);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::SetDate(LPCTSTR lpszName,int nY,int nM,int nD){
    ASSERT(m_rs);
    COleDateTime ct=COleDateTime::GetCurrentTime();
    ct.SetDate(nY,nM,nD);
    try{
        m_rs->SetFieldValue(lpszName,(COleVariant)ct);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::SetDate(int nOrdinal,int nY,int nM,int nD){
    ASSERT(m_rs);
    COleDateTime ct=COleDateTime::GetCurrentTime();
    ct.SetDate(nY,nM,nD);
    try{
        m_rs->SetFieldValue(nOrdinal,(COleVariant)ct);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::SetToday(LPCTSTR lpszName){
    ASSERT(m_rs);
    try{
        m_rs->SetFieldValue(lpszName,(COleVariant)COleDateTime::GetCurrentTime());
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::SetToday(int nOrdinal){
    ASSERT(m_rs);
    try{
        m_rs->SetFieldValue(nOrdinal,(COleVariant)COleDateTime::GetCurrentTime());
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::Set(LPCTSTR lpszName, const COleVariant& varValue){
    ASSERT(m_rs);
    try{
        m_rs->SetFieldValue(lpszName,varValue);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::Set(int nOrdinal, const COleVariant& varValue){
    ASSERT(m_rs);
    try{
        m_rs->SetFieldValue(nOrdinal,varValue);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::Set(LPCTSTR lpszName, LPCTSTR lpszValue){
    ASSERT(m_rs);
    try{
        if         (lpszValue==NULL)         m_rs->SetFieldValueNull(lpszName);
        else if     (strlen(lpszValue)==0)     m_rs->SetFieldValueNull(lpszName);
        else m_rs->SetFieldValue(lpszName,lpszValue);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::Set( int nOrdinal, LPCTSTR lpszValue){
    ASSERT(m_rs);
    try{
        if         (lpszValue==NULL)         m_rs->SetFieldValueNull(nOrdinal);
        else if     (strlen(lpszValue)==0)     m_rs->SetFieldValueNull(nOrdinal);
        else m_rs->SetFieldValue(nOrdinal,lpszValue);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::Set(LPCTSTR lpszName, long n){
    COleVariant c;    c=n;    return( Set(lpszName,c) );
}
BOOL CDAODB::Set(int nOrdinal, long n){
    COleVariant c;    c=n;    return( Set(nOrdinal,c) );
}
BOOL CDAODB::Set(LPCTSTR lpszName, float n){
    COleVariant c;    c=n;    return( Set(lpszName,c) );
}
BOOL CDAODB::Set(int nOrdinal, float n){
    COleVariant c;    c=n;    return( Set(nOrdinal,c) );
}
BOOL CDAODB::Set(LPCTSTR lpszName, double n){
    COleVariant c;    c=n;    return( Set(lpszName,c) );
}
BOOL CDAODB::Set(int nOrdinal, double n){
    COleVariant c;    c=n;    return( Set(nOrdinal,c) );
}
BOOL CDAODB::Set(LPCTSTR lpszName, short n){
    COleVariant c;    c=n;    return( Set(lpszName,c) );
}
BOOL CDAODB::Set(int nOrdinal, short n){
    COleVariant c;    c=n;    return( Set(nOrdinal,c) );
}

BOOL CDAODB::SetNull(LPCTSTR lpszName){
    ASSERT(m_rs);
    try{
        m_rs->SetFieldValueNull(lpszName);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::SetNull( int nOrdinal){
    ASSERT(m_rs);
    try{
        m_rs->SetFieldValueNull(nOrdinal);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}

//-------------------------------------
BOOL CDAODB::IsBOF(void){
    ASSERT(m_rs);
    try{
        return m_rs->IsBOF();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::IsEOF(void){
    ASSERT(m_rs);
    try{
        return m_rs->IsEOF();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::IsDeleted(void){
    ASSERT(m_rs);
    try{
        return m_rs->IsDeleted();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::IsOpen(void){
    ASSERT(m_rs);
    try{
        return m_rs->IsOpen();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::GetInfo(int nIndex, CDaoFieldInfo& fieldinfo, DWORD dwInfoOptions ){
    ASSERT(m_rs);
    try{
        m_rs->GetFieldInfo(nIndex,fieldinfo,dwInfoOptions);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::GetInfo(LPCTSTR lpszName, CDaoFieldInfo& fieldinfo, DWORD dwInfoOptions ){
    ASSERT(m_rs);
    try{
        m_rs->GetFieldInfo(lpszName,fieldinfo,dwInfoOptions);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}

//-------------------------------------
BOOL CDAODB::Delete(long n){
    ASSERT(m_rs);
    try{
        if(SetPos(n)==FALSE)return FALSE;
        m_rs->Delete();
        m_rs->MoveFirst();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::Delete(void){
    ASSERT(m_rs);
    try{
        m_rs->Delete();
        m_rs->MoveFirst();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
float CDAODB::GetPerPos    (void){
    ASSERT(m_rs);
    float n;
    try{
        MoveLast(); // access last record before this function
        n = m_rs->GetPercentPosition();
    }
    catch(CDaoException* e)        { e->Delete(); return -1;    }
    catch(CMemoryException* e)    { e->Delete(); return -1;    }
    return n;
}
BOOL CDAODB::SetPos        (long lPos){
    ASSERT(m_rs);
    try{
        MoveLast(); // access last record before this function
        m_rs->SetAbsolutePosition(lPos);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
long CDAODB::GetPos(void){
    ASSERT(m_rs);
    long n;
    try{
        MoveLast(); // access last record before this function
        n = m_rs->GetAbsolutePosition();
    }
    catch(CDaoException* e)        { e->Delete(); return -1;    }
    catch(CMemoryException* e)    { e->Delete(); return -1;    }
    return n;
}
long CDAODB::GetCount(void){
    ASSERT(m_rs);
    long n;
    try{
        if(IsEOF()!=TRUE)
            MoveLast(); // access last record before this function
        n = m_rs->GetRecordCount();
    }
    catch(CDaoException* e)        { e->Delete(); return -1;    }
    catch(CMemoryException* e)    { e->Delete(); return -1;    }
    return n;
}

BOOL CDAODB::AddNew(void){
    ASSERT(m_rs);
    try{
        if(m_rs->CanAppend()==FALSE) return FALSE;
        m_rs->AddNew();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::CancelUpdate(void){
    ASSERT(m_rs);
    try{
        m_rs->CancelUpdate();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::Update(void){
    ASSERT(m_rs);
    try{
        if(m_rs->CanUpdate()==FALSE) return FALSE;
            m_rs->Update();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}

BOOL CDAODB::OpenRecord(int nOpenType , int nOptions){
    ASSERT(m_tbl);
    ASSERT(m_rs);
    try{
        m_rs->Open(m_tbl,nOpenType,nOptions);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
BOOL CDAODB::CloseRecord(void){
    ASSERT(m_rs);
    try{
        m_rs->Close();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
//----------------------------------------------------------------------------
BOOL CDAODB::AddNew        (CWnd *lpcWnd){
    int n = 0;
    long j = 0;
    DWORD d1,d2;
    SYSTEMTIME st1,st2;
    GetSystemTime(&st1);
    while( AddNew() != TRUE ){
        while(1){
            d1 = st1.wSecond;
            d1 += st1.wMilliseconds;
            GetSystemTime(&st2);
            d2 = st2.wSecond;
            d2 += st2.wMilliseconds;
            if(d1!=d2)break;
        }st1=st2;
        j++;
        if((j&30)==0){
            if( lpcWnd->MessageBox("現在他のユーザーが書き込みしています\n長時間この状態が続く場合はシステム管理者に連絡してください",
                "書き込みタイムアウト",MB_RETRYCANCEL | MB_ICONEXCLAMATION )==IDCANCEL){
                return FALSE;
            }else{
                j=0;
                GetSystemTime(&st1);
            }
        }
    }
    return TRUE;
}
BOOL CDAODB::Edit        (CWnd *lpcWnd){
    int n = 0;
    long j = 0;
    DWORD d1,d2;
    SYSTEMTIME st1,st2;
    GetSystemTime(&st1);
    while( Edit() != TRUE ){
        while(1){
            d1 = st1.wSecond;
            d1 += st1.wMilliseconds;
            GetSystemTime(&st2);
            d2 = st2.wSecond;
            d2 += st2.wMilliseconds;
            if(d1!=d2)break;
        }st1=st2;
        j++;
        if((j&30)==0){
            if( lpcWnd->MessageBox("現在他のユーザーが書き込みしています\n長時間この状態が続く場合はシステム管理者に連絡してください",
                "書き込みタイムアウト",MB_RETRYCANCEL | MB_ICONEXCLAMATION )==IDCANCEL){
                return FALSE;
            }else{
                j=0;
                GetSystemTime(&st1);
            }
        }
    }
    return TRUE;
}
BOOL CDAODB::Edit(void){
    ASSERT(m_rs);
    try{
        m_rs->Edit();
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
}
//----------------------------------------------------------------------------
COleDateTime CDAODB::GetDateCreated(void){
    if(m_rs ==NULL)return COleDateTime::GetCurrentTime();
    try{
        return ( m_rs->GetDateCreated() );
    }
    catch(CDaoException* e)        { e->Delete(); return COleDateTime::GetCurrentTime();    }
    catch(CMemoryException* e)    { e->Delete(); return COleDateTime::GetCurrentTime();    }
    return COleDateTime::GetCurrentTime();
}
COleDateTime CDAODB::GetDateLastUpdated(void){
    if(m_rs ==NULL)return COleDateTime::GetCurrentTime();
    try{
        return ( m_rs->GetDateLastUpdated() );
    }
    catch(CDaoException* e)        { e->Delete(); COleDateTime::GetCurrentTime();    }
    catch(CMemoryException* e)    { e->Delete(); COleDateTime::GetCurrentTime();    }
    return COleDateTime::GetCurrentTime();
}

//----------------------------------------------------------------------------
CString        CDAODB::GetVersion(void){
    if(m_cdao==NULL)return CString("NULL");
    return(m_cdao->GetVersion());
};
BOOL CDAODB::Create(LPCSTR filename, LPCTSTR lpszLocale , int dwOptions ){
    try{
        if(m_rs!=NULL){
            m_rs->Close(); delete m_rs; m_rs=NULL;
        }
        if(m_tbl!=NULL){
            m_tbl->Close(); delete m_tbl; m_tbl=NULL;
        }
        if(m_cdao!=NULL){
            m_cdao->Close(); delete m_cdao; m_cdao = NULL;
        }
        m_cdao = new CDaoDatabase(m_ws);
        m_cdao->Create(filename,lpszLocale,dwOptions);
        m_tbl = new CDaoTableDef(m_cdao);
        m_rs = new CDaoRecordset(m_cdao);
    }
    catch(CDaoException* e)        { e->Delete(); return FALSE;    }
    catch(CMemoryException* e)    { e->Delete(); return FALSE;    }
    return TRUE;
};
BOOL CDAODB::ReOpen    ( BOOL bExclusive , BOOL bReadOnly, LPCTSTR lpszConnect){
    Close();
    return(Open(szOrgFileName,bExclusive,bReadOnly,lpszConnect));
};
void CDAODB::SetOpenPassword(LPCTSTR lpszPassword){
    strcpy(szPassword,lpszPassword);
}

BOOL CDAODB::Open( LPCTSTR lpszName, LPCTSTR lpszConnect ,BOOL bExclusive , BOOL bReadOnly){
    return Open(lpszName,bExclusive,bReadOnly,lpszConnect);
}

BOOL CDAODB::Open( LPCTSTR lpszName, BOOL bExclusive, BOOL bReadOnly , LPCTSTR lpszConnect ){
    try{
        if(m_rs!=NULL){
            m_rs->Close(); delete m_rs; m_rs=NULL;
        }
        if(m_tbl!=NULL){
            m_tbl->Close(); delete m_tbl; m_tbl=NULL;
        }
        if(m_cdao!=NULL){
            m_cdao->Close(); delete m_cdao; m_cdao = NULL;
        }
        m_cdao = new CDaoDatabase(m_ws);
        strcpy(szOrgFileName,lpszName);

        if( strlen(szPassword)!=0 ){
            char buf[_MAX_PATH];
            wsprintf(buf,";PWD=%s",szPassword);
            m_cdao->Open(lpszName,bExclusive,bReadOnly,_T(buf) );
        }
        else m_cdao->Open(lpszName,bExclusive,bReadOnly,lpszConnect);
        m_tbl = new CDaoTableDef(m_cdao);
        m_rs = new CDaoRecordset(m_cdao);
    }
    catch(CDaoException* e)        {
        char errmes[256];
        e->GetErrorMessage(errmes,256);
//        MessageBox(NULL,errmes,"CDaoException Error",MB_OK);
        e->Delete(); return FALSE;     }
    catch(CMemoryException* e)    {
        char errmes[256];
        e->GetErrorMessage(errmes,256);
//        MessageBox(NULL,errmes,"CDaoException Error",MB_OK);

        e->Delete(); return FALSE;     }
    return TRUE;
};
//--------------------------------------
long CDAODB::Search(int        nFieldIndex ,LPCSTR szData){
    BOOL b,b_tbl,b_rs;
    long i,nCount;
    char *p;

    b_rs = b_tbl = FALSE;
    if(m_tbl == NULL){
        b_tbl = TRUE;
        if((b=OpenTable("Default"))==FALSE){ return -1;}
    }
    if(m_rs == NULL){
        b_rs = TRUE;
        if((b= OpenRecord())!=TRUE){Close(); return -1;}
    }
    nCount = GetCount(); // get records
    SetPos(0);
    for(i=0;i<nCount;i++,MoveNext()){
        p=GetStr(nFieldIndex);
        if(p==NULL)continue;
        if(strcmp(p,szData)==0)break;
    }
    if(i==nCount)i=-1;
    if(b_rs == TRUE) b = CloseRecord();
    if(b_tbl == TRUE) CloseTable();
    return i;
}

long CDAODB::Search(LPCSTR    szFieldIndex,LPCSTR szData){
    BOOL b,b_tbl,b_rs;
    long i,nCount;
    char *p;

    b_rs = b_tbl = FALSE;
    if(m_tbl == NULL){
        b_tbl = TRUE;
        if((b=OpenTable("Default"))==FALSE){ return -1;}
    }
    if(m_rs == NULL){
        b_rs = TRUE;
        if((b= OpenRecord())!=TRUE){Close(); return -1;}
    }
    nCount = GetCount(); // get records
    SetPos(0);
    for(i=0;i<nCount;i++,MoveNext()){
        p=GetStr(szFieldIndex);
        if(p==NULL)continue;
        if(strcmp(szData,p)==0)break;
    }
    if(i==nCount)i=-1;
    if(b_rs == TRUE) b = CloseRecord();
    if(b_tbl == TRUE) CloseTable();
    return i;
}
long CDAODB::Search(int nFieldIndex,int nFieldIndex2,LPCSTR szData,LPCSTR szData2){
    BOOL b,b_tbl,b_rs;
    long i,nCount;
    char *p;

    b_rs = b_tbl = FALSE;
    if(m_tbl == NULL){
        b_tbl = TRUE;
        if((b=OpenTable("Default"))==FALSE){ return -1;}
    }
    if(m_rs == NULL){
        b_rs = TRUE;
        if((b= OpenRecord())!=TRUE){Close(); return -1;}
    }
    nCount = GetCount(); // get records
    SetPos(0);
    for(i=0;i<nCount;i++,MoveNext()){
        p=GetStr(nFieldIndex);
        if(p==NULL)continue;
        if(strcmp(p,szData)==0)
        {
            p=GetStr(nFieldIndex2);
            if(p==NULL){
                if(strlen(szData2)==0) break;
                continue;
            }
            if(strcmp(p,szData2)==0)break;
        }
    }
    if(i==nCount)i=-1;
    if(b_rs == TRUE) b = CloseRecord();
    if(b_tbl == TRUE) CloseTable();
    return i;
}
long CDAODB::Search(LPCSTR    szFieldIndex,LPCSTR     szFieldIndex2,LPCSTR szData,LPCSTR szData2){
    BOOL b,b_tbl,b_rs;
    long i,nCount;
    char *p;

    b_rs = b_tbl = FALSE;
    if(m_tbl == NULL){
        b_tbl = TRUE;
        if((b=OpenTable("Default"))==FALSE){ return -1;}
    }
    if(m_rs == NULL){
        b_rs = TRUE;
        if((b= OpenRecord())!=TRUE){Close(); return -1;}
    }
    nCount = GetCount(); // get records
    SetPos(0);
    for(i=0;i<nCount;i++,MoveNext()){
        p=GetStr(szFieldIndex);
        if(p==NULL)continue;
        if(strcmp(p,szData)==0)
        {
            p=GetStr(szFieldIndex2);
            if(p==NULL){
                if(strlen(szData2)==0) break;
                continue;
            }
            if(strcmp(p,szData2)==0)break;
        }
    }
    if(i==nCount)i=-1;
    if(b_rs == TRUE) b = CloseRecord();
    if(b_tbl == TRUE) CloseTable();
    return i;
}
//--------------------------------------
long CDAODB::SearchI(int        nFieldIndex ,LPCSTR szData){
    BOOL b,b_tbl,b_rs;
    long i,nCount;
    char *p;

    b_rs = b_tbl = FALSE;
    if(m_tbl == NULL){
        b_tbl = TRUE;
        if((b=OpenTable("Default"))==FALSE){ return -1;}
    }
    if(m_rs == NULL){
        b_rs = TRUE;
        if((b= OpenRecord())!=TRUE){Close(); return -1;}
    }
    nCount = GetCount(); // get records
    SetPos(0);
    for(i=0;i<nCount;i++,MoveNext()){
        p=GetStr(nFieldIndex);
        if(p==NULL)continue;
        if(strcmpi(p,szData)==0)break;
    }
    if(i==nCount)i=-1;
    if(b_rs == TRUE) b = CloseRecord();
    if(b_tbl == TRUE) CloseTable();
    return i;
}

long CDAODB::SearchI(LPCSTR    szFieldIndex,LPCSTR szData){
    BOOL b,b_tbl,b_rs;
    long i,nCount;
    char *p;

    b_rs = b_tbl = FALSE;
    if(m_tbl == NULL){
        b_tbl = TRUE;
        if((b=OpenTable("Default"))==FALSE){ return -1;}
    }
    if(m_rs == NULL){
        b_rs = TRUE;
        if((b= OpenRecord())!=TRUE){Close(); return -1;}
    }
    nCount = GetCount(); // get records
    SetPos(0);
    for(i=0;i<nCount;i++,MoveNext()){
        p=GetStr(szFieldIndex);
        if(p==NULL)continue;
        if(strcmpi(p,szData)==0)break;
    }
    if(i==nCount)i=-1;
    if(b_rs == TRUE) b = CloseRecord();
    if(b_tbl == TRUE) CloseTable();
    return i;
}
long CDAODB::SearchI(int nFieldIndex,int nFieldIndex2,LPCSTR szData,LPCSTR szData2){
    BOOL b,b_tbl,b_rs;
    long i,nCount;
    char *p;

    b_rs = b_tbl = FALSE;
    if(m_tbl == NULL){
        b_tbl = TRUE;
        if((b=OpenTable("Default"))==FALSE){ return -1;}
    }
    if(m_rs == NULL){
        b_rs = TRUE;
        if((b= OpenRecord())!=TRUE){Close(); return -1;}
    }
    nCount = GetCount(); // get records
    SetPos(0);
    for(i=0;i<nCount;i++,MoveNext()){
        p=GetStr(nFieldIndex);
        if(p==NULL)continue;
        if(strcmpi(p,szData)==0)
        {
            p=GetStr(nFieldIndex2);
            if(p==NULL){
                if(strlen(szData2)==0) break;
                continue;
            }
            if(strcmpi(p,szData2)==0)break;
        }
    }
    if(i==nCount)i=-1;
    if(b_rs == TRUE) b = CloseRecord();
    if(b_tbl == TRUE) CloseTable();
    return i;
}
long CDAODB::SearchI(LPCSTR    szFieldIndex,LPCSTR     szFieldIndex2,LPCSTR szData,LPCSTR szData2){
    BOOL b,b_tbl,b_rs;
    long i,nCount;
    char *p;

    b_rs = b_tbl = FALSE;
    if(m_tbl == NULL){
        b_tbl = TRUE;
        if((b=OpenTable("Default"))==FALSE){ return -1;}
    }
    if(m_rs == NULL){
        b_rs = TRUE;
        if((b= OpenRecord())!=TRUE){Close(); return -1;}
    }
    nCount = GetCount(); // get records
    SetPos(0);
    for(i=0;i<nCount;i++,MoveNext()){
        p=GetStr(szFieldIndex);
        if(p==NULL)continue;
        if(strcmpi(p,szData)==0)
        {
            p=GetStr(szFieldIndex2);
            if(p==NULL){
                if(strlen(szData2)==0) break;
                continue;
            }
            if(strcmpi(p,szData2)==0)break;
        }
    }
    if(i==nCount)i=-1;
    if(b_rs == TRUE) b = CloseRecord();
    if(b_tbl == TRUE) CloseTable();
    return i;
}
//--------------------------------------------
long CDAODB::GetCurrentRecords(void){
    BOOL b;
    long nCount;
    if((b=OpenTable("Default"))==FALSE){ return -1;}
    b = OpenRecord();
    if(b!=TRUE){Close(); return -1;}
    nCount = GetCount(); // get records
    b = CloseRecord();
    CloseTable();
    return nCount;
}
//--------------------------------------
// 指定フィールドの値がＮＵＬＬならば指定データで初期化する
BOOL CDAODB::CkUpdateField(LPSTR szFieldName,COleVariant c){
    BOOL b;
    long i,nCount;

    CDaoTableDefInfo tabledefinfo;
    if((b= OpenTable("Default"))==FALSE){ return -1;}
    if((b= OpenRecord())!=TRUE){Close(); return -1;}
    nCount = GetCount(); // get records
    for(i=0;i<nCount;i++){
        COleVariant cd;
        b=SetPos(i);
        b=Get(szFieldName,cd);
        if(LPVARIANT(cd)->byref==NULL){
            b=Edit();
            b=Set(szFieldName,c);
            b=Update();
        }
    }
    if(i==nCount)i=-1;
    b = CloseRecord();
    CloseTable();
    return TRUE;
}

//--------------------------------------
// CommonDlg32 file open (load/save)
LPSTR CDAODB::File2Load( CWnd *lpcWnd ){
    return(File2Load(lpcWnd->m_hWnd));
}

LPSTR CDAODB::File2Save( CWnd *lpcWnd ){
    return(File2Save(lpcWnd->m_hWnd));
}
LPSTR CDAODB::File2Load( HWND hWnd )
{
static TCHAR strInitialDir[512] = "";
static TCHAR strPath[512];
static TCHAR strFileName[512];
TCHAR strCurrentName[512] = "*.mdb";
OPENFILENAME ofn = { sizeof(OPENFILENAME), hWnd, NULL, "MS Access\0.mdb", NULL,
0, 1, strCurrentName, 512, strFileName, 512, NULL,
"Open mdb File", OFN_FILEMUSTEXIST, 0, 1, ".mdb", 0,
NULL, NULL };
    ofn.lpstrInitialDir =strInitialDir;
// Display the OpenFileName dialog. Then, try to load the specified file
if( TRUE == GetOpenFileName( &ofn ) ) { //return strFileName;
        strcpy(strFileName,ofn.lpstrFile);return strFileName; }
return NULL;
}
LPSTR CDAODB::File2Save( HWND hWnd )
{
static TCHAR strInitialDir[512] = "";
static TCHAR strPath[512];
static TCHAR strFileName[512];
TCHAR strCurrentName[512] = "*.mdb";
OPENFILENAME ofn = { sizeof(OPENFILENAME), hWnd, NULL, "MS Access\0.mdb", NULL,
0, 1, strCurrentName, 512, strFileName, 512, NULL,
"Open mdb File", OFN_FILEMUSTEXIST, 0, 1, ".mdb", 0,
NULL, NULL };
    ofn.lpstrInitialDir =strInitialDir;
if( TRUE == GetSaveFileName( &ofn ) ) {//return strFileName;
        strcpy(strFileName,ofn.lpstrFile);return strFileName; }
return NULL;
}
//--------------------------------------
void CDAODB::CreateWorkspace(void){
    m_ws = new CDaoWorkspace();
}
BOOL CDAODB::CreateWS( LPCTSTR lpszName, LPCTSTR lpszUserName , LPCTSTR lpszPassword ){
    if(m_ws==NULL) m_ws = new CDaoWorkspace();
    try{
        m_ws->Create(lpszName,lpszUserName ,lpszPassword);
    }
    catch(CDaoException* e)        {
        char errmes[256];
        e->GetErrorMessage(errmes,256);
        MessageBox(NULL,errmes,"CDaoException Error",MB_OK);
        e->Delete(); return FALSE;     }
    catch(CMemoryException* e)    {
        char errmes[256];
        e->GetErrorMessage(errmes,256);
        MessageBox(NULL,errmes,"CDaoMemoryException Error",MB_OK);
        e->Delete(); return FALSE;    
    }
    return TRUE;
};
BOOL CDAODB::OpenWS(LPCTSTR szName){
    if(m_ws==NULL) m_ws = new CDaoWorkspace();
    try{
        m_ws->Open(szName);
    }
    catch(CDaoException* e)        {
        char errmes[256];
        e->GetErrorMessage(errmes,256);
        MessageBox(NULL,errmes,"CDaoException Error",MB_OK);
        e->Delete(); return FALSE;     }
    catch(CMemoryException* e)    {
        char errmes[256];
        e->GetErrorMessage(errmes,256);
        MessageBox(NULL,errmes,"CDaoMemoryException Error",MB_OK);
        e->Delete(); return FALSE;    
    }
    return TRUE;
};
void CDAODB::CloseWS(void){
    if(m_ws==NULL) return;
    m_ws->Close();
    delete(m_ws);
    m_ws=NULL;
};

BOOL CDAODB::SetDefaultPassword( long dwPassword){
    char buf[128];
    wsprintf(buf,"%ld",dwPassword );
    return SetDefaultPassword( buf );
}
BOOL CDAODB::SetDefaultPassword( LPCTSTR lpszPassword){
    ASSERT(m_ws);
    try{
        m_ws->SetDefaultPassword(lpszPassword);
    }
    catch(CDaoException* e)        {
        char errmes[256];
        e->GetErrorMessage(errmes,256);
        MessageBox(NULL,errmes,"CDaoException Error",MB_OK);
        e->Delete(); return FALSE;     }
    catch(CMemoryException* e)    {
        char errmes[256];
        e->GetErrorMessage(errmes,256);
        MessageBox(NULL,errmes,"CDaoMemoryException Error",MB_OK);
        e->Delete(); return FALSE;    
    }
    return TRUE;
};
// EOF
//--------------------------------------

Copyright (C) Kitaro 1998