Oktatóanyag: Delta Lake-táblák létrehozása és kezelése

Ez az oktatóanyag mintaadatokkal mutatja be a Delta-tábla gyakori műveleteit. A Delta Lake az optimalizált tárolási réteg, amely a Databricks tábláinak alapjait biztosítja. Ha másként nincs megadva, a Databricks összes táblája Delta-táblák.

Mielőtt hozzákezdene

Az oktatóanyag elvégzéséhez a következőkre van szüksége:

• Engedély meglévő számítási erőforrás használatára vagy új számítási erőforrás létrehozására. Lásd : Compute.
• Unity Catalog-engedélyek: USE CATALOG, USE SCHEMA, és CREATE TABLE a workspace katalógusban. Az engedélyek beállításához tekintse meg a Databricks-rendszergazdai vagy a Unity Catalog-jogosultságokat és a biztonságos objektumokat.

Ezek a példák egy szintetikus személyrekordok nevű adatkészletre támaszkodnak: 10K–10M Rekordok. Ez az adatkészlet fiktív rekordokat tartalmaz az emberekről, beleértve a vezeték- és utónevüket, a nemüket és az életkorukat.

Először töltse le az oktatóanyaghoz tartozó adatkészletet.

1. Látogasson el a Szintetikus személyrekordok: 10K-tól 10M-ig rekord oldalra a Kaggle-on.
2. Kattintson a Letöltés gombra, majd töltse le az adathalmazt zip formátumban. Ez letölt egy, a helyi gépre elnevezett archive.zip fájlt.
3. Bontsa ki a archive mappát a archive.zip fájlból.

Ezután töltse fel az person_10000.csv adathalmazt egy Unity Catalog-kötetbe az Azure Databricks-munkaterületen belül. Az Azure Databricks azt javasolja, hogy töltse fel az adatokat egy Unity Catalog-kötetbe, mert a kötetek lehetővé teszik a fájlok elérését, tárolását, szabályozását és rendszerezését.

1. Az kattintva nyissa meg a Katalóguskezelőt.Katalógus az oldalsávon.
2. A Katalóguskezelőben kattintson az Adatok hozzáadása és a Kötet létrehozása.
3. Nevezze el a kötetet my-volume , és válassza a Felügyelt kötetet kötettípusként.
4. Jelölje ki a katalógust workspace és a sémát, majd kattintson a defaultLétrehozás gombra.
5. Nyissa meg my-volume, és kattintson Feltöltés erre a kötetre elemre.
6. Húzza át és dobja le, vagy keresse meg és válassza ki a person_10000.csv fájlt a archive mappából a saját gépén.
7. Kattintson a Feltöltés gombra.

Végül hozzon létre egy jegyzetfüzetet a mintakód futtatásához.

1. Az oldalsávon kattintson a Új gombra.
2. Kattintson Jegyzetfüzet új jegyzetfüzet létrehozásához.
3. Válasszon egy nyelvet a jegyzetfüzethez.

Tábla létrehozása

Hozzon létre egy új, Unity Catalog által felügyelt táblát, amelynek neve workspace.default.people_10k és forrása person_10000.csv. A Delta Lake az azure Databricks összes tábla-létrehozási, olvasási és írási parancsának alapértelmezett értéke.

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)

Scala

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;

A táblák létrehozásának vagy klónozásának számos különböző módja van. További információért lásd CREATE TABLE.

A Databricks Runtime 13.3 LTS és újabb verzióiban létrehozhat egy új üres Delta-táblát, CREATE TABLE LIKE amely duplikálja a forrás Delta-tábla sémáját és táblázattulajdonságait. Ez akkor lehet hasznos, ha a táblákat egy fejlesztői környezetből éles környezetbe telepíti.

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

Fontos

Ez a funkció a nyilvános előzetes verzióban érhető el.

A DeltaTableBuilder és a Scalához készült API használatával hozzon létre egy üres táblát. Az DataFrameWriter és DataFrameWriterV2 összehasonlítva a DeltaTableBuilder API-val egyszerűbben megadható további információ, például oszlophozzászólások, táblázattulajdonságok és létrehozott oszlopok.

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

Scala

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

Beszúrás vagy frissítés egy táblába

Módosítsa a tábla meglévő rekordjait, vagy adjon hozzá újakat egy upsert nevű művelettel. Ha frissítéseket és beszúrásokat szeretne egy meglévő Delta-táblába egyesíteni, használja a DeltaTable.merge és a Scala metódust, valamint az MERGE INTO SQL utasítását.

Például egyesítse az adatokat a forrástáblából people_10k_updates a cél Delta-táblába workspace.default.people_10k. Ha mindkét táblában egyező sor található, a Delta Lake a megadott kifejezéssel frissíti az adatoszlopot. Ha nincs egyező sor, a Delta Lake új sort ad hozzá.

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)

Scala

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

Az SQL-ben az * operátor frissíti vagy beszúrja a céltábla összes oszlopát, feltéve, hogy a forrástábla oszlopai megegyeznek a céltáblával. Ha a céltábla nem rendelkezik ugyanazokkal az oszlopokkal, a lekérdezés elemzési hibát jelez. Emellett a táblázat minden oszlopához meg kell adnia egy értéket a beszúrási művelet végrehajtásakor. Az oszlopértékek lehetnek például üresek ''. Beszúrási művelet végrehajtásakor nem kell frissítenie az összes értéket.

Táblázat olvasása

A deltatáblák adatainak eléréséhez használja a tábla nevét vagy elérési útját. A Unity Catalog által felügyelt táblák eléréséhez használjon teljes értékű táblanevet. Az elérési útalapú hozzáférés csak kötetekhez és külső táblákhoz támogatott, felügyelt táblákhoz nem. További információ: Elérési utak szabályai és hozzáférés a Unity Katalógus köteteiben.

Python

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

Scala

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

SQL

SELECT * FROM workspace.default.people_10k;

Írás táblába

A Delta Lake a szabványos szintaxist használja adatok táblákba való írásához. Ha új adatokat szeretne hozzáadni egy meglévő Delta-táblához, használja a hozzáfűzési módot. Az upsertingtől eltérően a táblába való írás nem ellenőrzi az ismétlődő rekordokat.

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)

Scala

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

A Databricks-jegyzetfüzet cellakimenetei legfeljebb 10 000 sort vagy 2 MB-ot jelenítenek meg, attól függően, hogy melyik az alacsonyabb. Mivel workspace.default.people_10k több mint 10 000 sort tartalmaz, csak az első 10 000 sor jelenik meg a jegyzetfüzet kimenetében display(df). A további sorok szerepelnek a táblában, de a korlát miatt nem jelennek meg a jegyzetfüzet kimenetében. A további sorokat külön szűréssel tekintheti meg.

A tábla összes adatának cseréjéhez használja a felülírási módot.

Python

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

Scala

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

SQL

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

Tábla frissítése

Adatok frissítése egy Delta-táblában egy predikátum alapján. Például változtassa meg az gender oszlop értékeit a következőről: Female -ra/c2 />, F -ról/c4 />, és Male -ról/c6 />.

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)

Scala

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;

Törlés táblából

Egy predikátumnak megfelelő adatok eltávolítása egy Delta-táblából. Az alábbi kód például két törlési műveletet mutat be: először törölje azokat a sorokat, amelyek életkora kisebb, mint 18, majd törölje azokat a sorokat, amelyek életkora kisebb, mint 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)

Scala

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;

Fontos

A törlés eltávolítja az adatokat a Delta-tábla legújabb verziójából, de nem távolítja el azokat a fizikai tárolóból, amíg a régi verziók explicit módon ki nem porszívózódnak. További információ: vákuum.

Táblaelőzmények megjelenítése

A DeltaTable.history és a Scalában használt metódussal és az DESCRIBE HISTORY SQL-ben található utasítással megtekintheti az egyes írások származási adatait egy táblába.

Python

from delta.tables import *

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

Scala

import io.delta.tables._

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

SQL

DESCRIBE HISTORY workspace.default.people_10k

A tábla egy korábbi verziójának lekérdezése időutazással

Egy Delta-tábla régebbi pillanatképének lekérdezése a Delta Lake időutazásával. Egy adott verzió lekérdezéséhez használja a tábla verziószámát vagy időbélyegét. Lekérdezési verzió 0 vagy időbélyeg 2026-01-05T23:09:47.000+00:00 például a tábla előzményeiből.

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'"))

Scala

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

Időbélyegek esetén a rendszer csak dátum- vagy időbélyeg-sztringeket fogad el. Például, a sztringeket "2026-01-05T22:43:15.000+00:00" vagy "2026-01-05 22:43:15" formátumban kell formázni.

A DataFrameReader beállításokkal olyan DataFrame-et hozhat létre egy Delta-táblából, amely a tábla egy adott verziójára vagy időbélyegére van javítva.

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)

Scala

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

További információ: Táblaelőzmények működése.

Táblázat optimalizálása

Egy tábla több módosítása több kis fájlt is létrehozhat, ami lelassítja a lekérdezés olvasását. Az optimalizálási művelettel javítja a sebességet a kis fájlok nagyobbakká való kombinálásával. Lásd a(z) OPTIMIZE.

Python

from delta.tables import *

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

Scala

import io.delta.tables._

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

SQL

OPTIMIZE workspace.default.people_10k

Feljegyzés

Ha engedélyezve van a prediktív optimalizálás, nem kell manuálisan optimalizálnia. A prediktív optimalizálás automatikusan kezeli a karbantartási feladatokat. További információ: A Unity Catalog által felügyelt táblák prediktív optimalizálása.

Z-sorrend oszlopok szerint

Az adatok z sorrendbe rendeléséhez és az olvasási teljesítmény további javításához adja meg a műveletben rendezendő oszlopokat. Például rendezd a magas kardinalitású oszlop firstName szerint. A z-rendelésről további információt az Adatok kihagyása című témakörben talál.

Python

from delta.tables import *

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

Scala

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)

Pillanatképek tisztítása a vákuumművelettel

A Delta Lake pillanatkép-elkülönítéssel rendelkezik az olvasásokhoz, ami azt jelenti, hogy biztonságosan futtathat optimalizálási műveletet, miközben más felhasználók vagy feladatok kérdezik le a táblát. A régi pillanatképeket azonban előbb-utóbb törölnie kell, mert ezzel csökkenti a tárolási költségeket, javítja a lekérdezési teljesítményt, és biztosítja az adatmegfelelőséget. Futtassa a VACUUM műveletet a régi pillanatképek törléséhez. Lásd a(z) VACUUM.

Python

from delta.tables import *

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

Scala

import io.delta.tables._

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

SQL

VACUUM workspace.default.people_10k

A vákuumművelet hatékony használatáról további információt a nem használt adatfájlok eltávolítása vákuummal című témakörben talál.

Következő lépések

• Folyékony csoportosítás alkalmazása táblákhoz
• A Delta Lake ajánlott eljárásai

Kapcsolódó erőforrások

• Mi az a Delta Lake az Azure Databricksben?