De Community Technical Preview (CTP)-release van SQL Server 2016 heeft ons de kans gegeven om enkele van de nieuwe functies uit te proberen die in de komende versie beschikbaar zullen zijn.
Dynamische gegevensmaskering
Met deze functie kunt u vertrouwelijke gegevens beschermen tegen gebruikers die niet geautoriseerd zijn om deze te zien door een deel of de gehele inhoud van een kolom te verbergen. U kunt bijvoorbeeld een deel van een creditcardnummer vrijgeven zodat helpdeskmedewerkers de laatste vier cijfers kunnen zien; u kunt ervoor kiezen om gegevens in een salariskolom volledig te verbergen.
Als u SQL Server CTP 2.0 gebruikt, moet u deze opdracht uitvoeren om dynamische gegevensmaskering in te schakelen:
DBCC TRACEON(209,219,-1)
Gebruik deze opdracht niet als u een latere versie van de CTP gebruikt, omdat hierdoor dynamische gegevensmaskering wordt uitgeschakeld. (Als u CTP 2.0 gebruikt en u niet voer deze DBCC-opdracht uit of u gebruikt CTP2.1+ en u doe Als u deze opdracht uitvoert, krijgt u de foutmelding "Incorrect syntax near 'masked'" wanneer u probeert een dynamisch masker voor een kolom te definiëren.
De volgende SQL maakt een tabel die dynamische gegevensmaskering gebruikt om de inhoud van drie kolommen te verbergen. De inhoud van de CreditCard kolom zijn gedeeltelijk belicht. Wat wordt onthuld in de Phone kolom wordt overgelaten aan het dynamische gegevensmasker. De standaard voor een tekenreekskolom is "xxxx". De standaardwaarde voor een numerieke kolom is "0". De Email kolom gebruikt een dynamisch gegevensmasker dat specifiek is afgestemd op de inhoud van die kolom.
CREATE TABLE Customer
(ID int IDENTITY PRIMARY KEY,
Name varchar(100) NOT NULL,
CreditCard varchar(9) MASKED WITH (FUNCTION = 'partial(0,"xxxxx",4)') NULL,
Phone varchar(12) MASKED WITH (FUNCTION = 'default()') NULL,
Email varchar(100) MASKED WITH (FUNCTION = 'email()') NULL);
INSERT INTO Customer VALUES('A Name', '111222333', '01937 860000',
'someone@somedomain')
De isql gebruiken programma dat is opgenomen in onze SQL Server ODBC-stuurprogrammadistributie, loggen we in met een SQL Server-account dat niet is geautoriseerd om de inhoud van een gemaskeerde kolom te bekijken:
$ /usr/local/easysoft/unixODBC/bin/isql.sh -v SQLSERVER_2016 myuser mypassword +---------------------------------------+ | Connected! | | | | sql-statement | | help [tablename] | | quit | | | +---------------------------------------+ SQL> select * from customer +----+-------+-----------+-------+---------------+ | ID | Name | CreditCard| Phone | Email | +----+-------+-----------+-------+---------------+ | 1 | A Name| xxxxx2333 | xxxx | [email protected] | +----+-------+-----------+-------+---------------+
We loggen dan in met een account dat wel voldoende rechten heeft:
$ /usr/local/easysoft/unixODBC/bin/isql.sh -v SQLSERVER_2016 sa mypassword +---------------------------------------+ | Connected! | | | | sql-statement | | help [tablename] | | quit | | | +---------------------------------------+ SQL> select * from customer +----+-------+-----------+--------------+------------------------+ | ID | Name | CreditCard| Phone | Email | +----+-------+-----------+--------------+------------------------+ | 1 | A Name| 111222333 | 01937 860000 | [email protected] | +----+-------+-----------+--------------+------------------------+
JSON-ondersteuning
JavaScript Object Notation (JSON) is een tekstformaat dat de uitwisseling van gegevens vergemakkelijkt. Naarmate meer applicatieontwikkelaars JSON gebruiken als hun voorkeursgegevensformaat, groeit de behoefte aan JSON-vriendelijke databases. Als gevolg hiervan hebben verschillende NoSQL-databases JSON gekozen als hun primaire gegevensformaat. Een van die databases is MongoDB.
Op onze testmachines hebben we de JSON-ondersteuning van SQL Server 2016 gebruikt om gegevens uit te wisselen tussen SQL Server en MongoDB.
We hebben het bulkkopieprogramma (bcp) gebruikt dat is opgenomen in de distributie van onze SQL Server ODBC-stuurprogramma's om de klantgegevens die we eerder hebben gemaakt in JSON-indeling te exporteren. (Het bcp-commando maakt verbinding met SQL Server als "sa" en dus worden de gegevens in de gemaskeerde kolommen zichtbaar.)
$ cd /usr/local/easysoft/sqlserver/bcp
$ ./bcp "select * from customer for json auto" queryout customer.json -U sa -c
Password:
Starting copy...
1 row successfully bulk-copied to host file. Total received: 1
Clock Time (ms.) Total : 12129 Average : 0.082 rows per second
$ more customer.json
[{"ID":1,"Name":"A Name","CreditCard":"111222333","Phone":"01937 860000",
"Email":"someone@somedomain"}]
Vervolgens hebben we de JSON-gegevens geïmporteerd in MongoDB:
$ cd /opt/mongodb-linux-x86_64-ubuntu1404-3.0.7/bin $ ./mongoimport --db=SQLServer --collection=Customer --file=customer.json --jsonArray $ connected to: localhost imported 1 document
$ ./mongo
MongoDB shell version: 3.0.7
connecting to: test
> use SQLServer
switched to db SQLServer
> db.Customer.find()
{ "_id" : ObjectId("56334017f6df768ab87f2e8c"), "ID" : 1, "Name" :
"A Name", "CreditCard" : "111222333", "Phone" : "01937 860000",
"Email" : "someone@somedomain" }
>
Beveiliging op rijniveau
Met de functie Beveiliging op rijniveau kan SQL Server 2016 de toegang tot rijgegevens beperken op basis van een SQL Server-aanmelding. Beveiliging op rijniveau is transparant voor SQL Server-gebruikers, ze zijn zich er niet van bewust dat rijen die ze niet mogen zien, worden gefilterd uit hun queryresultaten.
Om deze functie uit te proberen met ons SQL Server ODBC-stuurprogramma, hebben we het beveiligingsvoorbeeld op rijniveau van Microsoft gereproduceerd. We hebben dit gedaan in een database met SQL Server-gebruikers met de namen "Sales1" en "Sales2", die SELECT hebben privileges.
We hebben een tabel gemaakt en gevuld met enkele verkoopgegevens. De SalesRep kolom slaat de gebruikersnaam van de relevante vertegenwoordiger op.
CREATE TABLE Sales ( OrderID int, SalesRep sysname, Product varchar(10), Qty int ); INSERT Sales VALUES (1, 'Sales1', 'Valve', 5), (2, 'Sales1', 'Wheel', 2), (3, 'Sales1', 'Valve', 4), (4, 'Sales2', 'Bracket', 2), (5, 'Sales2', 'Wheel', 5), (6, 'Sales2', 'Seat', 5);
Beveiliging op rijniveau wordt geïmplementeerd met een functie met tabelwaarde die ofwel een enkele rij retourneert, als de gebruiker de juiste toegang heeft, of geen resultaten. In het volgende voorbeeld retourneert de functie tabelwaarde een rij als de SalesRep kolom is dezelfde als de gebruiker die de zoekopdracht uitvoert.
CREATE SCHEMA Security;
CREATE FUNCTION Security.fn_securitypredicate(@SalesRep AS sysname)
RETURNS TABLE
WITH SCHEMABINDING
AS
RETURN SELECT 1 AS fn_securitypredicate_result
WHERE @SalesRep = USER_NAME();
CREATE SECURITY POLICY SalesFilter
ADD FILTER PREDICATE Security.fn_securitypredicate(SalesRep)
ON dbo.Sales
WITH (STATE = ON);
We gebruikten de SQL Server ODBC-driver om als Sales2-gebruiker verbinding te maken met de database. Beveiliging op rijniveau zorgt ervoor dat deze gebruiker alleen verkopen kan zien die zijn gedaan door de gebruiker Sales2.
$ /usr/local/easysoft/unixODBC/bin/isql.sh -v SQLSERVER_2016 Sales2 mypassword +---------------------------------------+ | Connected! | | | | sql-statement | | help [tablename] | | quit | | | +---------------------------------------+ SQL> select * from Sales +------------+----------+-----------+-------+ | OrderID | SalesRep | Product | Qty | +------------+----------+-----------+-------+ | 4 | Sales2 | Bracket | 2 | | 5 | Sales2 | Wheel | 5 | | 6 | Sales2 | Seat | 5 | +------------+----------+-----------+-------+ SQL> select * from Sales where OrderID = 1 +------------+----------+-----------+-------+ | OrderID | SalesRep | Product | Qty | +------------+----------+-----------+-------+ | | | | | +------------+----------+-----------+-------+
In-database R
Met de aankoop door Microsoft van Revolution Analytics, een leverancier van software en diensten voor de programmeertaal R, kunnen ze R integreren met SQL Server. SQL Server 2016 zal de eerste versie van de database zijn die R bevat, waardoor R-code kan worden uitgevoerd in de SQL Server-database-engine.
Als u een eerdere versie van SQL Server hebt, is het alternatief om gegevens van SQL Server naar R te extraheren met behulp van ODBC. Het RODBC-pakket bood een ODBC-interface voor R. We hebben RODBC gebouwd tegen de unixODBC Driver Manager die is opgenomen in de distributie van onze SQL Server-stuurprogramma's en hebben vervolgens enkele SQL Server-gegevens uit R opgehaald:
# export ODBC_LIBS=/usr/local/easysoft/unixODBC/lib
# export ODBC_INCLUDE=/usr/local/easysoft/unixODBC/include
# R CMD INSTALL RODBC_1.3-12.tar.gz
$ R
> library("RODBC")
> ch <- odbcConnect("SQLSERVER_2016")
> sqlQuery(ch, paste("SELECT * from Customer"))
ID Name CreditCard Phone Email
1 1 A Name 111222333 01937 860000 someone@somedomain