Dataklassificering

Översikt

För att hantera känsliga data introducerade SQL Server och Azure SQL Server möjligheten att tillhandahålla databaskolumner med känslighetsmetadata som gör att klientprogrammet kan hantera olika typer av känsliga data (till exempel hälsa, ekonomi osv.) i enlighet med dataskyddsprinciper.

Mer information om hur du tilldelar klassificering till kolumner finns i SQL Data Discovery and Classification ( SQL Data Discovery and Classification).

Microsoft ODBC Driver 17.2 eller senare tillåter hämtning av dessa metadata via SQLGetDescField med hjälp av SQL_CA_SS_DATA_CLASSIFICATION fältidentifierare.

Format

SQLGetDescField har följande syntax:

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

DescriptorHandle
[Indata] IRD-handtag (Implementeringsradbeskrivning). Kan hämtas med ett anrop till SQLGetStmtAttr med SQL_ATTR_IMP_ROW_DESC-instruktionsattribut

RecNumber
[Indata] 0

FieldIdentifier
[Indata] SQL_CA_SS_DATA_CLASSIFICATION

ValuePtr
[Utdata] Utdatabuffert

BufferLength
[Indata] Längden på utdatabufferten i byte

StringLengthPtr [Utdata] Pekare till bufferten där det totala antalet tillgängliga byte som ska returneras i ValuePtr returneras.

Anmärkning

Om buffertens storlek är okänd kan den fastställas genom att anropa SQLGetDescField med ValuePtr som NULL och undersöka värdet för StringLengthPtr.

Om information om dataklassificering inte är tillgänglig returneras ett ogiltigt beskrivningsfältfel .

Vid ett lyckat anrop till SQLGetDescField innehåller bufferten som valuePtr pekar på följande data:

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

Anmärkning

nn nn, tt tt, och cc cc är flerbytes heltal, som lagras med minst betydande byte på den lägsta adressen.

sensitivitylabel och informationtype är båda av formen

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

columnsensitivity är i formen

nn nn [n sensitivityprops]

För varje kolumn (c)finns n 4 byte sensitivityprops :

ss ss tt tt

s – indexera i sensitivitylabels arrayen, FF FF om den inte är märkt

t – index till informationtypes-arrayen, FF FF om den inte är märkt

Dataformatet kan uttryckas som följande pseudostrukturer:

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

Kodexempel

Testprogram som visar hur du läser metadata för dataklassificering. I Windows kan den kompileras med hjälp av cl /MD dataclassification.c /I (directory of msodbcsql.h) /link odbc32.lib och köras med en anslutningssträng och en SQL-fråga (som returnerar klassificerade kolumner) som parametrar:

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

Version som stöds

Microsoft ODBC Driver 17.2 tillåter hämtning av dataklassificeringsinformation via SQLGetDescField om FieldIdentifier är inställt på SQL_CA_SS_DATA_CLASSIFICATION (1237).

Från och med Microsoft ODBC Driver 17.4.1.1 går det att hämta den version av dataklassificering som stöds av en server via SQLGetDescField fältidentifieraren SQL_CA_SS_DATA_CLASSIFICATION_VERSION (1238). I 17.4.1.1 är den dataklassificeringsversion som stöds inställd på "2".

Från och med 17.4.2.1 är standardversionen av dataklassificering inställd på "1" och är den version som drivrutinen rapporterar till SQL Server som stöds. Ett nytt anslutningsattribut SQL_COPT_SS_DATACLASSIFICATION_VERSION (1400) kan göra det möjligt för programmet att ändra den version av dataklassificering som stöds från "1" upp till det högsta antal som stöds.

Exempel:

För att ställa in versionen bör det här anropet göras direkt före SQLConnect- eller SQLDriverConnect-anropet:

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

Värdet för den version av dataklassificering som stöds för närvarande kan hämtas via SQLGetConnectAttr-anrop:

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

Feedback

Var den här sidan hjälpsam?

Last updated on 2026-01-16