Datavirtualisering med Azure SQL Managed Instance

Gäller för:Azure SQL Managed Instance

Med datavirtualiseringsfunktionen i Azure SQL Managed Instance kan du köra Transact-SQL-frågor (T-SQL) på filer som lagrar data i vanliga dataformat i Azure Data Lake Storage Gen2 eller Azure Blob Storage och kombinera dem med lokalt lagrade relationsdata med hjälp av kopplingar. På så sätt kan du transparent komma åt externa data (i skrivskyddat läge) samtidigt som du behåller dem i dess ursprungliga format och plats , även kallat datavirtualisering.

Översikt

Datavirtualisering ger två sätt att köra frågor mot filer som är avsedda för olika uppsättningar scenarier:

• OPENROWSET-syntax – optimerad för ad hoc-frågekörning av filer. Används vanligtvis för att snabbt utforska innehållet och strukturen för en ny uppsättning filer.
• CREATE EXTERNAL TABLE syntax – optimerad för repetitiv frågekörning av filer med identisk syntax som om data lagrades lokalt i databasen. Externa tabeller kräver flera förberedelsesteg jämfört med OPENROWSET-syntaxen, men ger mer kontroll över dataåtkomst. Externa tabeller används vanligtvis för analytiska arbetsbelastningar och rapportering.

I båda fallen måste en extern datakälla skapas med T-SQL-syntaxen SKAPA EXTERN DATAKÄLLA , vilket visas i den här artikeln.

Det finns också en CREATE EXTERNAL TABLE AS SELECT-syntax för Azure SQL Managed Instance för att exportera resultatet av en T-SQL SELECT-instruktion till Parquet- eller CSV-filerna i Azure Blob Storage eller Azure Data Lake Storage (ADLS) Gen 2 och skapa en extern tabell ovanpå dessa filer.

Filformat

Filformat för parquet och avgränsad text (CSV) stöds direkt. JSON-filformatet stöds indirekt genom att ange CSV-filformatet där frågor returnerar varje dokument som en separat rad. Du kan parsa rader ytterligare med hjälp av JSON_VALUE och OPENJSON.

Lagringstyper

Filer kan lagras i Azure Data Lake Storage Gen2 eller Azure Blob Storage. Om du vill fråga efter filer måste du ange platsen i ett visst format och använda platstypprefixet som motsvarar typen av extern källa och slutpunkt/protokoll, till exempel följande exempel:

--Blob Storage endpoint
abs://<container>@<storage_account>.blob.core.windows.net/<path>/<file_name>.parquet

--Data Lake endpoint
adls://<container>@<storage_account>.dfs.core.windows.net/<path>/<file_name>.parquet

Kom igång

Om du är nybörjare på datavirtualisering och snabbt vill testa funktioner börjar du med att fråga offentliga datauppsättningar som är tillgängliga i Azure Open Datasets, till exempel datauppsättningen COVID-19 i Bing som tillåter anonym åtkomst.

Använd följande slutpunkter för att köra frågor mot datauppsättningarna I Bing COVID-19:

• Parquet: abs://public@pandemicdatalake.blob.core.windows.net/curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.parquet
• CSV: abs://public@pandemicdatalake.blob.core.windows.net/curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.csv

För en snabbstart kör du den här enkla T-SQL-frågan för att få första insikter om datauppsättningen. Den här frågan använder OPENROWSET för att fråga en fil som lagras i ett offentligt tillgängligt lagringskonto:

--Quick query on a file stored in a publicly available storage account:
SELECT TOP 10 *
FROM OPENROWSET(
 BULK 'abs://public@pandemicdatalake.blob.core.windows.net/curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.parquet',
 FORMAT = 'parquet'
) AS filerows

Du kan fortsätta datamängdsutforskningen genom att lägga till WHERE, GROUP BY och andra satser baserat på resultatuppsättningen för den första frågan.

Om den första frågan misslyckas på den hanterade instansen har den instansen sannolikt begränsad åtkomst till Azure-lagringskonton och du bör kontakta nätverksexperten för att aktivera åtkomst innan du kan fortsätta med frågor.

När du har bekantat dig med att fråga offentliga datamängder kan du byta till icke-offentliga datauppsättningar som kräver att du anger autentiseringsuppgifter, beviljar åtkomsträttigheter och konfigurerar brandväggsregler. I många verkliga scenarier kommer du främst att arbeta med privata datamängder.

Åtkomst till icke-offentliga lagringskonton

En användare som är inloggad i en hanterad instans måste ha behörighet att komma åt och köra frågor mot filer som lagras i ett icke-offentligt lagringskonto. Auktoriseringsstegen beror på hur den hanterade instansen autentiserar till lagringen. Typen av autentisering och eventuella relaterade parametrar tillhandahålls inte direkt med varje fråga. De kapslas in i det databasomfattande autentiseringsobjektet som lagras i användardatabasen. Autentiseringsuppgifterna används av databasen för att komma åt lagringskontot när frågan körs. Azure SQL Managed Instance stöder följande autentiseringstyper:

-- Optional: Create MASTER KEY if it doesn't exist in the database:
-- CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<Some Very Strong Password Here>'
GO
CREATE DATABASE SCOPED CREDENTIAL MyCredential
WITH IDENTITY = 'Managed Identity'

-- Optional: Create MASTER KEY if it doesn't exist in the database:
-- CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<Some Very Strong Password Here>'
GO
CREATE DATABASE SCOPED CREDENTIAL MyCredential
WITH IDENTITY = 'SHARED ACCESS SIGNATURE',
SECRET = 'sv=2018-03-28&ss=bfqt&srt=sco&sp=rwdlacup&se=2019-04-18T20:42:12Z&st=2019-04-18T12:42:12Z&spr=https&sig=lQHczNvrk1KoYLCpFdSsMANd0ef9BrIPBNJ3VYEIq78%3D'

Extern datakälla

En extern datakälla är en abstraktion som gör det enkelt att referera till en filplats i flera frågor. Om du vill fråga offentliga platser behöver du bara ange när du skapar en extern datakälla på filplatsen:

CREATE EXTERNAL DATA SOURCE MyExternalDataSource
WITH (
    LOCATION = 'abs://public@pandemicdatalake.blob.core.windows.net/curated/covid-19/bing_covid-19_data/latest'
)

När du kommer åt icke-offentliga lagringskonton, tillsammans med platsen, måste du också referera till en databasomfattande autentiseringsuppgift med inkapslade autentiseringsparametrar. Följande skript skapar en extern datakälla som pekar på filsökvägen och refererar till en databasomfattande autentiseringsuppgift.

--Create external data source pointing to the file path, and referencing database-scoped credential:
CREATE EXTERNAL DATA SOURCE MyPrivateExternalDataSource
WITH (
    LOCATION = 'abs://public@pandemicdatalake.blob.core.windows.net/curated/covid-19/bing_covid-19_data/latest'
        CREDENTIAL = [MyCredential];
)

Fråga datakällor med OPENROWSET

OPENROWSET-syntaxen möjliggör omedelbar ad hoc-frågor samtidigt som du bara skapar det minimala antalet databasobjekt som krävs.

OPENROWSET kräver endast att du skapar den externa datakällan (och eventuellt autentiseringsuppgifterna) i motsats till metoden för extern tabell, vilket kräver ett externt filformat och själva den externa tabellen .

Parametervärdet DATA_SOURCE läggs automatiskt till i BULK-parametern för att bilda den fullständiga sökvägen till filen.

När du använder OPENROWSET anger du formatet för filen, till exempel följande exempel, som frågar en enda fil:

SELECT TOP 10 *
FROM OPENROWSET(
 BULK 'bing_covid-19_data.parquet',
 DATA_SOURCE = 'MyExternalDataSource',
 FORMAT = 'parquet'
) AS filerows;

Fråga flera filer och mappar

Kommandot OPENROWSET gör det också möjligt att köra frågor mot flera filer eller mappar med hjälp av jokertecken i BULK-sökvägen.

I följande exempel används nyc yellow taxi trip records open data set.

Skapa först den externa datakällan:

--Create the data source first:
CREATE EXTERNAL DATA SOURCE NYCTaxiExternalDataSource
WITH (LOCATION = 'abs://nyctlc@azureopendatastorage.blob.core.windows.net');

Nu kan vi fråga alla filer med .parquet-tillägget i mappar. Här frågar vi till exempel bara de filer som matchar ett namnmönster:

--Query all files with .parquet extension in folders matching name pattern:
SELECT TOP 10 *
FROM OPENROWSET(
 BULK 'yellow/puYear=*/puMonth=*/*.parquet',
 DATA_SOURCE = 'NYCTaxiExternalDataSource',
 FORMAT = 'parquet'
) AS filerows;

När du kör frågor mot flera filer eller mappar måste alla filer som nås med den enskilda OPENROWSET filen ha samma struktur (till exempel samma antal kolumner och datatyper). Det går inte att bläddra igenom mappar rekursivt.

Schemahärledning

Automatisk schemainferens hjälper dig att snabbt skriva frågor och utforska data när du inte känner till filscheman. Schemainferens fungerar bara med parquet-filer.

Även om det är praktiskt kan härledda datatyper vara större än de faktiska datatyperna eftersom det kan finnas tillräckligt med information i källfilerna för att säkerställa att rätt datatyp används. Detta kan leda till dåliga frågeprestanda. Parquet-filer innehåller till exempel inte metadata om maximal kolumnlängd för tecken, så instansen härleder den som varchar(8000).

Använd den lagrade proceduren sp_describe_first_results_set och kontrollera de resulterande datatyperna för frågan, som i följande exempel:

EXEC sp_describe_first_result_set N'
 SELECT
 vendorID, tpepPickupDateTime, passengerCount
 FROM
 OPENROWSET(
  BULK ''yellow/*/*/*.parquet'',
  DATA_SOURCE = ''NYCTaxiExternalDataSource'',
  FORMAT=''parquet''
 ) AS nyc';

När du känner till datatyperna kan du sedan ange dem med hjälp av WITH -satsen för att förbättra prestanda:

SELECT TOP 100
 vendorID, tpepPickupDateTime, passengerCount
FROM
OPENROWSET(
 BULK 'yellow/*/*/*.parquet',
 DATA_SOURCE = 'NYCTaxiExternalDataSource',
 FORMAT='PARQUET'
 )
WITH (
vendorID varchar(4), -- we're using length of 4 instead of the inferred 8000
tpepPickupDateTime datetime2,
passengerCount int
) AS nyc;

Eftersom schemat för CSV-filer inte kan fastställas automatiskt måste kolumner alltid anges med hjälp av WITH -satsen:

SELECT TOP 10 id, updated, confirmed, confirmed_change
FROM OPENROWSET(
 BULK 'bing_covid-19_data.csv',
 DATA_SOURCE = 'MyExternalDataSource',
 FORMAT = 'CSV',
 FIRSTROW = 2
)
WITH (
 id int,
 updated date,
 confirmed int,
 confirmed_change int
) AS filerows;

Filmetadatafunktioner

När du kör frågor mot flera filer eller mappar kan du använda filepath() och filename() funktioner för att läsa filmetadata och hämta en del av sökvägen eller den fullständiga sökvägen och namnet på filen som raden i resultatuppsättningen kommer från:

--Query all files and project file path and file name information for each row:
SELECT TOP 10 filerows.filepath(1) as [Year_Folder], filerows.filepath(2) as [Month_Folder],
filerows.filename() as [File_name], filerows.filepath() as [Full_Path], *
FROM OPENROWSET(
 BULK 'yellow/puYear=*/puMonth=*/*.parquet',
 DATA_SOURCE = 'NYCTaxiExternalDataSource',
 FORMAT = 'parquet') AS filerows;
--List all paths:
SELECT DISTINCT filerows.filepath(1) as [Year_Folder], filerows.filepath(2) as [Month_Folder]
FROM OPENROWSET(
 BULK 'yellow/puYear=*/puMonth=*/*.parquet',
 DATA_SOURCE = 'NYCTaxiExternalDataSource',
 FORMAT = 'parquet') AS filerows;

När den filepath() anropas utan en parameter returnerar funktionen den filsökväg som raden kommer från. När DATA_SOURCE används i OPENROWSETreturneras sökvägen i förhållande till DATA_SOURCE, annars returneras en fullständig filsökväg.

När den anropas med en parameter returneras en del av sökvägen som matchar jokertecknet på den position som anges i parametern. Parametervärdet 1 returnerar till exempel en del av sökvägen som matchar det första jokertecknet.

Funktionen filepath() kan också användas för att filtrera och aggregera rader:

SELECT
 r.filepath() AS filepath
 ,r.filepath(1) AS [year]
 ,r.filepath(2) AS [month]
 ,COUNT_BIG(*) AS [rows]
FROM OPENROWSET(
 BULK 'yellow/puYear=*/puMonth=*/*.parquet',
DATA_SOURCE = 'NYCTaxiExternalDataSource',
FORMAT = 'parquet'
 ) AS r
WHERE
 r.filepath(1) IN ('2017')
 AND r.filepath(2) IN ('10', '11', '12')
GROUP BY
 r.filepath()
 ,r.filepath(1)
 ,r.filepath(2)
ORDER BY
 filepath;

Skapa vy ovanpå OPENROWSET

Du kan skapa och använda vyer för att omsluta OPENROWSET-frågor så att du enkelt kan återanvända den underliggande frågan:

CREATE VIEW TaxiRides AS
SELECT *
FROM OPENROWSET(
 BULK 'yellow/puYear=*/puMonth=*/*.parquet',
 DATA_SOURCE = 'NYCTaxiExternalDataSource',
 FORMAT = 'parquet'
) AS filerows

Det är också praktiskt att lägga till kolumner med filplatsdata i en vy med hjälp av filepath() funktionen för enklare och mer högpresterande filtrering. Med hjälp av vyer kan du minska antalet filer och mängden data som frågan ovanpå vyn behöver läsa och bearbeta när den filtreras av någon av dessa kolumner:

CREATE VIEW TaxiRides AS
SELECT *
 , filerows.filepath(1) AS [year]
 , filerows.filepath(2) AS [month]
FROM OPENROWSET(
 BULK 'yellow/puYear=*/puMonth=*/*.parquet',
 DATA_SOURCE = 'NYCTaxiExternalDataSource',
 FORMAT = 'parquet'
) AS filerows

Vyer gör det också möjligt för rapporterings- och analysverktyg som Power BI att använda resultatet av OPENROWSET.

Externa tabeller

Externa tabeller kapslar in åtkomst till filer som gör frågeupplevelsen nästan identisk med att köra frågor mot lokala relationsdata som lagras i användartabeller. För att skapa en extern tabell krävs att externa datakällor och externa filformatobjekt finns:

--Create external file format
CREATE EXTERNAL FILE FORMAT DemoFileFormat
WITH (
 FORMAT_TYPE=PARQUET
)
GO

--Create external table:
CREATE EXTERNAL TABLE tbl_TaxiRides(
 vendorID VARCHAR(100) COLLATE Latin1_General_BIN2,
 tpepPickupDateTime DATETIME2,
 tpepDropoffDateTime DATETIME2,
 passengerCount INT,
 tripDistance FLOAT,
 puLocationId VARCHAR(8000),
 doLocationId VARCHAR(8000),
 startLon FLOAT,
 startLat FLOAT,
 endLon FLOAT,
 endLat FLOAT,
 rateCodeId SMALLINT,
 storeAndFwdFlag VARCHAR(8000),
 paymentType VARCHAR(8000),
 fareAmount FLOAT,
 extra FLOAT,
 mtaTax FLOAT,
 improvementSurcharge VARCHAR(8000),
 tipAmount FLOAT,
 tollsAmount FLOAT,
 totalAmount FLOAT
)
WITH (
 LOCATION = 'yellow/puYear=*/puMonth=*/*.parquet',
 DATA_SOURCE = NYCTaxiExternalDataSource,
 FILE_FORMAT = DemoFileFormat
);
GO

När den externa tabellen har skapats kan du fråga den precis som andra tabeller:

SELECT TOP 10 *
FROM tbl_TaxiRides;

Precis som OPENROWSETmed externa tabeller kan du köra frågor mot flera filer och mappar med hjälp av jokertecken. Schemainferens stöds inte med externa tabeller.

Prestandaöverväganden

Det finns ingen hård gräns för antalet filer eller mängden data som kan efterfrågas, men frågeprestanda beror på mängden data, dataformat, hur data organiseras och komplexiteten för frågor och kopplingar.

Fråga partitionerade data

Data organiseras ofta i undermappar som även kallas partitioner. Du kan instruera den hanterade instansen att endast köra frågor mot vissa mappar och filer. Detta minskar antalet filer och mängden data som frågan behöver läsa och bearbeta, vilket ger bättre prestanda. Den här typen av frågeoptimering kallas partitionsrensning eller partitionseliminering. Du kan eliminera partitioner från frågekörning med hjälp av metadatafunktionen filepath() i WHERE-satsen för frågan.

Följande exempelfråga läser datafiler för NYC Yellow Taxi endast för de tre sista månaderna 2017:

SELECT
    r.filepath() AS filepath
    ,r.filepath(1) AS [year]
    ,r.filepath(2) AS [month]
    ,COUNT_BIG(*) AS [rows]
FROM OPENROWSET(
        BULK 'yellow/puYear=*/puMonth=*/*.parquet',
        DATA_SOURCE = 'NYCTaxiExternalDataSource',
        FORMAT = 'parquet'
    )
WITH (
    vendorID INT
) AS [r]
WHERE
    r.filepath(1) IN ('2017')
    AND r.filepath(2) IN ('10', '11', '12')
GROUP BY
    r.filepath()
    ,r.filepath(1)
    ,r.filepath(2)
ORDER BY
    filepath;

Om dina lagrade data inte är partitionerade kan du överväga att partitionera dem för att förbättra frågeprestandan.

Om du använder externa tabeller filepath() och filename() funktioner stöds men inte i WHERE-satsen. Du kan fortfarande filtrera efter filename eller filepath om du använder dem i beräknade kolumner. Följande exempel visar detta:

CREATE EXTERNAL TABLE tbl_TaxiRides (
 vendorID VARCHAR(100) COLLATE Latin1_General_BIN2,
 tpepPickupDateTime DATETIME2,
 tpepDropoffDateTime DATETIME2,
 passengerCount INT,
 tripDistance FLOAT,
 puLocationId VARCHAR(8000),
 doLocationId VARCHAR(8000),
 startLon FLOAT,
 startLat FLOAT,
 endLon FLOAT,
 endLat FLOAT,
 rateCodeId SMALLINT,
 storeAndFwdFlag VARCHAR(8000),
 paymentType VARCHAR(8000),
 fareAmount FLOAT,
 extra FLOAT,
 mtaTax FLOAT,
 improvementSurcharge VARCHAR(8000),
 tipAmount FLOAT,
 tollsAmount FLOAT,
 totalAmount FLOAT,
 [Year]  AS CAST(filepath(1) AS INT), --use filepath() for partitioning
 [Month]  AS CAST(filepath(2) AS INT) --use filepath() for partitioning
)
WITH (
 LOCATION = 'yellow/puYear=*/puMonth=*/*.parquet',
 DATA_SOURCE = NYCTaxiExternalDataSource,
 FILE_FORMAT = DemoFileFormat
);
GO

SELECT *
      FROM tbl_TaxiRides
WHERE
      [year]=2017            
      AND [month] in (10,11,12);

Om dina lagrade data inte är partitionerade kan du överväga att partitionera dem för att förbättra frågeprestandan.

Statistik

Att samla in statistik om dina externa data är en av de viktigaste sakerna du kan göra för frågeoptimering. Ju mer instansen vet om dina data, desto snabbare kan den köra frågor. Frågeoptimeraren för SQL-motorn är en kostnadsbaserad optimerare. Den jämför kostnaden för olika frågeplaner och väljer sedan planen med den lägsta kostnaden. I de flesta fall väljer den den plan som körs snabbast.

Automatiskt skapande av statistik

Azure SQL Managed Instance analyserar inkommande användarfrågor för statistik som saknas. Om statistik saknas skapar frågeoptimeraren automatiskt statistik för enskilda kolumner i frågepredikatet eller kopplingsvillkoret för att förbättra kardinalitetsuppskattningarna för frågeplanen. Automatisk skapande av statistik görs synkront så du kan få något sämre frågeprestanda om dina kolumner saknar statistik. Tiden för att skapa statistik för en enskild kolumn beror på storleken på de filer som är mål.

Manuell statistik för OPENROWSET

Enkolumnsstatistik för OPENROWSET sökvägen kan skapas med hjälp av den sys.sp_create_openrowset_statistics lagrade proceduren genom att skicka select-frågan med en enda kolumn som en parameter:

EXEC sys.sp_create_openrowset_statistics N'
SELECT pickup_datetime
FROM OPENROWSET(
 BULK ''abs://public@pandemicdatalake.blob.core.windows.net/curated/covid-19/bing_covid-19_data/latest/*.parquet'',
 FORMAT = ''parquet'') AS filerows
';

Som standard använder instansen 100 % av de data som anges i datamängden för att skapa statistik. Du kan också ange exempelstorleken som en procentandel med hjälp av TABLESAMPLE alternativen. Om du vill skapa statistik med en kolumn för flera kolumner kör sys.sp_create_openrowset_statistics du för var och en av kolumnerna. Du kan inte skapa statistik för flera kolumner för OPENROWSET sökvägen.

Om du vill uppdatera befintlig statistik släpper du dem först med hjälp av den sys.sp_drop_openrowset_statistics lagrade proceduren och återskapar dem sedan med hjälp av sys.sp_create_openrowset_statistics:

EXEC sys.sp_drop_openrowset_statistics N'
SELECT pickup_datetime
FROM OPENROWSET(
 BULK ''abs://public@pandemicdatalake.blob.core.windows.net/curated/covid-19/bing_covid-19_data/latest/*.parquet'',
 FORMAT = ''parquet'') AS filerows
';

Manuell statistik för extern tabell

Syntaxen för att skapa statistik i externa tabeller liknar den som används för vanliga användartabeller. Om du vill skapa statistik för en kolumn anger du ett namn för statistikobjektet och namnet på kolumnen:

CREATE STATISTICS sVendor
ON tbl_TaxiRides (vendorID)
WITH FULLSCAN, NORECOMPUTE;

Alternativen WITH är obligatoriska och för exempelstorleken är FULLSCAN de tillåtna alternativen och SAMPLE n procent.

• Om du vill skapa statistik med en kolumn för flera kolumner kör CREATE STATISTICS du för var och en av kolumnerna.
• Statistik för flera kolumner stöds inte.

Felsöka

Problem med frågekörning orsakas vanligtvis av att den hanterade instansen inte kan komma åt filplatsen. De relaterade felmeddelandena kan rapportera otillräckliga åtkomsträttigheter, icke-existerande plats eller filsökväg, fil som används av en annan process eller att katalogen inte kan visas. I de flesta fall indikerar detta att åtkomsten till filer blockeras av principer för nätverkstrafikkontroll eller på grund av bristande åtkomsträttigheter. Detta är vad som ska kontrolleras:

• Fel eller felstavad platssökväg.
• SAS-nyckelns giltighet: den kan ha upphört att gälla och innehålla ett stavfel, med början med ett frågetecken.
• Tillåtna SAS-nyckelbehörigheter: Läs minst och Lista om jokertecken används.
• Blockerad inkommande trafik på lagringskontot. Mer information finns i Hantera regler för virtuella nätverk för Azure Storage och se till att åtkomst från det hanterade virtuella instansnätverket tillåts.
• Utgående trafik blockerades på den hanterade instansen med hjälp av lagringsslutpunktsprincipen. Tillåt utgående trafik till lagringskontot.
• Åtkomsträttigheter för hanterad identitet: Kontrollera att den hanterade identiteten för instansen har beviljats åtkomstbehörighet till lagringskontot.
• Databasens kompatibilitetsnivå måste vara 130 eller högre för att datavirtualiseringsfrågor ska fungera.

CREATE EXTERNAL TABLE AS SELECT (CETAS)

MED SKAPA EXTERN TABELL SOM SELECT (CETAS) kan du exportera data från din SQL-hanterade instans till ett externt lagringskonto. Du kan använda CETAS för att skapa en extern tabell ovanpå Parquet- eller CSV-filerna Azure Blob Storage eller Azure Data Lake Storage (ADLS) Gen2. CETAS kan också parallellt exportera resultatet av en T-SQL SELECT-instruktion till den skapade externa tabellen. Det finns potential för dataexfiltreringsrisk med dessa funktioner, så CETAS är inaktiverat som standard för Azure SQL Managed Instance. Om du vill aktivera kan du läsa SKAPA EXTERN TABELL SOM SELECT (CETAS).

Begränsningar

• Säkerhetsfunktionen på radnivå stöds inte med externa tabeller.
• Det går inte att definiera regeln för dynamisk datamaskering för en kolumn i en extern tabell.

Kända problem

• När parameterisering för Always Encrypted är aktiverad i SQL Server Management Studio (SSMS) misslyckas datavirtualiseringsfrågor med Incorrect syntax near 'PUSHDOWN' felmeddelande.

Relaterat innehåll

• OPENROWSET T-SQL
• SKAPA EXTERN TABELL
• CREATE EXTERNAL FILE FORMAT
• SKAPA EN EXTERN DATAKÄLLA
• SKAPA EXTERN TABELL SOM VÄLJ