Klasyfikacja danych

pobierz sterownika ODBC

Przegląd

W przypadku zarządzania danymi poufnymi program SQL Server i program Azure SQL Server wprowadził możliwość udostępniania kolumn bazy danych z metadanymi poufności, które umożliwiają aplikacji klienckiej obsługę różnych typów poufnych danych (takich jak kondycja, finanse itp.) zgodnie z zasadami ochrony danych.

Aby uzyskać więcej informacji na temat przypisywania klasyfikacji do kolumn, zobacz Odnajdywanie i klasyfikacja danych SQL.

Sterownik Microsoft ODBC 17.2 lub nowszy zezwala na pobieranie tych metadanych za pośrednictwem polecenia SQLGetDescField przy użyciu identyfikatora pola SQL_CA_SS_DATA_CLASSIFICATION.

Format

SQLGetDescField ma następującą składnię:

SQLRETURN SQLGetDescField(  
     SQLHDESC        DescriptorHandle,  
     SQLSMALLINT     RecNumber,  
     SQLSMALLINT     FieldIdentifier,  
     SQLPOINTER      ValuePtr,  
     SQLINTEGER      BufferLength,  
     SQLINTEGER *    StringLengthPtr);

DeskryptorHandle
[Dane wejściowe] Dojście IRD (deskryptor wiersza implementacji). Można pobrać za pomocą wywołania funkcji SQLGetStmtAttr z atrybutem polecenia SQL_ATTR_IMP_ROW_DESC

NumerRekordów
[Dane wejściowe] 0

FieldIdentifier
[Dane wejściowe] SQL_CA_SS_DATA_CLASSIFICATION

Valueptr
[Dane wyjściowe] Bufor wyjściowy

BufferLength
[Dane wejściowe] Długość buforu wyjściowego w bajtach

StringLengthPtr [Output] Wskaźnik do buforu, w którym należy zwrócić całkowitą liczbę bajtów dostępnych do zwrócenia w ValuePtr.

Uwaga / Notatka

Jeśli rozmiar buforu jest nieznany, można go określić, wywołując element SQLGetDescField z wartością ValuePtr jako null i sprawdzając wartość StringLengthPtr.

Jeśli informacje o klasyfikacji danych nie są dostępne, zostanie zwrócony błąd Nieprawidłowe pole deskryptora .

Po pomyślnym wywołaniu metody SQLGetDescField bufor wskazywany przez element ValuePtr będzie zawierać następujące dane:

nn nn [n sensitivitylabels] tt tt [t informationtypes] cc cc [c columnsensitivitys]

Uwaga / Notatka

nn nn, tt tti cc cc są liczbami całkowitymi wielobajtowymi, które są przechowywane z najmniej znaczącym bajtem na najniższym adresie.

sensitivitylabel i informationtype mają obie formę

nn [n bytes name] ii [i bytes id]

columnsensitivity ma postać

nn nn [n sensitivityprops]

Dla każdej kolumny (c), n 4-bajtowe sensitivityprops są obecne:

ss ss tt tt

s — indeks w sensitivitylabels tablicy, FF FF jeśli nie jest oznaczony

t — indeks w informationtypes tablicy, FF FF jeśli nie oznaczono etykietą

Format danych można wyrazić jako następujące pseudo-struktury:

struct IDnamePair {
 BYTE nameLen;
 USHORT name[nameLen];
 BYTE idLen;
 USHORT id[idLen];
};

struct SensitivityProp {
 USHORT labelIdx;
 USHORT infoTypeIdx;
};

USHORT nLabels;
struct IDnamePair labels[nLabels];
USHORT nInfoTypes;
struct IDnamePair infotypes[nInfoTypes];
USHORT nColumns;
struct {
 USHORT nProps;
 struct SensitivityProp[nProps];
} columnClassification[nColumns];

Przykład kodu

Testowanie aplikacji, która demonstruje sposób odczytywania metadanych klasyfikacji danych. W systemie Windows można go skompilować przy użyciu cl /MD dataclassification.c /I (directory of msodbcsql.h) /link odbc32.lib i uruchomić z parametrami obejmującymi ciąg połączenia oraz zapytanie SQL (które zwraca sklasyfikowane kolumny).

#ifdef _WIN32
#include <windows.h>
#endif
#include <sql.h>
#include <sqlext.h>
#include <msodbcsql.h>
#include <stdio.h>
SQLHANDLE env, dbc, stmt;
void checkRC_exit(SQLRETURN rc, SQLHANDLE hand, SQLSMALLINT htype, int retcode, char *action)
{
    if ((rc == SQL_ERROR || rc == SQL_SUCCESS_WITH_INFO) && hand)
    {
        char msg[1024], state[6];
        int i = 0;
        SQLRETURN rc2;
        SQLINTEGER err;
        SQLSMALLINT lenout;
        while ((rc2 = SQLGetDiagRec(htype, hand, ++i, state, &err, msg, sizeof(msg), &lenout)) == SQL_SUCCESS ||
            rc2 == SQL_SUCCESS_WITH_INFO)
            printf("%d (%d)[%s]%s\n", i, err, state, msg);
    }
    if (rc == SQL_ERROR && retcode)
    {
        printf("Error occurred%s%s\n", action ? " upon " : "", action ? action : "");
        exit(retcode);
    }
}
void printLabelInfo(char *type, char **pptr)
{
    char *ptr = *pptr;
    unsigned short nlabels;
    printf("----- %s(%u) -----\n", type, nlabels = *(unsigned short*)ptr);
    ptr += sizeof(unsigned short);
    while (nlabels--)
    {
        int namelen, idlen;
        char *nameptr, *idptr;
        namelen = *ptr++;
        nameptr = ptr;
        ptr += namelen * 2;
        idlen = *ptr++;
        idptr = ptr;
        ptr += idlen * 2;
        wprintf(L"Name: \"%.*s\" Id: \"%.*s\"\n", namelen, nameptr, idlen, idptr);
    }
    *pptr = ptr;
}
int main(int argc, char **argv)
{
    unsigned char *dcbuf;
    unsigned int dclen = 0;
    SQLRETURN rc;
    SQLHANDLE ird;
    if (argc < 3)
    {
        fprintf(stderr, "usage: dataclassification connstr query\n");
        return 1;
    }
    checkRC_exit(SQLAllocHandle(SQL_HANDLE_ENV, 0, &env), 0, 0,
        2, "allocate environment");
    checkRC_exit(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0), env, SQL_HANDLE_ENV,
        3, "set ODBC version");
    checkRC_exit(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), env, SQL_HANDLE_ENV,
        4, "allocate connection");
    checkRC_exit(SQLDriverConnect(dbc, 0, argv[1], SQL_NTS, 0, 0, 0, SQL_DRIVER_NOPROMPT), dbc, SQL_HANDLE_DBC,
        5, "connect to server");
    checkRC_exit(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), dbc, SQL_HANDLE_DBC,
        6, "allocate statement");
    checkRC_exit(SQLExecDirect(stmt, argv[2], SQL_NTS), stmt, SQL_HANDLE_STMT,
        7, "execute query");
    checkRC_exit(SQLGetStmtAttr(stmt, SQL_ATTR_IMP_ROW_DESC, (SQLPOINTER)&ird, SQL_IS_POINTER, 0), stmt, SQL_HANDLE_STMT,
        8, "get IRD handle");
    rc = SQLGetDescFieldW(ird, 0, SQL_CA_SS_DATA_CLASSIFICATION, dcbuf, 0, &dclen);

    checkRC_exit(rc, ird, SQL_HANDLE_DESC, 0, 0);
  

    SQLINTEGER dclenout;
    unsigned char *dcptr;
    unsigned short ncols;
    printf("Data Classification information (%u bytes):\n", dclen);
    if (!(dcbuf = malloc(dclen)))
    {
        printf("Memory Allocation Error");
        return 9;
    }
    checkRC_exit(SQLGetDescFieldW(ird, 0, SQL_CA_SS_DATA_CLASSIFICATION, dcbuf, dclen, &dclenout),
            ird, SQL_HANDLE_DESC, 10, "reading SQL_CA_SS_DATA_CLASSIFICATION");
    dcptr = dcbuf;
    printLabelInfo("Labels", &dcptr);
    printLabelInfo("Information Types", &dcptr);
    printf("----- Column Sensitivities(%u) -----\n", ncols = *(unsigned short*)dcptr);
    dcptr += sizeof(unsigned short);
    while (ncols--)
    {
        unsigned short nprops = *(unsigned short*)dcptr;
        dcptr += sizeof(unsigned short);
        while (nprops--)
        {
            unsigned short labelidx, typeidx;
            labelidx = *(unsigned short*)dcptr; dcptr += sizeof(unsigned short);
            typeidx = *(unsigned short*)dcptr; dcptr += sizeof(unsigned short);
            printf(labelidx == 0xFFFF ? "(none) " : "%u ", labelidx);
            printf(typeidx == 0xFFFF ? "(none)\n" : "%u\n", typeidx);
        }
        printf("-----\n");
    }
    if (dcptr != dcbuf + dclen)
    {
        printf("Error: unexpected parse of DATACLASSIFICATION data\n");
        return 11;
    }
    free(dcbuf);
    
    return 0;
}

Obsługiwana wersja

Sterownik Microsoft ODBC 17.2 umożliwia pobieranie informacji o klasyfikacji danych za pośrednictwem SQLGetDescField, jeśli FieldIdentifier jest ustawione na SQL_CA_SS_DATA_CLASSIFICATION (1237).

Począwszy od Microsoft ODBC Driver 17.4.1.1, można pobrać wersję klasyfikacji danych obsługiwaną przez serwer przy użyciu identyfikatora pola SQL_CA_SS_DATA_CLASSIFICATION_VERSION (1238). W wersji 17.4.1.1 obsługiwana wersja klasyfikacji danych ma wartość "2".

Począwszy od wersji 17.4.2.1, domyślna wersja klasyfikacji danych jest ustawiona na "1" i jest to wersja, którą sterownik zgłasza jako obsługiwaną do SQL Server. Nowy atrybut SQL_COPT_SS_DATACLASSIFICATION_VERSION połączenia (1400) może umożliwić aplikacji zmianę obsługiwanej wersji klasyfikacji danych z "1" do maksymalnej obsługiwanej wersji.

Przykład:

Aby ustawić wersję, należy wykonać to wywołanie bezpośrednio przed wywołaniem SQLConnect lub SQLDriverConnect:

ret = SQLSetConnectAttr(dbc, SQL_COPT_SS_DATACLASSIFICATION_VERSION, (SQLPOINTER)2, SQL_IS_INTEGER);

Wartość aktualnie obsługiwanej wersji klasyfikacji danych można pobrać za pośrednictwem wywołania SQLGetConnectAttr:

ret = SQLGetConnectAttr(dbc, SQL_COPT_SS_DATACLASSIFICATION_VERSION, (SQLPOINTER)&dataClassVersion, SQL_IS_INTEGER, 0);

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2026-01-16