Démarrage rapide : Connecter et interroger avec C++ et ODBC

S’applique à :SQL ServerAzure SQL Database

Dans ce démarrage rapide, vous construisez une application console C++ sur Windows, Linux ou macOS. L’application se connecte à une AdventureWorksLT base de données en utilisant le pilote ODBC 18 de Microsoft pour SQL Server, lie un paramètre de requête, exécute la requête et lit les lignes de résultats.

Prerequisites

  • Microsoft ODBC Driver 18 pour SQL Server. Installez le pilote pour Windows, Linux ou macOS.
  • Un compilateur C++17 et les fichiers de développement ODBC de la plateforme :
    • Sur Windows, installez Visual Studio 2022 ou les outils de compilation pour Visual Studio 2022 avec la charge de travail Développement de bureau avec C++. Le SDK Windows fournit les en-têtes ODBC et odbc32.lib.
    • Sous Linux, installez un compilateur C++ et le paquet de développement unixODBC pour votre distribution. Le package fournit les en-têtes ODBC et libodbc.
    • Sur macOS, installez les outils en ligne de commande Xcode et unixODBC depuis Homebrew.
  • Une base de données dans Azure SQL Database ou SQL Server qui contient les données d’exempleAdventureWorksLT. Pour Azure SQL Database, sélectionnez la source de données d’exemple lorsque vous créez une base de données unique. Pour SQL Server, restaurez une AdventureWorksLT sauvegarde à partir des bases de données d’exemple AdventureWorks.

Vérifiez le pilote

Confirmez que le gestionnaire de pilotes peut trouver le pilote ODBC 18 de Microsoft pour SQL Server.

Exécutez cette commande dans PowerShell :

Get-OdbcDriver -Name "ODBC Driver 18 for SQL Server"

Chaque commande devrait indiquer ODBC Driver 18 for SQL Server. Si le pilote n’est pas indiqué, réinstalle-le avant de continuer.

Configurez la connexion

L’application lit la chaîne de connexion complète à partir de la ODBC_CONNECTION_STRING variable environnement. Il n'affiche pas la chaîne de connexion ni ne l'accepte comme un argument en ligne de commande.

Utilisez une chaîne de connexion du pilote 18 valide pour votre base de données et votre méthode d’authentification. L’exemple suivant d’authentification SQL fonctionne sur Windows, Linux et macOS lorsque la base de données permet l’authentification SQL :

Driver={ODBC Driver 18 for SQL Server};Server=tcp:<server>,1433;Database=<database>;UID=<user_id>;PWD=<password>;Encrypt=yes;TrustServerCertificate=no;

Pour les options d’authentification Microsoft Entra, voir Utiliser Microsoft Entra ID avec le pilote ODBC. Pour tous les paramètres pris en charge, consultez DSN et mots-clés et attributs de chaîne de connexion.

Le pilote ODBC 18 de Microsoft active le chiffrement par défaut. Précisez Encrypt=yes que l’exigence de l’application soit explicite. Gardez TrustServerCertificate=no en production pour que le pilote valide le certificat serveur. Le certificat doit associer le nom et la chaîne du serveur à une autorité de certification en laquelle le client a confiance. Pour des conseils de configuration, voir Échecs de validation des certificats.

Avertissement

TrustServerCertificate=yes Saute la validation des certificats. Utilisez-le uniquement pour le développement local isolé pendant que vous configurez un certificat auquel le client a confiance. Ne l’utilisez pas en production.

Définissez la variable environnement sans ajouter la chaîne de connexion à l’historique de votre shell.

OpenDeveloper PowerShell pour VS 2022. Exécutez ces commandes, puis collez la chaîne de connexion à l’invite :

$secureConnectionString = Read-Host "ODBC connection string" -AsSecureString
$env:ODBC_CONNECTION_STRING = [System.Net.NetworkCredential]::new(
    "", $secureConnectionString).Password
$secureConnectionString = $null

Une variable d’environnement empêche la chaîne de connexion d’entrer dans le fichier source, mais le processus et ses processus enfants peuvent la lire. Pour les applications de production, utilisez l’authentification Microsoft Entra lorsque possible et récupérez les secrets depuis un magasin sécurisé à l’exécution.

Créer l’application

  1. Créez un répertoire de projet et changez-le :

    New-Item -ItemType Directory odbc-quickstart
Set-Location odbc-quickstart

  1. Créez un fichier nommé odbc-quickstart.cpp avec le code suivant :

    #ifdef _WIN32
#include <windows.h>
#endif

#include <sql.h>
#include <sqlext.h>
#include <sqltypes.h>

#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <string>

std::string ReadEnvironmentVariable(const char* name)
{
#ifdef _WIN32
    char* value = nullptr;
    std::size_t length = 0;
    if (_dupenv_s(&value, &length, name) != 0 || value == nullptr)
        return {};

    std::string result(value);
    std::free(value);
    return result;
#else
    const char* value = std::getenv(name);
    return value == nullptr ? std::string{} : value;
#endif
}

void PrintDiagnostics(SQLSMALLINT handleType, SQLHANDLE handle)
{
    SQLCHAR state[6];
    SQLINTEGER nativeError;
    SQLCHAR message[SQL_MAX_MESSAGE_LENGTH];
    SQLSMALLINT messageLength;

    for (SQLSMALLINT record = 1;
         SQL_SUCCEEDED(SQLGetDiagRec(handleType, handle, record, state,
                                     &nativeError, message, sizeof(message),
                                     &messageLength));
         ++record)
    {
        std::cerr << '[' << state << "] (" << nativeError << ") "
                  << message << '\n';
    }
}

bool Succeeded(SQLRETURN result, SQLSMALLINT handleType, SQLHANDLE handle)
{
    if (SQL_SUCCEEDED(result))
        return true;

    PrintDiagnostics(handleType, handle);
    return false;
}

struct OdbcHandles
{
    SQLHENV environment = SQL_NULL_HENV;
    SQLHDBC connection = SQL_NULL_HDBC;
    SQLHSTMT statement = SQL_NULL_HSTMT;

    ~OdbcHandles()
    {
        if (statement != SQL_NULL_HSTMT)
            SQLFreeHandle(SQL_HANDLE_STMT, statement);
        if (connection != SQL_NULL_HDBC)
        {
            SQLDisconnect(connection);
            SQLFreeHandle(SQL_HANDLE_DBC, connection);
        }
        if (environment != SQL_NULL_HENV)
            SQLFreeHandle(SQL_HANDLE_ENV, environment);
    }
};

int main()
{
    std::string connectionString =
        ReadEnvironmentVariable("ODBC_CONNECTION_STRING");
    if (connectionString.empty())
    {
        std::cerr << "Set ODBC_CONNECTION_STRING before running.\n";
        return 1;
    }

    OdbcHandles handles;
    SQLRETURN result = SQLAllocHandle(
        SQL_HANDLE_ENV, SQL_NULL_HANDLE, &handles.environment);
    if (!SQL_SUCCEEDED(result))
    {
        std::cerr << "Unable to allocate an ODBC environment handle.\n";
        return 1;
    }

    result = SQLSetEnvAttr(
        handles.environment,
        SQL_ATTR_ODBC_VERSION,
        reinterpret_cast<SQLPOINTER>(SQL_OV_ODBC3_80),
        0);
    if (!Succeeded(result, SQL_HANDLE_ENV, handles.environment))
        return 1;

    result = SQLAllocHandle(
        SQL_HANDLE_DBC, handles.environment, &handles.connection);
    if (!Succeeded(result, SQL_HANDLE_ENV, handles.environment))
        return 1;

    result = SQLDriverConnect(
        handles.connection,
        nullptr,
        reinterpret_cast<SQLCHAR*>(connectionString.data()),
        SQL_NTS,
        nullptr,
        0,
        nullptr,
        SQL_DRIVER_NOPROMPT);
    if (!Succeeded(result, SQL_HANDLE_DBC, handles.connection))
        return 1;

    result = SQLAllocHandle(
        SQL_HANDLE_STMT, handles.connection, &handles.statement);
    if (!Succeeded(result, SQL_HANDLE_DBC, handles.connection))
        return 1;

    SQLINTEGER minimumProductId = 0;
    SQLLEN minimumProductIdLength = 0;
    result = SQLBindParameter(
        handles.statement,
        1,
        SQL_PARAM_INPUT,
        SQL_C_SLONG,
        SQL_INTEGER,
        10,
        0,
        &minimumProductId,
        0,
        &minimumProductIdLength);
    if (!Succeeded(result, SQL_HANDLE_STMT, handles.statement))
        return 1;

    SQLCHAR query[] =
        "SELECT TOP (5) ProductID, Name "
        "FROM SalesLT.Product "
        "WHERE ProductID > ? "
        "ORDER BY ProductID;";
    result = SQLExecDirect(handles.statement, query, SQL_NTS);
    if (!Succeeded(result, SQL_HANDLE_STMT, handles.statement))
        return 1;

    std::cout << "Product ID  Name\n"
              << "----------  ----\n";

    while (SQL_SUCCEEDED(result = SQLFetch(handles.statement)))
    {
        SQLINTEGER productId;
        SQLLEN productIdLength;
        SQLCHAR productName[256];
        SQLLEN productNameLength;

        result = SQLGetData(
            handles.statement, 1, SQL_C_SLONG, &productId,
            sizeof(productId), &productIdLength);
        if (!Succeeded(result, SQL_HANDLE_STMT, handles.statement))
            return 1;

        result = SQLGetData(
            handles.statement, 2, SQL_C_CHAR, productName,
            sizeof(productName), &productNameLength);
        if (!Succeeded(result, SQL_HANDLE_STMT, handles.statement))
            return 1;

        std::cout << std::left << std::setw(12) << productId
                  << productName << '\n';
    }

    if (result != SQL_NO_DATA)
    {
        PrintDiagnostics(SQL_HANDLE_STMT, handles.statement);
        return 1;
    }

    return 0;
}

L’application utilise uniquement l’API ODBC standard, elle inclut donc les en-têtes driver-manager et les liens vers la bibliothèque driver-manager. La chaîne de connexion sélectionne le pilote Microsoft ODBC 18 pour SQL Server à l’exécution.

SQL_DRIVER_NOPROMPT empêche SQLDriverConnect l’ouverture d’une boîte de dialogue de configuration. Si la chaîne de connexion est incomplète, l’appel renvoie une erreur et l’application imprime tous les enregistrements de diagnostic.

La requête associe 0 à un paramètre SQL Server de type int, lit les cinq premiers produits dans SalesLT.Product, et récupère l’identifiant et le nom de chaque produit avec SQLGetData.

Générer et exécuter l’application

  1. Dans la même fenêtre PowerShell développeur, compilez l’application :

    cl /std:c++17 /EHsc /W4 odbc-quickstart.cpp /link odbc32.lib

  2. Exécutez l’application :

    .\odbc-quickstart.exe

La sortie standard de l’application est la suivante :

Product ID  Name
----------  ----
680         HL Road Frame - Black, 58
706         HL Road Frame - Red, 58
707         Sport-100 Helmet, Red
708         Sport-100 Helmet, Black
709         Mountain Bike Socks, M

Effacez la chaîne de connexion quand vous avez terminé.

Remove-Item Env:\ODBC_CONNECTION_STRING

Contenu connexe

  • Last updated on