Schnellstart: Verbinden und Abfragen mit dem Microsoft OLE DB-Treiber

In diesem Quickstart baust du eine Windows C++-Konsolenanwendung mit Visual Studio 2022 und neueren Versionen. Die Anwendung verbindet sich mit der Azure SQL-Datenbank, der SQL-Datenbank in Microsoft Fabric oder dem SQL Server mit Microsoft OLE DB Driver 19 für SQL Server. Es führt eine parametrisierte Abfrage anhand der AdventureWorksLT Stichprobendaten aus und überprüft das Ergebnis.

Prerequisites

Visual Studio 2022 und spätere Versionen mit der Desktop-Entwicklung mit C++-Workload. Diese Arbeitslast installiert die x64 Native Tools Command Prompt, die in diesem Quickstart verwendet wird. Anweisungen zum Öffnen finden Sie unter Verwenden einer 64-Bit-Verknüpfung für die gehostete Entwickler-Eingabeaufforderung.
Microsoft OLE DB Driver 19 für SQL Server. Installieren Sie den x64-Treiber und wählen Sie sowohl die Client-Komponenten als auch das Softwareentwicklungskit (SDK) aus.

Erstellen einer SQL-Datenbank

Erstellen oder verbinden Sie sich mit einer SQL-Datenbank auf einer der folgenden Plattformen:

Erstellen einer SQL-Datenbank in Minuten mithilfe des Azure-Portals

Für diesen Quickstart wählen oder laden Sie die AdventureWorksLT Beispieldaten.

Für einen SQL Server-Container erstellen Sie den Container und laden die Beispieldaten in einem Befehl:

sqlcmd create mssql --accept-eula --using https://aka.ms/AdventureWorksLT.bak

Für eine bestehende SQL Server-Instanz stellen Sie ein AdventureWorksLT Backup aus AdventureWorks-Beispieldatenbanken wieder her.

Die OLE-Datenbank-Client-Anwendung in diesem Quickstart läuft unter Windows. Ein SQL Server-Container kann auf einem anderen unterstützten Host ausgeführt werden.

Überprüfen Sie den Fahrer

Öffnen Sie eine x64 Native Tools-Eingabeaufforderung für Ihre Visual Studio-Version und führen Sie dann folgenden Befehl aus:

Important

Die Befehle in diesem Quickstart verwenden die Eingabeaufforderungssyntax. Führen Sie sie in einer x64 Native Tools-Eingabeaufforderung aus, bei der die Eingabeaufforderung mit > endet. Führe sie nicht in PowerShell aus, wo der Prompt mit PSbeginnt.

reg query HKCR\MSOLEDBSQL19

Der Befehl zeigt den registrierten MSOLEDBSQL19 Anbieter an.

Konfigurieren Sie die Verbindung

Legen Sie OLEDB_CONNECTION_STRING in der x64 Native Tools-Eingabeaufforderung fest. Die Anwendung liest den Verbindungszeichenfolge aus der Umgebung und zeigt ihn nicht an.

Für Azure SQL-Datenbank oder SQL Database in Fabric verwenden Sie Microsoft Entra interaktive Authentifizierung. Ersetzen Sie die Platzhalter durch den Server, die Datenbank und die Microsoft Entra-Benutzer-ID aus Ihrer SQL-Ressource:

set "OLEDB_CONNECTION_STRING=Provider=MSOLEDBSQL19;Data Source=tcp:<server>,1433;Initial Catalog=<database>;Authentication=ActiveDirectoryInteractive;User ID=<user_id>;Use Encryption for Data=Mandatory;Trust Server Certificate=false;"

Für eine SQL-Datenbank in Fabric benötigt Ihre Identität die Leseberechtigung für das Datenbankelement. SQL-Authentifizierung wird nicht unterstützt. Weitere Informationen finden Sie unter Authentifizierung in SQL-Datenbanken in Microsoft Fabric.

Für eine bestehende SQL Server-Instanz, die Windows-Authentifizierung akzeptiert, verwenden Sie Integrated Security=SSPI:

set "OLEDB_CONNECTION_STRING=Provider=MSOLEDBSQL19;Data Source=tcp:<server>,1433;Initial Catalog=<database>;Integrated Security=SSPI;Use Encryption for Data=Mandatory;Trust Server Certificate=false;"

Für eine SQL Server-Instanz oder einen Container, der SQL-Authentifizierung akzeptiert, verwenden Sie Authentication=SqlPassword:

set "OLEDB_USER_ID=<user_id>"
set "OLEDB_PASSWORD=<password>"
set "OLEDB_CONNECTION_STRING=Provider=MSOLEDBSQL19;Data Source=tcp:<server>,1433;Initial Catalog=<database>;Authentication=SqlPassword;User ID=%OLEDB_USER_ID%;Password=%OLEDB_PASSWORD%;Use Encryption for Data=Mandatory;Trust Server Certificate=false;"

Das SQL Server-Zertifikat muss den Servernamen und die Kette mit einer Zertifizierungsstelle (CA) abstimmen, der der Windows-Client vertraut. Für einen SQL Server-Container konfigurieren Sie Transport Layer Security (TLS) im Container und registrieren Sie die ausstellende CA im Windows-Client, bevor Sie die Anwendung ausführen. Weitere Informationen finden Sie unter Verschlüsseln von Verbindungen mit SQL Server unter Linux und Konfigurieren der SQL Server-Datenbank-Engine zum Verschlüsseln von Verbindungen.

Erstellen der Anwendung

Erstellen Sie ein Projektverzeichnis:

mkdir oledb-quickstart
cd oledb-quickstart

Erstellen Sie eine Datei mit dem Namen oledb-quickstart.cpp und dem folgenden Code:

#include <windows.h>
#include <oledb.h>
#include <msdasc.h>
#include <msoledbsql.h>

#include <cstddef>
#include <iomanip>
#include <iostream>
#include <string>

template <typename T>
void Release(T*& pointer)
{
    if (pointer != nullptr)
    {
        pointer->Release();
        pointer = nullptr;
    }
}

struct ParameterData
{
    DBSTATUS status;
    DBLENGTH length;
    LONG value;
};

constexpr std::size_t productNameCharacters = 51;

struct RowData
{
    DBSTATUS productIdStatus;
    DBLENGTH productIdLength;
    LONG productId;
    DBSTATUS nameStatus;
    DBLENGTH nameLength;
    wchar_t name[productNameCharacters];
};

std::wstring ReadEnvironmentVariable(const wchar_t* name)
{
    const DWORD length = GetEnvironmentVariableW(name, nullptr, 0);
    if (length == 0)
        return {};

    std::wstring value(length, L'\0');
    const DWORD copied = GetEnvironmentVariableW(
        name,
        value.data(),
        length);
    if (copied == 0 || copied >= length)
        return {};

    value.resize(copied);
    return value;
}

int wmain()
{
    const std::wstring connectionString =
        ReadEnvironmentVariable(L"OLEDB_CONNECTION_STRING");
    if (connectionString.empty())
    {
        std::wcerr << L"Set OLEDB_CONNECTION_STRING before running.\n";
        return 1;
    }

    HRESULT result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
    if (FAILED(result))
    {
        std::wcerr << L"COM initialization failed: 0x"
                   << std::hex << result << L'\n';
        return 1;
    }

    IDataInitialize* dataInitialize = nullptr;
    IDBInitialize* dbInitialize = nullptr;
    IDBCreateSession* createSession = nullptr;
    IDBCreateCommand* createCommand = nullptr;
    ICommandText* commandText = nullptr;
    ICommandWithParameters* commandParameters = nullptr;
    IAccessor* parameterAccessor = nullptr;
    IRowset* rowset = nullptr;
    IAccessor* rowAccessor = nullptr;
    HACCESSOR parameterHandle = DB_NULL_HACCESSOR;
    HACCESSOR rowHandle = DB_NULL_HACCESSOR;
    HROW* rows = nullptr;
    DBCOUNTITEM rowCount = 0;
    bool initialized = false;

    do
    {
        result = CoCreateInstance(
            CLSID_MSDAINITIALIZE,
            nullptr,
            CLSCTX_INPROC_SERVER,
            IID_IDataInitialize,
            reinterpret_cast<void**>(&dataInitialize));
        if (FAILED(result))
            break;

        result = dataInitialize->GetDataSource(
            nullptr,
            CLSCTX_INPROC_SERVER,
            connectionString.c_str(),
            IID_IDBInitialize,
            reinterpret_cast<IUnknown**>(&dbInitialize));
        if (FAILED(result))
            break;

        result = dbInitialize->Initialize();
        if (FAILED(result))
            break;
        initialized = true;

        result = dbInitialize->QueryInterface(
            IID_IDBCreateSession,
            reinterpret_cast<void**>(&createSession));
        if (FAILED(result))
            break;

        result = createSession->CreateSession(
            nullptr,
            IID_IDBCreateCommand,
            reinterpret_cast<IUnknown**>(&createCommand));
        if (FAILED(result))
            break;

        result = createCommand->CreateCommand(
            nullptr,
            IID_ICommandText,
            reinterpret_cast<IUnknown**>(&commandText));
        if (FAILED(result))
            break;

        result = commandText->SetCommandText(
            DBGUID_DBSQL,
            const_cast<wchar_t*>(
                L"SELECT TOP (5) ProductID, Name "
                L"FROM SalesLT.Product "
                L"WHERE ProductID > ? "
                L"ORDER BY ProductID;"));
        if (FAILED(result))
            break;

        result = commandText->QueryInterface(
            IID_ICommandWithParameters,
            reinterpret_cast<void**>(&commandParameters));
        if (FAILED(result))
            break;

        DB_UPARAMS parameterOrdinal = 1;
        wchar_t parameterType[] = L"int";
        DBPARAMBINDINFO parameterInfo = {};
        parameterInfo.pwszDataSourceType = parameterType;
        parameterInfo.ulParamSize = sizeof(LONG);
        parameterInfo.dwFlags = DBPARAMFLAGS_ISINPUT;
        parameterInfo.bPrecision = 10;

        result = commandParameters->SetParameterInfo(
            1,
            &parameterOrdinal,
            &parameterInfo);
        if (FAILED(result))
            break;

        result = commandText->QueryInterface(
            IID_IAccessor,
            reinterpret_cast<void**>(&parameterAccessor));
        if (FAILED(result))
            break;

        DBBINDING parameterBinding = {};
        parameterBinding.iOrdinal = 1;
        parameterBinding.obStatus = offsetof(ParameterData, status);
        parameterBinding.obLength = offsetof(ParameterData, length);
        parameterBinding.obValue = offsetof(ParameterData, value);
        parameterBinding.dwPart = DBPART_STATUS | DBPART_LENGTH | DBPART_VALUE;
        parameterBinding.dwMemOwner = DBMEMOWNER_CLIENTOWNED;
        parameterBinding.eParamIO = DBPARAMIO_INPUT;
        parameterBinding.cbMaxLen = sizeof(LONG);
        parameterBinding.wType = DBTYPE_I4;
        parameterBinding.bPrecision = 10;

        DBBINDSTATUS parameterBindStatus = DBBINDSTATUS_OK;
        result = parameterAccessor->CreateAccessor(
            DBACCESSOR_PARAMETERDATA,
            1,
            &parameterBinding,
            sizeof(ParameterData),
            &parameterHandle,
            &parameterBindStatus);
        if (FAILED(result) || parameterBindStatus != DBBINDSTATUS_OK)
        {
            if (SUCCEEDED(result))
                result = E_FAIL;
            break;
        }

        ParameterData parameter = {
            DBSTATUS_S_OK,
            sizeof(LONG),
            0
        };
        DBPARAMS parameters = {
            &parameter,
            1,
            parameterHandle
        };

        result = commandText->Execute(
            nullptr,
            IID_IRowset,
            &parameters,
            nullptr,
            reinterpret_cast<IUnknown**>(&rowset));
        if (FAILED(result))
            break;

        result = rowset->QueryInterface(
            IID_IAccessor,
            reinterpret_cast<void**>(&rowAccessor));
        if (FAILED(result))
            break;

        DBBINDING rowBindings[2] = {};
        rowBindings[0].iOrdinal = 1;
        rowBindings[0].obStatus = offsetof(RowData, productIdStatus);
        rowBindings[0].obLength = offsetof(RowData, productIdLength);
        rowBindings[0].obValue = offsetof(RowData, productId);
        rowBindings[0].dwPart =
            DBPART_STATUS | DBPART_LENGTH | DBPART_VALUE;
        rowBindings[0].dwMemOwner = DBMEMOWNER_CLIENTOWNED;
        rowBindings[0].eParamIO = DBPARAMIO_NOTPARAM;
        rowBindings[0].cbMaxLen = sizeof(LONG);
        rowBindings[0].wType = DBTYPE_I4;
        rowBindings[0].bPrecision = 10;

        rowBindings[1].iOrdinal = 2;
        rowBindings[1].obStatus = offsetof(RowData, nameStatus);
        rowBindings[1].obLength = offsetof(RowData, nameLength);
        rowBindings[1].obValue = offsetof(RowData, name);
        rowBindings[1].dwPart =
            DBPART_STATUS | DBPART_LENGTH | DBPART_VALUE;
        rowBindings[1].dwMemOwner = DBMEMOWNER_CLIENTOWNED;
        rowBindings[1].eParamIO = DBPARAMIO_NOTPARAM;
        rowBindings[1].cbMaxLen =
            productNameCharacters * sizeof(wchar_t);
        rowBindings[1].wType = DBTYPE_WSTR;

        DBBINDSTATUS rowBindStatus[2] = {
            DBBINDSTATUS_OK,
            DBBINDSTATUS_OK
        };
        result = rowAccessor->CreateAccessor(
            DBACCESSOR_ROWDATA,
            2,
            rowBindings,
            sizeof(RowData),
            &rowHandle,
            rowBindStatus);
        if (FAILED(result) ||
            rowBindStatus[0] != DBBINDSTATUS_OK ||
            rowBindStatus[1] != DBBINDSTATUS_OK)
        {
            if (SUCCEEDED(result))
                result = E_FAIL;
            break;
        }

        DBCOUNTITEM productsPrinted = 0;
        while (true)
        {
            result = rowset->GetNextRows(
                DB_NULL_HCHAPTER,
                0,
                1,
                &rowCount,
                &rows);
            if (FAILED(result) || rowCount == 0)
                break;

            RowData row = {};
            result = rowset->GetData(rows[0], rowHandle, &row);
            if (FAILED(result) ||
                row.productIdStatus != DBSTATUS_S_OK ||
                row.productIdLength != sizeof(LONG) ||
                row.nameStatus != DBSTATUS_S_OK ||
                row.nameLength == 0 ||
                row.nameLength % sizeof(wchar_t) != 0 ||
                row.nameLength >= sizeof(row.name))
            {
                result = E_FAIL;
                break;
            }
            row.name[row.nameLength / sizeof(wchar_t)] = L'\0';

            if (productsPrinted == 0)
            {
                std::wcout << L"Connected with MSOLEDBSQL19.\n\n";
                std::wcout << std::left
                           << std::setw(12) << L"Product ID"
                           << L"Name\n";
                std::wcout << std::setw(12) << L"----------"
                           << L"----\n";
            }

            std::wcout << std::left
                       << std::setw(12) << row.productId
                       << row.name << L'\n';
            ++productsPrinted;

            result = rowset->ReleaseRows(
                rowCount,
                rows,
                nullptr,
                nullptr,
                nullptr);
            CoTaskMemFree(rows);
            rows = nullptr;
            rowCount = 0;
            if (FAILED(result))
                break;
        }

        if (FAILED(result))
            break;
        if (productsPrinted == 0)
        {
            result = E_FAIL;
            break;
        }
    }
    while (false);

    if (rows != nullptr)
    {
        if (rowset != nullptr && rowCount != 0)
            rowset->ReleaseRows(rowCount, rows, nullptr, nullptr, nullptr);
        CoTaskMemFree(rows);
    }
    if (rowHandle != DB_NULL_HACCESSOR && rowAccessor != nullptr)
        rowAccessor->ReleaseAccessor(rowHandle, nullptr);
    if (parameterHandle != DB_NULL_HACCESSOR && parameterAccessor != nullptr)
        parameterAccessor->ReleaseAccessor(parameterHandle, nullptr);

    Release(rowAccessor);
    Release(rowset);
    Release(parameterAccessor);
    Release(commandParameters);
    Release(commandText);
    Release(createCommand);
    Release(createSession);
    if (initialized)
        dbInitialize->Uninitialize();
    Release(dbInitialize);
    Release(dataInitialize);
    CoUninitialize();

    if (FAILED(result))
    {
        std::wcerr << L"OLE DB operation failed: 0x"
                   << std::hex << result << L'\n';
        return 1;
    }

    return 0;
}

Die Verbindungszeichenfolge wird an IDataInitialize::GetDataSourceübergeben. Diese API verwendet die Schlüsselwortnamen mit Leerzeichen Use Encryption for Data und Trust Server Certificate. Die Verbindungsfolgen fordern Verschlüsselung an und erfordern eine Zertifikatsvalidierung.

Die Abfrage verwendet ein Fragezeichen als Parametermarker. Die Anwendung bindet die minimale Produkt-ID 0 als SQL Server int, liest bis zu fünf Zeilen aus SalesLT.Productund druckt die Produkt-ID und den Namen aus.

Erstellen und Ausführen der Anwendung

Im selben x64 Native Tools Command Prompt finden Sie den installierten OLE DB SDK-Header und speichern Sie dessen Verzeichnis in OLEDB_INCLUDE:

for /f "delims=" %i in ('where /r "%ProgramFiles%\Microsoft SQL Server\Client SDK\OLEDB" msoledbsql.h') do for %j in ("%~dpi.") do set "OLEDB_INCLUDE=%~fj"

Zeigen Sie das ausgewählte Verzeichnis an und überprüfen Sie, ob es den Header enthält:
```
echo %OLEDB_INCLUDE%
dir "%OLEDB_INCLUDE%\msoledbsql.h"
```

Kompilieren Sie die Anwendung:

cl /std:c++17 /EHsc /W4 /I"%OLEDB_INCLUDE%" oledb-quickstart.cpp /link ole32.lib oleaut32.lib

Führen Sie die Anwendung aus:
```
oledb-quickstart.exe
```
Löschen Sie die Verbindungszeichenfolge in der aktuellen Eingabeaufforderung:
```
set OLEDB_CONNECTION_STRING=
set OLEDB_USER_ID=
set OLEDB_PASSWORD=
```

Die Produktzeilen können je nach AdventureWorksLT-Version variieren. Die Ausgabe ähnelt dem folgenden Beispiel:

Connected with MSOLEDBSQL19.

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

Feedback

War diese Seite hilfreich?

Last updated on 2026-09-19