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
warehousedär hanterade tabelldata lagras.Externa tabeller
Spark tillhandahåller också sätt att skapa externa tabeller över befintliga data, antingen genom att ange
LOCATIONalternativet 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 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 namnet på det ADLS Gen2-lagringskonto som du använder, <fs> med filsystemnamnet 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 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