Gegevensclassificatie

Overzicht

Voor het beheren van gevoelige gegevens hebben SQL Server en Azure SQL Server de mogelijkheid geïntroduceerd om databasekolommen te voorzien van vertrouwelijkheidsmetagegevens waarmee de clienttoepassing verschillende typen gevoelige gegevens (zoals status, financieel, enzovoort) kan verwerken in overeenstemming met het beleid voor gegevensbescherming.

Zie SQL Data Discovery en Classification voor meer informatie over het toewijzen van classificatie aan kolommen.

Microsoft ODBC-stuurprogramma 17.2 of hoger staat het ophalen van deze metagegevens via SQLGetDescField toe met behulp van de SQL_CA_SS_DATA_CLASSIFICATION veld-id.

Formaat

SQLGetDescField heeft de volgende syntaxis:

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

DescriptorHandle
[Invoer] IRD-handle (Implementatierijbeschrijving). Kan worden opgehaald via een oproep naar SQLGetStmtAttr met het instructiekenmerk SQL_ATTR_IMP_ROW_DESC

RecNumber
[Invoer] 0

FieldIdentifier
[Invoer] SQL_CA_SS_DATA_CLASSIFICATION

ValuePtr
[Uitvoer] Uitvoerbuffer

BufferLength
[Invoer] Lengte van uitvoerbuffer in bytes

StringLengthPtr [Output] Wijzer naar de buffer waarin het totale aantal bytes dat beschikbaar is om te retourneren via ValuePtr wordt aangegeven.

Opmerking

Als de grootte van de buffer onbekend is, kan deze worden bepaald door SQLGetDescField aan te roepen met ValuePtr als NULL en de waarde van StringLengthPtr te onderzoeken.

Als gegevensclassificatiegegevens niet beschikbaar zijn, wordt er een ongeldige descriptorveldfout geretourneerd.

Na een geslaagde aanroep van SQLGetDescField bevat de buffer die door ValuePtr wordt verwezen de volgende gegevens:

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

Opmerking

nn nn, tt tt en cc cc zijn multibyte gehele getallen, die worden opgeslagen met de minst significante byte op het laagste adres.

sensitivitylabel en informationtype hebben beide dezelfde vorm

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

columnsensitivity heeft de vorm

nn nn [n sensitivityprops]

Voor elke kolom (c) zijn n 4-byte sensitivityprops aanwezig:

ss ss tt tt

s - indexeren in de sensitivitylabels matrix, FF FF indien niet gelabeld

t - index in de informationtypes array, FF FF indien niet gelabeld

De indeling van de gegevens kan worden uitgedrukt als de volgende pseudostructuren:

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

Codevoorbeeld

Testtoepassing die laat zien hoe u metagegevens van gegevensclassificatie kunt lezen. In Windows kan het worden gecompileerd met behulp van cl /MD dataclassification.c /I (directory of msodbcsql.h) /link odbc32.lib een verbindingsreeks en een SQL-query (die geclassificeerde kolommen retourneert) als parameters:

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

Ondersteunde versie

Microsoft ODBC-stuurprogramma 17.2 staat het ophalen van gegevensclassificatie toe via SQLGetDescField als FieldIdentifier is ingesteld op SQL_CA_SS_DATA_CLASSIFICATION (1237).

Vanaf Microsoft ODBC-stuurprogramma 17.4.1.1 is het mogelijk om de versie van gegevensclassificatie op te halen die wordt ondersteund door een server met SQLGetDescField behulp van de SQL_CA_SS_DATA_CLASSIFICATION_VERSION veld-id (1238). In 17.4.1.1 is de ondersteunde versie van de gegevensclassificatie ingesteld op '2'.

Vanaf 17.4.2.1 is de standaardversie van gegevensclassificatie ingesteld op 1 en is de versie die het stuurprogramma rapporteert aan SQL Server zoals ondersteund. Met een nieuw verbindingskenmerk SQL_COPT_SS_DATACLASSIFICATION_VERSION (1400) kan de toepassing de ondersteunde versie van gegevensclassificatie wijzigen van '1' tot het maximum dat wordt ondersteund.

Voorbeeld:

Als u de versie wilt instellen, moet deze aanroep direct vóór de SQLConnect- of SQLDriverConnect-aanroep worden uitgevoerd:

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

De waarde van de momenteel ondersteunde versie van gegevensclassificatie kan worden opgehaald via de SQLGetConnectAttr-aanroep:

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

Feedback

Is deze pagina nuttig?

Last updated on 2026-01-16