#pragma once
#include "msjetodb.h"
class CJetDataConnection : public CDataConnection
{
    HRESULT OpenExistingFile(LPCTSTR strFilePath, LPCTSTR strPassword, bool bExclusively = false)
    {
        USES_CONVERSION;

        HRESULT result;
        
        CDBPropSet dbinit[2];
        dbinit[0].SetGUID(DBPROPSET_DBINIT);
        dbinit[0].AddProperty( DBPROP_INIT_DATASOURCE, 
                               T2BSTR(strFilePath));
        
        if (bExclusively)
        {
            dbinit[0].AddProperty( DBPROP_INIT_MODE, 
                                   (long)DB_MODE_SHARE_EXCLUSIVE);
        }
        
        dbinit[1].SetGUID(DBPROPSET_JETOLEDB_DBINIT);
        dbinit[1].AddProperty( DBPROP_JETOLEDB_DATABASEPASSWORD, T2BSTR(strPassword));
        dbinit[1].AddProperty( DBPROP_JETOLEDB_ENCRYPTDATABASE, true);
        dbinit[1].AddProperty( DBPROP_JETOLEDB_ENGINE, (long)JETDBENGINETYPE_JET4X);
        
        result = m_source.Open(_T("Microsoft.Jet.OLEDB.4.0"), dbinit, 2);

        return result;
    }
    //
    ///////////////////////////////////////////////////////////////////////////
    //
    HRESULT OpenNewFile(LPCTSTR strFilePath, LPCTSTR strPassword, bool bExclusively = true)
    {
        USES_CONVERSION;
        CComPtr<IDBInitialize>      DbInit;
        CComPtr<IDBDataSourceAdmin> DbAdmin;

        HRESULT  result;
        CLSID    clsid;
        LPWSTR   szProgID = L"Microsoft.Jet.OLEDB.4.0";

        result = CLSIDFromProgID(szProgID, &clsid);    
        
        if (FAILED(result)) 
        {
            return result;
        }
        
        result = CoCreateInstance( clsid, 
                                   NULL, 
                                   CLSCTX_INPROC_SERVER, 
                                   __uuidof(IDBInitialize),
                                   (void**)&DbInit);
        if (FAILED(result)) 
        {
            return result;
        }
        result = DbInit->QueryInterface( IID_IDBDataSourceAdmin,
                                         (void**)&DbAdmin );
        if (FAILED(result)) 
        {
            return result;
        }
        CDBPropSet dbinit[2];
        dbinit[0].SetGUID(DBPROPSET_DBINIT);
        dbinit[0].AddProperty(DBPROP_INIT_DATASOURCE, T2BSTR(strFilePath));

        if (bExclusively)
        {
            dbinit[0].AddProperty( DBPROP_INIT_MODE, (long)DB_MODE_SHARE_EXCLUSIVE);
        }

        dbinit[1].SetGUID(DBPROPSET_JETOLEDB_DBINIT);
        dbinit[1].AddProperty( DBPROP_JETOLEDB_DATABASEPASSWORD, T2BSTR(strPassword));
        dbinit[1].AddProperty( DBPROP_JETOLEDB_ENCRYPTDATABASE, true);
        dbinit[1].AddProperty( DBPROP_JETOLEDB_ENGINE, (long)JETDBENGINETYPE_JET4X);
        

        result = DbAdmin->CreateDataSource(2, dbinit, NULL, IID_NULL, NULL);
        if (SUCCEEDED(result)) 
        {
            DbAdmin.Release();
            DbInit.Release();

            result = m_source.Open(clsid, dbinit, 2);
        }
        DbAdmin.Release();
        DbInit.Release();
        return result;
    }
};

//-----------------------------------------------------------------------------
#import "C:/Program Files/Common Files/System/ADO/msadox.dll" 
#import "C:/Program Files/Common Files/System/ADO/msado15.dll"
//-----------------------------------------------------------------------------
#include "windows.h"
#include <iostream>
//-----------------------------------------------------------------------------
const char     bd_name[] = "test.mdb"; 
const unsigned max_path  = 1000;
//-----------------------------------------------------------------------------
struct tagInitCom
{
    tagInitCom() { ::CoInitialize( NULL ); }
   ~tagInitCom() {    ::CoUninitialize(); }
} InitCom;
//-----------------------------------------------------------------------------
_bstr_t GetDBFileName()
{
    char buf[max_path];
    
    unsigned int size = GetModuleFileName(NULL, buf, max_path);

    while (buf[size--] != '\\');
    
    buf[size + 2] = 0;
    
    lstrcat(buf, bd_name);
    
    return _bstr_t(buf);
}
//-----------------------------------------------------------------------------
int main(int argc, char* argv[])
{
    ADOX::_CatalogPtr       pCatalog    = NULL;
    ADODB::_ConnectionPtr    pConnection = NULL;

    _bstr_t     command_str    = "CREATE TABLE MyCustomers (ID integer PRIMARY KEY, NAME integer)";
    _bstr_t        connection_str = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=";
    
    connection_str += GetDBFileName();

    try {

// Create Database        

        pCatalog.CreateInstance(__uuidof (ADOX::Catalog));

        pCatalog->Create( connection_str );    

// Create Table
        pConnection = pCatalog->GetActiveConnection();

        pConnection->Execute( command_str, NULL, -1 );

    }
    catch(_com_error *e)
    {
        std::cerr << e->ErrorMessage() << std::endl;
    }
    catch(...)
    {
        std::cerr << "Error" << std::endl;
    }

    return 0;
}

// BeginCreateDatabaseCpp
#import "msado15.dll"
#import "msadox.dll" no_namespace

#define TESTHR(x) if FAILED(x) _com_issue_error(x);

#include "iostream.h"
#include "stdio.h"
#include "conio.h"

//Function declarations
void CreateDatabaseX(void);

//------------------------------------------------------------//
//Main Function                                    
//Purpose:  Test Driver
//------------------------------------------------------------//
void main()
{
    HRESULT hr = S_OK;

    hr = ::CoInitialize(NULL);
    if(SUCCEEDED(hr))
    {
        CreateDatabaseX();

        //Wait here for the user to see the output
        printf("Press any key to continue...");
        getch();
        
        ::CoUninitialize();
    }
}

//------------------------------------------------------------//
//CreateDatabaseX                                
//Purpose:  create a new Jet database with the Create method
//------------------------------------------------------------//
void CreateDatabaseX()
{    
    HRESULT hr = S_OK;

    // Define ADOX object pointers.
    // Initialize pointers on define.
    // These are in the ADOX::  namespace.
    
    _CatalogPtr m_pCatalog = NULL;

    
    //Set ActiveConnection of Catalog to this string
    _bstr_t strcnn("Provider='Microsoft.JET.OLEDB.4.0';"
                "Data source = c:\\new.mdb");
    try
    {
        TESTHR(hr = m_pCatalog.CreateInstance(__uuidof (Catalog)));
        m_pCatalog->Create(strcnn);
        printf("Database 'c:\\new.mdb' is created.\n");
    }
    catch(_com_error &e)
    {
        // Notify the user of errors if any.
        _bstr_t bstrSource(e.Source());
        _bstr_t bstrDescription(e.Description());
          
        printf("\n\tSource :  %s \n\tdescription : %s \n ",
            (LPCSTR)bstrSource,(LPCSTR)bstrDescription);

    }
    catch(...)
    {
        cout << "Error occured in CreateDatabaseX...."<< endl;
    }

}
// EndCreateDatabaseCpp