Creare tabelle nel catalogo unity

  • Articolo

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 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

Ottenere il notebook

Creare e gestire una tabella nel catalogo Unity usando il notebook SQL

Ottenere il notebook

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'oggetto LOCATION 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 esterna a Unity Catalog.

È 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

Ottenere il notebook

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

  1. Elencare i file in un percorso di archiviazione cloud:

    LIST 'abfss://<path-to-files>';

  2. Eseguire una query sui dati nei file in un determinato percorso:

    SELECT * FROM <format>.`abfss://<path-to-files>`;

Python

  1. Elencare i file in un percorso di archiviazione cloud:

    display(spark.sql("LIST 'abfss://<path-to-files>'"))

  2. Eseguire una query sui dati nei file in un determinato percorso:

    display(spark.read.load("abfss://<path-to-files>"))

R

  1. Elencare i file in un percorso di archiviazione cloud:

    library(SparkR)

display(sql("LIST 'abfss://<path-to-files>'"))

  2. Eseguire una query sui dati nei file in un determinato percorso:

    library(SparkR)

display(loadDF("abfss://<path-to-files>"))

Scala

  1. Elencare i file in un percorso di archiviazione cloud:

    display(spark.sql("LIST 'abfss://<path-to-files>'"))

  2. 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 esterna a Unity Catalog.

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 e USE 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 esempio delta.
  • <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 e USE 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:

Passaggi successivi