Gyorsindítás: Csatlakozz és kérdezz a Microsoft OLE DB Driverrel

Ebben a gyorsindításban egy Windows C++ konzol alkalmazást építesz Visual Studio 2022 és újabb verziókkal. Az alkalmazás a Microsoft OLE DB Driver 19 for SQL Server használatával csatlakozik az Azure SQL Database-hez, a Microsoft Fabricben található SQL-adatbázishoz vagy az SQL Serverhez. Paraméterezett lekérdezést hajt végre a AdventureWorksLT mintaadatokra, és ellenőrzi az eredményt.

Prerequisites

Visual Studio 2022 vagy újabb verziók az Asztali fejlesztés C++ használatával munkaterheléssel. Ez a munkaterhelés telepíti az x64 Native Tools parancssort, amelyet ebben a gyorsindításban használtak. A megnyitására vonatkozó utasításokért lásd: A 64 bites üzemeltetett fejlesztői parancssor parancsikonjának használata.
Microsoft OLE DB Driver 19 for SQL Server. Telepítsd az x64 illevezetőt, és válaszd ki mind a kliens komponenseket, mind a szoftverfejlesztő készletet (SDK).

SQL-adatbázis létrehozása

Létrehozni vagy csatlakozni SQL adatbázishoz az alábbi platformok egyikén:

SQL-adatbázis létrehozása percek alatt az Azure Portal használatával

Ehhez a gyorsindításhoz válaszd vagy töltsd be a AdventureWorksLT mintaadatokat.

SQL Server konténerhez hozzuk létre a konténert, és töltsd be a mintaadatokat egy parancsban:

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

Egy meglévő SQL Server példány esetén állíts vissza egy AdventureWorksLT biztonsági mentést az AdventureWorks mintaadatbázisaiból.

Az OLE DB kliens alkalmazás ebben a gyorsindításban Windows-on fut. Egy SQL Server konténer egy másik támogatott hoszton is futhat.

Ellenőrizd a sofőröt

Nyiss meg egy x64 Native Tools parancssort a Visual Studio verziódhoz, majd futtasd le a következő parancsot:

Important

A gyorsindítás parancsai a Parancssor-szintaxist használják. Futtasd őket egy x64 Native Tools Parancssorban, ahol a parancssor vége >. Ne futtasd őket a PowerShellben, ahol a parancssor PS karakterekkel kezdődik.

reg query HKCR\MSOLEDBSQL19

A parancs megjeleníti a regisztrált MSOLEDBSQL19 szolgáltatót.

Konfiguráld a kapcsolatot

Állítsa be a(z) OLEDB_CONNECTION_STRING értéket az x64 Native Tools parancssorban. Az alkalmazás felolvassa a kapcsolati karakterlánc-et a környezetből, és nem jeleníti meg.

Azure SQL Database vagy SQL database in Fabric esetén használd a Microsoft Entra interaktív hitelesítést. Helyettesítsd a helyőrzőket az SQL-erőforrásodban található kiszolgáló, adatbázis és Microsoft Entra felhasználói azonosító értékével:

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;"

Az Fabric SQL adatbázishoz az identitásodnak olvasási engedélyre van szüksége az adatbázis elemhez. Az SQL hitelesítés nem támogatott. További információ: Hitelesítés az SQL Database-ben a Microsoft Fabricben.

Egy meglévő SQL Server példányhoz, amely elfogadja a Windows hitelesítést, használd Integrated Security=SSPIa következőket:

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;"

SQL-hitelesítést elfogadó SQL Server-példány vagy -tároló esetén használja a következőt: 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;"

Az SQL Server tanúsítványnak a szerver nevét és láncát egy olyan tanúsító hatósággal (CA) kell egyeztetnie, amelyet a Windows kliens megbízik. SQL Server konténerhez konfiguráld a Transport Layer Security (TLS) rendszert a konténerben, és regisztráld a kiadó CA-t a Windows kliensben, mielőtt elindítanád az alkalmazást. További információért lásd: Titkosítsa kapcsolatokat SQL Server on Linux és Configure SQL Server adatbázismotor a titkosítási kapcsolatok számára.

Az alkalmazás létrehozása

Hozz létre egy projektkönyvtárat:

mkdir oledb-quickstart
cd oledb-quickstart

Hozzon létre egy oledb-quickstart.cpp nevű fájlt a következő kóddal:

#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;
}

A kapcsolati karakterlánc átadódik a következőnek: IDataInitialize::GetDataSource. Ez az API a szóközzel elválasztott kulcsszóneveket használja: Use Encryption for Data és Trust Server Certificate. A kapcsolati láncok titkosítást kérnek és tanúsítvány ellenőrzést igényelnek.

A lekérdezés kérdőjelet használ paraméterjelölőként. Az alkalmazás a minimális termékazonosítót 0 SQL Server int néven köti meg, legfeljebb öt sort olvas ki , SalesLT.Productés kinyomtatja a termékazonosítót és a nevet.

Az alkalmazás létrehozása és futtatása

Ugyanebben az x64 Native Tools parancssorban keresd meg a telepített OLE DB SDK fejlécét, és tárold a könyvtárat a következőkben 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"

Jelenítse meg a kiválasztott könyvtárat, és ellenőrizze, hogy tartalmazza-e a fejlécet:
```
echo %OLEDB_INCLUDE%
dir "%OLEDB_INCLUDE%\msoledbsql.h"
```

Fordítsa le az alkalmazást

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

Futtassa az alkalmazást:
```
oledb-quickstart.exe
```

Távolítsd el a kapcsolati sztringet az aktuális Parancssorból:

set OLEDB_CONNECTION_STRING=
set OLEDB_USER_ID=
set OLEDB_PASSWORD=

A terméksorok az AdventureWorksLT verziótól függően változhatnak. A kimenet a következő példához hasonlít:

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

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-09-19