Zelfstudie: Delta Lake-tabellen maken en beheren

In deze zelfstudie ziet u veelvoorkomende Delta-tabelbewerkingen met behulp van voorbeeldgegevens. Delta Lake is de geoptimaliseerde opslaglaag die de basis biedt voor tabellen in Databricks. Tenzij anders opgegeven, zijn alle tabellen in Databricks Delta-tabellen.

Voordat u begint

U hebt het volgende nodig om deze zelfstudie te voltooien:

• Machtiging om een bestaande rekenresource te gebruiken of een nieuwe rekenresource te maken. Zie Compute.
• Machtigingen voor Unity Catalog: USE CATALOG, USE SCHEMAen CREATE TABLE in de workspace catalogus. Als u deze machtigingen wilt instellen, kunt u uw Databricks-beheerder raadplegen of de Unity Catalog-bevoegdheden en beveiligbare objectenbekijken.

Deze voorbeelden zijn afhankelijk van een gegevensset met de naam Synthetic Person Records: 10K tot 10M Records. Deze gegevensset bevat fictieve records van personen, inclusief voor- en achternamen, geslacht en leeftijd.

Download eerst de gegevensset voor deze zelfstudie.

1. Ga naar de pagina Synthetische persoonsrecords: 10K tot 10M Records op Kaggle.
2. Klik op Downloaden en klik vervolgens op Gegevensset downloaden als zip. Hiermee wordt een bestand met de naam naar uw lokale computer gedownload archive.zip .
3. Pak de archive map uit het archive.zip bestand uit.

Upload vervolgens de person_10000.csv gegevensset naar een Unity Catalog-volume in uw Azure Databricks-werkruimte. Azure Databricks raadt u aan uw gegevens te uploaden naar een Unity Catalog-volume, omdat volumes mogelijkheden bieden voor het openen, opslaan, beheren en ordenen van bestanden.

1. Open Catalog Explorer door op te klikken.Catalogus in de zijbalk.
2. Klik in Catalog Explorer op Gegevens toevoegen en maak een volume.
3. Geef het volume my-volume een naam en selecteer Beheerd volume als volumetype.
4. Selecteer de workspace catalogus en het default schema en klik vervolgens op Maken.
5. Open my-volume en klik op Naar dit volume uploaden.
6. Sleep en zet neer of blader naar en selecteer het person_10000.csv bestand uit de archive map op je lokale computer.
7. Klik op Uploaden.

Maak ten slotte een notebook voor het uitvoeren van de voorbeeldcode.

1. Klik op Nieuw in de zijbalk.
2. Klik op Notebook voor het maken van een nieuw notitieblok.
3. Kies een taal voor het notitieblok.

Een tabel maken

Maak in Unity Catalog een nieuwe beheerde tabel met de naam workspace.default.people_10k van person_10000.csv. Delta Lake is de standaardinstelling voor het maken, lezen en schrijven van tabellen in 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)

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;

Er zijn verschillende manieren om tabellen te maken of te klonen. Zie CREATE TABLE voor meer informatie.

In Databricks Runtime 13.3 LTS en hoger kunt u met CREATE TABLE LIKE een nieuwe lege Delta-tabel maken waarmee het schema en de tabeleigenschappen van een delta-brontabel worden gedupliceerd. Dit kan handig zijn bij het overzetten van tabellen uit een ontwikkelomgeving naar een productieomgeving.

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

Belangrijk

Deze functie is beschikbaar als openbare preview. U kunt de preview-inschrijving bevestigen op de pagina Previews . Zie Azure Databricks-previews beheren.

Gebruik de DeltaTableBuilder API voor Python en Scala om een lege tabel te maken. DataFrameWriter Vergeleken met enDataFrameWriterV2, maakt de DeltaTableBuilder API het eenvoudiger om aanvullende informatie op te geven, zoals kolomopmerkingen, tabeleigenschappen en gegenereerde kolommen.

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

Upsert naar een tabel

Wijzig bestaande records in een tabel of voeg nieuwe records toe met behulp van een bewerking die upsert wordt genoemd. Als u een set updates en invoegingen wilt samenvoegen in een bestaande Delta-tabel, gebruikt u de DeltaTable.merge methode in Python en Scala en de MERGE INTO instructie in SQL.

U kunt bijvoorbeeld gegevens uit de brontabel people_10k_updates samenvoegen naar de delta-doeltabel workspace.default.people_10k. Wanneer er een overeenkomende rij in beide tabellen is, werkt Delta Lake de gegevenskolom bij met behulp van de opgegeven expressie. Wanneer er geen overeenkomende rij is, voegt Delta Lake een nieuwe rij toe.

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

In SQL werkt de * operator alle kolommen in de doeltabel bij of voegt deze in, ervan uitgaande dat de brontabel dezelfde kolommen heeft als de doeltabel. Als de doeltabel niet dezelfde kolommen heeft, genereert de query een analysefout. U moet ook een waarde opgeven voor elke kolom in de tabel wanneer u een invoegbewerking uitvoert. De kolomwaarden kunnen leeg zijn, bijvoorbeeld ''. Wanneer u een invoegbewerking uitvoert, hoeft u niet alle waarden bij te werken.

Een tabel lezen

Gebruik de tabelnaam of het pad voor toegang tot gegevens in Delta-tabellen. Gebruik een volledig gekwalificeerde tabelnaam om toegang te krijgen tot beheerde tabellen in Unity Catalog. Padgebaseerde toegang wordt alleen ondersteund voor volumes en externe tabellen, niet voor beheerde tabellen. Zie Padregels en toegang in Unity Catalog-volumes voor meer informatie.

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;

Schrijven naar een tabel

Delta Lake gebruikt de standaardsyntaxis voor het schrijven van gegevens naar tabellen. Als u nieuwe gegevens wilt toevoegen aan een bestaande Delta-tabel, gebruikt u de toevoegmodus. In tegenstelling tot upserting, wordt bij het schrijven naar een tabel niet gecontroleerd op dubbele records.

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;

De uitvoer van Databricks-notebookcellen bevat maximaal 10.000 rijen of 2 MB, afhankelijk van wat het laagst is. Omdat workspace.default.people_10k deze meer dan 10.000 rijen bevat, worden alleen de eerste 10.000 rijen weergegeven in de notebookuitvoer voor display(df). De extra rijen zijn aanwezig in de tabel, maar worden niet weergegeven in de notebookuitvoer vanwege deze limiet. U kunt de extra rijen weergeven door er specifiek op te filteren.

Als u alle gegevens in een tabel wilt vervangen, gebruikt u de overschrijfmodus.

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

Een tabel bijwerken

Gegevens in een Delta-tabel bijwerken op basis van een predicaat. Wijzig bijvoorbeeld de waarden in de gender kolom van Female naar F, van Male naar Men van Other naar 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)

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;

Verwijderen uit een tabel

Gegevens verwijderen die overeenkomen met een predicaat uit een Delta-tabel. De onderstaande code laat bijvoorbeeld twee verwijderbewerkingen zien: eerst rijen verwijderen waarbij de leeftijd kleiner is dan 18 en rijen worden verwijderd waarbij de leeftijd kleiner is dan 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;

Belangrijk

Verwijdering verwijdert de gegevens uit de nieuwste versie van de Delta-tabel, maar verwijdert deze niet uit de fysieke opslag totdat de oude versies expliciet worden leeggezogen. Zie vacuüm voor meer informatie.

Tabelgeschiedenis weergeven

Gebruik de DeltaTable.history methode in Python en Scala en de DESCRIBE HISTORY instructie in SQL om de herkomstinformatie voor elke schrijfbewerking naar een tabel weer te geven.

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

Een query uitvoeren op een eerdere versie van de tabel met behulp van tijdreizen

Een query uitvoeren op een oudere momentopname van een Delta-tabel met behulp van Delta Lake-tijdreizen. Als u een query wilt uitvoeren op een specifieke versie, gebruikt u het versienummer of de tijdstempel van de tabel. Bijvoorbeeld een queryversie 0 of tijdstempel 2026-01-05T23:09:47.000+00:00 uit de geschiedenis van de tabel.

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

Voor tijdstempels worden alleen datum- of tijdstempeltekenreeksen geaccepteerd. Een tekenreeks moet bijvoorbeeld worden opgemaakt als "2026-01-05T22:43:15.000+00:00" of "2026-01-05 22:43:15".

Gebruik DataFrameReader opties om een DataFrame te maken op basis van een Delta-tabel die is vastgezet aan een specifieke versie of tijdstempel van de tabel.

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;

Zie Werken met tabelgeschiedenis voor meer informatie.

Een tabel optimaliseren

Meerdere wijzigingen in een tabel kunnen verschillende kleine bestanden maken, waardoor de prestaties van leesquery's worden vertraagd. Gebruik de optimalisatiebewerking om de snelheid te verbeteren door kleine bestanden te combineren in grotere bestanden. Zie 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

Notitie

Als voorspellende optimalisatie is ingeschakeld, hoeft u niet handmatig te optimaliseren. Voorspellende optimalisatie beheert automatisch onderhoudstaken. Zie Voorspellende optimalisatie voor beheerde tabellen in Unity Catalog voor meer informatie.

Z-volgorde op kolommen

Als u gegevens in z-volgorde wilt orden en de leesprestaties verder wilt verbeteren, geeft u de kolommen op die in de bewerking moeten worden gesorteerd. Plaats bijvoorbeeld het collocate op basis van de kolom firstNamemet hoge kardinaliteit. Zie Gegevens overslaan voor meer informatie over z-ordering.

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)

Momentopnamen opschonen met de vacuümbewerking

Delta Lake heeft isolatie van momentopnamen voor leesbewerkingen, wat betekent dat het veilig is om een optimalisatiebewerking uit te voeren terwijl andere gebruikers of taken query's uitvoeren op de tabel. U moet echter uiteindelijk oude momentopnamen opschonen, omdat dit de opslagkosten verlaagt, de queryprestaties verbetert en gegevenscompatibiliteit garandeert. Voer de VACUUM bewerking uit om oude momentopnamen op te schonen. Zie 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

Zie Ongebruikte gegevensbestanden verwijderen met vacuüm voor meer informatie over het effectief gebruik van de vacuümbewerking.

Volgende stappen

• Liquid clustering gebruiken voor tabellen
• Best practices voor Delta Lake

Verwante middelen

• Wat is Delta Lake in Azure Databricks?