conjunto de registros: Vinculação dinâmica colunas de dados (ODBC)

Este tópico se aplica a classes MFC ODBC.

Recordsets gerenciar vinculação de colunas da tabela que você especificar no time de design, mas há casos quando quiser BIND colunas foram desconhecidas para você time de design.Este tópico explica:

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

• Como associar colunas dinamicamente em time de execução.

Observação:
Este tópico se aplica aos objetos derivados CRecordset em qual linha em massa a busca 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 buscar a linha em massa, consulte conjunto de registros: Buscando os registros em massa (ODBC).

Quando você pode BIND dinamicamente colunas

Em time de design, o Assistente de aplicativo do MFC ou Assistente de consumidor ODBC do MFC (a partir de Adicionar classe) cria classes de conjunto de registros com base nas tabelas conhecidas e colunas na fonte de dados.Bancos de dados podem alterar entre quando você cria-las e mais recente quando o aplicativo usa essas tabelas e colunas em time 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 seu 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 as alterações no esquema de banco de dados diferentes de um novo projeto e recompilar?O objetivo deste tópico é responder essa pergunta.

Este tópico descreve o caso mais comum na qual você pode BIND 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 time de execução.Ainda mais o tópico pressupõe que as colunas adicionais mapeiam para CString campo de membros de dados, caso mais comum, embora sugestões são fornecidas para ajudar você a gerenciar outros tipos de dados.

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

• Determinar quais colunas estão disponível em time de execução.

• BIND dinamicamente, colunas adicionais a seu conjunto de registros em time de execução.

O conjunto de registros contém membros de dados para as colunas que sabia sobre em time de design.Ele também contém uma pequena quantidade de código extra 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 para membros de dados do conjunto de registros).

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

Como BIND dinamicamente colunas

Para BIND dinamicamente colunas, você deve saber (ou ser capaz de determinar) os nomes das colunas adicionais.Você também 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.A segunda é um conjunto de registros de coluna especial usado para obter informações sobre as colunas da tabela de destino.

Processo geral

Nível mais geral, você execute as seguintes etapas:

1. Construa o objeto conjunto de registros principal.

   Opcionalmente, passe um ponteiro para um em aberto CDatabase objeto ou poderá fornecer informações de conexão com o conjunto de registros de coluna de alguma Outros maneira.

2. Execute as etapas para adicionar colunas dinamicamente.

   Consulte o processo descrito em Adicionando colunas abaixo.

3. Abra o conjunto de registros principal.

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

Adicionando as colunas

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

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

   Uma mercadoria abordagem é usar uma classe de conjunto de registros de coluna projetada para consultar a fonte de dados para obter informações de coluna para a tabela de destino (sistema autônomo coluna Nome e tipo de dados).

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

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

   Criando listas de colunas para BIND dinamicamente

   

3. Adicionar uma telefonar de função RFX no DoFieldExchange função de cada coluna adicional. 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 o armazenamento fornecido dinamicamente para eles.

   Uma abordagem é adicionar um loop DoFieldExchange função percorre a lista de novas colunas, chamar a função RFX apropriada para cada coluna na lista. Em cada telefonar RFX, passe um nome de coluna da lista de nomes de coluna e um local de armazenamento no membro correspondente da lista de valores de resultado.

Listas de colunas

Quatro listas com que precisam trabalhar são mostradas na tabela a seguir.

• corrente-tabela Columns (lista 1 na ilustração)
  Uma lista de colunas no momento na tabela na fonte de dados.Essa lista pode correspondem à lista de colunas atualmente limite conjunto de registros.

• limite-conjunto de registros colunas (lista 2 na ilustração)
  Uma lista das colunas limite conjunto de registros.Essas colunas já RFX instruções em seu DoFieldExchange função.

• Colunas-para-Bind-dinamicamente (lista 3 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 BIND dinamicamente.

• Dinâmico-coluna valores (lista 4 na ilustração)
  Uma lista que contém o armazenamento para os valores são recuperados do colunas que BIND dinamicamente.Elementos desta lista correspondem às colunas-para-Bind-dinamicamente, um para um.

Criação de suas listas

Com uma estratégia geral em mente, você pode ativar os detalhes.Os procedimentos no restante neste tópico mostram como a compilação listas mostradas no Listas de colunas.Os procedimentos orientá-lo por meio de:

• Determinar os nomes das colunas não conjunto de registros.

• Oferecendo armazenamento dinâmico para colunas recém-adicionadas à tabela.

• Adicionar dinamicamente RFX chama para novas colunas.

Determinar quais colunas da tabela não estão no seu conjunto de registros

compilação uma lista (limite-Recordset-colunas, sistema autônomo na lista 2 no ilustração) que contém uma lista das colunas já limite principal conjunto de registros.Em seguida, compilação (colunas-para-Bind-dinamicamente, derivado de colunas da tabela corrente e vinculados a colunas de Recordset) uma lista que contém nomes de coluna na tabela na fonte de dados, mas não no seu conjunto de registros principal.

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

1. compilação uma lista (limite-Recordset colunas) de colunas já limite principal conjunto de registros.

   Uma abordagem é criar limite - conjunto de registros - colunas em time de design.Você pode examinar visualmente as chamadas de função RFX do conjunto de registros DoFieldExchange função para obter esses nomes. Em seguida, configurar sua lista sistema autônomo uma matriz inicializada com sistema autônomo nomes.

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

2. Comparar colunas da tabela corrente e limites-Recordset-colunas a compilação (colunas-para-Bind-dinamicamente) uma lista das colunas não já limite principal conjunto de registros.

   Uma abordagem é fazer o loop por meio de sua lista de colunas na tabela em time de execução (corrente-Table Columns) e sua lista de colunas já limite no seu conjunto de registros (Recordset-limite-colunas) em paralelo.Em colunas-para-Bind-dinamicamente colocar todos os nomes corrente--colunas da tabela que não são exibidas em colunas de conjunto de registros de limite.

   Por exemplo, a ilustração mostra colunas-para-Bind-dinamicamente (lista de 3) com um elemento: a coluna Phone encontrada no corrente-tabela Columns (lista 1), mas não no conjunto de registros-limite-colunas (lista de 2).

3. Criar uma lista das Dynamic-coluna-valores (sistema autônomo em lista 4 no ilustração) na qual deseja armazenar sistema autônomo valores de dados correspondentes a cada nome de coluna armazenado na sua lista de colunas para vincular dinamicamente (colunas-para-Bind-dinamicamente).

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

Fornecimento de armazenamento para colunas novas

Em seguida, configure os locais de armazenamento para as colunas a ser limite dinamicamente.A idéia é fornecer um elemento da lista na qual deseja armazenar o valor de cada 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 para novas colunas (Dynamic-coluna valores)

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

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

  No caso mais comum, valores de coluna dinâmica tem elementos do tipo CString. Se você estiver lidando com colunas de diferentes tipos de dados, é necessário uma lista que pode conter elementos de uma variedade de tipos de.

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

Dica:

Se as novas colunas não são todos do mesmo tipo de dados, talvez seja necessário um paralelo extra listar contendo itens, de alguma forma, definir o tipo de cada elemento correspondente na lista de colunas.(Você pode usar os valores AFX_RFX_BOOL, AFX_RFX_BYTE e assim por diante, se você deseja.Essas constantes são definidas em AFXDB.H.) escolher um tipo de lista com base em como você representa os tipos de dados de coluna.

Adicionando chamadas RFX para BIND a colunas

Por fim, providenciar a vinculação dinâmica ocorra, colocando RFX chamadas para as novas colunas no seu DoFieldExchange função.

Adicionar dinamicamente RFX chama para novas colunas

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

No caso comum, no seu RFX_Text chamadas de função que é extrair CString objetos de listas, sistema autônomo sistema autônomo seguintes linhas de código, onde é colunas-para-Bind-dinamicamente uma 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 globais in the Referência da biblioteca de classes.

Dica:
Se as novas colunas diferentes tipos de dados, use uma demonstrativo comutador em seu loop para chamar a função RFX apropriada para cada tipo.

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

Consulte também

Conceitos

conjunto de registros (ODBC)

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