Delade metadatatabeller i Azure Synapse Analytics
Med Azure Synapse Analytics kan de olika beräkningsmotorerna för arbetsytor 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 gemener. Dessa tabeller blir omedelbart tillgängliga för frågor från någon av Spark-poolerna i Azure Synapse-arbetsytan. De kan också användas från alla Spark-jobb som omfattas av behörigheter.
Spark-tabellerna som skapats, hanteras och externt 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 Spark-skapad 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 exponerar 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 normalt i katalogen
warehousedär hanterade tabelldata lagras.Externa tabeller
Spark tillhandahåller också sätt att skapa externa tabeller över befintliga data, antingen genom att tillhandahålla
LOCATIONalternativet eller använda 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 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.
Kommentar
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 är 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 datakällan 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, , longbigint |
bigint |
Spark: LongType representerar 8 byte signerade heltalsnummer. SQL: Se int, bigint, smallint och tinyint. |
BooleanType, boolean |
bit (Parquet), varchar(6) (CSV) |
Spark: Boolesk. SQL: Se [/sql/t-sql/data-types/bit-transact-sql). |
DecimalType, decimal, , decnumeric |
decimal |
Spark: DecimalType representerar signerade decimaltal med godtycklig precision. Backas 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 decimaltecken. Se decimal och numeriskt. |
IntegerType, , Integerint |
int |
Spark IntegerType representerar 4 byte signerade heltalsnummer. SQL: Se int, bigint, smallint och tinyint. |
ByteType, , Bytetinyint |
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, , Shortsmallint |
smallint |
Samma som ovan. |
DoubleType, Double |
float |
Spark: DoubleType representerar flyttal med 8 byte med dubbel precision. SQL: Se float och real. |
FloatType, , floatreal |
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, , Stringvarchar |
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äsningskolumn av typen CharType(n) returnerar alltid strängvärden med längden 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 den 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, , mapstruct |
varchar(max) |
SQL: Serialiserar till JSON med sortering Latin1_General_100_BIN2_UTF8. Se JSON-data. |
Kommentar
Sortering på databasnivå är Latin1_General_100_CI_AS_SC_UTF8.
Säkerhetsmodell
Spark-databaserna och tabellerna och 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 Den delade databasen i Azure Synapse Analytics.
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.
Kommentar
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.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.
Till exempel med SparkSQL-körning:
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 filsystemets namn som 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