SKAPA EXTERN TABELL SOM SELECT (CETAS) (Transact-SQL)

gäller för: SQL Server 2022 (16.x) och senare Azure Synapse AnalyticsAnalytics Platform System (PDW)

Skapar en extern tabell och exporterar sedan, parallellt, resultatet av en Transact-SQL SELECT-instruktion.

• Azure Synapse Analytics and Analytics Platform System stöder Hadoop eller Azure Blob Storage.
• SQL Server 2022 (16.x) och senare versioner stöder CREATE EXTERNAL TABLE AS SELECT (CETAS) för att skapa en extern tabell och exporterar sedan, parallellt, resultatet av en Transact-SQL SELECT-instruktion till Azure Data Lake Storage (ADLS) Gen2, Azure Storage Account V2 och S3-kompatibel objektlagring.

Not

Funktionerna och säkerheten för CETAS för Azure SQL Managed Instance skiljer sig från SQL Server eller Azure Synapse Analytics. Mer information finns i Azure SQL Managed Instance-versionen av CREATE EXTERNAL TABLE AS SELECT.

Not

Funktionerna och säkerheten i CETAS för serverlösa pooler i Azure Synapse Analytics skiljer sig från SQL Server. Mer information finns i CETAS med Synapse SQL.

Transact-SQL syntaxkonventioner

Syntax

CREATE EXTERNAL TABLE { [ [ database_name . [ schema_name ] . ] | schema_name . ] table_name }
    [ (column_name [ , ...n ] ) ]
    WITH (
        LOCATION = 'hdfs_folder' | '<prefix>://<path>[:<port>]' ,
        DATA_SOURCE = external_data_source_name ,
        FILE_FORMAT = external_file_format_name
        [ , <reject_options> [ , ...n ] ]
    )
    AS <select_statement>
[;]

<reject_options> ::=
{
    | REJECT_TYPE = value | percentage
    | REJECT_VALUE = reject_value
    | REJECT_SAMPLE_VALUE = reject_sample_value
}

<select_statement> ::=
    [ WITH <common_table_expression> [ , ...n ] ]
    SELECT <select_criteria>

Argument

[ [ database_name . [ schema_name ] . ] | schema_name . ] table_name

Tabellnamnet i en till tre delar som ska skapas i databasen. För en extern tabell lagrar relationsdatabasen endast tabellmetadata.

[ ( column_name [ ,... n ] ) ]

Namnet på en tabellkolumn.

PLATS

gäller för: Azure Synapse Analytics and Analytics Platform System

'hdfs_folder'**
Anger var resultatet av SELECT-instruktionen ska skrivas på den externa datakällan. Platsen är ett mappnamn och kan eventuellt innehålla en sökväg som är relativ till rotmappen för Hadoop-klustret eller Blob Storage. PolyBase skapar sökvägen och mappen om den inte redan finns.

De externa filerna skrivs till hdfs_folder och heter QueryID_date_time_ID.format, där ID är en inkrementell identifierare och format är det exporterade dataformatet. Ett exempel är QID776_20160130_182739_0.orc.

LOCATION måste peka på en mapp och ha en avslutande /, till exempel: aggregated_data/.

gäller för: SQL Server 2022 (16.x) och senare

prefix://path[:port] tillhandahåller anslutningsprotokollet (prefixet), sökvägen och eventuellt porten till den externa datakällan, där resultatet av SELECT-instruktionen skrivs.

Om målet är S3-kompatibelt objektlagring måste det först finnas en bucket, men PolyBase kan skapa undermappar om det behövs. SQL Server 2022 (16.x) stöder Azure Data Lake Storage Gen2, Azure Storage Account V2 och S3-kompatibel objektlagring. ORC-filer stöds inte för närvarande.

DATA_SOURCE = external_data_source_name

Anger namnet på det externa datakällans objekt som innehåller den plats där externa data lagras eller kommer att lagras. Platsen är antingen ett Hadoop-kluster eller en Azure Blob Storage. Om du vill skapa en extern datakälla använder du CREATE EXTERNAL DATA SOURCE (Transact-SQL).

FILE_FORMAT = external_file_format_name

Anger namnet på det externa filformatobjektet som innehåller formatet för den externa datafilen. Om du vill skapa ett externt filformat använder du CREATE EXTERNAL FILE FORMAT (Transact-SQL).

ALTERNATIV FÖR AVVISA

AVVISA-alternativ gäller inte när den här CREATE EXTERNAL TABLE AS SELECT-instruktionen körs. I stället anges de här så att databasen kan använda dem vid ett senare tillfälle när den importerar data från den externa tabellen. När instruktionen CREATE TABLE AS SELECT senare väljer data från den externa tabellen använder databasen alternativen för att avvisa för att fastställa antalet eller procentandelen rader som inte kan importeras innan importen stoppas.

• REJECT_VALUE = reject_value

  Anger värdet eller procentandelen rader som inte kan importeras innan databasen stoppar importen.

• REJECT_TYPE = värde | procent

  Klargör om alternativet REJECT_VALUE är ett literalvärde eller en procentsats.

  • värde

    Används om REJECT_VALUE är ett literalvärde, inte en procentandel. Databasen slutar importera rader från den externa datafilen när antalet misslyckade rader överskrider reject_value.

    Om REJECT_VALUE = 5 och REJECT_TYPE = valueslutar databasen till exempel att importera rader efter att fem rader inte har importerats.

  • procentsats

    Används om REJECT_VALUE är en procentandel, inte ett literalvärde. Databasen slutar importera rader från den externa datafilen när den procentandelen av misslyckade rader överskrider reject_value. Procentandelen misslyckade rader beräknas med intervall. Gäller endast i dedikerade SQL-pooler när TYPE=HADOOP.

• REJECT_SAMPLE_VALUE = reject_sample_value

  Krävs när REJECT_TYPE = percentage. Anger antalet rader som ska importeras innan databasen beräknar om procentandelen misslyckade rader.

  Om till exempel REJECT_SAMPLE_VALUE = 1 000 beräknar databasen procentandelen misslyckade rader när den har försökt importera 1 000 rader från den externa datafilen. Om procentandelen misslyckade rader är mindre än reject_valueförsöker databasen läsa in ytterligare 1 000 rader. Databasen fortsätter att beräkna om procentandelen misslyckade rader när den försöker importera ytterligare 1 000 rader.

  Not

  Eftersom databasen beräknar procentandelen misslyckade rader med intervall kan den faktiska procentandelen misslyckade rader överskrida reject_value.

  Exempel:

  Det här exemplet visar hur de tre REJECT-alternativen interagerar med varandra. Om REJECT_TYPE = percentage, REJECT_VALUE = 30, REJECT_SAMPLE_VALUE = 100kan till exempel följande scenario inträffa:

  • Databasen försöker läsa in de första 100 raderna, varav 25 misslyckas och 75 lyckas.
  • Procentandelen misslyckade rader beräknas som 25%, vilket är mindre än värdet för avvisande av 30%. Så det finns ingen anledning att stoppa belastningen.
  • Databasen försöker läsa in de kommande 100 raderna. Den här gången lyckas 25 och 75 misslyckas.
  • Procenten misslyckade rader beräknas om till 50%. Procentandelen misslyckade rader har överskridit värdet 30% avvisa.
  • Belastningen misslyckas med 50% misslyckade rader efter försök att läsa in 200 rader, vilket är större än den angivna gränsen på 30%.

MED common_table_expression

Anger en tillfällig namngiven resultatuppsättning, som kallas för ett gemensamt tabelluttryck (CTE). Mer information finns i WITH common_table_expression (Transact-SQL)

VÄLJ <select_criteria>

Fyller i den nya tabellen med resultatet från en SELECT-instruktion. select_criteria är brödtexten i SELECT-instruktionen som avgör vilka data som ska kopieras till den nya tabellen. Information om SELECT-instruktioner finns i SELECT (Transact-SQL).

Not

ORDER BY-satsen i SELECT har ingen effekt på CETAS.

Kolumnalternativ

• column_name [ ,... n ]

  Kolumnnamn tillåter inte de kolumnalternativ som anges i CREATE TABLE. I stället kan du ange en valfri lista med ett eller flera kolumnnamn för den nya tabellen. Kolumnerna i den nya tabellen använder de namn som du anger. När du anger kolumnnamn måste antalet kolumner i kolumnlistan matcha antalet kolumner i urvalsresultatet. Om du inte anger några kolumnnamn använder den nya måltabellen kolumnnamnen i select-instruktionsresultatet.

  Du kan inte ange några andra kolumnalternativ, till exempel datatyper, sortering eller nullabilitet. Vart och ett av dessa attribut härleds från resultatet av SELECT-instruktionen. Du kan dock använda SELECT-instruktionen för att ändra attributen. Ett exempel finns i Använda CETAS för att ändra kolumnattribut.

Behörigheter

För att köra det här kommandot behöver -databasanvändaren alla dessa behörigheter eller medlemskap:

• ALTER SCHEMA behörighet för det lokala schemat som innehåller den nya tabellen eller medlemskapet i den db_ddladmin fasta databasrollen.
• SKAPA TABELL behörighet eller medlemskap i den db_ddladmin fasta databasrollen.
• SELECT behörighet för alla objekt som refereras i select_criteria.

Inloggningen behöver alla dessa behörigheter:

• ADMINISTRERA MASSÅTGÄRDER
• ÄNDRA ALLA EXTERNA DATAKÄLLOR
• ÄNDRA ALLA EXTERNA FILFORMAT
• I allmänhet måste du ha behörighet att Lista mappinnehåll och Skriva till MAPPEN LOCATION för CETAS.
• I Azure Synapse Analytics and Analytics Platform System Skriv behörighet att läsa och skriva till den externa mappen i Hadoop-klustret eller i Azure Blob Storage.
• I SQL Server 2022 (16.x) måste du också ange rätt behörigheter på den externa platsen. Skriv behörighet att mata ut data till platsen och Läs behörighet att komma åt dem.
• För Azure Blob Storage och Azure Data Lake Gen2 måste SHARED ACCESS SIGNATURE-token beviljas följande behörigheter för containern: Läs, Skriva, ListaSkapa.
• För Azure Blog Storage måste kryssrutan Allowed Services: Blob vara markerad för att generera SAS-token.
• För Azure Data Lake Gen2 måste kryssrutorna Allowed Services: Container och Object markeras för att generera SAS-token.

Viktig

Behörigheten ALTER ANY EXTERNAL DATA SOURCE ger alla huvudnamn möjlighet att skapa och ändra alla externa datakällans objekt, så det ger också möjlighet att komma åt alla databasomfattningsautentiseringsuppgifter i databasen. Den här behörigheten måste betraktas som högprivilegierad och får endast beviljas betrodda huvudnamn i systemet.

Felhantering

När CREATE EXTERNAL TABLE AS SELECT exporterar data till en textavgränsad fil finns det ingen avvisande fil för rader som inte kan exporteras.

När du skapar den externa tabellen försöker databasen ansluta till den externa platsen. Om anslutningen misslyckas misslyckas kommandot och den externa tabellen skapas inte. Det kan ta en minut eller mer innan kommandot misslyckas eftersom databasen försöker ansluta igen minst tre gånger.

Om CREATE EXTERNAL TABLE AS SELECT avbryts eller misslyckas gör databasen ett engångsförsök att ta bort alla nya filer och mappar som redan har skapats på den externa datakällan.

I Azure Synapse Analytics and Analytics Platform System rapporterar databasen eventuella Java-fel som inträffar på den externa datakällan under dataexporten.

Anmärkningar

När CREATE EXTERNAL TABLE AS SELECT-instruktionen är klar kan du köra Transact-SQL frågor i den externa tabellen. Dessa åtgärder importerar data till databasen under frågans varaktighet såvida du inte importerar med hjälp av instruktionen CREATE TABLE AS SELECT.

Det externa tabellnamnet och definitionen lagras i databasens metadata. Data lagras i den externa datakällan.

CREATE EXTERNAL TABLE AS SELECT-instruktionen skapar alltid en icke-partitionerad tabell, även om källtabellen är partitionerad.

För SQL Server 2022 (16.x) måste alternativet allow polybase export aktiveras med hjälp av sp_configure. Mer information finns i Ange allow polybase export konfigurationsalternativ.

För frågeplaner i Azure Synapse Analytics and Analytics Platform System, som skapats med EXPLAIN, använder databasen dessa frågeplansåtgärder för externa tabeller: Flytt av extern shuffle, extern sändningsflytt, extern partitionsflytt.

I Analytics Platform System måste installationsadministratören konfigurera Hadoop-anslutning som en förutsättning för att skapa en extern tabell. Mer information finns i "Konfigurera anslutning till externa data (Analytics Platform System)" i dokumentationen för Analysplattformssystemet, som du kan ladda ned från Microsoft Download Center.

Begränsningar och begränsningar

Eftersom externa tabelldata finns utanför databasen fungerar säkerhetskopierings- och återställningsåtgärder endast på data som lagras i databasen. Därför säkerhetskopieras och återställs endast metadata.

Databasen verifierar inte anslutningen till den externa datakällan när du återställer en databassäkerhetskopia som innehåller en extern tabell. Om den ursprungliga källan inte är tillgänglig kommer metadataåterställningen för den externa tabellen fortfarande att lyckas, men SELECT-åtgärder i den externa tabellen misslyckas.

Databasen garanterar inte datakonsekvens mellan databasen och externa data. Du, kunden, är ensam ansvarig för att upprätthålla konsekvensen mellan externa data och databasen.

DML-åtgärder (Data Manipulation Language) stöds inte i externa tabeller. Du kan till exempel inte använda Transact-SQL uppdatera, infoga eller ta bort Transact-SQL-instruktioner för att ändra externa data.

ÅTGÄRDERNA CREATE TABLE, DROP TABLE, CREATE STATISTICS, DROP STATISTICS, CREATE VIEW och DROP VIEW är de enda DDL-åtgärder (Data Definition Language) som tillåts i externa tabeller.

Begränsningar och begränsningar för Azure Synapse Analytics

• I dedikerade SQL-pooler i Azure Synapse Analytics och Analytics Platform System kan PolyBase använda högst 33 000 filer per mapp när 32 samtidiga PolyBase-frågor körs. Det här maximala antalet inkluderar både filer och undermappar i varje HDFS-mapp. Om samtidigheten är mindre än 32 kan en användare köra PolyBase-frågor mot mappar i HDFS som innehåller mer än 33 000 filer. Vi rekommenderar att användare av Hadoop och PolyBase håller filsökvägarna korta och använder högst 30 000 filer per HDFS-mapp. När för många filer refereras inträffar ett undantag från JVM out-of-memory.

• I serverlösa SQL-pooler kan externa tabeller inte skapas på en plats där du för närvarande har data. Om du vill återanvända en plats som har använts för att lagra data måste platsen tas bort manuellt på ADLS. Fler begränsningar och metodtips finns i Metodtips för filteroptimering.

I dedikerade SQL-pooler i Azure Synapse Analytics och Analytics Platform System får kolumnvärdena i RCFile inte innehålla tecknet pipe (|) när CREATE EXTERNAL TABLE AS SELECT väljer från en RCFile.

SET ROWCOUNT (Transact-SQL) har ingen effekt på SKAPA EXTERN TABELL SOM SELECT. Använd TOP (Transact-SQL)för att uppnå ett liknande beteende.

Granska Namngivning och referens av containrar, blobar och metadata för begränsningar i filnamn.

Teckenfel

Följande tecken som finns i data kan orsaka fel, inklusive avvisade poster med CREATE EXTERNAL TABLE AS SELECT till Parquet-filer.

I Azure Synapse Analytics and Analytics Platform System gäller detta även för ORC-filer.

• |
• " (citattecken)
• \r\n
• \r
• \n

Om du vill använda CREATE EXTERNAL TABLE AS SELECT som innehåller dessa tecken måste du först köra CREATE EXTERNAL TABLE AS SELECT-instruktionen för att exportera data till avgränsade textfiler där du sedan kan konvertera dem till Parquet eller ORC med hjälp av ett externt verktyg.

Arbeta med parquet

När du arbetar med parquet-filer genererar CREATE EXTERNAL TABLE AS SELECT en parquetfil per tillgänglig PROCESSOR, upp till den konfigurerade maximala graden av parallellitet (MAXDOP). Varje fil kan växa upp till 190 GB, efter det genererar SQL Server fler Parquet-filer efter behov.

Frågetipset OPTION (MAXDOP n) påverkar bara SELECT-delen av CREATE EXTERNAL TABLE AS SELECT. Det har ingen inverkan på antalet parquet-filer. Endast MAXDOP på databasnivå och MAXDOP på instansnivå beaktas.

Låsning

Tar ett delat lås på OBJEKTET SCHEMARESOLUTION.

Datatyper som stöds

CETAS kan användas för att lagra resultatuppsättningar med följande SQL-datatyper:

• binär
• varbinary
• röding
• varchar
• nchar
• nvarchar
• smalldate
• datum
• datetime
• datetime2
• datetimeoffset
• Tid
• decimal
• numerisk
• flyta
• verklig
• bigint
• tinyint
• smallint
• Int
• bigint
• bit
• pengar
• smallmoney

Exempel

A. Skapa en Hadoop-tabell med HJÄLP av CREATE EXTERNAL TABLE AS SELECT

gäller för: Azure Synapse Analytics and Analytics Platform System

I följande exempel skapas en ny extern tabell med namnet hdfsCustomer som använder kolumndefinitionerna och data från källtabellen dimCustomer.

Tabelldefinitionen lagras i databasen och resultatet av SELECT-instruktionen exporteras till den /pdwdata/customer.tbl filen på den externa Hadoop-datakällan customer_ds. Filen är formaterad enligt det externa filformatet customer_ff.

Filnamnet genereras av databasen och innehåller fråge-ID:t för att enkelt justera filen med frågan som genererade den.

Sökvägen hdfs://xxx.xxx.xxx.xxx:5000/files/ före kundkatalogen måste redan finnas. Om kundkatalogen inte finns skapar databasen katalogen.

Not

Det här exemplet anger för 5 000. Om porten inte anges använder databasen 8020 som standardport.

Den resulterande Hadoop-platsen och filnamnet blir hdfs:// xxx.xxx.xxx.xxx:5000/files/Customer/ QueryID_YearMonthDay_HourMinutesSeconds_FileIndex.txt..

-- Example is based on AdventureWorks
CREATE EXTERNAL TABLE hdfsCustomer
    WITH (
            LOCATION = '/pdwdata/customer.tbl',
            DATA_SOURCE = customer_ds,
            FILE_FORMAT = customer_ff
            ) AS

SELECT *
FROM dimCustomer;
GO

B. Använd ett frågetips med CREATE EXTERNAL TABLE AS SELECT

gäller för: Azure Synapse Analytics and Analytics Platform System

Den här frågan visar den grundläggande syntaxen för att använda ett frågekopplingstips med instruktionen CREATE EXTERNAL TABLE AS SELECT. När frågan har skickats använder databasen hashkopplingsstrategin för att generera frågeplanen. Mer information om kopplingstips och hur du använder OPTION-satsen finns i OPTION-satsen (Transact-SQL).

Not

Det här exemplet anger för 5 000. Om porten inte anges använder databasen 8020 som standardport.

-- Example is based on AdventureWorks
CREATE EXTERNAL TABLE dbo.FactInternetSalesNew
    WITH (
            LOCATION = '/files/Customer',
            DATA_SOURCE = customer_ds,
            FILE_FORMAT = customer_ff
            ) AS

SELECT T1.*
FROM dbo.FactInternetSales T1
INNER JOIN dbo.DimCustomer T2
    ON (T1.CustomerKey = T2.CustomerKey)
OPTION (HASH JOIN);
GO

C. Använda CETAS för att ändra kolumnattribut

gäller för: Azure Synapse Analytics and Analytics Platform System

I det här exemplet används CETAS för att ändra datatyper, nullabilitet och sortering för flera kolumner i FactInternetSales-tabellen.

-- Example is based on AdventureWorks
CREATE EXTERNAL TABLE dbo.FactInternetSalesNew
    WITH (
            LOCATION = '/files/Customer',
            DATA_SOURCE = customer_ds,
            FILE_FORMAT = customer_ff
            ) AS

SELECT T1.ProductKey AS ProductKeyNoChange,
    T1.OrderDateKey AS OrderDate,
    T1.ShipDateKey AS ShipDate,
    T1.CustomerKey AS CustomerKeyNoChange,
    T1.OrderQuantity AS Quantity,
    T1.SalesAmount AS MONEY
FROM dbo.FactInternetSales T1
INNER JOIN dbo.DimCustomer T2
    ON (T1.CustomerKey = T2.CustomerKey)
OPTION (HASH JOIN);
GO

D. Använd CREATE EXTERNAL TABLE AS SELECT för att exportera data som parquet

gäller för: SQL Server 2022 (16.x)

I följande exempel skapas en ny extern tabell med namnet ext_sales som använder data från tabellen SalesOrderDetail i AdventureWorks2022. Alternativet tillåta konfiguration av polybase-export måste vara aktiverat.

Resultatet av SELECT-instruktionen sparas på S3-kompatibel objektlagring som tidigare konfigurerats och heter s3_edsoch rätt autentiseringsuppgifter som skapats som s3_dsc. Parquet-filplatsen kommer att vara <ip>:<port>/cetas/sales.parquet där cetas är den tidigare skapade lagringshinken.

Not

Delta-format stöds för närvarande endast som skrivskyddat.

-- Credential to access the S3-compatible object storage
CREATE DATABASE SCOPED CREDENTIAL s3_dsc
    WITH IDENTITY = 'S3 Access Key',
        SECRET = '<accesskeyid>:<secretkeyid>'
GO

-- S3-compatible object storage data source
CREATE EXTERNAL DATA SOURCE s3_eds
    WITH (
            LOCATION = 's3://<ip>:<port>',
            CREDENTIAL = s3_dsc
            )

-- External File Format for PARQUET
CREATE EXTERNAL FILE FORMAT ParquetFileFormat
    WITH (FORMAT_TYPE = PARQUET);
GO

CREATE EXTERNAL TABLE ext_sales
    WITH (
            LOCATION = '/cetas/sales.parquet',
            DATA_SOURCE = s3_eds,
            FILE_FORMAT = ParquetFileFormat
            ) AS

SELECT *
FROM AdventureWorks2022.[Sales].[SalesOrderDetail];
GO

E. Använd CREATE EXTERNAL TABLE AS SELECT från deltatabell till parquet

gäller för: SQL Server 2022 (16.x)

I följande exempel skapas en ny extern tabell med namnet Delta_to_Parquet, som använder Delta Table-typen av data som finns i en S3-kompatibel objektlagring med namnet s3_deltaoch skriver resultatet i en annan datakälla med namnet s3_parquet som en parquet-fil. För det använder exemplet kommandot OPENROWSET. Alternativet tillåta konfiguration av polybase-export måste vara aktiverat.

-- External File Format for PARQUET
CREATE EXTERNAL FILE FORMAT ParquetFileFormat
    WITH (FORMAT_TYPE = PARQUET);
GO

CREATE EXTERNAL TABLE Delta_to_Parquet
    WITH (
            LOCATION = '/backup/sales.parquet',
            DATA_SOURCE = s3_parquet,
            FILE_FORMAT = ParquetFileFormat
            ) AS

SELECT *
FROM OPENROWSET(BULK '/delta/sales_fy22/', FORMAT = 'DELTA', DATA_SOURCE = 's3_delta') AS [r];
GO

F. Använda CREATE EXTERNAL TABLE AS SELECT med en vy som källa

gäller för: Serverlösa SQL-pooler och dedikerade SQL-pooler i Azure Synapse Analytics.

Använd följande exempel som en mall för att skriva CETAS med en användardefinierad vy som källa, med hjälp av en hanterad identitet för autentisering och abfs:-slutpunkten:

CREATE DATABASE [<mydatabase>];
GO

USE [<mydatabase>];
GO

CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<strong password>';

CREATE DATABASE SCOPED CREDENTIAL [WorkspaceIdentity] WITH IDENTITY = 'managed identity';
GO

CREATE EXTERNAL FILE FORMAT [ParquetFF] WITH (
    FORMAT_TYPE = PARQUET,
    DATA_COMPRESSION = 'org.apache.hadoop.io.compress.SnappyCodec'
);
GO

CREATE EXTERNAL DATA SOURCE [SynapseSQLwriteable] WITH (
    LOCATION = 'abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path>/<file_name>',
    CREDENTIAL = [WorkspaceIdentity]
);
GO

CREATE EXTERNAL TABLE [dbo].[<myexternaltable>] WITH (
        LOCATION = '<myoutputsubfolder>/',
        DATA_SOURCE = [SynapseSQLwriteable],
        FILE_FORMAT = [ParquetFF]
) AS
SELECT * FROM [<myview>];
GO

G. Använda CREATE EXTERNAL TABLE AS SELECT med en vy som källa

gäller för: Serverlösa SQL-pooler och dedikerade SQL-pooler i Azure Synapse Analytics.

I det här exemplet kan vi se exempel på en mallkod för att skriva CETAS med en användardefinierad vy som källa, använda hanterad identitet som autentisering och https:.

CREATE DATABASE [<mydatabase>];
GO

USE [<mydatabase>];
GO

CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<strong password>';

CREATE DATABASE SCOPED CREDENTIAL [WorkspaceIdentity] WITH IDENTITY = 'managed identity';
GO

CREATE EXTERNAL FILE FORMAT [ParquetFF] WITH (
    FORMAT_TYPE = PARQUET,
    DATA_COMPRESSION = 'org.apache.hadoop.io.compress.SnappyCodec'
);
GO

CREATE EXTERNAL DATA SOURCE [SynapseSQLwriteable] WITH (
    LOCATION = 'https://<mystoageaccount>.dfs.core.windows.net/<mycontainer>/<mybaseoutputfolderpath>',
    CREDENTIAL = [WorkspaceIdentity]
);
GO

CREATE EXTERNAL TABLE [dbo].[<myexternaltable>] WITH (
        LOCATION = '<myoutputsubfolder>/',
        DATA_SOURCE = [SynapseSQLwriteable],
        FILE_FORMAT = [ParquetFF]
) AS
SELECT * FROM [<myview>];
GO

Nästa steg

• SKAPA EXTERN DATAKÄLLA (Transact-SQL)
• SKAPA EXTERNT FILFORMAT (Transact-SQL)
• SKAPA EXTERN TABELL (Transact-SQL)
• CREATE TABLE (Azure Synapse Analytics, Parallel Data Warehouse)
• CREATE TABLE AS SELECT (Azure Synapse Analytics)
• DROP TABLE (Transact-SQL)
• ALTER TABLE (Transact-SQL)