Função SQLBindCol

Conformidade
Versão introduzida: ODBC 1.0 Conformidade com os padrões: ISO 92

Summary
O SQLBindCol vincula buffers de dados de aplicação às colunas do conjunto de resultados.

Sintaxe

  
SQLRETURN SQLBindCol(  
      SQLHSTMT       StatementHandle,  
      SQLUSMALLINT   ColumnNumber,  
      SQLSMALLINT    TargetType,  
      SQLPOINTER     TargetValuePtr,  
      SQLLEN         BufferLength,  
      SQLLEN *       StrLen_or_IndPtr);  

Argumentos

Identificador de declaração
[Entrada] Identificador de instrução.

Número da Coluna
[Entrada] Número do conjunto de resultados para vincular. As colunas são numeradas em ordem crescente começando em 0, onde a coluna 0 é a coluna de favoritos. Se os favoritos não forem usados – ou seja, o atributo SQL_ATTR_USE_BOOKMARKS da instrução for definido como SQL_UB_OFF – então o número das colunas começa em 1.

Tipo de Destino
[Entrada] O identificador do tipo de dado C do buffer *TargetValuePtr . Quando ele está recuperando dados da fonte de dados com SQLFetch, SQLFetchScroll, SQLBulkOperations ou SQLSetPos, o driver converte os dados para esse tipo; quando envia dados para a fonte de dados com SQLBulkOperations ou SQLSetPos, o driver converte os dados desse tipo. Para uma lista de tipos de dados C válidos e identificadores de tipo, veja a seção Tipos de Dados C no Apêndice D: Tipos de Dados.

Se o argumento TargetType for um tipo de dado de intervalo, a precisão padrão de intervalo inicial (2) e a precisão padrão de intervalo de segundos (6), conforme definidas nos campos SQL_DESC_DATETIME_INTERVAL_PRECISION e SQL_DESC_PRECISION do ARD, respectivamente, são usadas para os dados. Se o argumento TargetType for SQL_C_NUMERIC, a precisão padrão (definida pelo driver) e a escala padrão (0), conforme definidas nos campos SQL_DESC_PRECISION e SQL_DESC_SCALE do ARD, são usadas para os dados. Se qualquer precisão ou escala padrão não for adequada, a aplicação deve definir explicitamente o campo descritor apropriado por meio de uma chamada para SQLSetDescField ou SQLSetDescRec.

Você também pode especificar um tipo de dados C estendido. Para obter mais informações, consulte Tipos de Dados C no ODBC.

TargetValuePtr
[Entrada/Saída Diferida] Apontar para o buffer de dados para vincular à coluna. SQLFetch e SQLFetchScroll retornam dados nesse buffer. O SQLBulkOperations retorna dados nesse buffer quando a Operação está SQL_FETCH_BY_BOOKMARK; ele recupera dados desse buffer quando a Operação está SQL_ADD ou SQL_UPDATE_BY_BOOKMARK. SQLSetPos retorna dados nesse buffer quando a Operação está SQL_REFRESH; ele recupera dados desse buffer quando a Operação está SQL_UPDATE.

Se TargetValuePtr for um ponteiro nulo, o driver desvincula o buffer de dados da coluna. Uma aplicação pode desvincular todas as colunas chamando SQLFreeStmt com a opção SQL_UNBIND. Uma aplicação pode desvincular o buffer de dados de uma coluna, mas ainda ter um limite de buffer de comprimento/indicador para a coluna, se o argumento TargetValuePtr na chamada para SQLBindCol for um ponteiro nulo, mas o argumento StrLen_or_IndPtr for um valor válido.

BufferLength
[Entrada] Comprimento do buffer *TargetValuePtr em bytes.

O driver usa BufferLength para evitar escrever além do final do buffer *TargetValuePtr quando retorna dados de comprimento variável, como dados de caracteres ou binários. Note que o driver conta o caractere de terminação nula quando retorna os dados do caractere para *TargetValuePtr. * Portanto, o TargetValuePtr deve conter espaço para o caractere de terminação nula, caso contrário o driver truncará os dados.

Quando o driver retorna dados de comprimento fixo, como um inteiro ou uma estrutura de data, ignora o BufferLength e assume que o buffer é grande o suficiente para armazenar os dados. Portanto, é importante que a aplicação aloque um buffer grande o suficiente para dados de comprimento fixo, caso contrário o driver irá escrever além do final do buffer.

SQLBindCol retorna SQLSTATE HY090 (comprimento de string ou buffer inválido) quando o BufferLength é menor que 0, mas não quando o BufferLength é 0. No entanto, se o TargetType especificar um tipo de caractere, uma aplicação não deve definir o BufferLength como 0, pois drivers compatíveis com ISO CLI retornam SQLSTATE HY090 (String ou buffer inválido) nesse caso.

StrLen_or_IndPtr
[Entrada/Saída Diferida] Aponte para o buffer de comprimento/indicador para vincular à coluna. SQLFetch e SQLFetchScroll retornam um valor nesse buffer. O SQLBulkOperations recupera um valor desse buffer quando a Operação está SQL_ADD, SQL_UPDATE_BY_BOOKMARK ou SQL_DELETE_BY_BOOKMARK. O SQLBulkOperations retorna um valor nesse buffer quando Operation está SQL_FETCH_BY_BOOKMARK. SQLSetPos retorna um valor nesse buffer quando Operação está SQL_REFRESH; ele recupera um valor desse buffer quando a Operação está SQL_UPDATE.

SQLFetch, SQLFetchScroll, SQLBulkOperations e SQLSetPos podem retornar os seguintes valores no buffer de comprimento/indicador:

• O comprimento dos dados disponíveis para serem retornados

• SQL_NO_TOTAL

• SQL_NULL_DATA

A aplicação pode colocar os seguintes valores no buffer de comprimento/indicador para uso com SQLBulkOperations ou SQLSetPos:

• O comprimento dos dados enviados

• SQL_NTS

• SQL_NULL_DATA

• SQL_DATA_AT_EXEC

• O resultado do macro SQL_LEN_DATA_AT_EXEC

• SQL_COLUMN_IGNORE

Se o buffer indicador e o buffer de comprimento forem buffers separados, o buffer indicador pode devolver apenas SQL_NULL_DATA, enquanto o buffer de comprimento pode retornar todos os outros valores.

Para mais informações, veja Função SQLBulkOperations, Função SQLFetch, Função SQLSetPos e Uso de Valores Comprimento/Indicador.

Se StrLen_or_IndPtr for um ponteiro nulo, nenhum valor de comprimento ou indicador é utilizado. Isso é um erro ao buscar dados e os dados são NULL.

Consulte Informações ODBC de 64 bits, se seu aplicativo for executado em um sistema operacional de 64 bits.

Returns

SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_ERROR ou SQL_INVALID_HANDLE.

Diagnostics

Quando o SQLBindCol retorna SQL_ERROR ou SQL_SUCCESS_WITH_INFO, um valor SQLSTATE associado pode ser obtido chamando SQLGetDiagRec com um HandleType de SQL_HANDLE_STMT e um Handle de StatementHandle. A tabela a seguir lista os valores SQLSTATE normalmente retornados pelo SQLBindCol e explica cada um no contexto dessa função; a notação "(DM)" precede as descrições dos SQLSTATEs retornadas pelo Gerenciador de Drivers. O código de retorno associado a cada valor SQLSTATE é SQL_ERROR, a menos que indicado de outra forma.

Comments

O SQLBindCol é usado para associar, ou vincular, colunas no conjunto de resultados a buffers de dados e buffers de comprimento/indicador na aplicação. Quando o aplicativo chama SQLFetch, SQLFetchScroll ou SQLSetPos para buscar dados, o driver retorna os dados das colunas limitadas nos buffers especificados; para mais informações, veja Função SQLFetch. Quando a aplicação chama SQLBulkOperations para atualizar ou inserir uma linha ou SQLSetPos para atualizar uma linha, o driver recupera os dados das colunas limitadas dos buffers especificados; para mais informações, veja Função SQLBulkOperations ou Função SQLSetPos. Para mais informações sobre encadernação, veja Recuperação de Resultados (Básico).

Note que as colunas não precisam ser vinculadas para recuperar dados delas. Uma aplicação também pode chamar SQLGetData para recuperar dados de colunas. Embora seja possível vincular algumas colunas em uma linha e chamar SQLGetData para outras, isso está sujeito a algumas restrições. Para mais informações, veja SQLGetData.

Encadernação, Desvinculação e Reencadernação de Colunas

Uma coluna pode ser limitada, não vinculada ou rebotada a qualquer momento, mesmo depois que os dados foram obtidos do conjunto de resultados. A nova ligação entra em vigor na próxima vez que uma função que usa ligações é chamada. Por exemplo, suponha que uma aplicação vincule as colunas de um conjunto de resultados e chame SQLFetch. O driver retorna os dados nos buffers vinculados. Agora suponha que a aplicação vincule as colunas a um conjunto diferente de buffers. O driver não coloca os dados da linha recém-buscada nos buffers recém-vinculados. Em vez disso, ele espera até que o SQLFetch seja chamado novamente e então coloca os dados da próxima linha nos buffers recém-vinculados.

Colunas de associação

Para vincular uma coluna, uma aplicação chama SQLBindCol e passa o número da coluna, tipo, endereço e comprimento de um buffer de dados, além do endereço de um buffer de comprimento/indicador. Para informações sobre como esses endereços são usados, veja "Endereços Buffer", mais adiante nesta seção. Para mais informações sobre colunas de binding, veja Using SQLBindCol.

O uso desses buffers é adiado; ou seja, a aplicação os vincula no SQLBindCol , mas o driver os acessa por outras funções - nomeadamente SQLBulkOperations, SQLFetch, SQLFetchScroll ou SQLSetPos. É responsabilidade da aplicação garantir que os ponteiros especificados no SQLBindCol permaneçam válidos enquanto a vinculação permanecer em vigor. Se a aplicação permite que esses ponteiros se tornem inválidos – por exemplo, libera um buffer – e então chama uma função que espera que sejam válidos, as consequências são indefinidas. Para mais informações, veja Buffers Diferidos.

A vinculação permanece em vigor até ser substituída por uma nova vinculação, a coluna ser desvinculada ou a afirmação ser liberada.

Desencadernação das Colunas

Para desvincular uma única coluna, uma aplicação chama SQLBindCol com ColumnNumber definido para o número dessa coluna e TargetValuePtr definido para um ponteiro nulo. Se ColumnNumber se referir a uma coluna não vinculada, SQLBindCol ainda retorna SQL_SUCCESS.

Para desvincular todas as colunas, uma aplicação chama SQLFreeStmt com fOption definido como SQL_UNBIND. Isso também pode ser feito definindo o campo SQL_DESC_COUNT do ARD a zero.

Colunas de Reencadernação

Um aplicativo pode executar uma das duas operações para alterar uma associação:

• Chame o SQLBindCol para especificar uma nova vinculação para uma coluna que já está vinculada. O driver substitui a associação antiga pela nova.

• Especifique um offset a ser adicionado ao endereço do buffer que foi especificado pela chamada de vinculação ao SQLBindCol. Para mais informações, veja a próxima seção, "Deslocamentos de Ligação."

Deslocamentos de ligação

Um deslocamento de vinculação é um valor que é adicionado aos endereços dos buffers de dados e comprimento/indicador (conforme especificado no argumento TargetValuePtr e StrLen_or_IndPtr ) antes de serem desreferenciados. Quando os deslocamentos são usados, as ligações são um "modelo" de como os buffers da aplicação são dispostos, e a aplicação pode mover esse "modelo" para diferentes áreas da memória alterando o deslocamento. Como o mesmo offset é adicionado a cada endereço em cada binding, os deslocamentos relativos entre buffers para diferentes colunas devem ser os mesmos dentro de cada conjunto de buffers. Isso é sempre verdade quando a binding por fileira é usada; A aplicação deve planejar cuidadosamente seus buffers para que isso seja verdade quando a vinculação por coluna é usada.

Usar um offset de binding tem basicamente o mesmo efeito que rebinding uma coluna chamando SQLBindCol. A diferença é que uma nova chamada para SQLBindCol especifica novos endereços para o buffer de dados e o buffer de comprimento/indicador, enquanto o uso de um offset de binding não altera os endereços, apenas adiciona um offset a eles. A aplicação pode especificar um novo deslocamento sempre que quiser, e esse deslocamento sempre é adicionado aos endereços originalmente vinculados. Em particular, se o deslocamento for definido como 0 ou se o atributo da instrução for definido como um ponteiro nulo, o driver usa os endereços originalmente vinculados.

Para especificar um deslocamento de ligação, a aplicação define o atributo da instrução SQL_ATTR_ROW_BIND_OFFSET_PTR para o endereço de um buffer SQLINTEIR. Antes que a aplicação chame uma função que usa bindings, ela coloca um offset em bytes nesse buffer. Para determinar o endereço do buffer a ser usado, o driver adiciona o offset ao endereço no binding. A soma do endereço e do deslocamento deve ser um endereço válido, mas o endereço ao qual o deslocamento é somado não precisa ser válido. Para mais informações sobre como os deslocamentos de vinculação são usados, veja "Endereços de Buffer", mais adiante nesta seção.

Matrizes de Ligação

Se o tamanho do conjunto de linhas (o valor do atributo SQL_ATTR_ROW_ARRAY_SIZE da instrução) for maior que 1, a aplicação vincula arrays de buffers em vez de buffers individuais. Para mais informações, veja Block Cursors.

A aplicação pode vincular arrays de duas maneiras:

• Associe uma matriz a cada coluna. Isso é chamado de vinculação por coluna a coluna porque cada estrutura de dados (array) contém dados para uma única coluna.

• Defina uma estrutura para armazenar os dados de uma linha inteira e vincule um array dessas estruturas. Isso é chamado de vinculação por linha a fila porque cada estrutura de dados contém os dados de uma única linha.

Cada array de buffers deve ter pelo menos tantos elementos quanto o tamanho do conjunto de linhas.

Associação de coluna

Na vinculação por coluna, a aplicação vincula dados separados e arrays de comprimento/indicador a cada coluna.

Para usar a vinculação por coluna, a aplicação primeiro define o atributo da instrução SQL_ATTR_ROW_BIND_TYPE como SQL_BIND_BY_COLUMN. (Esse é o padrão.) Para cada coluna a ser associada, o aplicativo executa as seguintes etapas:

1. Aloca um array de buffer de dados.

2. Aloca uma matriz de buffers de comprimento/indicador.

   Note

   Se o aplicativo gravar diretamente nos descritores quando a associação em colunas for usada, matrizes separadas poderão ser usadas para dados de comprimento e indicador.

3. Chama SQLBindCol com os seguintes argumentos:

   • TargetType é o tipo de um único elemento no array de buffer de dados.

   • TargetValuePtr é o endereço do array de buffer de dados.

   • BufferLength é o tamanho de um único elemento no array de buffer de dados. O argumento BufferLength é ignorado quando os dados são dados de comprimento fixo.

   • StrLen_or_IndPtr é o endereço da matriz de comprimento/indicador.

Para mais informações sobre como essas informações são usadas, veja "Endereços de Buffer", mais adiante nesta seção. Para mais informações sobre encadernação por coluna, veja Column-Wise Encadernação.

Associação de linha

Na vinculação por linhas, a aplicação define uma estrutura que contém dados e buffers de comprimento/indicador para cada coluna a ser encadernada.

Para usar a associação de linha, o aplicativo executa as seguintes etapas:

1. Define uma estrutura para armazenar uma única linha de dados (incluindo tanto dados quanto buffers de comprimento/indicador) e aloca um array dessas estruturas.

   Note

   Se o aplicativo gravar diretamente nos descritores quando a associação de linha for usada, campos separados poderão ser usados para dados de comprimento e indicador.

2. Define o atributo SQL_ATTR_ROW_BIND_TYPE de instrução ao tamanho da estrutura que contém uma única linha de dados ou ao tamanho de uma instância de um buffer no qual as colunas de resultados serão vinculadas. O comprimento deve incluir espaço para todas as colunas encadernadas, e qualquer preenchimento da estrutura ou buffer, para garantir que, quando o endereço de uma coluna limitada for incrementado com o comprimento especificado, o resultado aponte para o início da mesma coluna na próxima linha. Ao usar o operador sizeof em ANSI C, esse comportamento é garantido.

3. Chama SQLBindCol com os seguintes argumentos para cada coluna a ser limitada:

   • TargetType é o tipo do membro do buffer de dados a ser vinculado à coluna.

   • TargetValuePtr é o endereço do membro do buffer de dados no primeiro elemento do array.

   • BufferLength é o tamanho do membro do buffer de dados.

   • StrLen_or_IndPtr é o endereço do membro de comprimento/indicador a ser vinculado.

Para mais informações sobre como essas informações são usadas, veja "Endereços de Buffer", mais adiante nesta seção. Para mais informações sobre encadernação por coluna, veja Row-Wise Encadernação.

Endereços de Buffer

O endereço do buffer é o endereço real do dado ou do buffer de comprimento/indicador. O driver calcula o endereço do buffer pouco antes de gravar nos buffers (como durante o tempo de busca). Ele é calculado a partir da seguinte fórmula, que utiliza os endereços especificados nos argumentos TargetValuePtr e StrLen_or_IndPtr , o deslocamento de ligação e o número da linha:

Endereço + VinculadoDeslocamento de Ligação + ((Número de Linha - 1) x Tamanho do Elemento)

onde as variáveis da fórmula são definidas conforme descrito na tabela a seguir.

Descriptors e SQLBindCol

As seções a seguir descrevem como o SQLBindCol interage com os descritores.

Mapeamentos de Argumentos

Conceitualmente, o SQLBindCol executa as seguintes etapas em sequência:

1. Chama SQLGetStmtAttr para obter o handle ARD.

2. Chama SQLGetDescField para obter o campo SQL_DESC_COUNT deste descritor e, se o valor no argumento ColumnNumber exceder o valor de SQL_DESC_COUNT, chama SQLSetDescField para aumentar o valor de SQL_DESC_COUNT para ColumnNumber.

3. Chama SQLSetDescField várias vezes para atribuir valores aos seguintes campos do ARD:

   • Define SQL_DESC_TYPE e SQL_DESC_CONCISE_TYPE ao valor de TargetType, exceto que, se TargetType for um dos identificadores concisos de um subtipo de data, hora ou intervalo, ele define SQL_DESC_TYPE para SQL_DATETIME ou SQL_INTERVAL, respectivamente; define SQL_DESC_CONCISE_TYPE ao identificador conciso; e define SQL_DESC_DATETIME_INTERVAL_CODE para o subcódigo de data-hora ou intervalo correspondente.

   • Define um ou mais de SQL_DESC_LENGTH, SQL_DESC_PRECISION, SQL_DESC_SCALE e SQL_DESC_DATETIME_INTERVAL_PRECISION, conforme apropriado para o Tipo de Alvo.

   • Define o campo SQL_DESC_OCTET_LENGTH como o valor de BufferLength.

   • Define o campo SQL_DESC_DATA_PTR para o valor de TargetValuePtr.

   • Define o campo SQL_DESC_INDICATOR_PTR para o valor de StrLen_or_IndPtr. (Veja o parágrafo a seguir.)

   • Define o campo SQL_DESC_OCTET_LENGTH_PTR para o valor de StrLen_or_IndPtr. (Veja o parágrafo a seguir.)

A variável à qual o argumento StrLen_or_IndPtr se refere é usada tanto para informações indicadoras quanto de comprimento. Se um fetch encontrar um valor nulo para a coluna, ele armazena SQL_NULL_DATA nessa variável; caso contrário, armazena o comprimento dos dados nessa variável. Passar um ponteiro nulo como StrLen_or_IndPtr impede que a operação de busca retorne o comprimento dos dados, mas faz com que a busca falha se encontrar um valor nulo e não tiver como retornar SQL_NULL_DATA.

Se a chamada ao SQLBindCol falhar, o conteúdo dos campos de descritores que ele teria definido no ARD permanece indefinido e o valor do campo SQL_DESC_COUNT do ARD permanece inalterado.

Resetar Implícito do Campo COUNT

O SQLBindCol define SQL_DESC_COUNT ao valor do argumento ColumnNumber apenas quando isso aumentaria o valor de SQL_DESC_COUNT. Se o valor no argumento TargetValuePtr for um ponteiro nulo e o valor no argumento ColumnNumber for igual a SQL_DESC_COUNT (isto é, ao desvincular a coluna com limite mais alto), então SQL_DESC_COUNT é definido para o número da coluna restante com limite mais alto.

Avisos sobre SQL_DEFAULT

Para recuperar os dados das colunas com sucesso, a aplicação deve determinar corretamente o comprimento e o ponto inicial dos dados no buffer da aplicação. Quando a aplicação especifica um Tipo de Alvo explícito, equívocos da aplicação são facilmente detectados. No entanto, quando a aplicação especifica um TargetType de SQL_DEFAULT, o SQLBindCol pode ser aplicado a uma coluna de um tipo de dado diferente daquele pretendido pela aplicação, seja por mudanças nos metadados ou aplicando o código a uma coluna diferente. Nesse caso, a aplicação pode nem sempre determinar o início ou o comprimento dos dados da coluna buscados. Isso pode levar a erros de dados não reportados ou violações de memória.

Exemplo de código

No exemplo a seguir, um aplicativo executa uma instrução SELECT na tabela Clientes para retornar um conjunto de resultados com os IDs dos clientes, nomes e números de telefone, ordenados por nome. Em seguida, ele chama SQLBindCol para vincular as colunas de dados a buffers locais. Por fim, o aplicativo busca cada linha de dados com SQLFetch e imprime o nome, ID e número de telefone de cada cliente.

Para mais exemplos de código, veja Função SQLBulkOperations, Função SQLColumns, Função SQLFetchScroll e Função SQLSetPos.

// SQLBindCol_ref.cpp  
// compile with: odbc32.lib  
#include <windows.h>  
#include <stdio.h>  
  
#define UNICODE  
#include <sqlext.h>  
  
#define NAME_LEN 50  
#define PHONE_LEN 60
  
void show_error() {  
   printf("error\n");  
}  
  
int main() {  
   SQLHENV henv;  
   SQLHDBC hdbc;  
   SQLHSTMT hstmt = 0;  
   SQLRETURN retcode;  
   SQLWCHAR szName[NAME_LEN], szPhone[PHONE_LEN], sCustID[NAME_LEN];  
   SQLLEN cbName = 0, cbCustID = 0, cbPhone = 0;  
  
   // Allocate environment handle  
   retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);  
  
   // Set the ODBC version environment attribute  
   if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {  
      retcode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER*)SQL_OV_ODBC3, 0);   
  
      // Allocate connection handle  
      if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {  
         retcode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);  
  
         // Set login timeout to 5 seconds  
         if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {  
            SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)5, 0);  
  
            // Connect to data source  
            retcode = SQLConnect(hdbc, (SQLWCHAR*) L"NorthWind", SQL_NTS, (SQLWCHAR*) NULL, 0, NULL, 0);  
  
            // Allocate statement handle  
            if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {   
               retcode = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);   
  
               retcode = SQLExecDirect(hstmt, (SQLWCHAR *) L"SELECT CustomerID, ContactName, Phone FROM CUSTOMERS ORDER BY 2, 1, 3", SQL_NTS);  
               if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {  
  
                  // Bind columns 1, 2, and 3  
                  retcode = SQLBindCol(hstmt, 1, SQL_C_WCHAR, &sCustID, 100, &cbCustID);  
                  retcode = SQLBindCol(hstmt, 2, SQL_C_WCHAR, szName, NAME_LEN, &cbName);  
                  retcode = SQLBindCol(hstmt, 3, SQL_C_WCHAR, szPhone, PHONE_LEN, &cbPhone);   
  
                  // Fetch and print each row of data. On an error, display a message and exit.  
                  for (int i=0 ; ; i++) {  
                     retcode = SQLFetch(hstmt);  
                     if (retcode == SQL_ERROR || retcode == SQL_SUCCESS_WITH_INFO)  
                        show_error();  
                     if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)  
                     {
                        //replace wprintf with printf
                        //%S with %ls
                        //warning C4477: 'wprintf' : format string '%S' requires an argument of type 'char *'
                        //but variadic argument 2 has type 'SQLWCHAR *'
                        //wprintf(L"%d: %S %S %S\n", i + 1, sCustID, szName, szPhone);  
                        printf("%d: %ls %ls %ls\n", i + 1, sCustID, szName, szPhone);  
                    }    
                     else  
                        break;  
                  }  
               }  
  
               // Process data  
               if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {  
                  SQLCancel(hstmt);  
                  SQLFreeHandle(SQL_HANDLE_STMT, hstmt);  
               }  
  
               SQLDisconnect(hdbc);  
            }  
  
            SQLFreeHandle(SQL_HANDLE_DBC, hdbc);  
         }  
      }  
      SQLFreeHandle(SQL_HANDLE_ENV, henv);  
   }  
}  

Veja também, Programa ODBC de exemplo.

Funções relacionadas

Conteúdo relacionado

• Referência da API ODBC
• Arquivos de cabeçalho ODBC