자습서: Delta Lake 테이블 만들기 및 관리

이 자습서에서는 샘플 데이터를 사용하는 일반적인 델타 테이블 작업을 보여 줍니다. Delta Lake 는 Databricks의 테이블에 대한 기초를 제공하는 최적화된 스토리지 계층입니다. 달리 지정하지 않는 한 Databricks의 모든 테이블은 델타 테이블입니다.

시작하기 전 주의 사항:

이 자습서를 완료하려면 다음이 필요합니다.

• 기존 컴퓨팅 리소스를 사용하거나 새 컴퓨팅 리소스를 만들 수 있는 권한입니다. Compute를 참조하세요.
• Unity 카탈로그 권한: USE CATALOG, USE SCHEMA 및 CREATE TABLE 및 workspace 카탈로그에 대한 권한. 이러한 권한을 설정하려면 Databricks 관리자 또는 Unity 카탈로그 권한 및 보안 개체을 참조하세요.

이러한 예제는 합성 인물 기록: 10K~10M 레코드라는 데이터셋을 사용합니다. 이 데이터 세트에는 이름과 성, 성별 및 나이를 포함한 가상의 사람들의 레코드가 포함됩니다.

먼저 이 자습서의 데이터 세트를 다운로드합니다.

1. Kaggle에서 가상 인물 레코드: 10K~10M 레코드 페이지를 방문합니다.
2. 다운로드를 클릭한 다음 데이터 세트를 zip으로 다운로드합니다. 그러면 로컬 컴퓨터에 이름이 지정된 archive.zip 파일이 다운로드됩니다.
3. archive 파일에서 archive.zip 폴더를 추출합니다.

다음으로, Azure Databricks 작업 영역 내의 Unity 카탈로그 person_10000.csv에 데이터 세트를 업로드 합니다. 볼륨은 파일 액세스, 저장, 관리 및 구성 기능을 제공하기 때문에 Azure Databricks는 Unity 카탈로그 볼륨에 데이터를 업로드하는 것이 좋습니다.

1. 을 클릭하여 카탈로그 탐색기를 엽니다.사이드바의 카탈로그입니다.
2. 카탈로그 탐색기에서 데이터 추가 및 볼륨 만들기를 클릭합니다.
3. 볼륨 my-volume 이름을 지정하고 볼륨 유형으로 관리되는 볼륨 을 선택합니다.
4. workspace 카탈로그와 스키마를 default 선택한 다음 만들기를 클릭합니다.
5. my-volume를 열고 이 볼륨에 업로드를 클릭합니다.
6. 로컬 컴퓨터의 person_10000.csv 폴더 내에서 archive 파일을 끌어서 놓거나 찾아서 선택합니다.
7. 업로드를 클릭합니다.

마지막으로 샘플 코드를 실행하기 위한 Notebook을 만듭니다.

1. 사이드바에서 새로 만들기를 클릭합니다.
2. 을 클릭하여 새 전자 필기장을 만듭니다.
3. 전자 필기장 언어를 선택합니다.

테이블 만들기

새 Unity 카탈로그 관리 테이블 workspace.default.people_10k을(를) person_10000.csv에서 만듭니다. Delta Lake는 Azure Databricks에서 모든 테이블 만들기, 읽기 및 쓰기 명령의 기본값입니다.

파이썬

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)

스칼라

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;

테이블을 만들거나 복제하는 방법에는 여러 가지가 있습니다. 자세한 내용은 CREATE TABLE를 참조하세요.

Databricks Runtime 13.3 LTS 이상에서는 원본 델타 테이블의 스키마 및 테이블 속성을 복제하는 빈 델타 테이블을 새로 만들 수 있습니다 CREATE TABLE LIKE . 이는 개발 환경에서 프로덕션 환경으로 테이블을 승격할 때 유용할 수 있습니다.

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

중요합니다

이 기능은 공개 미리 보기 상태입니다.

DeltaTableBuilder Python 및 Scala용 API를 사용하여 빈 테이블을 만듭니다. DataFrameWriter API와 DataFrameWriterV2DeltaTableBuilder 비교하면 열 주석, 테이블 속성 및 생성된 열과 같은 추가 정보를 더 쉽게 지정할 수 있습니다.

파이썬

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

스칼라

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

테이블에서 기존 레코드를 수정하거나 upsert라는 작업을 사용하여 새 레코드를 추가합니다. 업데이트 및 삽입 집합을 기존 델타 테이블에 병합하려면 DeltaTable.merge 및 Scala의 메서드와 SQL의 MERGE INTO 문을 사용합니다.

예를 들어 원본 테이블의 데이터를 대상 델타 테이블 people_10k_updatesworkspace.default.people_10k로 병합합니다. 두 테이블에 일치하는 행이 있는 경우 Delta Lake는 지정된 식을 사용하여 데이터 열을 업데이트합니다. 일치하는 행이 없으면 Delta Lake에서 새 행을 추가합니다.

파이썬

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)

스칼라

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

SQL * 에서 연산자는 원본 테이블에 대상 테이블과 동일한 열이 있다고 가정하여 대상 테이블의 모든 열을 업데이트하거나 삽입합니다. 대상 테이블에 동일한 열이 없으면 쿼리는 분석 오류를 throw합니다. 또한 삽입 작업을 수행할 때 테이블의 모든 열에 대한 값을 지정해야 합니다. 열 값은 비어 있을 수 있습니다(예: .) ''. 삽입 작업을 수행할 때 모든 값을 업데이트할 필요는 없습니다.

테이블 읽기

테이블 이름 또는 경로를 사용하여 델타 테이블의 데이터에 액세스합니다. Unity 카탈로그 관리 테이블에 액세스하려면 정규화된 테이블 이름을 사용합니다. 경로 기반 액세스는 관리되는 테이블이 아닌 볼륨 및 외부 테이블에 대해서만 지원됩니다. 자세한 내용은 Unity 카탈로그 볼륨의 경로 규칙 및 액세스를 참조하세요.

파이썬

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

스칼라

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

SQL

SELECT * FROM workspace.default.people_10k;

테이블에 쓰기

Delta Lake는 테이블에 데이터를 쓰는 데 표준 구문을 사용합니다. 기존 델타 테이블에 새 데이터를 추가하려면 추가 모드를 사용합니다. upserting과 달리 테이블에 데이터를 쓰는 작업은 중복 레코드를 확인하지 않습니다.

파이썬

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)

스칼라

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

Databricks Notebook 셀 출력은 10,000개의 행이나 2MB 중 더 작은 것을 기준으로 최대 표시됩니다. workspace.default.people_10k 10,000개 이상의 행을 포함하므로 처음 10,000개의 행만 Notebook 출력에 display(df)표시됩니다. 추가 행은 테이블에 있지만 이 제한으로 인해 Notebook 출력에 렌더링되지 않습니다. 추가 행을 보려면 특정하게 필터링하십시오.

테이블의 모든 데이터를 바꾸려면 덮어쓰기 모드를 사용합니다.

파이썬

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

스칼라

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

SQL

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

테이블 업데이트

조건자를 기반으로 델타 테이블의 데이터를 업데이트합니다. 열의 값을 gender에서 Female로, F에서 Male로, M에서 Other로 변경합니다.

파이썬

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)

스칼라

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;

테이블에서 삭제

델타 테이블에서 조건자와 일치하는 데이터를 제거합니다. 예를 들어 아래 코드는 두 가지 삭제 작업을 보여 줍니다. 먼저 연령이 18보다 작은 행을 삭제한 다음, 연령이 21보다 작은 행을 삭제합니다.

파이썬

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)

스칼라

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;

중요합니다

삭제는 델타 테이블의 최신 버전에서 데이터를 제거하지만 이전 버전이 명시적으로 진공 상태일 때까지 실제 스토리지에서 데이터를 제거하지 않습니다. 자세한 내용은 진공을 참조하세요.

테이블 기록 표시

DeltaTable.history 및 Scala의 메서드와 SQL의 DESCRIBE HISTORY 문을 사용하여 테이블에 쓸 때마다 출처 정보를 볼 수 있습니다.

파이썬

from delta.tables import *

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

스칼라

import io.delta.tables._

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

SQL

DESCRIBE HISTORY workspace.default.people_10k

타임 트래블 기능을 사용하여 테이블의 이전 버전을 쿼리합니다.

Delta Lake 시간 여행을 사용하여 델타 테이블의 이전 스냅샷을 쿼리합니다. 특정 버전을 쿼리하려면 테이블의 버전 번호 또는 타임스탬프를 사용합니다. 예를 들어 테이블 기록의 쿼리 버전 0 또는 타임스탬프 2026-01-05T23:09:47.000+00:00 입니다.

파이썬

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

스칼라

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

타임스탬프의 경우 날짜 또는 타임스탬프 문자열만 허용됩니다. 예를 들어, 문자열은 "2026-01-05T22:43:15.000+00:00" 또는 "2026-01-05 22:43:15" 형식으로 지정해야 합니다.

옵션 DataFrameReader을 사용하여 특정 버전 또는 타임스탬프로 고정된 Delta 테이블에서 DataFrame을 만듭니다.

파이썬

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

스칼라

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

자세한 내용은 테이블 기록 작업을 참조하세요.

테이블 최적화

테이블을 여러 개 변경하면 여러 개의 작은 파일이 생성되어 읽기 쿼리 성능이 저하될 수 있습니다. 최적화 작업을 사용하여 작은 파일을 더 큰 파일로 결합하여 속도를 향상시킵니다. OPTIMIZE을(를) 참조하세요.

파이썬

from delta.tables import *

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

스칼라

import io.delta.tables._

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

SQL

OPTIMIZE workspace.default.people_10k

참고 항목

예측 최적화를 사용하는 경우 수동으로 최적화할 필요가 없습니다. 예측 최적화는 유지 관리 작업을 자동으로 관리합니다. 자세한 내용은 Unity 카탈로그 관리 테이블에 대한 예측 최적화를 참조하세요.

열별 Z 순서

데이터를 z 순서로 정렬하고 읽기 성능을 향상시키려면 작업에서 정렬할 열을 지정합니다. 예를 들어 높은 카디널리티 열 firstName로 정렬합니다. z 순서 지정에 대한 자세한 내용은 데이터 건너뛰기 참조

파이썬

from delta.tables import *

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

스칼라

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)

진공 작업으로 스냅샷 정리

Delta Lake에는 읽기에 대한 스냅샷 격리가 있습니다. 즉, 다른 사용자 또는 작업이 테이블을 쿼리하는 동안 최적화 작업을 실행하는 것이 안전합니다. 그러나 이렇게 하면 스토리지 비용이 절감되고 쿼리 성능이 향상되며 데이터 규정 준수가 보장되므로 결국 이전 스냅샷을 정리해야 합니다. VACUUM 작업을 실행하여 이전 스냅샷을 정리합니다. VACUUM을(를) 참조하세요.

파이썬

from delta.tables import *

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

스칼라

import io.delta.tables._

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

SQL

VACUUM workspace.default.people_10k

진공 작업을 효과적으로 사용하는 방법에 대한 자세한 내용은 진공 상태에서 사용되지 않는 데이터 파일 제거를 참조하세요.

다음 단계

• 테이블에 액체 클러스터링 사용
• 모범 사례: Delta Lake

관련 리소스

• Azure Databricks의 Delta Lake란?