Creare tabelle nel catalogo unity
Questo articolo presenta il concetto di tabelle gestite ed esterne nel catalogo di Unity e descrive come creare tabelle in Unity Catalog.
Nota
Quando si crea una tabella, assicurarsi di fare riferimento a un catalogo regolato da Unity Catalog o impostare il catalogo predefinito su un catalogo regolato da Unity Catalog. Vedere Gestire il catalogo predefinito.
Il catalogo viene visualizzato in Esplora cataloghi, ma non è considerato governato dal catalogo hive_metastore
unity. Viene gestito dal metastore Hive dell'area di lavoro di Azure Databricks. Tutti gli altri cataloghi elencati sono regolati da Unity Catalog.
È possibile usare l'interfaccia di aggiornamento della tabella di Unity Catalog per aggiornare le tabelle esistenti registrate nel metastore Hive al catalogo Unity. Vedere Aggiornare tabelle e viste Hive a Unity Catalog.
Tabelle gestite
Le tabelle gestite rappresentano il modo predefinito per creare tabelle nel catalogo unity. Unity Catalog gestisce il ciclo di vita e il layout dei file per queste tabelle. Non è consigliabile usare strumenti esterni ad Azure Databricks per modificare direttamente i file in queste tabelle.
Le tabelle gestite vengono archiviate nell'archiviazione gestita, a livello di metastore, catalogo o schema, a seconda della configurazione dello schema e del catalogo. Vedere Specificare un percorso di archiviazione gestito nel catalogo unity.
Le tabelle gestite usano sempre il formato di tabella Delta .
Quando una tabella gestita viene eliminata, i dati sottostanti vengono eliminati dal tenant cloud entro 30 giorni.
Tabelle esterne
Le tabelle esterne sono tabelle i cui dati vengono archiviati all'esterno del percorso di archiviazione gestito specificato per il metastore, il catalogo o lo schema. Usare tabelle esterne solo quando è necessario l'accesso diretto ai dati all'esterno dei cluster di Azure Databricks o di Databricks SQL Warehouse.
Quando si esegue DROP TABLE
in una tabella esterna, Unity Catalog non elimina i dati sottostanti. Per eliminare una tabella, è necessario essere il proprietario. È possibile gestire i privilegi per le tabelle esterne e usarli nelle query nello stesso modo delle tabelle gestite. Per creare una tabella esterna con SQL, specificare un LOCATION
percorso nell'istruzione CREATE TABLE
. Le tabelle esterne possono usare i formati di file seguenti:
- DELTA
- CSV
- JSON
- AVRO
- PARQUET
- ORC
- TEXT
Per gestire l'accesso all'archiviazione cloud sottostante per una tabella esterna, è necessario configurare le credenziali di archiviazione e le posizioni esterne.
Per altre informazioni, vedere Creare una tabella esterna.
Requisiti
È necessario avere il CREATE TABLE
privilegio per lo schema in cui si desidera creare la tabella, nonché il USE SCHEMA
privilegio per lo schema e il USE CATALOG
privilegio nel catalogo padre.
Se si crea una tabella esterna, vedere Creare una tabella esterna per altri requisiti.
Creare una tabella gestita
Per creare una tabella gestita, eseguire il comando SQL seguente. È anche possibile usare il notebook di esempio per creare una tabella. Gli elementi tra parentesi quadre sono facoltativi. Sostituire i valori segnaposto:
<catalog-name>
: nome del catalogo che conterrà la tabella.Questo non può essere il
hive_metastore
catalogo creato automaticamente per il metastore Hive associato all'area di lavoro di Azure Databricks. È possibile eliminare il nome del catalogo se si crea la tabella nel catalogo predefinito dell'area di lavoro.<schema-name>
: nome dello schema che conterrà la tabella.<table-name>
: nome della tabella.<column-specification>
: nome e tipo di dati per ogni colonna.
SQL
CREATE TABLE <catalog-name>.<schema-name>.<table-name>
(
<column-specification>
);
Python
spark.sql("CREATE TABLE <catalog-name>.<schema-name>.<table-name> "
"("
" <column-specification>"
")")
R
library(SparkR)
sql(paste("CREATE TABLE <catalog-name>.<schema-name>.<table-name> ",
"(",
" <column-specification>",
")",
sep = ""))
Scala
spark.sql("CREATE TABLE <catalog-name>.<schema-name>.<table-name> " +
"(" +
" <column-specification>" +
")")
È anche possibile creare una tabella gestita usando il provider Databricks Terraform e databricks_table. È possibile recuperare un elenco di nomi completi di tabella usando databricks_tables.
Ad esempio, per creare la tabella main.default.department
e inserire cinque righe:
SQL
CREATE TABLE main.default.department
(
deptcode INT,
deptname STRING,
location STRING
);
INSERT INTO main.default.department VALUES
(10, 'FINANCE', 'EDINBURGH'),
(20, 'SOFTWARE', 'PADDINGTON'),
(30, 'SALES', 'MAIDSTONE'),
(40, 'MARKETING', 'DARLINGTON'),
(50, 'ADMIN', 'BIRMINGHAM');
Python
spark.sql("CREATE TABLE main.default.department "
"("
" deptcode INT,"
" deptname STRING,"
" location STRING"
")"
"INSERT INTO main.default.department VALUES "
" (10, 'FINANCE', 'EDINBURGH'),"
" (20, 'SOFTWARE', 'PADDINGTON'),"
" (30, 'SALES', 'MAIDSTONE'),"
" (40, 'MARKETING', 'DARLINGTON'),"
" (50, 'ADMIN', 'BIRMINGHAM')")
R
library(SparkR)
sql(paste("CREATE TABLE main.default.department ",
"(",
" deptcode INT,",
" deptname STRING,",
" location STRING",
")",
"INSERT INTO main.default.department VALUES ",
" (10, 'FINANCE', 'EDINBURGH'),",
" (20, 'SOFTWARE', 'PADDINGTON'),",
" (30, 'SALES', 'MAIDSTONE'),",
" (40, 'MARKETING', 'DARLINGTON'),",
" (50, 'ADMIN', 'BIRMINGHAM')",
sep = ""))
Scala
spark.sql("CREATE TABLE main.default.department " +
"(" +
" deptcode INT," +
" deptname STRING," +
" location STRING" +
")" +
"INSERT INTO main.default.department VALUES " +
" (10, 'FINANCE', 'EDINBURGH')," +
" (20, 'SOFTWARE', 'PADDINGTON')," +
" (30, 'SALES', 'MAIDSTONE')," +
" (40, 'MARKETING', 'DARLINGTON')," +
" (50, 'ADMIN', 'BIRMINGHAM')")
Notebook di esempio: Creare tabelle gestite
È possibile usare i notebook di esempio seguenti per creare un catalogo, uno schema e una tabella gestita e gestirli.
Creare e gestire una tabella nel catalogo unity usando il notebook Python
Creare e gestire una tabella nel catalogo Unity usando il notebook SQL
Eliminare una tabella gestita
Per eliminare una tabella, è necessario essere il proprietario della tabella. Per eliminare una tabella gestita, eseguire il comando SQL seguente:
DROP TABLE IF EXISTS catalog_name.schema_name.table_name;
Quando una tabella gestita viene eliminata, i dati sottostanti vengono eliminati dal tenant cloud entro 30 giorni.
Creare una tabella esterna
I dati in una tabella esterna vengono archiviati in un percorso nel tenant cloud. Per lavorare con tabelle esterne, Il catalogo di Unity introduce due oggetti per accedere e lavorare con l'archiviazione cloud esterna:
- Una credenziale di archiviazione contiene un metodo di autenticazione per l'accesso a un percorso di archiviazione cloud. Le credenziali di archiviazione non contengono un mapping al percorso a cui concede l'accesso. Archiviazione credenziali sono controllate dall'accesso per determinare quali utenti possono usare le credenziali.
- Una posizione esterna esegue il mapping di una credenziale di archiviazione con un percorso di archiviazione cloud a cui concede l'accesso. La posizione esterna concede l'accesso solo al percorso di archiviazione cloud e al relativo contenuto. Le posizioni esterne sono controllate dall'accesso per determinare quali utenti possono usarli. Un percorso esterno viene usato automaticamente quando il comando SQL contiene una
LOCATION
clausola .
Requisiti
Per creare una tabella esterna, è necessario disporre di:
- Privilegio
CREATE EXTERNAL TABLE
in una posizione esterna che concede l'accesso all'oggettoLOCATION
a cui accede la tabella esterna. - Autorizzazione
USE SCHEMA
per lo schema padre della tabella. - Autorizzazione
USE CATALOG
per il catalogo padre della tabella. - Autorizzazione
CREATE TABLE
per lo schema padre della tabella.
Le posizioni esterne e le credenziali di archiviazione vengono archiviate a livello di metastore, anziché in un catalogo. Per creare credenziali di archiviazione, è necessario essere un amministratore dell'account o avere il CREATE STORAGE CREDENTIAL
privilegio . Per creare un percorso esterno, è necessario essere l'amministratore del metastore o avere il CREATE EXTERNAL LOCATION
privilegio . Vedere Connessione all'archiviazione di oggetti cloud usando il catalogo unity.
Crea una tabella
Usare uno degli esempi di comando seguenti in un notebook o nell'editor di query SQL per creare una tabella esterna.
È anche possibile usare un notebook di esempio per creare le credenziali di archiviazione, la posizione esterna e la tabella esterna e gestire le autorizzazioni per tali credenziali.
Negli esempi seguenti sostituire i valori segnaposto:
<catalog>
: nome del catalogo che conterrà la tabella.Questo non può essere il
hive_metastore
catalogo creato automaticamente per il metastore Hive associato all'area di lavoro di Azure Databricks. È possibile eliminare il nome del catalogo se si crea la tabella nel catalogo predefinito dell'area di lavoro.<schema>
: nome dello schema che conterrà la tabella.<table-name>
: nome della tabella.<column-specification>
: nome e tipo di dati per ogni colonna.<bucket-path>
: percorso del bucket di archiviazione cloud in cui verrà creata la tabella.<table-directory>
: directory in cui verrà creata la tabella. Usare una directory univoca per ogni tabella.
Importante
Dopo aver creato una tabella in un percorso, gli utenti non possono più accedere direttamente ai file in tale percorso da Azure Databricks anche se sono stati concessi privilegi per una posizione esterna o credenziali di archiviazione a tale scopo. In questo modo gli utenti non possono aggirare i controlli di accesso applicati alle tabelle leggendo direttamente i file dal tenant cloud.
SQL
CREATE TABLE <catalog>.<schema>.<table-name>
(
<column-specification>
)
LOCATION 'abfss://<bucket-path>/<table-directory>';
Python
spark.sql("CREATE TABLE <catalog>.<schema>.<table-name> "
"("
" <column-specification>"
") "
"LOCATION 'abfss://<bucket-path>/<table-directory>'")
R
library(SparkR)
sql(paste("CREATE TABLE <catalog>.<schema>.<table-name> ",
"(",
" <column-specification>",
") ",
"LOCATION 'abfss://<bucket-path>/<table-directory>'",
sep = ""))
Scala
spark.sql("CREATE TABLE <catalog>.<schema>.<table-name> " +
"(" +
" <column-specification>" +
") " +
"LOCATION 'abfss://<bucket-path>/<table-directory>'")
Unity Catalog verifica di avere le autorizzazioni seguenti:
CREATE EXTERNAL TABLE
nella posizione esterna che fa riferimento al percorso di archiviazione cloud specificato.CREATE TABLE
nello schema padre.USE SCHEMA
nello schema padre.USE CATALOG
nel catalogo padre.
In questo caso, viene creata la tabella esterna. In caso contrario, si verifica un errore e la tabella esterna non viene creata.
Nota
È invece possibile eseguire la migrazione di una tabella esterna esistente nel metastore Hive in Unity Catalog senza duplicarne i dati. Vedere Aggiornare una singola tabella Hive a una tabella esterna del catalogo Unity usando la procedura guidata di aggiornamento.
È anche possibile creare una tabella esterna usando il provider Databricks Terraform e databricks_table. È possibile recuperare un elenco di nomi completi di tabella usando databricks_tables.
Notebook di esempio: Creare tabelle esterne
È possibile usare il notebook di esempio seguente per creare un catalogo, uno schema e una tabella esterna e gestire le autorizzazioni per tali tabelle.
Creare e gestire una tabella esterna nel notebook del catalogo Unity
Creare una tabella da file archiviati nel tenant cloud
È possibile popolare una tabella gestita o esterna con record di file archiviati nel tenant cloud. Unity Catalog legge i file in tale posizione e ne inserisce il contenuto nella tabella. In Unity Catalog, questa operazione è denominata accesso basato sul percorso.
È possibile seguire gli esempi in questa sezione o usare l'interfaccia utente aggiungi dati.
Esplorare il contenuto dei file
Per esplorare i dati archiviati in una posizione esterna prima di creare tabelle da tali dati, è possibile usare Esplora cataloghi o i comandi seguenti.
Autorizzazioni necessarie: è necessario disporre dell'autorizzazione READ FILES
per il percorso esterno associato al percorso di archiviazione cloud per restituire un elenco di file di dati in tale percorso.
Sql
Elencare i file in un percorso di archiviazione cloud:
LIST 'abfss://<path-to-files>';
Eseguire una query sui dati nei file in un determinato percorso:
SELECT * FROM <format>.`abfss://<path-to-files>`;
Python
Elencare i file in un percorso di archiviazione cloud:
display(spark.sql("LIST 'abfss://<path-to-files>'"))
Eseguire una query sui dati nei file in un determinato percorso:
display(spark.read.load("abfss://<path-to-files>"))
R
Elencare i file in un percorso di archiviazione cloud:
library(SparkR) display(sql("LIST 'abfss://<path-to-files>'"))
Eseguire una query sui dati nei file in un determinato percorso:
library(SparkR) display(loadDF("abfss://<path-to-files>"))
Scala
Elencare i file in un percorso di archiviazione cloud:
display(spark.sql("LIST 'abfss://<path-to-files>'"))
Eseguire una query sui dati nei file in un determinato percorso:
display(spark.read.load("abfss://<path-to-files>"))
Creare una tabella dai file
Seguire gli esempi in questa sezione per creare una nuova tabella e popolarla con i file di dati nel tenant cloud.
Nota
È invece possibile eseguire la migrazione di una tabella esterna esistente nel metastore Hive in Unity Catalog senza duplicarne i dati. Vedere Aggiornare una singola tabella Hive a una tabella esterna del catalogo Unity usando la procedura guidata di aggiornamento.
Importante
- Quando si crea una tabella usando questo metodo, il percorso di archiviazione viene letto una sola volta per impedire la duplicazione dei record. Se si desidera rileggere il contenuto della directory, è necessario eliminare e ricreare la tabella. Per una tabella esistente, è possibile inserire record da un percorso di archiviazione.
- Il percorso del bucket in cui si crea una tabella non può essere usato anche per leggere o scrivere file di dati.
- Solo i file nella directory esatta sono letti; la lettura non è ricorsiva.
- È necessario disporre delle autorizzazioni seguenti:
USE CATALOG
nel catalogo padre eUSE SCHEMA
nello schema.CREATE TABLE
nello schema padre.READ FILES
nel percorso esterno associato al percorso del bucket in cui si trovano i file o direttamente nelle credenziali di archiviazione se non si usa un percorso esterno.- Se si crea una tabella esterna, è necessario
CREATE EXTERNAL TABLE
nel percorso del bucket in cui verrà creata la tabella.
Per creare una nuova tabella gestita e popolarla con i dati nell'archiviazione cloud, usare gli esempi seguenti.
SQL
CREATE TABLE <catalog>.<schema>.<table-name>
(
<column-specification>
)
SELECT * from <format>.`abfss://<path-to-files>`;
Python
spark.sql("CREATE TABLE <catalog>.<schema>.<table-name> "
"( "
" <column-specification> "
") "
"SELECT * from <format>.`abfss://<path-to-files>`")
R
library(SparkR)
sql(paste("CREATE TABLE <catalog>.<schema>.<table-name> ",
"( ",
" <column-specification> ",
") ",
"SELECT * from <format>.`abfss://<path-to-files>`",
sep = ""))
Scala
spark.sql("CREATE TABLE <catalog>.<schema>.<table-name> " +
"( " +
" <column-specification> " +
") " +
"SELECT * from <format>.`abfss://<path-to-files>`")
Per creare una tabella esterna e popolarla con i dati nell'archiviazione cloud, aggiungere una LOCATION
clausola:
SQL
CREATE TABLE <catalog>.<schema>.<table-name>
(
<column-specification>
)
USING <format>
LOCATION 'abfss://<table-location>'
SELECT * from <format>.`abfss://<path-to-files>`;
Python
spark.sql("CREATE TABLE <catalog>.<schema>.<table-name> "
"( "
" <column-specification> "
") "
"USING <format> "
"LOCATION 'abfss://<table-location>' "
"SELECT * from <format>.`abfss://<path-to-files>`")
R
library(SparkR)
sql(paste("CREATE TABLE <catalog>.<schema>.<table-name> ",
"( ",
" <column-specification> ",
") ",
"USING <format> ",
"LOCATION 'abfss://<table-location>' ",
"SELECT * from <format>.`abfss://<path-to-files>`",
sep = ""))
Scala
spark.sql("CREATE TABLE <catalog>.<schema>.<table-name> " +
"( " +
" <column-specification> " +
") " +
"USING <format> " +
"LOCATION 'abfss://<table-location>' " +
"SELECT * from <format>.`abfss://<path-to-files>`")
Inserire record da un percorso in una tabella esistente
Per inserire record da un percorso bucket in una tabella esistente, usare il COPY INTO
comando . Negli esempi seguenti sostituire i valori segnaposto:
<catalog>
: nome del catalogo padre della tabella.<schema>
: nome dello schema padre della tabella.<path-to-files>
: percorso del bucket che contiene i file di dati.<format>
: formato dei file, ad esempiodelta
.<table-location>
: percorso del bucket in cui verrà creata la tabella.
Importante
- Quando si inseriscono record in una tabella usando questo metodo, il percorso del bucket specificato viene letto una sola volta, per impedire la duplicazione dei record.
- Il percorso del bucket in cui si crea una tabella non può essere usato anche per leggere o scrivere file di dati.
- Solo i file nella directory esatta sono letti; la lettura non è ricorsiva.
- È necessario disporre delle autorizzazioni seguenti:
USE CATALOG
nel catalogo padre eUSE SCHEMA
nello schema.MODIFY
sulla tabella.READ FILES
nel percorso esterno associato al percorso del bucket in cui si trovano i file o direttamente nelle credenziali di archiviazione se non si usa un percorso esterno.- Per inserire record in una tabella esterna, è necessario
CREATE EXTERNAL TABLE
nel percorso del bucket in cui si trova la tabella.
Per inserire record da file in un percorso bucket in una tabella gestita, usando un percorso esterno per leggere dal percorso del bucket:
SQL
COPY INTO <catalog>.<schema>.<table>
FROM (
SELECT *
FROM 'abfss://<path-to-files>'
)
FILEFORMAT = <format>;
Python
spark.sql("COPY INTO <catalog>.<schema>.<table> "
"FROM ( "
" SELECT * "
" FROM 'abfss://<path-to-files>' "
") "
"FILEFORMAT = <format>")
R
library(SparkR)
sql(paste("COPY INTO <catalog>.<schema>.<table> ",
"FROM ( ",
" SELECT * ",
" FROM 'abfss://<path-to-files>' ",
") ",
"FILEFORMAT = <format>",
sep = ""))
Scala
spark.sql("COPY INTO <catalog>.<schema>.<table> " +
"FROM ( " +
" SELECT * " +
" FROM 'abfss://<path-to-files>' " +
") " +
"FILEFORMAT = <format>")
Per inserire in una tabella esterna, aggiungere una LOCATION
clausola :
SQL
COPY INTO <catalog>.<schema>.<table>
LOCATION 'abfss://<table-location>'
FROM (
SELECT *
FROM 'abfss://<path-to-files>'
)
FILEFORMAT = <format>;
Python
spark.sql("COPY INTO <catalog>.<schema>.<table> "
"LOCATION 'abfss://<table-location>' "
"FROM ( "
" SELECT * "
" FROM 'abfss://<path-to-files>' "
") "
"FILEFORMAT = <format>")
R
library(SparkR)
sql(paste("COPY INTO <catalog>.<schema>.<table> ",
"LOCATION 'abfss://<table-location>' ",
"FROM ( ",
" SELECT * ",
" FROM 'abfss://<path-to-files>' ",
") ",
"FILEFORMAT = <format>",
sep = ""))
Scala
spark.sql("COPY INTO <catalog>.<schema>.<table> " +
"LOCATION 'abfss://<table-location>' " +
"FROM ( " +
" SELECT * " +
" FROM 'abfss://<path-to-files>' " +
") " +
"FILEFORMAT = <format>")
Aggiungere commenti a una tabella
In qualità di proprietario della tabella o utente con privilegi MODIFY
per una tabella, è possibile aggiungere commenti a una tabella e alle relative colonne. È possibile aggiungere commenti usando la funzionalità seguente:
- Comando COMMENT ON . Questa opzione non supporta i commenti delle colonne.
- Opzione
COMMENT
quando si usano i comandi CREATE TABLE e ALTER TABLE . Questa opzione supporta i commenti di colonna. - Campo commento "manuale" in Esplora cataloghi. Questa opzione supporta i commenti di colonna. Vedere Document data in Catalog Explorer using markdown comments (Visualizzare i dati dei documenti in Esplora cataloghi usando i commenti markdown).
- Commenti generati dall'intelligenza artificiale (nota anche come documentazione generata dall'intelligenza artificiale) in Esplora cataloghi. È possibile visualizzare un commento suggerito da un modello LLM (Large Language Model) che tiene conto dei metadati della tabella, ad esempio lo schema della tabella e i nomi di colonna, e modificare o accettare il commento così come è per aggiungerlo. Vedere Aggiungere commenti generati dall'intelligenza artificiale a una tabella.
Passaggi successivi
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per