delade metadatatabeller för Azure Synapse Analytics

Azure Synapse Analytics gör att de olika beräkningsmotorerna för arbetsytan kan dela databaser och tabeller mellan sina Apache Spark-pooler och en serverlös SQL-pool.

När en databas har skapats av ett Spark-jobb kan du skapa tabeller i den med Spark som använder Parquet, Delta eller CSV som lagringsformat. Tabellnamn konverteras till gemener och måste efterfrågas med hjälp av gemener. Dessa tabeller blir omedelbart tillgängliga för frågor från någon av Azure Synapse Spark-pooler på arbetsytan. De kan också användas från alla Spark-jobb som omfattas av behörigheter.

De Spark-skapade, hanterade och externa tabellerna görs också tillgängliga som externa tabeller med samma namn i motsvarande synkroniserade databas i en serverlös SQL-pool. Om du exponerar en Spark-tabell i SQL får du mer information om tabellsynkroniseringen.

Eftersom tabellerna synkroniseras till en serverlös SQL-pool asynkront blir det en liten fördröjning tills de visas.

Hantera en Skapad Spark-tabell

Använd Spark för att hantera Spark-skapade databaser. Ta till exempel bort det via ett serverlöst Apache Spark-pooljobb och skapa tabeller i det från Spark.

Objekt i synkroniserade databaser kan inte ändras från en serverlös SQL-pool.

Exponera en Spark-tabell i SQL

Delade Spark-tabeller

Spark tillhandahåller två typer av tabeller som Azure Synapse exponeras automatiskt i SQL:

  • Hanterade tabeller

    Spark innehåller många alternativ för hur du lagrar data i hanterade tabeller, till exempel TEXT, CSV, JSON, JDBC, PARQUET, ORC, HIVE, DELTA och LIBSVM. Dessa filer lagras vanligtvis i katalogen warehouse där hanterade tabelldata lagras.

  • Externa tabeller

    Spark tillhandahåller också sätt att skapa externa tabeller över befintliga data, antingen genom att ange LOCATION alternativet eller med Hive-formatet. Sådana externa tabeller kan vara över en mängd olika dataformat, inklusive Parquet.

Azure Synapse delar för närvarande endast hanterade och externa Spark-tabeller som lagrar sina data i Parquet-, DELTA- eller CSV-format med SQL-motorerna. Tabeller som backas upp av andra format synkroniseras inte automatiskt. Du kanske kan synkronisera sådana tabeller explicit själv som en extern tabell i din egen SQL-databas om SQL-motorn stöder tabellens underliggande format.

Anteckning

För närvarande stöds endast Parquet- och CSV-format fullt ut i en serverlös SQL-pool. Spark Delta-tabeller är också tillgängliga i den serverlösa SQL-poolen, men den här funktionen finns i offentlig förhandsversion. Externa tabeller som skapats i Spark är inte tillgängliga i dedikerade SQL-pooldatabaser.

Dela Spark-tabeller

De delade hanterade och externa Spark-tabellerna som exponeras i SQL-motorn som externa tabeller med följande egenskaper:

  • Den externa SQL-tabellens datakälla är den datakälla som representerar Spark-tabellens platsmapp.
  • Den externa SQL-tabellens filformat är Parquet, Delta eller CSV.
  • Den externa SQL-tabellens åtkomstautentiseringsuppgifter är genomströmning.

Eftersom alla Spark-tabellnamn är giltiga SQL-tabellnamn och alla Spark-kolumnnamn är giltiga SQL-kolumnnamn används Spark-tabellen och kolumnnamnen för den externa SQL-tabellen.

Spark-tabeller tillhandahåller olika datatyper än Synapse SQL-motorerna. I följande tabell mappas Spark-tabelldatatyper till SQL-typerna:

Spark-datatyp SQL-datatyp Kommentarer
LongType, long, bigint bigint Spark: LongType representerar 8 byte signerade heltalsnummer.
SQL: Se int, bigint, smallint och tinyint.
BooleanType, boolean bit (Parquet), varchar(6) (CSV) Spark: Booleskt.
SQL: Se [/sql/t-sql/data-types/bit-transact-sql).
DecimalType, decimal, dec, numeric decimal Spark: DecimalType representerar signerade decimaltal med godtycklig precision. Backas upp internt av java.math.BigDecimal. Ett BigDecimal består av ett godtyckligt precisions heltalsvärde och en 32-bitars heltalsskala.
SQL: Fasta precisions- och skalningsnummer. När maximal precision används är giltiga värden från - 10^38 +1 till 10^38 - 1. ISO-synonymerna för decimaler är dec och dec(p, s). numeriskt är funktionellt identiskt med decimal. Se decimaler och numeriska.
IntegerType, Integer, int int SparkIntegerType representerar 4 byte signerade heltalsnummer.
SQL: Se int, bigint, smallint och tinyint.
ByteType, Byte, tinyint smallint Spark: ByteType representerar 1 byte signerade heltalsnummer [-128 till 127] och ShortType representerar 2 byte signerade heltalsnummer [-32768 till 32767].
SQL: Tinyint representerar 1 byte signerade heltalsnummer [0, 255] och smallint representerar 2 byte signerade heltalsnummer [-32768, 32767]. Se int, bigint, smallint och tinyint.
ShortType, Short, smallint smallint Samma som ovan.
DoubleType, Double float Spark: DoubleType representerar flyttal med 8 byte med dubbel precision. SQL: Se float och real.
FloatType, float, real real Spark: FloatType representerar flyttal med 4 byte med dubbel precision. SQL: Se float och real.
DateType, date date Spark: DateType representerar värden som består av värden för fälten år, månad och dag, utan tidszon.
SQL: Se datum.
TimestampType, timestamp datetime2 Spark: TimestampType representerar värden som består av värden för fälten år, månad, dag, timme, minut och sekund, med den lokala tidszonen för sessionen. Tidsstämpelvärdet representerar en absolut tidpunkt.
SQL: Se datetime2.
char char
StringType, String, varchar Varchar(n) Spark: StringType representerar teckensträngsvärden. VarcharType(n) är en variant av StringType som har en längdbegränsning. Dataskrivning misslyckas om indatasträngen överskrider längdbegränsningen. Den här typen kan bara användas i tabellschemat, inte i funktioner/operatorer.
CharType(n) är en variant av VarcharType(n) som är fast längd. Läsningskolumnen av typen CharType(n) returnerar alltid strängvärden för längd n. CharType(n) kolumnjämförelse kommer att fylla den korta till den längre längden.
SQL: Om det finns en längd från Spark anges n i varchar(n) till den längden. Om den är partitionerad kolumn kan n vara max 2048. Annars blir det varchar(max). Se char och varchar.
Använd den med sortering Latin1_General_100_BIN2_UTF8.
BinaryType, binary varbinary(n) SQL: Om det finns en längd från Spark n anges längden i Varbinary(n). Om den är partitionerad kolumn kan n vara max 2048. Annars blir det Varbinary(max). Se binär och varbinär.
array, map, struct varchar(max) SQL: Serialiserar till JSON med sortering Latin1_General_100_BIN2_UTF8. Se JSON-data.

Anteckning

Sortering på databasnivå är Latin1_General_100_CI_AS_SC_UTF8.

Säkerhetsmodell

Spark-databaser och tabeller samt deras synkroniserade representationer i SQL-motorn skyddas på den underliggande lagringsnivån. Eftersom de för närvarande inte har behörighet för själva objekten kan objekten visas i objektutforskaren.

Det säkerhetsobjekt som skapar en hanterad tabell anses vara ägare av den tabellen och har alla rättigheter till tabellen samt underliggande mappar och filer. Dessutom blir databasens ägare automatiskt medägare till tabellen.

Om du skapar en Spark- eller SQL-tabell med direktautentisering skyddas data endast på mapp- och filnivå. Om någon kör frågor mot den här typen av extern tabell skickas säkerhetsidentiteten för frågeskickaren vidare till filsystemet, som kontrollerar åtkomstbehörigheter.

Mer information om hur du anger behörigheter för mappar och filer finns i Azure Synapse Analytics delade databas.

Exempel

Skapa en hanterad tabell i Spark och fråga från en serverlös SQL-pool

I det här scenariot har du en Spark-databas med namnet mytestdb. Se Skapa och ansluta till en Spark-databas med en serverlös SQL-pool.

Skapa en hanterad Spark-tabell med SparkSQL genom att köra följande kommando:

    CREATE TABLE mytestdb.myparquettable(id int, name string, birthdate date) USING Parquet

Det här kommandot skapar tabellen myparquettable i databasen mytestdb. Tabellnamn konverteras till gemener. Efter en kort fördröjning kan du se tabellen i din serverlösa SQL-pool. Kör till exempel följande -instruktion från din serverlösa SQL-pool.

    USE mytestdb;
    SELECT * FROM sys.tables;

Kontrollera att myparquettable det ingår i resultatet.

Anteckning

En tabell som inte använder Delta, Parquet eller CSV som lagringsformat synkroniseras inte.

Infoga sedan några värden i tabellen från Spark, till exempel med följande C#Spark-instruktioner i en C#-notebook-fil:

using Microsoft.Spark.Sql.Types;

var data = new List<GenericRow>();

data.Add(new GenericRow(new object[] { 1, "Alice", new Date(2010, 1, 1)}));
data.Add(new GenericRow(new object[] { 2, "Bob", new Date(1990, 1, 1)}));

var schema = new StructType
    (new List<StructField>()
        {
            new StructField("id", new IntegerType()),
            new StructField("name", new StringType()),
            new StructField("birthdate", new DateType())
        }
    );

var df = spark.CreateDataFrame(data, schema);
df.Write().Mode(SaveMode.Append).InsertInto("mytestdb.myparquettable");

Nu kan du läsa data från din serverlösa SQL-pool på följande sätt:

SELECT * FROM mytestdb.dbo.myparquettable WHERE name = 'Alice';

Du bör få följande rad som resultat:

id | name | birthdate
---+-------+-----------
1 | Alice | 2010-01-01

Skapa en extern tabell i Spark och fråga från en serverlös SQL-pool

I det här exemplet skapar vi en extern Spark-tabell över Parquet-datafilerna som skapades i föregående exempel för den hanterade tabellen.

Med SparkSQL kör du till exempel:

CREATE TABLE mytestdb.myexternalparquettable
    USING Parquet
    LOCATION "abfss://<storage-name>.dfs.core.windows.net/<fs>/synapse/workspaces/<synapse_ws>/warehouse/mytestdb.db/myparquettable/"

Ersätt platshållaren <storage-name> med det ADLS Gen2-lagringskontonamn som du använder, <fs> med filsystemnamnet du använder och platshållaren <synapse_ws> med namnet på den Azure Synapse arbetsyta som du använder för att köra det här exemplet.

I föregående exempel skapas tabellen myextneralparquettable i databasen mytestdb. Efter en kort fördröjning kan du se tabellen i din serverlösa SQL-pool. Kör till exempel följande -instruktion från din serverlösa SQL-pool.

USE mytestdb;
SELECT * FROM sys.tables;

Kontrollera att myexternalparquettable det ingår i resultatet.

Nu kan du läsa data från din serverlösa SQL-pool på följande sätt:

SELECT * FROM mytestdb.dbo.myexternalparquettable WHERE name = 'Alice';

Du bör få följande rad som resultat:

id | name | birthdate
---+-------+-----------
1 | Alice | 2010-01-01

Nästa steg