TN054: chamando DAO diretamente usando classes DAO MFC

Ao usar as classes de banco de dados MFC DAO, pode haver situações em que é necessário usar o DAO diretamente. Normalmente, esse não será o caso, mas o MFC forneceu alguns mecanismos auxiliares para facilitar a simplificação das chamadas DAO diretas ao combinar o uso das classes MFC com chamadas DEO diretas. Fazer chamadas diretas de DAO para os métodos de um objeto DAO gerenciado por MFC deve exigir apenas algumas linhas de código. Se você precisar criar e usar objetos DAO que não são gerenciados pelo MFC, será necessário trabalhar um pouco mais para chamar Release no objeto. Esta nota técnica explica quando você pode querer chamar o DAO diretamente, o que os auxiliares do MFC podem fazer para ajudá-lo e como usar as interfaces OLE do DAO. Por fim, esta nota fornece algumas funções de exemplo mostrando como chamar o DAO diretamente para recursos de segurança do DAO.

Quando fazer chamadas diretas de DAO

As situações mais comuns para fazer chamadas diretas de DAO ocorrem quando as coleções precisam ser atualizadas ou quando você está implementando recursos não encapsulados pelo MFC. O recurso mais significativo não exposto pelo MFC é a segurança. Se você quiser implementar recursos de segurança, precisará usar diretamente os objetos Usuários e Grupos do DAO. Além da segurança, há apenas alguns outros recursos de DAO sem suporte do MFC. Isso inclui a clonagem de conjunto de registros e os recursos de replicação de banco de dados, bem como algumas adições tardias ao DAO.

Uma breve visão geral da implementação do DAO e do MFC

O encapsulamento de DAO do MFC facilita o uso do DAO manipulando muitos dos detalhes para que você não precise se preocupar com pequenas coisas. Isso inclui a inicialização do OLE, a criação e o gerenciamento dos objetos DAO (especialmente os objetos da coleção), a verificação de erros e o fornecimento de uma interface fortemente tipada e mais simples (sem VARIANT ou BSTR argumentos). Você pode fazer chamadas diretas de DAO e ainda aproveitar esses recursos. Tudo o que o seu código deve fazer é chamar Release para qualquer objeto criado por chamadas diretas de DAO e não modificar nenhum dos ponteiros de interface dos quais o MFC pode depender internamente. Por exemplo, não modifique o membro m_pDAORecordset de um objeto aberto CDaoRecordset , a menos que você entenda todas as ramificações internas. No entanto, você pode usar a interface m_pDAORecordset para chamar o DAO diretamente para obter a coleção Fields. Nesse caso, o membro m_pDAORecordset não seria modificado. Você simplesmente precisa chamar Release no objeto de coleção Fields quando terminar de usar o objeto.

Descrição dos auxiliares para facilitar as chamadas de DAO

Os auxiliares fornecidos para facilitar a chamada de DAO são os mesmos auxiliares usados internamente nas classes de Banco de Dados DAO do MFC. Esses auxiliares são usados para verificar os códigos de retorno ao fazer uma chamada de DAO direta, registrar a saída de depuração em log, verificar se há erros esperados e lançar exceções apropriadas, se necessário. Há duas funções auxiliares subjacentes e quatro macros que são mapeadas para um desses dois auxiliares. A melhor explicação seria simplesmente ler o código. Consulte DAO_CHECK, DAO_CHECK_ERROR, DAO_CHECK_MEM e DAO_TRACE em AFXDAO.H para ver as macros, e consulte AfxDaoCheck e AfxDaoTrace em DAOCORE.CPP.

Usando as interfaces OLE do DAO

As interfaces OLE para cada objeto na hierarquia de objetos DAO são definidas no arquivo de cabeçalho DBDAOINT. H, que é encontrado no diretório \Program Files\Microsoft Visual Studio .NET 2003\VC7\include. Essas interfaces fornecem métodos que permitem manipular toda a hierarquia da DAO.

Para muitos dos métodos nas interfaces DAO, você precisará manipular um BSTR objeto (uma cadeia de caracteres com prefixo de comprimento usada na automação OLE). O BSTR objeto normalmente é encapsulado dentro do tipo de dados VARIANT . A própria classe COleVariant MFC herda do tipo de dados VARIANT . Dependendo se você criar seu projeto para ANSI ou Unicode, as interfaces DAO retornarão BSTRs ANSI ou Unicode. Duas macros, V_BSTR e V_BSTRT, são úteis para assegurar que a interface DAO obtenha o BSTR tipo esperado.

V_BSTR extrairá o membro bstrVal de um COleVariant. Essa macro normalmente é usada quando você precisa passar o conteúdo de um COleVariant para um método de uma interface DAO. O fragmento de código a seguir mostra as declarações e o uso real para dois métodos da interface DAOUser que aproveitam a macro V_BSTR:

COleVariant varOldName;
COleVariant varNewName(_T("NewUser"), VT_BSTRT);

// Code to assign pUser to a valid value omitted DAOUser *pUser = NULL;

// These method declarations were taken from DBDAOINT.H
// STDMETHOD(get_Name) (THIS_ BSTR FAR* pbstr) PURE;
// STDMETHOD(put_Name) (THIS_ BSTR bstr) PURE;
DAO_CHECK(pUser->get_Name(&V_BSTR (&varOldName)));
DAO_CHECK(pUser->put_Name(V_BSTR (&varNewName)));

Observe que o VT_BSTRT argumento especificado no COleVariant construtor acima garante que haverá um ANSI BSTR no COleVariant caso de você criar uma versão ANSI do seu aplicativo e um Unicode BSTR para uma versão Unicode do seu aplicativo. Isso é o que o DAO espera.

A outra macro, V_BSTRT, extrairá um membro bstrVal ANSI ou Unicode de COleVariant, dependendo do tipo de build (ANSI ou Unicode). O código a seguir demonstra como extrair o valor do BSTR de um COleVariant num CString:

COleVariant varName(_T("MyName"), VT_BSTRT);
CString str = V_BSTRT(&varName);

A macro V_BSTRT, juntamente com outras técnicas para abrir outros tipos armazenados COleVariant, é demonstrada no exemplo DAOVIEW. Especificamente, essa tradução é executada no CCrack::strVARIANT método. Esse método, sempre que possível, converte o valor de COleVariant em uma instância de CString.

Exemplo simples de uma chamada direta para DAO

Situações podem surgir quando for necessário atualizar os objetos de coleção DAO subjacentes. Normalmente, isso não deve ser necessário, mas é um procedimento simples, se necessário. Um exemplo de quando uma coleção pode precisar ser atualizada é ao operar em um ambiente multiusuário com vários usuários criando novos tabledefs. Nesse caso, sua coleção tabledefs pode ficar obsoleta. Para atualizar a coleção, basta chamar o Refresh método do objeto de coleção específico e verificar se há erros:

DAO_CHECK(pMyDaoDatabase->m_pDAOTableDefs->Refresh());

Observe que atualmente todas as interfaces de objeto da coleção DAO são detalhes de implementação não documentados das classes de banco de dados MFC DAO.

Usar o DAO diretamente para recursos de segurança do DAO

As classes de banco de dados MFC DAO não encapsulam os recursos de segurança do DAO. Para usar alguns recursos de segurança do DAO, você deve chamar métodos das interfaces DAO. A função a seguir define o banco de dados do sistema e altera a senha do usuário. Essa função chama três outras funções, que são definidas posteriormente.

void ChangeUserPassword()
{
    // Specify path to the Microsoft Access *// system database
    CString strSystemDB =
        _T("c:\\Program Files\\MSOffice\\access\\System.mdw");

    // Set system database before MFC initilizes DAO
    // NOTE: An MFC module uses only one instance
    // of a DAO database engine object. If you have
    // called a DAO object in your application prior
    // to calling the function below, you must call
    // AfxDaoTerm to destroy the existing database
    // engine object. Otherwise, the database engine
    // object already in use will be reused, and setting
    // a system datbase will have no effect.
    //
    // If you have used a DAO object prior to calling
    // this function it is important that DAO be
    // terminated with AfxDaoTerm since an MFC
    // module only gets one copy of the database engine
    // and that engine will be reused if it hasn't been
    // terminated. In other words, if you do not call
    // AfxDaoTerm and there is currently a database
    // initialized, setting the system database will
    // have no effect.
    SetSystemDB(strSystemDB);

    // User name and password manually added
    // by using Microsoft Access
    CString strUserName = _T("NewUser");
    CString strOldPassword = _T("Password");
    CString strNewPassword = _T("NewPassword");

    // Set default user so that MFC will be able
    // to log in by default using the user name and
    // password from the system database
    SetDefaultUser(strUserName, strOldPassword);

    // Change the password. You should be able to
    // call this function from anywhere in your
    // MFC application
    ChangePassword(strUserName, strOldPassword, strNewPassword);

    // ...
}

Os próximos quatro exemplos demonstram como:

• Definir o banco de dados DAO do sistema (arquivo .MDW).

• Defina o usuário e a senha padrão.

• Altere a senha de um usuário.

• Alterar a senha de um arquivo .MDB.

Definindo o Banco de Dados do Sistema

Veja abaixo uma função de exemplo para definir o banco de dados do sistema que será usado por um aplicativo. Essa função deve ser chamada antes que outras chamadas da DAO sejam feitas.

// Set the system database that the
// DAO database engine will use

void SetSystemDB(CString& strSystemMDB)
{
    COleVariant varSystemDB(strSystemMDB, VT_BSTRT);

    // Initialize DAO for MFC
    AfxDaoInit();
    DAODBEngine* pDBEngine = AfxDaoGetEngine();

    ASSERT(pDBEngine != NULL);

    // Call put_SystemDB method to set the *// system database for DAO engine
    DAO_CHECK(pDBEngine->put_SystemDB(varSystemDB.bstrVal));
}

Definindo o usuário e a senha padrão

Para definir o usuário e a senha padrão para um banco de dados do sistema, use a seguinte função:

void SetDefaultUser(CString& strUserName,
    CString& strPassword)
{
    COleVariant varUserName(strUserName, VT_BSTRT);
    COleVariant varPassword(strPassword, VT_BSTRT);

    DAODBEngine* pDBEngine = AfxDaoGetEngine();
    ASSERT(pDBEngine != NULL);

    // Set default user:
    DAO_CHECK(pDBEngine->put_DefaultUser(varUserName.bstrVal));

    // Set default password:
    DAO_CHECK(pDBEngine->put_DefaultPassword(varPassword.bstrVal));
}

Alterando a senha de um usuário

Para alterar a senha de um usuário, use a seguinte função:

void ChangePassword(CString &strUserName,
    CString &strOldPassword,
    CString &strNewPassword)
{
    // Create (open) a workspace
    CDaoWorkspace wsp;
    CString strWspName = _T("Temp Workspace");

    wsp.Create(strWspName, strUserName, strOldPassword);
    wsp.Append();

    // Determine how many objects there are *// in the Users collection
    short nUserCount;
    short nCurrentUser;
    DAOUser *pUser = NULL;
    DAOUsers *pUsers = NULL;

    // Side-effect is implicit OLE AddRef()
    // on DAOUser object:
    DAO_CHECK(wsp.m_pDAOWorkspace->get_Users(&pUsers));

    // Side-effect is implicit OLE AddRef()
    // on DAOUsers object
    DAO_CHECK(pUsers->getcount(&nUserCount));

    // Traverse through the list of users
    // and change password for the userid
    // used to create/open the workspace
    for(nCurrentUser = 0; nCurrentUser <nUserCount; nCurrentUser++)
    {
        COleVariant varIndex(nCurrentUser, VT_I2);
        COleVariant varName;

        // Retrieve information for user nCurrentUser
        DAO_CHECK(pUsers->get_Item(varIndex, &pUser));

        // Retrieve name for user nCurrentUser
        DAO_CHECK(pUser->get_Name(&V_BSTR(&varName)));

        CString strTemp = V_BSTRT(&varName);

        // If there is a match, change the password
        if (strTemp == strUserName)
        {
            COleVariant varOldPwd(strOldPassword, VT_BSTRT);
            COleVariant varNewPwd(strNewPassword, VT_BSTRT);

            DAO_CHECK(pUser->NewPassword(V_BSTR(&varOldPwd),
                V_BSTR(&varNewPwd)));

            TRACE("\t Password is changed\n");
        }
    }
    // Clean up: decrement the usage count
    // on the OLE objects
    pUser->Release();
    pUsers->Release();
    wsp.Close();
}

Alterando a senha de um arquivo .MDB

Para alterar a senha de um . Arquivo MDB, use a seguinte função:

void SetDBPassword(LPCTSTR pDB,
    LPCTSTR pszOldPassword,
    LPCTSTR pszNewPassword)
{
    CDaoDatabase db;
    CString strConnect(_T(";pwd="));

    // the database must be opened as exclusive
    // to set a password
    db.Open(pDB, TRUE, FALSE, strConnect + pszOldPassword);

    COleVariant NewPassword(pszNewPassword, VT_BSTRT),
                OldPassword(pszOldPassword, VT_BSTRT);

    DAO_CHECK(db.m_pDAODatabase->NewPassword(V_BSTR(&OldPassword),
        V_BSTR(&NewPassword)));

    db.Close();
}

Consulte também

Notas técnicas por número
Notas técnicas por categoria