O conjunto de registros: Vinculando dinamicamente a colunas de dados (ODBC)

Este tópico se aplica às classes MFC ODBC.

Colunas da tabela de ligação que você especificar em tempo de design de gerenciar conjuntos de registros, mas há casos, quando desejar vincular as colunas que foram desconhecidas para você em tempo de design. Este tópico explica:

• Quando você talvez queira vincular colunas dinamicamente a um conjunto de registros.

• Como ligar colunas dinamicamente em tempo de execução.

Observação
Este tópico se aplica aos objetos derivados de CRecordset no qual linha em massa buscando não foi implementada. As técnicas descritas geralmente não são recomendadas se você estiver usando a busca de linha em massa. Para obter mais informações sobre a busca de linha em massa, consulte Recordset: Buscar registros em massa (ODBC).

Quando você pode vincular dinamicamente colunas

Em tempo de design, o Assistente de aplicativo do MFC ou Assistente de consumidor ODBC MFC (de Add Class) cria classes de conjunto de registros com base na conhecidos de tabelas e colunas na fonte de dados. Bancos de dados podem alterar entre quando você cria-las e posterior, quando o aplicativo usa essas tabelas e colunas em tempo de execução. Você ou outro usuário pode adicionar ou soltar uma tabela ou adicionar ou soltar colunas de uma tabela que depende do conjunto de registros do aplicativo. Isso provavelmente não é uma preocupação para todos os aplicativos de acesso a dados, mas se ele for seu, como pode você lidar com alterações no esquema do banco de dados, seja por reprojetar e recompilar? O objetivo deste tópico é responder essa pergunta.

Este tópico descreve o caso mais comum na qual você pode vincular dinamicamente colunas — tendo começado com um conjunto de registros baseado em um esquema de banco de dados conhecidos, que você deseja manipular colunas adicionais em tempo de execução. O tópico mais pressupõe que as colunas adicionais mapeiam para CString campo de membros de dados, o caso mais comum, embora as sugestões são fornecidas para ajudá-lo a gerenciar outros tipos de dados.

Com uma pequena quantidade de código extra, você pode:

• Determinar quais colunas estão disponíveis em tempo de execução.

• Vincular colunas adicionais a seu recordset dinamicamente, em tempo de execução.

O conjunto de registros ainda contém membros de dados para as colunas que soubessem em tempo de design. Ele também contém uma pequena quantidade de código extra que dinamicamente determina se quaisquer novas colunas foram adicionadas à sua tabela de destino e, em caso afirmativo, vincula essas novas colunas para o armazenamento alocado dinamicamente (em vez de membros de dados do conjunto de registros).

Este tópico não abrange outros casos de vinculação dinâmica, como, por exemplo, descartados de tabelas ou colunas. Nesses casos, você precisará usar chamadas API ODBC mais diretamente. Para obter informações, consulte o SDK do ODBC referência do programador no CD de Biblioteca MSDN.

Como ligar colunas dinamicamente

Para vincular a colunas dinamicamente, você deve saber (ou ser capaz de determinar) os nomes das colunas adicionais. Você deve alocar armazenamento para os membros de dados de campo adicional, especificar seus nomes e seus tipos e especifique o número de colunas que você está adicionando.

Discussão a seguir menciona dois conjuntos de registros diferentes. A primeira é o principal conjunto de registros que seleciona os registros da tabela de destino. O segundo é um conjunto de registros de coluna especial usado para obter informações sobre as colunas da tabela de destino.

Processo de geral

O nível mais geral, essas etapas:

1. Construa seu objeto recordset principal.

   Opcionalmente, passe um ponteiro para uma abertura CDatabase de objeto ou ser capaz de fornecer informações de conexão para o conjunto de registros de coluna em alguma outra maneira.

2. Etapas para adicionar colunas dinamicamente.

   Consulte o processo descrito em adicionando as colunas abaixo.

3. Abra seu principal conjunto de registros.

   O conjunto de registros seleciona os registros e usa a troca de campo de registro (RFX) para ligar as colunas estáticas (aquelas mapeados para membros de dados de campo do conjunto de registros) e colunas dinâmicas (mapeadas para o armazenamento extra que você alocar).

Adicionando colunas

Vinculando dinamicamente adicionado colunas em tempo de execução requer as seguintes etapas:

1. Determine em tempo de execução quais colunas na tabela de destino. Extrai informações uma lista das colunas que foram adicionados à tabela como sua classe de conjunto de registros foi projetado.

   Uma boa abordagem é usar uma classe de conjunto de registros de coluna projetada para consultar a fonte de dados para informações de coluna para a tabela de destino (como o tipo de dados e o nome da coluna).

2. Fornecem armazenamento para os novos membros de dados do campo. Porque sua classe principal do conjunto de registros não tem membros de dados de campo para colunas desconhecidos, você deve fornecer um local para armazenar nomes, valores de resultados e, possivelmente informações de tipo de dados (se as colunas são os diferentes tipos de dados).

   Uma abordagem é criar uma ou mais listas dinâmicas, um para as novas colunas nomes, outro para seus valores de resultados e um terceiro para seus tipos de dados (se necessário). Essas listas, particularmente, a lista de valores, fornecem as informações e o armazenamento necessário para a ligação. A figura a seguir ilustra a criação de listas.

   A criação de listas de colunas para vincular dinamicamente

   

3. Adicionar uma chamada de função RFX no seu conjunto de registros principal DoFieldExchange a função para cada coluna adicionada. Essas chamadas RFX fazem o trabalho de buscar um registro, incluindo as colunas adicionais e vinculando as colunas para membros de dados do conjunto de registros ou para seu armazenamento dinamicamente fornecido para eles.

   Uma abordagem é adicionar um loop para o conjunto de registros principal DoFieldExchange função que percorre a lista de novas colunas, chamar a função RFX apropriada para cada coluna na lista. Em cada chamada RFX passe um nome de coluna da coluna da lista nome e um local de armazenamento no membro correspondente na lista de valor do resultado.

Listas de colunas

Quatro listas que você precisa trabalhar com são mostradas na tabela a seguir.

• Atual--colunas da tabela (1 da lista na ilustração)
  Uma lista das colunas atualmente na tabela na fonte de dados. Nesta lista pode coincidir com a lista de colunas atualmente ligados de registros.

• Ligado--colunas do conjunto (lista 2 na ilustração)
  Uma lista das colunas vinculado no seu conjunto de registros. Essas colunas já tem instruções de RFX sua DoFieldExchange função.

• Colunas-para-Bind-dinamicamente (3 da lista na ilustração)
  Uma lista de colunas na tabela, mas não no seu conjunto de registros. Essas são as colunas que você deseja ligar dinamicamente.

• Dinâmico--valores de coluna (4 de lista na ilustração)
  Recuperado de uma lista contendo o armazenamento para os valores das colunas que você pode vincular dinamicamente. Os elementos desta lista correspondem às colunas-para-Bind-dinamicamente, um para um.

A criação de suas listas

Com uma estratégia geral em mente, você pode ativar os detalhes. Os procedimentos no restante deste tópico mostram como criar listas mostradas na Lista de colunas. Os procedimentos orientação-lo:

• Determinando os nomes das colunas não de registros.

• Fornecendo armazenamento dinâmico para colunas recentemente adicionadas à tabela de.

• Adicionar dinamicamente RFX chama para novas colunas.

Determinar quais colunas da tabela não são de registros

Criar uma lista (ligado--colunas do conjunto, como na lista 2 a ilustração) que contém uma lista das colunas já está ligado no seu conjunto de registros principal. Em seguida, crie uma lista (colunas-para-Bind-dinamicamente, derivado de colunas da tabela atual e colunas do conjunto de limite) que contém os nomes de coluna da tabela na fonte de dados, mas não no seu conjunto de registros principal.

Para determinar os nomes das colunas não está no conjunto de registros (colunas-para-Bind-dinamicamente)

1. Crie uma lista (colunas de Recordset vinculados) das colunas já está ligado no seu conjunto de registros principal.

   Uma abordagem é criar as colunas do conjunto de limite em tempo de design. Você pode examinar visualmente as chamadas de função RFX no conjunto de registros DoFieldExchange função para obter esses nomes. Em seguida, configure a lista como uma matriz inicializada com os nomes.

   Por exemplo, o ilustração mostra vinculados--colunas do conjunto (lista 2) com três elementos. Colunas do conjunto de limite está faltando a coluna Phone mostrada na atual--colunas da tabela (1 da lista).

2. Compare colunas da tabela atual e colunas do conjunto de limite para criar uma lista (colunas-para-Bind-dinamicamente) das colunas que ainda não estiver ligado em seu conjunto de registros principal.

   Uma abordagem é percorrer a lista de colunas na tabela em tempo de execução (colunas de tabela atual) e a sua lista de colunas já vinculado no seu conjunto de registros (colunas de Recordset vinculados) em paralelo. Em colunas-para-Bind-dinamicamente coloca quaisquer nomes atual--colunas da tabela que não aparecem nas colunas do conjunto de limite.

   Por exemplo, o ilustração mostra colunas-para-Bind-dinamicamente (lista 3) com um elemento: a coluna de telefone encontrada atual--colunas da tabela (lista 1) mas não de ligado--colunas do conjunto (lista 2).

3. Criar uma lista de valores de coluna dinâmicos (como na lista de 4 na ilustração) para armazenar os valores de dados correspondente a cada nome de coluna armazenado na sua lista de colunas para ligar dinamicamente (colunas-para-Bind-dinamicamente).

   Os elementos desta lista desempenham a função de um novo conjunto de registros a membros de dados do campo. Eles são os locais de armazenamento ao qual as colunas dinâmicas são vinculadas. Para obter descrições das listas, consulte Lista de colunas.

O fornecimento de armazenamento para as novas colunas

Em seguida, configure os locais de armazenamento para as colunas devem ser vinculados dinamicamente. A idéia é fornecer um elemento da lista na qual deseja armazenar o valor da coluna. Esses locais de armazenamento paralela as variáveis de membro do conjunto de registros, armazenam as colunas acopladas normalmente.

Para fornecer armazenamento dinâmico novas colunas (valores de coluna dinâmicos)

• Compilação dinâmica--valores de coluna, paralelas para colunas-para-Bind-dinamicamente, para conter o valor dos dados em cada coluna.

  Por exemplo, o ilustração mostra dinâmico--valores de coluna (4 da lista) com um elemento: um CString objeto contendo o número de telefone real para o registro atual: "555-1212".

  No caso mais comum, os valores de coluna dinâmicos tem elementos do tipo CString. Se você estiver lidando com colunas de variados tipos de dados, você precisa de uma lista que pode conter elementos de uma variedade de tipos.

O resultado dos procedimentos anteriores é duas listas principais: Colunas-para-Bind-dinamicamente que contém os nomes das colunas e dinâmico--valores da coluna que contém os valores nas colunas para o registro atual.

Dica

Se as novas colunas não são todas do mesmo tipo de dados, convém um paralelo extra que contém itens de alguma forma, definir o tipo de cada elemento correspondente na lista de colunas de lista. (Você pode usar os valores AFX_RFX_BOOL, AFX_RFX_BYTEe assim por diante, este se você deseja obter. Essas constantes são definidas em AFXDB.H.) Escolha um tipo de lista com base em como você representa os tipos de dados da coluna.

Adicionando chamadas RFX para ligar as colunas

Finalmente, organizar para a vinculação dinâmica ocorra colocando RFX chama para as novas colunas em sua DoFieldExchange função.

Para adicionar dinamicamente RFX chama para novas colunas

• No seu conjunto de registros principal DoFieldExchange membro funcionar, adicione o código percorre a lista de novas colunas (colunas-para-Bind-dinamicamente). Em cada loop, extrai o nome de uma coluna de colunas-para-Bind-dinamicamente e um valor de resultado para a coluna de valores de coluna dinâmicos. Passe esses itens para uma chamada de função RFX apropriado para o tipo de dados da coluna. Para obter descrições das listas, consulte Lista de colunas.

No caso comum, no seu RFX_Text chamadas de função que você extraia CString objetos nas listas, como as seguintes linhas de código, onde é colunas-para-Bind-dinamicamente um CStringList chamado m_listName e valores de coluna dinâmico é um CStringList chamado m_listValue:

RFX_Text( pFX, 
            m_listName.GetNext( posName ), 
            m_listValue.GetNext( posValue ));

Para obter mais informações sobre funções RFX, consulte Macros e Globals na Referência da biblioteca de classe.

Dica

Se as novas colunas diferentes tipos de dados, use uma instrução switch em seu loop para chamar a função RFX adequada para cada tipo.

Quando a estrutura chama DoFieldExchange durante a Abrir processo para vincular as colunas no conjunto de registros, as chamadas RFX para as colunas estáticas vincular essas colunas. Em seguida, o loop chama repetidamente as funções de RFX para as colunas dinâmicas.

Consulte também

Conceitos

O conjunto de registros (ODBC)

O conjunto de registros: Trabalhando com itens grandes de dados (ODBC)