Delta Lake 权威指南——安装Delta Lake

在本章中，我们将向您展示如何设置 Delta Lake，并引导您完成启动第一个独立应用程序的简单步骤。

安装 Delta Lake 有多种方法。如果您刚刚开始，使用单台机器并借助 Delta Lake Docker 镜像是最佳选择。如果您不想麻烦地进行本地安装，可以使用免费的 Databricks Community Edition，其中包含最新版本的 Delta Lake。

Databricks 提供的各种免费试用版也提供了 Delta Lake；您可以查看云提供商的文档以获取更多详细信息。本章还讨论了 Delta Rust Python 绑定、Delta Rust API 和 Apache Spark 等选项。在本章中，我们还将创建并验证 Delta Lake 表，以便用于说明目的。Delta Lake 表的创建及其他 CRUD 操作将在第 3 章中深入讨论。

Delta Lake Docker 镜像

Delta Lake Docker 镜像包含了读取和写入 Delta Lake 所需的所有组件，包括 Python、Rust、PySpark、Apache Spark 和 Jupyter Notebooks。基本的前提条件是你的本地机器上已安装 Docker（可以在 Get Docker 找到安装说明）。安装 Docker 后，你可以从 DockerHub 下载最新的 Delta Lake Docker 镜像的预构建版本，或者按照 Delta Lake Docker GitHub 仓库中的说明自行构建 Docker 镜像。构建完成镜像或下载了正确的镜像后，你可以继续在笔记本或终端中运行快速入门代码。本书中的所有代码片段推荐使用 Docker 镜像来运行。

请注意，以下内容已预安装在此 Docker 镜像中：

Apache Arrow

Apache Arrow 是一个内存分析开发平台，旨在为平面和层次数据提供一个标准化的、语言无关的列式内存格式，以及用于处理该格式的库和工具。它能够加速数据处理，并使数据在不同系统和语言之间快速流动，如 C、C++、C#、Go、Java、JavaScript、Julia、MATLAB、Python、R、Ruby 和 Rust。

DataFusion

DataFusion 是一个高性能的、可扩展的查询引擎，用于构建高质量的数据中心系统。它是用 Rust 编写的，使用 Apache Arrow 内存格式，最初于 2017 年创建，并于 2019 年捐赠给 Apache Arrow 项目。

ROAPI

ROAPI 是一个无代码解决方案，用于自动生成只读 API，支持 Delta Lake 和其他数据源。它建立在 Apache Arrow 和 DataFusion 之上。

Rust

Rust 是一种静态类型的编译语言，性能类似于 C 和 C++，但它更加注重安全性和内存管理。Rust 以其独特的所有权模型而闻名，这种模型在没有垃圾回收器的情况下确保内存安全，特别适合需要对系统资源进行精细控制的系统编程。

注意

本书使用的是 Linux/macOS 系统。如果你在 Windows 上运行，可以使用 Git Bash、WSL 或任何配置了 bash 命令的 shell。有关使用其他软件（如 Docker）的具体实现说明，请参考相关文档。

我们将详细讨论以下接口，并介绍如何通过每个接口创建和读取 Delta Lake 表：

• Python
• PySpark Shell
• JupyterLab Notebook
• Scala Shell
• Delta Rust API
• ROAPI

运行 Docker 容器

要启动一个带有 bash shell 的 Docker 容器：

1. 打开一个 bash shell。

2. 使用以下命令从构建的镜像启动容器，并设置 bash 作为入口点：

   docker run --name delta_quickstart --rm -it --entrypoint bash delta_quickstart
   

Delta Lake for Python

首先，打开一个 bash shell，并从构建的镜像中运行一个带有 bash 入口点的容器。

接下来，使用 python3 命令启动 Python 交互式 shell 会话。以下代码片段将创建一个 Pandas DataFrame，创建一个 Delta Lake 表，生成新数据，通过追加新数据来写入该表，最后读取并展示 Delta Lake 表中的数据：

# Python
import pandas as pd
from deltalake.writer import write_deltalake
from deltalake import DeltaTable

df = pd.DataFrame(range(5), columns=["id"])     # 创建 Pandas DataFrame
write_deltalake("/tmp/deltars_table", df)       # 写入 Delta Lake 表
df = pd.DataFrame(range(6, 11), columns=["id"]) # 生成新数据
write_deltalake("/tmp/deltars_table", df, mode="append")  # 追加新数据
dt = DeltaTable("/tmp/deltars_table")           # 读取 Delta Lake 表
dt.to_pandas()                                  # 展示 Delta Lake 表

输出应该类似于以下内容：

# Output
    0
0   0
1   1
... ...
8   9
9  10

通过这些 Python 命令，你已经创建了你的第一个 Delta Lake 表。你可以通过查看构成该表的底层文件系统来验证这一点。要做到这一点，可以在关闭 Python 进程后，运行以下 ls 命令列出你在 /tmp/deltars_table 保存的 Delta Lake 表文件夹中的内容：

# Bash
$ ls -lsgA /tmp/deltars_table
total 12
4 -rw-r--r-- 1 NBuser 1610 Apr 13 05:48 0-...-f3c05c4277a2-0.parquet
4 -rw-r--r-- 1 NBuser 1612 Apr 13 05:48 1-...-674ccf40faae-0.parquet
4 drwxr-xr-x 2 NBuser 4096 Apr 13 05:48 _delta_log

.parquet 文件包含你在 Delta Lake 表中看到的数据，而 _delta_log 包含 Delta 表的事务日志。我们将在第三章中详细讨论事务日志。

PySpark Shell

首先，打开一个 bash shell，并从构建的镜像中运行一个带有 bash 入口点的容器。

接下来，启动一个 PySpark 交互式 shell 会话：

# Bash
$SPARK_HOME/bin/pyspark --packages io.delta:${DELTA_PACKAGE_VERSION} \
--conf "spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension" \
--conf "spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog"

在 shell 中运行一些基本命令：

# Python
# 创建一个 Spark DataFrame
data = spark.range(0, 5)

# 写入 Delta Lake 表
(data
   .write
   .format("delta")
   .save("/tmp/delta-table")
)

# 从 Delta Lake 表读取数据
df = (spark
        .read
        .format("delta")
        .load("/tmp/delta-table")
        .orderBy("id")
      )

# 展示 Delta Lake 表
df.show()

要验证你是否创建了 Delta Lake 表，可以列出 Delta Lake 表文件夹中的内容。例如，在上面的代码中，你将表保存到了 /tmp/delta-table。一旦关闭了你的 PySpark 进程，运行以下 ls 命令，你应该看到类似如下内容：

# Bash
$ ls -lsgA /tmp/delta-table
total 36
4 drwxr-xr-x 2 NBuser 4096 Apr 13 06:01 _delta_log
4 -rw-r--r-- 1 NBuser  478 Apr 13 06:01 part-00000-56a2c68a-f90e-4764-8bf7-a29a21a04230-c000.snappy.parquet
4 -rw-r--r-- 1 NBuser   12 Apr 13 06:01 .part-00000-56a2c68a-f90e-4764-8bf7-a29a21a04230-c000.snappy.parquet.crc
4 -rw-r--r-- 1 NBuser  478 Apr 13 06:01 part-00001-bcbb45ab-6317-4229-a6e6-80889ee6b957-c000.snappy.parquet
4 -rw-r--r-- 1 NBuser   12 Apr 13 06:01 .part-00001-bcbb45ab-6317-4229-a6e6-80889ee6b957-c000.snappy.parquet.crc
4 -rw-r--r-- 1 NBuser  478 Apr 13 06:01 part-00002-9e0efb76-a0c9-45cf-90d6-0dba912b3c2f-c000.snappy.parquet
4 -rw-r--r-- 1 NBuser   12 Apr 13 06:01 .part-00002-9e0efb76-a0c9-45cf-90d6-0dba912b3c2f-c000.snappy.parquet.crc
4 -rw-r--r-- 1 NBuser  486 Apr 13 06:01 part-00003-909fee02-574a-47ba-9a3b-d531eec7f0d7-c000.snappy.parquet
4 -rw-r--r-- 1 NBuser   12 Apr 13 06:01 .part-00003-909fee02-574a-47ba-9a3b-d531eec7f0d7-c000.snappy.parquet.crc

JupyterLab Notebook

打开一个 bash shell，并从构建的镜像中运行一个带有 JupyterLab 入口点的容器：

# Bash
docker run --name delta_quickstart --rm -it \
-p 8888-8889:8888-8889 delta_quickstart

该命令将输出一个 JupyterLab notebook 的 URL。复制该 URL 并在浏览器中打开，跟随笔记本中的步骤运行每个代码单元。

Scala Shell

首先，打开一个 bash shell，并从构建的镜像中运行一个带有 bash 入口点的容器。接下来，启动一个 Scala 交互式 shell 会话：

# Bash
$SPARK_HOME/bin/spark-shell --packages io.delta:${DELTA_PACKAGE_VERSION} \
--conf "spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension" \
--conf "spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog"

在 shell 中运行一些基本命令：

// Scala
// 创建一个 Spark DataFrame
val data = spark.range(0, 5)

// 写入 Delta Lake 表
(data
   .write
   .format("delta")
   .save("/tmp/delta-table")
)

// 从 Delta Lake 表读取数据
val df = (spark
            .read
            .format("delta")
            .load("/tmp/delta-table")
            .orderBy("id")
         )

// 展示 Delta Lake 表
df.show()

有关如何验证 Delta Lake 表的说明，请参阅“PySpark Shell”。

Delta Rust API

首先，打开一个 bash shell，并从构建的镜像中运行一个带有 bash 入口点的容器。

接下来，执行 examples/read_delta_table.rs 来查看 covid19_nyt Delta Lake 表的元数据和文件；此命令将列出有用的输出，包括已写入的文件数量及其绝对路径等信息：

# Bash
cd rs
cargo run --example read_delta_table

最后，执行 examples/read_delta_datafusion.rs 来使用 DataFusion 查询 covid19_nyt Delta Lake 表：

# Bash
cargo run --example read_delta_datafusion

运行上述命令后，应该会列出 covid19_nyt Delta Lake 表的模式和五行数据。

ROAPI

Delta Lake 周围的丰富开放生态系统支持许多新颖的工具，例如 ROAPI，它包含在 quickstart 容器中。使用 ROAPI，你可以为静态的 Delta Lake 数据集启动只读 API，无需编写任何代码。你可以使用 ROAPI 通过 Apache Arrow 和 DataFusion 查询 Delta Lake 表，这些工具也已预安装在 Docker 镜像中。

首先，打开一个 bash shell，并从构建的镜像中运行一个带有 bash 入口点的容器：

# Bash
docker run --name delta_quickstart --rm -it \
-p 8080:8080 --entrypoint bash delta_quickstart

API 调用会被推送到 nohup.out 文件。如果你还没有在容器中创建 deltars_table，请使用“Delta Lake for Python”部分中描述的方法创建它。或者，你可以省略命令中的 --table 'deltars_table=/tmp/deltars_table/,format=delta'，以及任何调用 deltars_table 的步骤。

使用以下 nohup 命令启动 ROAPI 工具：

# Bash
nohup roapi --addr-http 0.0.0.0:8080 \
--table 'deltars_table=/tmp/deltars_table/,format=delta' \
--table 'covid19_nyt=/opt/spark/work-dir/rs/data/COVID-19_NYT,format=delta' &

接下来，打开另一个 shell 并连接到同一个 Docker 镜像：

# Bash
docker exec -it delta_quickstart /bin/bash

在你上一步启动的 bash shell 中，运行接下来的三个步骤。

检查两个 Delta Lake 表的模式：

# Bash
curl localhost:8080/api/schema

上述命令的输出应该类似如下：

# Output
{
   "covid19_nyt":{
       "fields":[
           {"name":"date","data_type":"Utf8","nullable":true,"dict_id":0,"dict_is_ordered":false},
           {"name":"county","data_type":"Utf8","nullable":true,"dict_id":0,"dict_is_ordered":false},
           {"name":"state","data_type":"Utf8","nullable":true,"dict_id":0,"dict_is_ordered":false},
           {"name":"fips","data_type":"Int32","nullable":true,"dict_id":0,"dict_is_ordered":false},
           {"name":"cases","data_type":"Int32","nullable":true,"dict_id":0,"dict_is_ordered":false},
           {"name":"deaths","data_type":"Int32","nullable":true,"dict_id":0,"dict_is_ordered":false}
       ]
   },
   "deltars_table":{
       "fields":[
           {"name":"0","data_type":"Int64","nullable":true,"dict_id":0,"dict_is_ordered":false}
       ]
   }
}

查询 deltars_table：

# Bash
curl -X POST -d "SELECT * FROM deltars_table" localhost:8080/api/sql

上述命令的输出应该类似如下：

# Output
[{"0":0},{"0":1},{"0":2},{"0":3},{"0":4},{"0":6},{"0":7},{"0":8},{"0":9},
{"0":10}]

查询 covid19_nyt Delta Lake 表：

# Bash
curl -X POST \
-d "SELECT cases, county, date FROM covid19_nyt ORDER BY cases DESC LIMIT 5" \
localhost:8080/api/sql

上述命令的输出应该类似如下：

# Output
[
   {"cases":1208672,"county":"Los Angeles","date":"2021-03-11"},
   {"cases":1207361,"county":"Los Angeles","date":"2021-03-10"},
   {"cases":1205924,"county":"Los Angeles","date":"2021-03-09"},
   {"cases":1204665,"county":"Los Angeles","date":"2021-03-08"},
   {"cases":1203799,"county":"Los Angeles","date":"2021-03-07"}
]

原生 Delta Lake 库

尽管 Delta Lake 的核心功能深度集成于 Apache Spark，但其底层数据格式和事务日志是设计为与编程语言无关的。这种灵活性促使了多种编程语言中 Delta Lake 原生库的开发，使得开发者可以直接与 Delta Lake 表进行交互，而无需依赖 Spark 的开销。

这些库提供了对 Delta Lake 功能的低级访问，使得开发者能够以与语言无关的方式构建高度优化和专业化的应用程序。开发者可以选择最适合其需求和专业技能的编程语言。我们将在第六章中对此进行更详细的讨论。

多种绑定可用

Rust 库为其他非 JVM（Java 虚拟机）库提供了坚实的基础，帮助其构建与 Delta Lake 的管道。最受欢迎和最重要的绑定之一是 Python 绑定，它暴露了 DeltaTable 类，并可选择与 Pandas 或 PyArrow 无缝集成。在本文写作时，Delta Lake 的 Python 包兼容 Python 3.7 及更高版本，并为大多数主要操作系统和架构提供了多个预构建的 wheel 文件，方便安装。

多个社区基于 Rust 库开发了绑定，将 Delta Lake 提供给 Ruby、Node 或其他基于 C 的连接器。尽管如此，目前没有哪个绑定达到了 Python 包所展现的成熟度，部分原因在于其他语言生态系统中未曾像 Python 社区一样进行过如此多的数据工具投资。Pandas、Polars、PyArrow、Dask 等为开发者提供了一套丰富的工具，用于从 Delta 表中读取数据或将数据写入 Delta 表。

最近，关于 Delta 核心（Delta Kernel）计划的实验性工作开始进行。该计划旨在为连接器提供原生的 Delta Lake 库接口，并将 Delta 协议抽象到一个地方。此工作仍处于早期阶段，但预计将有助于统一支持原生（例如 C/C++）和更高层次引擎（例如 Python 或 Node），使所有人都能通过简单地升级其底层的 Delta Kernel 版本，受益于更多高级特性，如删除向量。

安装 Delta Lake Python 包

Delta Lake 提供了基于 delta-rs 项目的原生 Python 绑定，并集成了 Pandas。可以通过以下命令轻松安装此 Python 包：

# Bash
pip install delta-lake

安装完成后，您可以按照“Delta Lake for Python”部分中概述的步骤进行操作。

Apache Spark 与 Delta Lake

Apache Spark 是一个开源引擎，旨在处理和分析大规模数据集。它的架构既快速又多功能，能够处理各种类型的分析，包括批处理和实时分析。Spark 提供了编程集群的接口，支持隐式的数据并行和容错功能。它通过内存计算来加速数据处理，超越了传统的 MapReduce 操作。

Spark 支持多语言编程，允许开发者使用多种语言构建应用，包括 Java、Scala、Python、R 和 SQL。Spark 还集成了多个库，支持广泛的数据分析任务，包括机器学习、流处理和图分析。

Spark 主要使用 Scala 编写，但它的 API 可以通过 Scala、Python、Java 和 R 来访问。Spark SQL 还允许用户编写和执行 SQL 或 HiveQL 查询。对于新用户，建议先通过 Python API 或 SQL 查询开始探索 Apache Spark。

想要更详细了解 Spark，可以参考《Learning Spark》（O’Reilly）或《Spark: The Definitive Guide》（O’Reilly）。

在 Apache Spark 上设置 Delta Lake

本节的步骤可以通过以下两种方式在本地机器上执行：

1. 交互式执行 启动 Spark shell（使用 spark-shell 启动 Scala，或使用 pyspark 启动 Python），然后在 shell 中交互式运行代码片段。本章中，我们将重点介绍交互式执行。
2. 作为项目运行 如果你有多个文件的代码，而不是单独的代码片段，可以设置一个 Maven 或 sbt 项目（适用于 Scala 或 Java），并将 Delta Lake 包含在项目中，运行该项目。你还可以使用 GitHub 仓库中提供的示例代码。

警告

在接下来的所有操作中，确保安装与 Delta Lake 2.3.0 兼容的 Spark 或 PySpark 版本。详情请参阅发布兼容性矩阵。

前提条件：安装 Java

如 Apache Spark 官方安装说明中所述，你必须确保系统中已正确安装并配置有效的 Java 版本（版本 8、11 或 17），并通过系统 PATH 或 JAVA_HOME 环境变量进行配置。

读者应确保使用与 Delta Lake 2.3.0 及以上版本兼容的 Apache Spark 版本。

设置交互式 Shell

要在 Spark SQL、Scala 或 Python shell 中交互式使用 Delta Lake，你需要本地安装 Apache Spark。根据你想使用 SQL、Python 还是 Scala，你可以分别设置 SQL、PySpark 或 Spark shell。

Spark SQL shell

Spark SQL shell，也称为 Spark SQL CLI，是一个交互式命令行工具，旨在方便地直接从命令行执行 SQL 查询。

按照 Spark 文档中的说明，下载兼容版本的 Apache Spark，可以通过 pip 安装，或者通过下载并解压归档文件后，在解压目录中运行 spark-sql：

# Bash
bin/spark-sql --packages io.delta:delta-core_2.12:2.3.0 --conf \
"spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension" --conf \
"spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog"

要创建第一个 Delta Lake 表，可以在 Spark SQL shell 提示符下运行以下 SQL：

-- SQL
CREATE TABLE delta.`/tmp/delta-table` USING DELTA AS
SELECT col1 AS id FROM VALUES 0, 1, 2, 3, 4;

可以通过另一个简单的 SQL 查询读取写入表的数据：

-- SQL
SELECT * FROM delta.`/tmp/delta-table`;

PySpark Shell

PySpark shell，也称为 PySpark CLI，是一个交互式环境，旨在使用 Python 编程语言与 Spark 的 API 进行交互。它作为一个学习平台，能够直接从命令行进行 PySpark 示例测试和数据分析。PySpark shell 以读取-评估-打印循环（REPL）的形式运行，为快速测试 PySpark 语句提供了便捷的环境。

通过在命令提示符下运行以下命令，安装与 Delta Lake 版本兼容的 PySpark 版本：

# Bash
pip install pyspark==<compatible-spark-version>

接下来，使用 Delta Lake 包和其他配置运行 PySpark：

# Bash
pyspark --packages io.delta:delta-core_2.12:2.3.0 --conf \
"spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension" --conf \
"spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog"

最后，在 PySpark shell 提示符下运行以下命令，创建你的第一个 Delta Lake 表：

# Python
data = spark.range(0, 5)
data.write.format("delta").save("/tmp/delta-table")

你可以通过以下简单的 PySpark 代码片段来读取写入表的数据：

# Python
df = spark.read.format("delta").load("/tmp/delta-table")
df.show()

Spark Scala Shell

Spark Scala shell，也称为 Spark Scala CLI，是一个交互式平台，允许用户使用 Scala 编程语言与 Spark 的 API 进行交互。它是一个强大的数据分析工具，也是学习 API 的一个便捷平台。

按照 Spark 文档中的说明，下载兼容版本的 Apache Spark，可以通过 pip 安装，或通过下载并解压归档文件后，在解压目录中运行 spark-shell：

# Bash
bin/spark-shell --packages io.delta:delta-core_2.12:2.3.0 --conf \
"spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension" --conf \
"spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog"

在 Scala shell 提示符下运行以下命令，创建你的第一个 Delta Lake 表：

// Scala
val data = spark.range(0, 5)
data.write.format("delta").save("/tmp/delta-table")

你可以通过以下简单的 PySpark 代码片段读取写入表的数据：

// Scala
val df = spark.read.format("delta").load("/tmp/delta-table")
df.show()

PySpark 声明式 API

Delta Lake 还提供了一个包含 Python API 的 PyPi 包，用于在 Apache Spark 中使用 Delta Lake。这对于设置 Python 项目以及进行单元测试非常有用。可以使用以下命令安装 Delta Lake：

# Bash
pip install delta-spark

在 Delta Lake 中，可以通过 configure_spark_with_delta_pip 工具函数配置 SparkSession：

# Python
from delta import *
builder = (
  pyspark.sql.SparkSession.builder.appName("MyApp").config(
    "spark.sql.extensions",
    "io.delta.sql.DeltaSparkSessionExtension"
  ).config(
    "spark.sql.catalog.spark_catalog",
    "org.apache.spark.sql.delta.catalog.DeltaCatalog"
  )
)

Databricks 社区版

Databricks 社区版为个人使用提供了一个平台，您可以通过该平台获得一个具有 15 GB 内存的集群，这对于使用笔记本和捆绑的 Spark 版本学习 Delta Lake 来说，可能正合适。

要注册 Databricks 社区版，请访问 Databricks 注册页面，填写表单中的信息并点击继续。在注册表单的第二页，点击“开始使用社区版”链接，选择社区版。

成功创建账户后，您将收到一封验证电子邮件。完成验证后，您就可以登录到 Databricks 社区版，查看 Databricks 工作区。

使用 Databricks Runtime 创建集群

首先，在左侧面板点击“计算”菜单项。您创建的所有集群将在此页面列出。如果这是您第一次登录该账户，页面将不会列出任何集群，因为您尚未创建任何集群。

点击“创建计算”将带您进入新集群页面。Databricks Runtime 13.3 LTS 是当前默认选择。您可以选择任何最新的（最好是 LTS）Databricks Runtime 版本来运行代码。在本例中，我们选择了 Databricks Runtime 13.3 LTS。有关 Databricks Runtime 发布和兼容性矩阵的更多信息，请查看 Databricks 网站。

接下来，为您的集群选择一个名称；我们选择了“Delta_Lake_DLDG”（见图 2-1）。然后点击页面顶部的“创建集群”按钮以启动集群。

您的集群应该在几分钟内启动并运行，如图 2-2 所示。

导入笔记本

为了简洁和易于理解，我们将使用在“JupyterLab Notebook”一节中看到的 Jupyter Notebook。这个笔记本可以在 delta-docs 的 GitHub 仓库中找到。请复制笔记本链接并保存在手边，因为您将在此步骤中导入该笔记本。
前往 Databricks Community Edition，点击 Workspace，然后点击右上角的三个堆叠的点，如图 2-3 所示。

在对话框中，点击 URL 单选按钮，粘贴笔记本的 URL，然后点击 Import。这将会在 Databricks Community Edition 中渲染 Jupyter Notebook。

附加笔记本

现在，选择您之前创建的 Delta_Lake_DLDG 集群来运行此笔记本，如图 2-4 所示。

现在，您可以在笔记本中运行每个单元，并按下 Control + Enter 键执行该单元。当 Spark 作业运行时，Databricks Community Edition 会直接在笔记本中显示更详细的信息。您也可以从这里导航到 Spark UI。

您将能够在这个笔记本中写入和读取 Delta Lake 表。

总结

在本章中，我们探讨了开始使用 Delta Lake 的多种方法，包括 Delta Docker、Delta Lake for Python、Apache Spark with Delta Lake、PySpark Declarative API，以及 Databricks Community Edition。我们展示了如何轻松运行一个简单的笔记本或命令行 Shell 来写入和读取 Delta Lake 表。下一章将详细介绍写入和读取操作。

最后，我们向您展示了如何使用这些方法中的任何一种来安装 Delta Lake，以及 Delta Lake 的多种可用方式。您还了解了如何通过 API 使用 SQL、Python、Scala、Java 和 Rust 编程语言访问 Delta Lake 表。在下一章中，我们将介绍使用 Delta Lake 所需的基本操作。