Datavirtualisering med Azure SQL Managed Instance

gäller för:Azure SQL Managed Instance

I den här artikeln beskrivs datavirtualiseringsfunktionen i Azure SQL Managed Instance. Med datavirtualisering 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. Du kan kombinera dessa data med lokalt lagrade relationsdata med hjälp av kopplingar. Med datavirtualisering kan du på ett transparent sätt komma åt externa data i skrivskyddat läge, samtidigt som du behåller dem i sin ursprungliga format och plats.

Översikt

Datavirtualisering ger två sätt att köra frågor mot filer som är avsedda för olika 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.
• SKAPA EXTERN TABELL syntax: Optimerad för repetitiv frågning av filer med samma 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. Använd externa tabeller för analytiska arbetsbelastningar och rapportering.

I båda fallen skapar du en extern datakälla med hjälp av T-SQL-syntaxen CREATE EXTERNAL DATA SOURCE( SKAPA EXTERN DATAKÄLLA ), vilket visas i den här artikeln.

CREATE EXTERNAL TABLE AS SELECT-syntaxen är också tillgänglig för Azure SQL Managed Instance. Det här är för att exportera resultatet av en T-SQL-instruktion SELECT 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

Lagra filer i Azure Data Lake Storage Gen2 eller Azure Blob Storage. Om du vill köra frågor mot filer anger du platsen i ett visst format och använder platstypsprefixet som motsvarar typen av extern källa och slutpunkt eller 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 hämta data från datauppsättningarna i Bing COVID-19.

• Parkettgolv: 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 en T-SQL-fråga 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 BYoch andra satser baserat på resultatuppsättningen för den första frågan.

Om den första frågan misslyckas på din SQL-hanterade instans har den instansen sannolikt begränsad åtkomst till Azure Storage-konton. Prata med nätverksexperten för att aktivera åtkomst innan du fortsätter med frågor.

När du är bekant med att köra frågor mot offentliga datauppsättningar bör du överväga att 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 arbetar du främst med privata datamängder.

Åtkomst till icke-offentliga lagringskonton

En användare som loggar in på en SQL-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 SQL-hanterade instansen autentiserar till lagringskontot. Typen av autentisering och eventuella relaterade parametrar tillhandahålls inte direkt med varje fråga. Det databasomfattande autentiseringsobjektet som lagras i användardatabasen kapslar in den här informationen. Databasen använder autentiseringsuppgifterna för att komma åt lagringskontot när frågan körs.

Azure SQL Managed Instance stöder följande autentiseringstyper:

• Hanterad identitet
• Signatur för delad åtkomst (SAS)

-- 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=lQHczNvrk1Ko3VYEIq78%3D'

Extern datakälla

En extern datakälla är en abstraktion som ger en enkel referens till en filplats för flera frågor. Om du vill fråga offentliga platser anger du filplatsen när du skapar en extern datakälla:

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

Om du vill komma åt icke-offentliga lagringskonton anger du platsen och refererar 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 that points to the file path, and that references a 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 OPENROWSETanger 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 New York Citys öppna datamängd för gula taxiresor.

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 du fråga alla filer med .parquet tillägget i mappar. Följande fråga gäller till exempel bara för 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 gör förfrågningar mot flera filer eller mappar måste alla filer som nås med ett enda OPENROWSET 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 kanske inte finns 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 anger du dem med hjälp av WITH -satsen för att förbättra prestandan:

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 anger du alltid kolumner med hjälp WITH av -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;

Filmetadata funktioner

När du ställer frågor mot flera filer eller mappar kan du använda filepath() och filename() funktioner för att läsa filmetadata och få en del av sökvägen eller hela sökvägen och namnet på filen som raden i resultatuppsättningen härstammar 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 funktionen filepath() anropas utan en parameter returnerar den filvägen 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, frågan ovanpå vyn måste läsas och bearbetas 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, så att fråga dem känns nästan detsamma som att fråga lokala relationsdata som lagras i användartabeller. Om du vill skapa en extern tabell måste du ha en extern datakälla och externa filformatobjekt på plats:

--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 du har skapat den externa tabellen kan du fråga den precis som andra tabeller:

SELECT TOP 10 *
FROM tbl_TaxiRides;

Likt OPENROWSET kan externa tabeller använda sig av wildcards för att fråga efter flera filer och mappar. Externa tabeller stöder dock inte schemainferens.

Prestandaöverväganden

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

Sök i partitionerade data

Data organiseras ofta i undermappar, även kallade partitioner. Du kan instruera SQL-hanterad instans 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ågeexekvering med hjälp av metadatafunktionen filepath() i WHERE-satsen av 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, till exempel i följande exempel:

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 data som anges i datauppsättningen 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ökning

Problem med körning av frågor inträffar vanligtvis när den SQL-hanterade instansen inte kan komma åt filplatsen. Relaterade felmeddelanden kan rapportera otillräckliga åtkomsträttigheter, en plats som inte finns, fil som används av en annan process eller så kan katalogen inte visas. I de flesta fall indikerar dessa fel att principer för nätverkstrafikkontroll blockerar åtkomst till filer eller att användaren saknar åtkomstbehörighet. Kontrollera följande:

• Fel eller felstavad platssökväg.
• SAS-nyckelns giltighet. Den kan ha upphört att gälla, innehålla ett stavfel eller börja med ett frågetecken.
• SAS-nyckelbehörigheter tillåts. 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 virtuella SQL-hanterade instansnätverket tillåts.
• Blockerade utgående trafik på den SQL-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 åtkomstbehörighet till lagringskontot.
• Databasens kompatibilitetsnivå måste vara 130 eller högre för att datavirtualiseringsfrågor ska fungera.

SKAPA EXTERN TABELL MED SELECT (CETAS)

CREATE EXTERNAL TABLE AS SELECT Med (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-filer i Azure Blob Storage eller Azure Data Lake Storage (ADLS) Gen2. CETAS kan också parallellt exportera resultatet av en T-SQL-instruktion SELECT till den skapade externa tabellen. Det finns potential för dataexfiltreringsrisk med dessa funktioner, så Azure SQL Managed Instance inaktiverar CETAS som standard. För att aktivera, se 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 problemområden

• 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 EXTERNTABELL
• CREATE EXTERNAL FILE FORMAT (Skapa ett externt filformat)
• SKAPA EN EXTERN DATAKÄLLA
• SKAPA EXTERN TABELL SOM VÄLJ