Udostępnij przez

Samouczek: tworzenie tabel usługi Delta Lake i zarządzanie nimi

W tym samouczku przedstawiono typowe operacje tabeli delty przy użyciu przykładowych danych. Usługa Delta Lake to zoptymalizowana warstwa magazynu, która stanowi podstawę dla tabel w usłudze Databricks. Jeśli nie określono inaczej, wszystkie tabele w usłudze Databricks są tabelami delty.

Zanim rozpoczniesz

Do ukończenia tego samouczka potrzebne są następujące elementy:

  • Uprawnienie do korzystania z istniejącego zasobu obliczeniowego lub tworzenia nowego zasobu obliczeniowego. Zobacz Compute.
  • Uprawnienia katalogu Unity: USE CATALOG, USE SCHEMA, i CREATE TABLE w katalogu workspace. Aby ustawić te uprawnienia, skontaktuj się z administratorem Databricks lub zobacz uprawnienia i zabezpieczane obiekty w Unity Catalog.

Te przykłady korzystają z zestawu danych o nazwie Syntetyczne rekordy osób: od 10 000 do 10 mln rekordów. Ten zestaw danych zawiera fikcyjne rekordy osób, w tym ich imię i nazwisko, płeć i wiek.

Najpierw pobierz zestaw danych dla tego samouczka.

  1. Odwiedź stronę Syntetyczne Rekordy Osób: od 10 tys. do 10 mln rekordów na Kaggle.
  2. Kliknij pozycję Pobierz , a następnie pozycję Pobierz zestaw danych jako zip. Spowoduje to pobranie pliku o nazwie archive.zip do komputera lokalnego.
  3. Wyodrębnij archive folder z archive.zip pliku.

Następnie przekaż zestaw danych do woluminu Unity Catalog w obszarze roboczym usługi Azure Databricks. Usługa Azure Databricks zaleca przesyłanie danych do woluminu Unity Catalog, ponieważ woluminy oferują możliwości dostępu, przechowywania, zarządzania i organizowania plików.

  1. Otwórz Eksploratora wykazu, klikając ikonę Dane.Wykaz na pasku bocznym.
  2. W Eksploratorze wykazu kliknij pozycję Dodaj lub ikonę plusaDodaj dane i Utwórz wolumin.
  3. Nadaj woluminowi my-volume nazwę i wybierz pozycję Zarządzany wolumin jako typ woluminu.
  4. workspace Wybierz wykaz i default schemat, a następnie kliknij przycisk Utwórz.
  5. Otwórz my-volume plik i kliknij pozycję Przekaż do tego woluminu.
  6. Przeciągnij i upuść lub przejdź do i wybierz person_10000.csv plik z archive folderu na komputerze lokalnym.
  7. Kliknij polecenie Przekaż.

Na koniec utwórz notes do uruchamiania przykładowego kodu.

  1. Kliknij przycisk Dodaj lub ikonę plusaNowy na pasku bocznym.
  2. Kliknij ikonę Notes.Notes do utworzenia nowego notesu.
  3. Wybierz język notesu.

Tworzenie tabeli

Utwórz nową tabelę zarządzaną Unity Catalog o nazwie workspace.default.people_10k na podstawie person_10000.csv. Usługa Delta Lake jest domyślną wartością dla wszystkich poleceń tworzenia, odczytu i zapisu tabel w usłudze Azure Databricks.

Python

from pyspark.sql.types import StructType, StructField, IntegerType, StringType

schema = StructType([
  StructField("id", IntegerType(), True),
  StructField("firstName", StringType(), True),
  StructField("lastName", StringType(), True),
  StructField("gender", StringType(), True),
  StructField("age", IntegerType(), True)
])

df = spark.read.format("csv").option("header", True).schema(schema).load("/Volumes/workspace/default/my-volume/person_10000.csv")

# Create the table if it does not exist. Otherwise, replace the existing table.
df.writeTo("workspace.default.people_10k").createOrReplace()

# If you know the table does not already exist, you can use this command instead.
# df.write.saveAsTable("workspace.default.people_10k")

# View the new table.
df = spark.read.table("workspace.default.people_10k")
display(df)

Skala

import org.apache.spark.sql.types._

val schema = StructType(Array(
  StructField("id", IntegerType, true),
  StructField("firstName", StringType, true),
  StructField("lastName", StringType, true),
  StructField("gender", StringType, true),
  StructField("age", IntegerType, true)
))

val df = spark.read
  .format("csv")
  .option("header", true)
  .schema(schema)
  .load("/Volumes/workspace/default/my-volume/person_10000.csv")

// Create the table if it does not exist. Otherwise, replace the existing table.
df.writeTo("workspace.default.people_10k").createOrReplace()

// If you know the table does not already exist, you can use this command instead.
// df.saveAsTable("workspace.default.people_10k")

// View the new table.
val df2 = spark.read.table("workspace.default.people_10k")
display(df2)

SQL

-- Create the table with only the required columns and rename person_id to id.
CREATE OR REPLACE TABLE workspace.default.people_10k AS
SELECT
  person_id AS id,
  firstname,
  lastname,
  gender,
  age
FROM read_files(
  '/Volumes/workspace/default/my-volume/person_10000.csv',
  format => 'csv',
  header => true
);

-- View the new table.
SELECT * FROM workspace.default.people_10k;

Istnieje kilka różnych sposobów tworzenia lub klonowania tabel. Aby uzyskać więcej informacji, zobacz CREATE TABLE.

W środowisku Databricks Runtime 13.3 LTS i nowszym można użyć CREATE TABLE LIKE, aby utworzyć nową, pustą Tabelę Delta, która duplikuje schemat i właściwości tabeli Tabela Delta źródłowej. Może to być przydatne podczas wdrażania tabel ze środowiska deweloperskiego do środowiska produkcyjnego.

CREATE TABLE workspace.default.people_10k_prod LIKE workspace.default.people_10k

Ważne

Ta funkcja jest dostępna w publicznej wersji zapoznawczej.

Użyj interfejsu DeltaTableBuilder API dla języków Python i Scala , aby utworzyć pustą tabelę. W porównaniu z oraz , interfejs API ułatwia określenie dodatkowych informacji, takich jak komentarze kolumn, właściwości tabeli i kolumny generowane .

Python

from delta.tables import DeltaTable

(
  DeltaTable.createIfNotExists(spark)
    .tableName("workspace.default.people_10k_2")
    .addColumn("id", "INT")
    .addColumn("firstName", "STRING")
    .addColumn("lastName", "STRING", comment="surname")
    .addColumn("gender", "STRING")
    .addColumn("age", "INT")
    .execute()
)

display(spark.read.table("workspace.default.people_10k_2"))

Skala

import io.delta.tables.DeltaTable

DeltaTable.createOrReplace(spark)
  .tableName("workspace.default.people_10k")
  .addColumn("id", "INT")
  .addColumn("firstName", "STRING")
  .addColumn(
    DeltaTable.columnBuilder("lastName")
      .dataType("STRING")
      .comment("surname")
      .build()
  )
  .addColumn("gender", "STRING")
  .addColumn("age", "INT")
  .execute()

display(spark.read.table("workspace.default.people_10k"))

Upsert do tabeli

Zmodyfikuj istniejące rekordy w tabeli lub dodaj nowe przy użyciu operacji o nazwie upsert. Aby scalić zestaw aktualizacji i wstawiania do istniejącej tabeli Delta, użyj metody DeltaTable.merge w językach Python i Scala oraz instrukcji MERGE INTO w języku SQL.

Na przykład scal dane z tabeli źródłowej people_10k_updates do docelowej tabeli Delta workspace.default.people_10k. Jeśli w obu tabelach istnieje pasujący wiersz, usługa Delta Lake aktualizuje kolumnę danych przy użyciu danego wyrażenia. Jeśli nie ma pasującego wiersza, usługa Delta Lake dodaje nowy wiersz.

Python

from pyspark.sql.types import StructType, StructField, StringType, IntegerType
from delta.tables import DeltaTable

schema = StructType([
  StructField("id", IntegerType(), True),
  StructField("firstName", StringType(), True),
  StructField("lastName", StringType(), True),
  StructField("gender", StringType(), True),
  StructField("age", IntegerType(), True)
])

data = [
  (10001, 'Billy', 'Luppitt', 'M', 55),
  (10002, 'Mary', 'Smith', 'F', 98),
  (10003, 'Elias', 'Leadbetter', 'M', 48),
  (10004, 'Jane', 'Doe', 'F', 30),
  (10005, 'Joshua', '', 'M', 90),
  (10006, 'Ginger', '', 'F', 16),
]

# Create the source table if it does not exist. Otherwise, replace the existing source table.
people_10k_updates = spark.createDataFrame(data, schema)
people_10k_updates.createOrReplaceTempView("people_10k_updates")

# Merge the source and target tables.
deltaTable = DeltaTable.forName(spark, 'workspace.default.people_10k')

(deltaTable.alias("people_10k")
  .merge(
    people_10k_updates.alias("people_10k_updates"),
    "people_10k.id = people_10k_updates.id")
  .whenMatchedUpdateAll()
  .whenNotMatchedInsertAll()
  .execute()
)

# View the additions to the table.
df = spark.read.table("workspace.default.people_10k")
df_filtered = df.filter(df["id"] >= 10001)
display(df_filtered)

Skala

import org.apache.spark.sql.types._
import io.delta.tables._

// Define schema
val schema = StructType(Array(
  StructField("id", IntegerType, true),
  StructField("firstName", StringType, true),
  StructField("lastName", StringType, true),
  StructField("gender", StringType, true),
  StructField("age", IntegerType, true)
))

// Create data as Seq of Tuples
val data = Seq(
  (10001, "Billy", "Luppitt", "M", 55),
  (10002, "Mary", "Smith", "F", 98),
  (10003, "Elias", "Leadbetter", "M", 48),
  (10004, "Jane", "Doe", "F", 30),
  (10005, "Joshua", "", "M", 90),
  (10006, "Ginger", "", "F", 16)
)

// Create DataFrame directly from Seq of Tuples
val people_10k_updates = spark.createDataFrame(data).toDF(
  "id", "firstName", "lastName", "gender", "age"
)
people_10k_updates.createOrReplaceTempView("people_10k_updates")

// Merge the source and target tables
val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

deltaTable.as("people_10k")
  .merge(
    people_10k_updates.as("people_10k_updates"),
    "people_10k.id = people_10k_updates.id"
  )
  .whenMatched()
  .updateAll()
  .whenNotMatched()
  .insertAll()
  .execute()

// View the additions to the table.
val df = spark.read.table("workspace.default.people_10k")
val df_filtered = df.filter($"id" >= 10001)
display(df_filtered)

SQL

-- Create the source table if it does not exist. Otherwise, replace the existing source table.
CREATE OR REPLACE TABLE workspace.default.people_10k_updates(
  id INT,
  firstName STRING,
  lastName STRING,
  gender STRING,
  age INT
);
-- Insert new data into the source table.
INSERT INTO workspace.default.people_10k_updates VALUES
  (10001, "Billy", "Luppitt", "M", 55),
  (10002, "Mary", "Smith", "F", 98),
  (10003, "Elias", "Leadbetter", "M", 48),
  (10004, "Jane", "Doe", "F", 30),
  (10005, "Joshua", "", "M", 90),
  (10006, "Ginger", "", "F", 16);

-- Merge the source and target tables.
MERGE INTO workspace.default.people_10k AS people_10k
USING workspace.default.people_10k_updates AS people_10k_updates
ON people_10k.id = people_10k_updates.id
WHEN MATCHED THEN
  UPDATE SET *
WHEN NOT MATCHED THEN
  INSERT *;

-- View the additions to the table.
SELECT * FROM workspace.default.people_10k WHERE id >= 10001

W programie SQL * operator aktualizuje lub wstawia wszystkie kolumny w tabeli docelowej, przy założeniu, że tabela źródłowa ma te same kolumny co tabela docelowa. Jeśli tabela docelowa nie ma tych samych kolumn, zapytanie zgłasza błąd analizy. Ponadto należy określić wartość dla każdej kolumny w tabeli podczas wykonywania operacji wstawiania. Wartości kolumn mogą być puste, na przykład ''. Podczas wykonywania operacji wstawiania nie trzeba aktualizować wszystkich wartości.

Odczytywanie tabeli

Użyj nazwy tabeli lub ścieżki, aby uzyskać dostęp do danych w tabelach delty. Aby uzyskać dostęp do tabel zarządzanych w Unity Catalog, użyj w pełni kwalifikowanej nazwy tabeli. Dostęp oparty na ścieżkach jest obsługiwany tylko w przypadku woluminów i tabel zewnętrznych, a nie dla tabel zarządzanych. Aby uzyskać więcej informacji, zobacz Reguły ścieżki i dostęp w woluminach Unity Catalog.

Python

people_df = spark.read.table("workspace.default.people_10k")
display(people_df)

Skala

val people_df = spark.read.table("workspace.default.people_10k")
display(people_df)

SQL

SELECT * FROM workspace.default.people_10k;

Zapisywanie w tabeli

Usługa Delta Lake używa standardowej składni do zapisywania danych w tabelach. Aby dodać nowe dane do istniejącej tabeli delty, użyj trybu dołączania. W przeciwieństwie do operacji upserting, zapisywanie w tabeli nie sprawdza zduplikowanych rekordów.

Python

from pyspark.sql.types import StructType, StructField, StringType, IntegerType
from pyspark.sql.functions import col

schema = StructType([
  StructField("id", IntegerType(), True),
  StructField("firstName", StringType(), True),
  StructField("lastName", StringType(), True),
  StructField("gender", StringType(), True),
  StructField("age", IntegerType(), True)
])

data = [
  (10007, 'Miku', 'Hatsune', 'F', 25)
]

# Create the new data.
df  = spark.createDataFrame(data, schema)

# Append the new data to the target table.
df.write.mode("append").saveAsTable("workspace.default.people_10k")

# View the new addition.
df = spark.read.table("workspace.default.people_10k")
df_filtered = df.filter(df["id"] == 10007)
display(df_filtered)

Skala

// Create the new data.
val data = Seq(
  (10007, "Miku", "Hatsune", "F", 25)
)

val df = spark.createDataFrame(data)
  .toDF("id", "firstName", "lastName", "gender", "age")

// Append the new data to the target table
df.write.mode("append").saveAsTable("workspace.default.people_10k")

// View the new addition.
val df2 = spark.read.table("workspace.default.people_10k")
val df_filtered = df2.filter($"id" === 10007)
display(df_filtered)

SQL

CREATE OR REPLACE TABLE workspace.default.people_10k_new (
  id INT,
  firstName STRING,
  lastName STRING,
  gender STRING,
  age INT
);

-- Insert the new data.
INSERT INTO workspace.default.people_10k_new VALUES
  (10007, 'Miku', 'Hatsune', 'F', 25);

-- Append the new data to the target table.
INSERT INTO workspace.default.people_10k
SELECT * FROM workspace.default.people_10k_new;

-- View the new addition.
SELECT * FROM workspace.default.people_10k WHERE id = 10007;

Komórki notatnika Databricks wyświetlają maksymalnie 10 000 wierszy lub 2 MB, w zależności od tego, co jest niższe. Ponieważ workspace.default.people_10k zawiera więcej niż 10 000 wierszy, w danych wyjściowych notesu są wyświetlane tylko pierwsze 10 000 wierszy.display(df) Dodatkowe wiersze znajdują się w tabeli, ale nie są renderowane w danych wyjściowych notesu z powodu tego limitu. Dodatkowe wiersze można wyświetlić, filtrując je specjalnie.

Aby zastąpić wszystkie dane w tabeli, użyj trybu zastępowania.

Python

df.write.mode("overwrite").saveAsTable("workspace.default.people_10k")

Skala

df.write.mode("overwrite").saveAsTable("workspace.default.people_10k")

SQL

INSERT OVERWRITE TABLE workspace.default.people_10k SELECT * FROM workspace.default.people_10k_2

Aktualizowanie tabeli

Aktualizowanie danych w tabeli Delta na podstawie predykatu. Na przykład, zmień wartości w kolumnie gender z Female na F, z Male na M, i z Other na O.

Python

from delta.tables import *
from pyspark.sql.functions import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

# Declare the predicate and update rows using a SQL-formatted string.
deltaTable.update(
  condition = "gender = 'Female'",
  set = { "gender": "'F'" }
)

# Declare the predicate and update rows using Spark SQL functions.
deltaTable.update(
  condition = col('gender') == 'Male',
  set = { 'gender': lit('M') }
)

deltaTable.update(
  condition = col('gender') == 'Other',
  set = { 'gender': lit('O') }
)

# View the updated table.
df = spark.read.table("workspace.default.people_10k")
display(df)

Skala

import io.delta.tables._
import org.apache.spark.sql.functions._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

// Declare the predicate and update rows using a SQL-formatted string.
deltaTable.updateExpr(
  "gender = 'Female'",
  Map("gender" -> "'F'")
)

// Declare the predicate and update rows using Spark SQL functions.
deltaTable.update(
  col("gender") === "Male",
  Map("gender" -> lit("M")));

deltaTable.update(
  col("gender") === "Other",
  Map("gender" -> lit("O")));

// View the updated table.
val df = spark.read.table("workspace.default.people_10k")
display(df)

SQL

-- Declare the predicate and update rows.
UPDATE workspace.default.people_10k SET gender = 'F' WHERE gender = 'Female';
UPDATE workspace.default.people_10k SET gender = 'M' WHERE gender = 'Male';
UPDATE workspace.default.people_10k SET gender = 'O' WHERE gender = 'Other';

-- View the updated table.
SELECT * FROM workspace.default.people_10k;

Usuwanie z tabeli

Usuwanie danych pasujących do predykatu z tabeli delty. Na przykład poniższy kod przedstawia dwie operacje usuwania: najpierw usuwanie wierszy, w których wiek jest krótszy niż 18, a następnie usuwanie wierszy, w których wiek jest krótszy niż 21.

Python

from delta.tables import *
from pyspark.sql.functions import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

# Declare the predicate and delete rows using a SQL-formatted string.
deltaTable.delete("age < '18'")

# Declare the predicate and delete rows using Spark SQL functions.
deltaTable.delete(col('age') < '21')

# View the updated table.
df = spark.read.table("workspace.default.people_10k")
display(df)

Skala

import io.delta.tables._
import org.apache.spark.sql.functions._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

// Declare the predicate and delete rows using a SQL-formatted string.
deltaTable.delete("age < '18'")

// Declare the predicate and delete rows using Spark SQL functions.
deltaTable.delete(col("age") < "21")

// View the updated table.
val df = spark.read.table("workspace.default.people_10k")
display(df)

SQL

-- Delete rows using a predicate.
DELETE FROM workspace.default.people_10k WHERE age < '21';

-- View the updated table.
SELECT * FROM workspace.default.people_10k;

Ważne

Usunięcie usuwa dane z najnowszej wersji tabeli delty, ale nie usuwa ich z magazynu fizycznego, dopóki stare wersje nie zostaną jawnie opróżnione. Aby uzyskać więcej informacji, zobacz odkurzacz.

Wyświetlanie historii tabeli

Użyj metody DeltaTable.history w językach Python i Scala oraz instrukcji DESCRIBE HISTORY w języku SQL, aby wyświetlić informacje o pochodzeniu dla każdego zapisu w tabeli.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
display(deltaTable.history())

Skala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
display(deltaTable.history())

SQL

DESCRIBE HISTORY workspace.default.people_10k

Zapytaj wcześniejszą wersję tabeli, wykorzystując podróżowanie w czasie

Wykonaj zapytanie na starszej migawce tabeli Delta za pomocą funkcji podróży w czasie Delta Lake. Aby wysłać zapytanie o określoną wersję, użyj numeru wersji tabeli lub znacznika czasu. Na przykład zapytanie o wersję 0 lub znacznik czasu 2026-01-05T23:09:47.000+00:00 z historii tabeli.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaHistory = deltaTable.history()

# Query using the version number.
display(deltaHistory.where("version == 0"))

# Query using the timestamp.
display(deltaHistory.where("timestamp == '2026-01-05T23:09:47.000+00:00'"))

Skala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
val deltaHistory = deltaTable.history()

// Query using the version number.
display(deltaHistory.where("version == 0"))

// Query using the timestamp.
display(deltaHistory.where("timestamp == '2026-01-05T23:09:47.000+00:00'"))

SQL

-- Query using the version number
SELECT * FROM workspace.default.people_10k VERSION AS OF 0;

-- Query using the timestamp
SELECT * FROM workspace.default.people_10k TIMESTAMP AS OF '2026-01-05T23:09:47.000+00:00';

W przypadku znaczników czasu akceptowane są tylko ciągi daty lub znacznika czasu. Na przykład ciągi muszą być sformatowane jako "2026-01-05T22:43:15.000+00:00" lub "2026-01-05 22:43:15".

Użyj DataFrameReader opcji, aby utworzyć ramkę danych na podstawie tabeli delty, która jest stała dla określonej wersji lub znacznika czasu tabeli.

Python

# Query using the version number.
df = spark.read.option('versionAsOf', 0).table("workspace.default.people_10k")

# Query using the timestamp.
df = spark.read.option('timestampAsOf', '2026-01-05T23:09:47.000+00:00').table("workspace.default.people_10k")

display(df)

Skala

// Query using the version number.
val dfVersion = spark.read
  .option("versionAsOf", 0)
  .table("workspace.default.people_10k")

// Query using the timestamp.
val dfTimestamp = spark.read
  .option("timestampAsOf", "2026-01-05T23:09:47.000+00:00")
  .table("workspace.default.people_10k")

display(dfVersion)
display(dfTimestamp)

SQL

-- Create a temporary view from version 0 of the table.
CREATE OR REPLACE TEMPORARY VIEW people_10k_v0 AS
SELECT * FROM workspace.default.people_10k VERSION AS OF 0;

-- Create a temporary view from a previous timestamp of the table.
CREATE OR REPLACE TEMPORARY VIEW people_10k_t0 AS
SELECT * FROM workspace.default.people_10k TIMESTAMP AS OF '2026-01-05T23:09:47.000+00:00';

SELECT * FROM people_10k_v0;
SELECT * FROM people_10k_t0;

Aby uzyskać więcej informacji, zobacz Praca z historią tabel.

Optymalizowanie tabeli

Wiele zmian w tabeli może utworzyć kilka małych plików, co spowalnia wydajność zapytań odczytu. Użyj operacji optymalizacji, aby zwiększyć szybkość, łącząc małe pliki w większe. Zobacz: OPTIMIZE.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.optimize().executeCompaction()

Skala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.optimize().executeCompaction()

SQL

OPTIMIZE workspace.default.people_10k

Uwaga

Jeśli optymalizacja predykcyjna jest włączona, nie trzeba optymalizować ręcznie. Optymalizacja predykcyjna automatycznie zarządza zadaniami konserwacji. Aby uzyskać więcej informacji, zobacz Optymalizacja predykcyjna dla tabel zarządzanych przez wykaz aparatu Unity.

Kolejność Z według kolumn

Aby uporządkować dane według z-order i zwiększyć wydajność odczytu, określ kolumny, które mają być uporządkowane w operacji. Na przykład sortowanie według kolumny firstNameo wysokiej kardynalności . Aby uzyskać więcej informacji na temat porządkowania według osi Z, odwiedź Pomijanie danych.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.optimize().executeZOrderBy("firstName")

Skala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.optimize().executeZOrderBy("firstName")

SQL

OPTIMIZE workspace.default.people_10k
ZORDER BY (firstName)

Czyszczenie migawek za pomocą operacji vacuowania

Delta Lake ma izolację migawek dla odczytów, co oznacza, że można bezpiecznie uruchomić operację optymalizacji, podczas gdy inni użytkownicy lub zadania przesyłają zapytania do tabeli. Należy jednak z czasem wyczyścić stare migawki, ponieważ zmniejsza to koszty magazynowania, poprawia wydajność zapytań i zapewnia zgodność danych. Uruchom operację VACUUM, aby wyczyścić stare migawki. Zobacz: VACUUM.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.vacuum()

Skala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.vacuum()

SQL

VACUUM workspace.default.people_10k

Aby uzyskać więcej informacji na temat efektywnego korzystania z operacji próżniowej, zobacz Usuwanie nieużywanych plików danych z próżnią.

Dalsze kroki

  • Last updated on