TinyDB 快速指南

---

---

TinyDB - 简介

什么是 TinyDB？

TinyDB，用纯 Python 编程语言编写，是一个小型且轻量级的文档型数据库，没有外部依赖项。它提供简单的 API，使其易于使用。我们可以将 TinyDB 数据库用于小型项目应用程序，无需任何配置。

TinyDB 模块，作为 Python 程序的第三方模块可用，可用于存储、检索和修改 JSON 格式的数据。

TinyDB 的特性

TinyDB 是一个干净且轻松的数据库，可以操作多种格式的文档。它具有以下特性。

• 非常小巧 − TinyDB 数据库本质上非常小巧，只有 1800 行代码和 1600 行测试。

• 易于使用 − 由于其简单且干净的 API，TinyDB 易于使用。

• 面向文档 − 在 TinyDB 中，我们可以存储任何文档。文档将表示为字典。

• 独立 − TinyDB 数据库独立于任何外部服务器和来自 PyPI 的外部依赖项。

• 兼容 Python 3.6 或更高版本 − TinyDB 已在 Python 3.6 及更高版本上进行了测试，并与之兼容。它也适用于 PyPY3。

• 可扩展 − TinDB 可以通过编写新的存储或修改存储的行为来轻松扩展。

TinyDB 的优势

TinyDB 为学生、用户和开发人员提供各种好处。

• TinyDB 是开源数据库，不需要任何外部配置。

• 它非常易于使用，用户可以轻松处理文档。

• 它会自动将文档存储在数据库中。

• TinyDB 非常适合个人项目，我们需要在其中安装一些数据。

• 它适用于小型应用程序，这些应用程序会被大型数据库（如 SQL 或外部数据库服务器）所淘汰。

• 它使用简单的命令行和查询来操作数据。

• 代码覆盖率达 100%，无需解释。

TinyDB 的局限性

如果您需要以下功能，TinyDB 将不是您项目的正确选择：

• 为表格创建索引，

• 管理表格之间的关系，

• 使用 HTTP 服务器，或

• 从多个处理器访问。

与其他数据库的比较

下表突出显示了 TinyDB 与 MySQL 和 Oracle 数据库的不同之处：

TinyDB - 环境设置

TinyDB 设置的先决条件

要安装 TinyDB，您的系统中必须安装 Python 3.6 或更高版本。您可以访问链接 www.python.org 并选择适合您的操作系统的最新版本，即 Windows 和 Linux/Unix。我们有一个关于 Python 的综合教程，您可以在 www.tutorialspoint.com 参考。

安装 TinyDB

您可以通过三种不同的方式安装 TinyDB：使用包管理器、从源代码安装或从 GitHub 安装。

使用包管理器

TinyDB 的最新发布版本在两个包管理器pip 和conda 上都可用。让我们检查一下如何使用它们来安装 TinyDB：

要使用pip 安装 TinyDB，您可以使用以下命令：

pip install tinydb

要通过conda-forge 安装 TinyDB，您可以使用以下命令：

conda install -c conda-forge tinydb

从源代码安装

您还可以从源代码分发版安装 TinyDB。访问链接 https://pypi.ac.cn/project/tinydb/#files 下载文件并从源代码构建。

从 GitHub 安装

要使用 GitHub 安装 TinyDB，请获取最新的开发版本，解压缩文件，并使用以下命令安装它：

pip install

设置 TinyDB

安装完成后，请按照以下步骤设置 TinyDB 数据库。

步骤 1：导入 TinyDB 及其查询

首先，我们需要导入 TinyDB 及其查询。使用以下命令：

from tinydb import TinyDB, Query

步骤 2：创建文件

TinyDB 数据库可以以多种格式存储数据，例如 XML、JSON 等。我们将使用以下文件创建一个 JSON 文件：

db = TinyDB('Leekha.json')

上述命令将创建一个 TinyDB 类的实例，并将文件 Leekha.Json 传递给它。这是我们将数据存储到的文件。现在，TinyDB 数据库已设置就绪，您可以对其进行操作了。我们现在可以插入数据并在数据库中操作值了。

卸载 TinyDB

如果需要卸载 TinyDB，可以使用以下命令：

pip uninstall tinydb

TinyDB - 插入数据

我们创建了 TinyDB 的实例，并将一个 JSON 文件传递给它，我们的数据将存储在其中。现在是时候将项目插入到我们的数据库中了。数据应采用 Python 字典的形式。

语法

要插入项目，可以使用insert() 方法，其语法如下所示：

db.insert({'type1': 'value1', 'type2': 'value2', 'typeN': 'valueN'})

我们也可以先创建一个字典，然后使用 insert() 方法将数据插入到我们的数据库中。

data_item = {'type1': 'value1', 'type2': 'value2', 'typeN': 'valueN' } db.insert(data_item)

运行上述命令后，insert() 方法将返回新创建对象的 ID。并且，我们的 JSON 文件将如下所示：

{"_default": {"1": {"type1": "value1", "type2": "value2", "typeN": "valueN"}}}

查看上表条目：'default' 是表的名称，'1' 是新创建对象的 ID，值是我们刚刚插入的数据。

示例：插入单个项目

让我们借助示例来理解上述概念。假设我们有一个数据库，其中包含学生信息，显示学号、姓名、分数、科目和地址。以下是存储在数据库中的信息：

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   }
]

在上述数据库中，如果要插入新的学生记录（即单个项目），请使用以下命令：

db.insert({
   'roll_number': 6,
   'st_name':'jim',
   'mark':300,
   'subject':'sql',
   'address':'pune'
})

它将返回新创建对象的 ID：

6

让我们再输入一条记录：

db.insert({
   'roll_number': 7,
   'st_name':'karan',
   'mark':290,
   'subject':'NoSQL',
   'address':'chennai'
})

它将返回新创建对象的 ID：

7

如果要检查数据库中存储的项目，请使用all() 方法，如下所示：

db.all()

它将产生以下输出：

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   },
   {
      "roll_number":6,
      "st_name":"jim",
      "mark":300,
      "subject":"sql",
      "address":"pune"
   },
   {
      "roll_number":7,
      "st_name":"karan",
      "mark":290,
      "subject":"NoSQL",
      "address":"chennai"
   }
]

您可以观察到它在 JSON 文件中添加了两个新的数据项。

示例：一次插入多个项目

您也可以一次在 TinyDB 数据库中插入多个项目。为此，您需要使用insert_multiple() 方法。让我们看一个例子：

items = [
   {'roll_number': 8, 'st_name': 'petter', 'address': 'mumbai'},
   {'roll_number': 9, 'st_name': 'sadhana', 'subject': 'SQL'}
]
db.insert_multiple(items)

现在，使用 all() 方法检查数据库中存储的项目，如下所示：

db.all()

它将产生以下输出：

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   },
   {
      "roll_number":6,
      "st_name":"jim",
      "mark":300,
      "subject":"sql",
      "address":"pune"
   },
   {
      "roll_number":7,
      "st_name":"karan",
      "mark":290,
      "subject":"NoSQL",
      "address":"chennai"
   },
   {
      "roll_number":8,
      "st_name":"petter",
      "address":"mumbai"
   },
   {
      "roll_number":9,
      "st_name":"sadhana",
      "subject":"SQL"
   }
]

您可以观察到它在 JSON 文件中添加了两个新的数据项。您还可以跳过数据项中的一些键值（就像我们所做的那样）在添加最后两个项目时。我们跳过了“mark”和“address”。

TinyDB - 检索数据

有许多方法可以帮助您从 TinyDB 数据库中检索数据。但是要使用这些方法，您首先需要创建一个 Query 类的实例，如下所示：

from tinydb import Query
Student = Query()

这里，Student 是数据库的名称。

让我们检查从 TinyDB 数据库中检索信息的不同方法。

使用 Search() 方法检索数据

search() 方法顾名思义，返回与我们提供的查询匹配的项目列表，否则将返回空列表。

对于此示例和其他示例，我们将使用以下学生数据库数据：

[
   {
      "roll_number": 1,
      "st_name": "elen",
      "mark": 250,
      "subject": "TinyDB",
      "address": "delhi"
   },
   {
      "roll_number": 2,
      "st_name": "Ram",
      "mark": [
         250,
         280
      ],
      "subject": [
         "TinyDB",
         "MySQL"
      ],
      "address": "delhi"
   },
   {
      "roll_number": 3,
      "st_name": "kevin",
      "mark": [
         180,
         200
      ],
      "subject": [
         "oracle",
         "sql"
      ],
      "address": "keral"
   },
   {
      "roll_number": 4,
      "st_name": "lakan",
      "mark": 200,
      "subject": "MySQL",
      "address": "mumbai"
   },
   {
      "roll_number": 5,
      "st_name": "karan",
      "mark": 275,
      "subject": "TinyDB",
      "address": "benglore"
   }
]

让我们举一个例子来理解 search() 方法：

from tinydb import TinyDB, Query
db = TinyDB("leekha.json")
student = Query()
db.search(student.subject == 'TinyDB' )

上述查询将从学生数据库中检索以下输出：

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

使用 get() 方法检索数据

与 search() 方法相反，get() 方法仅返回一个匹配的文档。否则将返回 None。例如，让我们看以下代码：

from tinydb import TinyDB, Query
student = Query()
db.get(student.subject == 'TinyDB' )

上述查询将从学生数据库中检索以下数据。

[{'roll_number': 1, 'st_name': 'elen', 'mark': 250, 'subject': 'TinyDB', 'address': 'delhi'}]

使用 all() 方法检索数据

all() 方法返回数据库中的所有文档。例如，

db.all()

它将从学生数据库中检索所有数据。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

使用 for 循环检索数据

for 循环也返回数据库中的所有文档。例如，

for info in db:
   print(info)

与 all() 方法一样，它将从学生数据库中检索所有行。

TinyDB - 更新数据

TinyDB 可以以多种格式存储数据，我们可以使用各种方法轻松检索存储的数据。但有时我们需要更新数据，为此我们可以使用update() 方法。

要更新数据库，我们首先需要创建一个Query 类的实例。您可以为此目的使用以下命令：

from tinydb import Query
Student = Query()

这里，Student 是我们数据库的名称。

update() 方法

以下是 update() 方法的语法：

db.update({ updated field: updated information… }, stable field: information)

让我们举一个例子来理解 update() 方法是如何工作的。对于此示例，我们将使用以下学生数据库：

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

根据给定数据，学号为“1”的学生姓名为“elen”。以下查询将学生姓名更新为“Adam”：

from tinydb import TinyDB, Query
student = Query()
db.update({'st_name' : 'Adam'}, student.roll_number == 1 )

它将返回已更新对象的 id：

[1]

现在，您可以使用 all() 方法查看已更新的数据库：

db.all()

它将显示已更新的数据：

[
   {
      "roll_number":1,
      "st_name":"Adam",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

有时，我们需要更新数据库中所有文档的一个或多个字段。为此，我们可以直接使用update() 方法，而无需编写查询参数。以下查询将所有学生的地址更改为'College_Hostel'：

db.update({'address': 'College_Hostel'})

它将返回已更新对象的 id：

[1,2,3,4,5]

同样，您可以使用 all() 方法查看已更新的数据库。

db.all()

它将显示已更新的数据：

[
   {
      "roll_number":1,
      "st_name":"Adam",
      "mark":250,
      "subject":"TinyDB",
      "address":"College_Hostel"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":" College_Hostel "
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":" College_Hostel "
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":" College_Hostel "
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":" College_Hostel "
   }
]

观察到所有行的地址字段都具有相同的数据，即'College_Hostel'。

TinyDB - 删除数据

如果您需要从 TinyDB 数据库中永久删除特定数据集，您可以使用remove() 方法来执行此操作。与检索和更新数据一样，您首先需要创建一个Query 类的实例才能删除数据。您可以为此目的使用以下命令：

from tinydb import Query
Student = Query()

这里，Student 是我们数据库的名称。

remove() 方法

以下是 remove() 方法的语法：

db.remove( Query() field regex )

remove() 方法接受可选条件以及可选的文档 ID 列表。

学生数据库

我们将使用以下学生数据库作为本章示例。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例：删除单行数据

让我们举个例子来理解remove()方法。

from tinydb import TinyDB, Query
student = Query()
db.remove(student.roll_number == 5)

以上查询将删除学生学号为5的数据。它将返回已删除对象的ID -

[5]

现在，我们可以使用all()方法查看更新后的数据库。

db.all()

它将显示更新后的数据库中的数据 -

[
   {
      "roll_number":1,
      "st_name":"Adam",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   }
]

示例：删除多行数据

如果您想一次删除多行，您可以按如下方式使用remove()方法 -

from tinydb import TinyDB, Query
student = Query()
db.remove(student.roll_number > 2)

它将返回已删除对象的ID

[3,4]

使用all()方法查看更新后的数据库。

db.all()

它将显示更新后的数据库中的数据 -

[
   {
      "roll_number":1,
      "st_name":"Adam",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   }
]

示例：删除所有数据

如果您想删除数据库中的所有数据，可以使用truncate()方法，如下所示 -

db.truncate()

接下来，使用all()方法查看更新后的数据库。

db.all()

它将显示一个空数据库作为输出 -

[]

TinyDB - 查询

TinyDB 有一套丰富的查询。我们有多种构建查询的方法：第一种方法类似于 ORM 工具的语法，第二种是使用“Where”子句的传统方法。

在本章中，让我们了解在 TinyDB 数据库中构建查询的这两种方法。

第一种方法：导入查询

第一种方法类似于 ORM 工具的语法，其中首先需要在命令提示符中导入查询。导入后，可以使用查询对象操作 TinyDB 数据库。语法如下所示 -

from tinydb import Query
student = Query()

这里，“student”是我们数据库的名称。在示例中，我们将使用以下student数据库。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例

以下是从student数据库中检索数据的查询，其中学生的roll_no小于3 -

>>> db.search(Query().roll_number < 3)

或者，

>>> student = Query()
>>> db.search(student.roll_number < 3)

上述搜索查询将产生以下结果 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   }
]

有时文件名不是有效的 Python 标识符。在这种情况下，我们将无法访问该字段。对于此类情况，我们需要切换到字典访问表示法，如下所示 -

student = Query();

# Invalid Python syntax
db.search(student.security-code == 'ABCD')

# Use the following dict access notation
db.search(student['security-code'] == 'ABCD')

第二种方法：使用“where”子句

第二种方法是使用“where”子句构建查询的传统方法。语法如下所示 -

from tinydb import where
db.search(where('field') == 'value')

示例

TinyDB where 子句用于subject字段 -

db.search(where('subject') == 'MySQL') 

以上查询将产生以下输出 -

[{
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
}]

TinyDB - 搜索

TinyDB 提供了search()方法来帮助您从文档中搜索任何数据。除了query()对象之外，search()方法还可以用于在 JSON 文件中查找数据。我们可以通过多种方式在 TinyDB 数据库上使用 search() 方法。

方法 1：TinyDB search() 与字段的存在

我们可以根据字段的存在从数据库中搜索数据。让我们用一个例子来理解它。对于这个和其他示例，我们将使用以下student数据库。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例

基于字段存在性的搜索查询如下所示 -

from tinydb import Query
student = Query()
db.search(student.address.exists())

以上查询将从student文件中检索以下数据 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

方法 2：TinyDB search() 与正则表达式

我们可以使用正则表达式 (Regex) 从数据库中搜索特定数据。让我们了解它如何通过几个示例工作。

示例 1

与正则表达式匹配的完整项目搜索 -

from tinydb import Query
student = Query()
db.search(student.st_name.matches('[aZ]*'))

此查询将产生以下输出 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例 2

使用正则表达式的区分大小写搜索 -

from tinydb import Query
import re
student = Query()
db.search(student.st_name.matches('lakan', flags=re.IGNORECASE))

它将产生以下输出 -

[{
   'roll_number': 4,
   'st_name': 'lakan',
   'mark': 200,
   'subject': 'MySQL',
   'address': 'mumbai'
}]

示例 3

与正则表达式匹配的项目的任何部分 -

from tinydb import Query
student = Query()
db.search(student.st_name.search('r+'))

此查询将产生以下输出 -

[{
   'roll_number': 5,
   'st_name': 'karan',
   'mark': 275,
   'subject': 'TinyDB',
   'address': 'benglore'
}]

方法 3：使用子字符串的 TinyDB search()

我们也可以在从 TinyDB 数据库搜索特定数据时使用子字符串。让我们了解它如何通过几个示例工作 -

示例 1

看看这个查询；它将获取“address”字段为“delhi”的所有行。

from tinydb import Query
student = Query()
db.search(student['address'] == 'delhi')

它将产生以下输出：

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   }
]

示例 2

在此查询中，我们对 search() 方法使用了略微不同的语法。

from tinydb import Query
student = Query()
db.search(student.address.search('mumbai'))

它将获取“address”字段为“mumbai”的所有行。

[{
   'roll_number': 4,
   'st_name': 'lakan',
   'mark': 200,
   'subject': 'MySQL',
   'address': 'mumbai'
}]

TinyDB - where 子句

TinyDB 提供了“where”子句，您可以在搜索特定数据时使用它。“where”子句通过过滤掉不需要的数据来提供帮助。借助“where”子句，您可以快速访问特定数据。

在使用“where”子句之前，我们需要先导入它。“where”子句的语法如下所示 -

from tinydb import where
db.search(where('field') == 'value')

让我们通过几个示例了解“where”子句的使用。

学生数据库

在示例中，我们将使用以下student数据库。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例 1

让我们对subject字段使用“where”子句 -

db.search(where('subject') == 'MySQL')

此查询将获取“subject”字段为“MySQL”的所有行。

[{
   'roll_number': 4,
   'st_name': 'lakan',
   'mark': 200, 
   'subject': 'MySQL',
   'address': 'mumbai'
}]

示例 2

让我们看看“where”子句与“不等于”条件的另一种用法 -

db.search(where('mark') != 275)

此查询将获取“mark”字段不等于“275”的所有行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   }
]

TinyDB - exists() 查询

TinyDB 提供了一个名为exists()的高级查询，用于检查 JSON 文件中数据的存在。exists()查询实际上测试了从 JSON 文件中获取子字段数据的可用性。exists()查询基于布尔条件工作。如果子字段存在（即 BOOLEAN TRUE），它将相应地从 JSON 文件中获取数据，否则它将返回一个空值。

语法

TinyDB exists() 的语法如下所示 -

db.search(Query().field.exists())

这里，field表示我们要访问的数据部分。Query()是从 JSON 表student创建的对象。

我们将使用我们在所有先前章节中使用的相同student数据库。

示例 1

让我们对名为“subject”的字段使用 TinyDB exists()查询 -

db.search(student.subject.exists())

此查询将获取所有行，因为所有行都具有“subject”字段 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":" TinyDB ",
      "address":"benglore"
   }
]

示例 2

现在让我们对“address”字段使用exists()查询 -

db.search(student.address.exists())

它将获取以下行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":" TinyDB ",
      "address":"benglore"
   }
]

示例 3

现在，让我们尝试对不存在的字段使用exists()查询 -

db.search(student.city.exists())

由于给定表中的任何行都没有名为“city”的字段，因此上述 exists() 查询将返回一个空值 -

[]

TinyDB - matches() 查询

matches() 查询将 JSON 文件中的数据与给定条件（以正则表达式的形式）匹配，并相应地返回结果。如果条件与文件中的数据不匹配，它将返回一个空值。

语法

TinyDB matches() 的语法如下所示 -

db.search(Query().field.matches(regular expression))

这里，field表示我们要访问的数据部分。Query()是我们名为student的 JSON 表创建的对象。

让我们通过几个示例了解它如何工作。我们将使用我们在所有先前章节中使用的相同student数据库。

示例 1

让我们看看如何对完整项目搜索使用matches()。

from tinydb import Query
student = Query()
db.search(student.st_name.matches('[aZ]*'))

此查询将获取所有行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例 2

让我们看看如何对区分大小写搜索使用 matches()。

from tinydb import Query
import re
student = Query()
db.search(student.st_name.matches('ram', flags=re.IGNORECASE))

此查询将获取学生姓名与字符串“ram”匹配的行。请注意，我们使用了标志在匹配字符串时忽略大小写。

[{
   'roll_number': 2,
   'st_name': 'Ram',
   'mark': [250, 280],
   'subject': ['TinyDB', 'MySQL'],
   'address': 'delhi'
}]

示例 3

让我们看看如何对特定项目使用 matches()。

student = Query()
db.search(student.address.matches('keral'))

此查询将获取地址与字符串“keral”匹配的行。

[{'roll_number': 3, 'st_name': 'kevin', 'mark': [180, 200], 'subject':
['oracle', 'sql'], 'address': 'keral'}]

示例 4

让我们看看当 matches() 找不到特定项目时会返回什么 -

student = Query()
db.search(student.address.matches('Ratlam'))

没有“address”字段与字符串“Ratlam”匹配的行，因此它将返回一个空值 -

[]

TinyDB - test() 查询

test()查询将测试给定的参数是否与表中的数据匹配。如果它与数据匹配，它将返回匹配的数据，否则它将返回空白。首先，我们需要定义一个test函数及其参数，然后它将在给定的数据库中搜索项目。

语法

TinyDB test() 的语法如下所示 -

db.search(Query().field.test(function or condition, *arguments))

这里，field表示我们要访问的数据部分。Query()是我们名为student的 JSON 表创建的对象。

我们可以创建自定义测试函数，如下所示 -

object = lambda t: t == 'value'

这里lamba关键字对于创建自定义测试函数很重要。

让我们通过几个示例了解它如何工作。我们将使用我们在所有先前章节中使用的相同student数据库。

示例 1

我们将首先创建一个测试函数，然后在我们的student表中使用它 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
objects = lambda t: t == [250, 280]
db.search(Query().mark.test(objects))

它将获取“mark”字段具有值[250, 280]的行 -

[{'roll_number': 2, 'st_name': 'Ram', 'mark': [250, 280], 'subject':
['TinyDB', 'MySQL'], 'address': 'delhi'}]

示例 2

在此示例中，我们将在测试函数中使用“subject”字段 -

student = Query()
db = TinyDB('student.json')
objects = lambda t: t == 'TinyDB'
db.search(student.subject.test(objects))

此查询将获取“subject”字段值为“TinyDB”的所有行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

TinyDB - any() 查询

为了搜索包含列表的字段，TinyDB 提供了一个名为any()的方法。此方法匹配数据库中至少一个给定的值。它根据提供的查询查找整个列表或至少一个值。

语法

TinyDB any() 的语法如下所示 -

db.search(Query().field.any(query|list)

这里，field表示我们要访问的数据部分。Query()是我们名为student的 JSON 表创建的对象。

• 如果我们将query作为any()方法的参数提供，它将匹配列表字段中至少一个文档与给定查询匹配的所有文档。

• 另一方面，如果我们将list作为any()方法的参数提供，它将匹配列表字段中至少一个文档存在于给定列表中的所有文档。

让我们通过几个示例了解它如何工作。我们将使用我们在所有先前章节中使用的相同student数据库。

示例 1

让我们看看如何找到我们的学生表中主题是 TinyDB 或 MySQL 或 SQL 或任意两个或三个组合的字段 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.any(['TinyDB', 'MySQL', 'oracle']))

以上查询将获取“subject”字段包含以下任何值的全部行：“TinyDB”、“MySQL”或“oracle” -

[
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   }
]

示例 2

让我们看看当any()方法与给定列表中的任何内容不匹配时会发生什么 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.any(['Oracle']))

此查询将返回一个空值，因为没有“subject”为“Oracle”的行。

[]

示例 3

请注意，它是区分大小写的。“subject”字段没有“Oracle”，但它确实有“oracle”。尝试以下查询 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.any(['oracle']))

它将获取以下行 -

[{
   'roll_number': 3,
   'st_name': 'kevin',
   'mark': [180, 200],
   'subject': ['oracle', 'sql'],
   'address': 'keral'
}]

由于它是区分大小写的，因此在前面的示例中返回了一个空值，因为没有“subject”为“Oracle”的行。

TinyDB - all() 查询

TinyDB 提供了一个名为all()的方法，该方法根据提供的查询查找值的整个列表。让我们举个例子，找出它是如何工作的。

语法

TinyDB all() 的语法如下所示 -

db.search(Query().field.all(query|list)

这里，field表示我们要访问的数据部分。Query()是我们名为student的 JSON 表创建的对象。

• 如果我们将query作为all()方法的参数提供，它将匹配列表字段中所有文档都与给定查询匹配的所有文档。

• 另一方面，如果我们将list作为all()方法的参数提供，它将匹配列表字段中所有文档都存在于给定列表中的所有文档。

让我们通过几个示例了解它如何工作。我们将使用我们在所有先前章节中使用的相同student数据库。

示例 1

让我们看看如何找到我们的学生表中主题同时为 TinyDB 和 MySQL 的字段 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.all(['TinyDB', 'MySQL']))

此查询将获取以下行 -

[{
   'roll_number': 2,
   'st_name': 'Ram',
   'mark': [250, 280],
   'subject': ['TinyDB', 'MySQL'],
   'address': 'delhi'
}]

示例 2

让我们看看如何使用all()从数据库中获取所有数据 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.all()

它将获取链接数据库中的所有行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

TinyDB - one_of() 查询

为了匹配子字段数据，TinyDB 提供了一种名为one_of()的方法。此方法搜索单个类别并获取至少一个相似值。如果字段包含在提供的列表中，则将匹配。

语法

TinyDB one_of()的语法如下 -

db.search(Query().field.one_of(list)

这里，field表示我们要访问的数据部分。Query()是我们名为student的 JSON 表创建的对象。它将获取一个类别的单个或多个值。

让我们借助几个示例了解其工作原理。我们将使用前面所有章节中使用过的相同student数据库。

示例 1

让我们看看如何查找student表中address为“delhi”或“pune”的字段 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().address.one_of(['delhi', 'pune']))

它将获取“address”字段包含“delhi”或“pune”的所有行。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   }
]

示例 2

让我们用'subject'字段再看一个例子 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.one_of(['TinyDB', 'MySQL']))

它将获取“subject”字段包含“TinyDB”或“MySQL”的所有行。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":4,
      "st_name":"lakhan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

TinyDB - 逻辑非

逻辑非作为反向逻辑门工作。它将匹配与给定查询不匹配的文档。简单来说，它将显示给定命令的反义。

语法

TinyDB 逻辑非的语法如下 -

db.search(~(Query().field)

这里，field表示我们要访问的数据部分。Query()是我们名为student的 JSON 表创建的对象。它将获取表示给定命令反义的数据。

让我们举几个例子，看看它是如何工作的。我们将使用前面所有章节中使用过的相同student数据库。

示例 1

让我们看看如何查找student表中学生姓名不为'elen'的字段 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(~(Query().st_name == 'elen'))

以上查询将获取学生姓名不为“elen”的所有行。

[
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例 2

让我们看看如何使用逻辑非避免特定地址 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(~(student.address.one_of(['keral', 'delhi'])))

此查询将获取“address”字段不包含“keral”或“delhi”的所有行。

[
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

TinyDB - 逻辑与

“逻辑与”运算符组合多个条件，如果所有条件都满足，则评估为 True。TinyDB 逻辑与作用于数据库的两个查询。如果两个查询都为 True，则 TinyDB 将获取所需数据。另一方面，如果其中任何一个查询为 False，它将返回一个空值。

语法

TinyDB 逻辑与的语法如下 -

db.search((Query().(query1) & (Query().(query2) 

这里，field表示我们要访问的数据部分。Query()是我们名为student的 JSON 表创建的对象。如果两个条件都满足，它将获取数据，否则将返回一个空值。

让我们举几个例子，看看 Logial AND 是如何工作的。我们将使用前面所有章节中使用过的相同student数据库。

示例 1

让我们看看当我们在“st_name=lakhan”和“subject=MYSQL”字段上应用逻辑与时，我们的 TinyDB Student 数据库返回什么 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search ((Query().st_name == 'lakhan') & (Query().subject == 'MySQL'))

此查询将仅获取学生姓名为“lakhan”且“subject”为“MySQL”的行。

[{
   'roll_number': 4,
   'st_name': 'lakhan',
   'mark': 200,
   'subject': 'MySQL',
   'address': 'mumbai'
}]

示例 2

在此示例中，让我们在“subject”和“roll_number”字段上应用逻辑与 -

from tinydb import TinyDB, Query
student = Query()
db = TinyDB('student.json')
db.search((student.subject.search('M')) & (student.roll_number < 5))

此查询将获取“roll_number”小于“4”且“subject”以字母“M”开头的所有行。

[{
   'roll_number': 4,
   'st_name': 'lakhan',
   'mark': 200,
   'subject': 'MySQL',
   'address': 'mumbai'
}]

TinyDB - 逻辑或

“逻辑或”运算符组合多个条件，仅当其中任何一个条件满足时才评估为 True。TinyDB 逻辑或作用于数据库的两个查询。如果其中任何一个查询为 True，则 TinyDB 将获取所需数据。另一方面，如果两个查询都为 False，它将返回一个空值。

语法

TinyDB 逻辑或的语法如下 -

db.search((Query().(query1) | (Query().(query2) 

这里，field表示我们要访问的数据部分。Query()是我们名为student的 JSON 表创建的对象。如果其中任何一个条件满足，它将获取数据，否则将返回一个空值。

让我们举几个例子，看看它是如何工作的。我们将使用前面所有章节中使用过的相同student数据库。

示例 1

让我们看看当我们在“st_name”和“subject”字段上应用逻辑或并检查以下条件：“st_name=lakhan”和“subject=TinyDB”时，我们的 TinyDB Student 数据库返回什么 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search ((Query().st_name == 'lakan') | (Query().subject == 'TinyDB')) 

此查询将获取以下行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":4,
      "st_name":"lakhan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例 2

在此示例中，让我们在“subject”和“roll_number”字段上应用逻辑或 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search((student.subject.search('M')) | (student.roll_number < 5))

此查询将获取“subject”字段以字母“M”开头或“roll_number”小于“5”的所有行。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakhan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   }
]

TinyDB - 处理数据查询

TinyDB - 存储多个数据

我们已经讨论了如何使用'insert'查询将数据存储在数据库中。类似地，您可以使用'insert_multiple'查询同时存储多个数据项。以下是 TinyDB 中'insert_multiple'查询的语法

db.insert_multiple ([
   { key1 : value1, key2 : value2, ..., keyN : valueN},
   { key1 : value1, key2 : value2, ..., keyN : valueN }
])

让我们举几个例子来演示“insert_multiple”查询是如何工作的。我们将使用前面所有章节中使用过的相同student数据库。

示例 1

让我们看看如何使用insert_multiple查询在我们的'student'表中插入两条学生记录 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.insert_multiple([
   {
      "roll_number":6,
      "st_name":"Siya",
      "mark":240,
      "subject":"NoSQL",
      "address":"pune"
   },
   {
      "roll_number":7,
      "st_name":"Adam",
      "mark":210,
      "subject":"oracle",
      "address":"Keral"
   }
])

它将显示新保存记录的文档 ID -

[6, 7]

让我们检查新记录是否已保存到数据库中？使用all()方法，如下所示 -

db.all()

它将显示给定表中存储的所有记录 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   },
   {
      "roll_number":6,
      "st_name":"Siya",
      "mark":240,
      "subject":"NoSQL",
      "address":"pune"
   },
   {
      "roll_number":7,
      "st_name":"Adam",
      "mark":210,
      "subject":"oracle",
      "address":"Keral"
   }
]

您可以看到两条新的students记录已保存到数据库中。

示例 2

让我们看看如何使用insert_multiple和for循环同时在表中插入多个值。使用以下代码 -

db.insert_multiple({'roll_number': 10, 'numbers': r} for r in range(3))

它将返回新保存记录的文档 ID -

[8, 9, 10]

再次，使用all()方法验证新记录是否已保存到数据库中？

db.all()

它将获取给定student表中存储的所有记录 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   },
   {
      "roll_number":6,
      "st_name":"Siya",
      "mark":240,
      "subject":"NoSQL",
      "address":"pune"
   },
   {
      "roll_number":7,
      "st_name":"Adam",
      "mark":210,
      "subject":"oracle",
      "address":"Keral"
   },
   {
      "roll_number":10,
      "numbers":0
   },
   {
      "roll_number":10,
      "numbers":1
   },
   {
      "roll_number":10,
      "numbers":2
   }
]

注意最后三行。我们使用了带for循环的insert_multiple方法插入了三个新条目。

TinyDB - 修改数据

我们已经讨论了update查询，借助它我们可以修改值以及处理数据库中的数据。但是update查询（例如db.update(fields, query)）允许我们通过添加或覆盖其值来更新文档。

但有时，我们想删除一个字段或需要增加其值。在这种情况下，我们可以传递一个函数而不是字段。我们可以将以下操作与更新查询一起使用 -

增量查询

增量查询顾名思义，用于增加数据库中键的值。增量查询的语法如下 -

from tinydb.operations import increment
db.update(increment('key'))

添加查询

添加查询用于向键的值添加值。它也适用于字符串。添加查询的语法如下 -

from tinydb.operations import add
db.update(add(key, value))

设置查询

此查询用于将键设置为数据的值。设置查询的语法如下 -

from tinydb.operations import set
db.update(set(key, value))

递减查询

递减查询用于递减键的值。递减查询的语法如下 -

from tinydb.operations import decrement
db.update(decrement(key))

减法查询

减法查询用于从键的值中减去值。减法查询的语法如下 -

from tinydb.operations import subtract
db.update(subtract(key, value))

删除查询

删除查询用于从文档中删除键。删除查询的语法如下 -

from tinydb.operations import delete
db.update(delete(key))

让我们举几个例子来演示如何将这些操作与update查询一起使用。我们将使用前面所有章节中使用过的相同student数据库。

示例 1

让我们看看如何增加student表中某个学生的成绩 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
from tinydb.operations import increment
db.update(increment('mark'), Query().mark == 275)

它将产生以下输出：

[5]

以上输出显示它已更新文档 ID 为 5 的记录。

示例 2

让我们看看如何添加5 分到student表中某个学生的成绩 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
from tinydb.operations import add
db.update(add('mark', 5), Query().mark == 200)

它将产生以下输出：

[4]

以上输出显示它已更新文档 ID 为 4 的记录。

示例 3

让我们看看如何在student表中将某个学生的成绩从 250 设置为 259 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
from tinydb.operations import add
db.update(add('mark', 259), Query().mark == 250)

它将产生以下输出：

[1]

以上输出显示它已更新文档 ID 为 1 的记录。

示例 4

让我们看看如何减少student表中某个学生的成绩 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
from tinydb.operations import decrement
db.update(decrement('mark'), Query().mark == 205)

它将产生以下输出：

[4]

以上输出显示它已更新文档 ID 为 4 的记录。

示例 5

让我们看看如何从student表中某个学生的成绩中减去5 分 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
from tinydb.operations import add
db.update(add('mark', 5), Query().mark == 204)

它将产生以下输出：

[4]

以上输出显示它已更新文档 ID 为 4 的记录。

示例 6

让我们看看如何从 student 表中某个学生的成绩中减去5 分 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
from tinydb.operations import delete
db.update(delete('mark'), Query().mark == 209)

它将产生以下输出：

[4]

以上输出显示它已更新文档 ID 为 4 的记录。它将从数据库中删除值为 209 的 mark 字段。

示例 7

让我们看看如何使用单个查询更新表中的多个值 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
from tinydb import where
db.update_multiple([
   ({'st_name':'Eliana'}, where ('roll_number')==1),
   ({'mark':20}, where ('roll_number') ==2)
])

它将产生以下输出：

[1,2]

以上输出显示它已更新文档 ID 为 1 和 2 的两条记录。

TinyDB - Upsert 数据

我们讨论了update和insert查询，但有时我们需要将两者结合起来使用。在这种情况下，TinyDB 提供了一个独特的upsert查询。此查询帮助我们根据条件一次性插入和更新数据。它以两种方式工作 -

• 如果数据可用，则选择update操作。

• 如果数据不可用，则选择insert操作。

语法

upsert查询的语法如下 -

db.upsert({ 'key' : 'value', 'logged - in' : True}, regular expression)

让我们举几个例子来演示如何在 TinyDB 中使用此upsert查询。我们将使用前面所有章节中使用过的相同student数据库。

示例 1

让我们看看如何使用upsert查询将学号为 2 的学生的地址更改为“surat”。在这种情况下，我们有一个匹配的用户，因此它将更新地址，并将登录状态设置为 True -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.upsert({'address':'Surat'}, Query().roll_number==2)

它将产生以下输出，这意味着记录号“2”已更新。

[2]

使用以下代码验证记录号“2”是否已更新 -

db.get(doc_id=2)

它将显示已更新的数据：

{
   'roll_number': 2,
   'st_name': 'Ram',
   'mark': [250, 280],
   'subject': ['TinyDB', 'MySQL'],
   'address': 'Surat'
}

示例 2

让我们看看如何在表中对不可用数据使用upsert查询 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.upsert({'E-mail':'[email protected]','logged-in': True},
Query().roll_number==2)

它将显示以下输出，这意味着文档 ID 为“2”的文档已更新。

[2]

使用以下代码验证更新的值 -

db.get(doc_id=2)

它将产生以下输出 -

{
   "roll_number":2,
   "st_name":"Ram",
   "mark":[
      250,
      280
   ],
   "subject":[
      "TinyDB",
      "MySQL"
   ],
   "address":"Surat",
   "logged-in":true,
   "E-mail":"[email protected]"
}

请注意，我们使用了upsert查询创建了一个新的键（E-mail），该键之前不存在，并为其提供了值“[email protected]”。

TinyDB - 检索数据

创建数据库后，我们需要频繁地从该数据库中检索数据。以下是我们可以从数据库中检索数据的方法 -

len() 查询

借助此查询，我们可以获取数据库中的文档数量。其语法如下 -

len(db)

get 查询

get 查询用于检索与查询匹配的特定文档。其语法如下所示：

db.get(query)

contains 查询

contains 查询用于检查数据库是否包含匹配的值。其语法如下所示：

db.contains(query)

count 查询

count 查询用于从数据库中检索匹配文档的数量。其语法如下所示：

db.count(query)

让我们通过一些示例来了解这些查询在 TinyDB 中是如何工作的。我们将使用在前面所有章节中使用过的相同学生数据库。

示例 1

让我们看看如何使用len() 查询获取数据库中文档的数量：

from tinydb import TinyDB
db = TinyDB('student.json')
print ("Number of documents in student db: ", len(db))

它将显示指定数据库中存在的文档数量：

Number of documents in student db: 5

示例 2

让我们看看如何使用get() 查询从数据库中获取特定文档：

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.get(Query().address == 'delhi')

此查询将获取“address”字段值为“delhi”的行。

{
   'roll_number': 1,
   'st_name': 'elen',
   'mark': 250,
   'subject': 'TinyDB',
   'address': 'delhi'
}

示例 3

让我们看看如何使用contains() 查询验证我们的数据库是否包含特定值：

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.contains(Query().address == 'delhi')

contains() 查询根据指定值在给定数据库中是否存在返回布尔值。在本例中，它将返回“True”，因为我们的数据库确实有一个值为“delhi”的“address”键。

True

示例 4

让我们看看如何使用count() 查询获取给定条件为 True 的文档数量：

from tinydb import TinyDB, Query
db = TinyDB('student.json')
print (db.count(Query().subject == 'NoSQL'))

它将返回以下输出：

3

这意味着数据库中有 3 个文档的“subject”键值为“NoSQL”。

TinyDB - 文档 ID

TinyDB 使用文档 ID（用doc_id表示）来访问和修改数据库中文档的值。在这里，我们将看到如何将此 document_id 用于各种操作。

使用文档 ID 显示数据

我们可以在get() 方法中使用doc_id 来显示数据库中的数据。其语法如下所示：

db.get(doc_id = value)

检查数据库中的文档

我们可以在contains() 方法中使用doc_id 来检查文档是否存在于数据库中。其语法如下所示：

db.contains(doc_id = value)

更新所有文档

我们可以在update() 方法中使用doc_id 来更新数据库中所有具有给定文档 ID 的文档。以下是其语法：

db.update({key : value}, doc_ids = […])

删除文档

我们可以在remove() 方法中使用doc_id 来删除特定文档或数据库中所有具有给定文档 ID 的文档。其语法如下所示：

db.remove(doc_ids = […])

让我们通过一些示例来演示如何在 TinyDB 中使用这些方法中的doc_id。我们将使用在前面所有章节中使用过的相同学生数据库。

示例 1

让我们看看如何使用doc_id 获取数据库中特定文档的数据：

from tinydb import TinyDB
db = TinyDB('student.json')
db.get(doc_id = 5)

它将获取文档 ID 为“5”的文档中的数据。

{
   'roll_number': 5,
   'st_name': 'karan',
   'mark': 275,
   'subject': 'oracle',
   'address': 'benglore'
}

示例 2

让我们看看如何使用doc_id 检查数据库是否包含具有特定 ID 的文档：

from tinydb import TinyDB
db = TinyDB('student.json')
db.contains(doc_id = 15)

根据文档的可用性，它将返回 True 或 False。在本例中，我们的数据库没有文档 ID 为“15”的文档。因此，它返回 False。

False

示例 3

让我们看看如何使用doc_id 更新数据库的文档：

from tinydb import TinyDB
db = TinyDB('student.json')
db.update({'mark':'280'}, doc_ids = [4])

在这里，我们更新了文档 ID 为“4”的文档的“marks”字段。要检查更新后的数据，请使用以下查询：

print(db.get(doc_id=4))

它将显示文档 ID 为“4”的文档的更新后的数据：

{
   'roll_number': 4,
   'st_name': 'lakan',
   'mark': '280',
   'subject': 'MySQL',
   'address': 'mumbai'
}

示例 4

让我们看看如何使用doc_id 从数据库中删除特定文档：

from tinydb import TinyDB
db = TinyDB('student.json')
db.remove(doc_ids = [3,4])

在这里，我们删除了文档 ID 为“3”和“4”的两个文档。要进行验证，请使用以下get() 查询：

db.get(doc_id=3)
db.get(doc_id=4)

它将显示以下输出：

None
None

这意味着我们已成功删除了文档 ID 为“3”和“4”的文档。

TinyDB - 表格

在 TinyDB 中，我们可以使用多个表。这些表与 TinyDB 类具有相同的属性。让我们看看如何在 TinyDB 中创建表并在其上应用各种操作：

创建表

在 TinyDB 中创建表非常容易。以下是其语法：

table_object = db.table('table name')

在表中插入值

要在特定表中插入数据，请使用以下语法：

table_object.insert({ 'key' : value })

从表中检索值

要从表中检索值，请使用以下查询：

table_object.all()

从数据库中删除表

要从数据库中删除表，请使用 drop_table() 查询。以下是其语法：

db.drop_table('table name')

从数据库中删除多个表

要从数据库中删除多个表，请使用以下查询：

db.drop_tables()

让我们了解如何通过一些示例来使用这些查询。我们将使用在前面所有章节中使用过的相同学生数据库。

示例 1

使用以下代码创建一个名为Student_Detail的新表：

from tinydb import TinyDB, Query
db = TinyDB("student.json")
table_object = db.table('Student_Detail')

示例 2

接下来，让我们在这个新的Student_Detail表中插入值：

from tinydb import TinyDB, Query
db = TinyDB("student.json")
table_object = db.table('Student_Detail')
table_object.insert({
   'roll_number': 1,
   'st_name': 'elen',
   'mark': 250,
   'subject': 'TinyDB',
   'address': 'delhi'
})

它将返回插入到表中的记录的 doc_id。

[1]

要进行验证，请使用以下代码：

from tinydb import TinyDB, Query
db = TinyDB("student.json")
table_object = db.table('Student_Detail')
table_object.all()

它将显示 Student_Detail 表中包含的数据：

{'roll_number': 1, 'st_name': 'elen', 'mark': 250, 'subject': 'TinyDB', 'address': 'delhi'}

示例 3

要查看数据库中存在的所有表，请使用以下查询：

from tinydb import TinyDB, Query
db = TinyDB("student.json")
print(db.tables())

“student.json”中有两个表。它将显示这两个表的名称：

{'Student_Detail', '_default'}

示例 4

让我们看看如何从表中检索所有值：

from tinydb import TinyDB, Query
db = TinyDB("student.json")
table_object = db.table("Student_Detail")
print(table_object.all())

它将显示以下输出：

[{
   'roll_number': 1,
   'st_name': 'elen',
   'mark': 250,
   'subject': 'TinyDB',
   'address': 'delhi'
}]

示例 5

让我们看看如何从数据库中删除表：

from tinydb import TinyDB, Query
db = TinyDB("student.json")
db.drop_table('Student_Detail')

它将从数据库中删除“Student_Detail”表。要删除数据库中的所有表，请使用“drop_tables()”查询：

db.drop_tables()

它将删除数据库中的所有表。

TinyDB - 默认表格

TinyDB 提供了一个默认表，它会自动保存和修改数据。我们也可以将一个表设置为默认表。基本查询、方法和操作将在该默认表上运行。在本章中，让我们看看如何查看数据库中的表以及如何将我们选择的表设置为默认表：

显示数据库中的表

要获取数据库中所有表的列表，请使用以下代码：

from tinydb import TinyDB, Query
db = TinyDB("student.json")
db.tables()

它将产生以下输出：我们在“student.json”中有两个表，因此它将显示这两个表的名称：

{'Student_Detail', '_default'}

输出显示我们的数据库中有两个表，一个是“Student_Detail”，另一个是“_default”。

显示默认表的值

如果您使用all() 查询，它将显示默认表的内容：

from tinydb import TinyDB
db = TinyDB("student.json")
db.all()

要显示“Student_Detail”表的内容，请使用以下查询：

from tinydb import TinyDB
db = TinyDB("student.json")
print(db.table("Student_Detail").all())

它将显示“Student_Detail”表的内容：

[{
   'roll_number': 1,
   'st_name': 'elen',
   'mark': 250,
   'subject': 'TinyDB',
   'address': 'delhi'
}]

设置默认表

您可以将您选择的表设置为默认表。为此，您需要使用以下代码：

from tinydb import TinyDB
db = TinyDB("student.json")
db.default_table_name = "Student_Detail"

它将“Student_Detail”表设置为我们数据库的默认表。

TinyDB - 缓存查询

缓存查询是 TinyDB 的一项高级功能，它可以缓存查询结果以优化性能。这样，当我们再次运行相同的查询时，TinyDB 不需要从存储中读取数据。我们可以将cache_size传递给 table 函数以优化查询缓存大小。

语法

TinyDB 查询缓存的语法如下所示：

table = db.table('table_name', cache_size=value)

示例

TinyDB 在给定的表中创建缓存大小的内存。

from tinydb import TinyDB
db = TinyDB('student.json')
objects = db.table('Student_Detail', cache_size = 50)
objects.all()

它将产生以下输出。请注意，缓存大小不会影响表值。

[{
   'roll_number': 1,
   'st_name': 'elen',
   'mark': 250,
   'subject': 'TinyDB',
   'address': 'delhi'
}]

我们可以通过设置“cache_size = None”来设置无限缓存大小。

objects = db.table('Student_Detail', cache_size = None)

我们也可以通过设置“cache_size = 0”来禁用缓存大小。

objects = db.table('Student_Detail', cache_size = 0)

要清除缓存大小，请使用以下查询：

db.clear_cache()

TinyDB - 存储类型

TinyDB 有两种类型的存储：JSON 和内存中存储。TinyDB 默认情况下将数据存储在 JSON 文件中。在创建数据库时，您需要指定在计算机上存储 JSON 文件的路径。

将数据存储在 JSON 文件中

首先，让我们看看如何使用 JSON 文件来存储数据：

from tinydb import TinyDB, where
db = TinyDB('path/to/file_name.json')

示例 1

在本例中，我们演示了如何将多个文档插入 JSON 文件：

from tinydb import TinyDB
db = TinyDB('storage.json')
db.insert_multiple([
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakhan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   }
])

在这里，我们在“storage.json”中插入了 5 个文档。要验证记录，请使用以下查询：

db.all()

它将显示“storage.json”文件的内容：

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakhan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   }
]

使用内存中存储来存储数据

现在，让我们看看如何使用“内存中存储”来存储数据：

from tinydb import TinyDB
from tinydb.storages import MemoryStorage
object = TinyDB(storage = MemoryStorage)
TinyDB.DEFAULT_STORAGE = MemoryStorage

示例 2

以下示例演示了如何将多个文档插入默认存储内存：

from tinydb import TinyDB
from tinydb.storages import MemoryStorage
object = TinyDB(storage = MemoryStorage)
TinyDB.DEFAULT_STORAGE = MemoryStorage
object.insert_multiple([
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   }
])

要验证文档是否已插入，请使用以下查询：

object.all()

以下输出显示了插入的数据：

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   }
]

TinyDB - 中间件

TinyDB 中间件通过包装现有存储来帮助我们自定义数据库存储行为。此中间件提高了数据库的性能。

缓存中间件

顾名思义，此中间件通过减少磁盘 I/O 来提高数据库的速度。CachingMiddleware 的工作原理如下：

• 首先，它捕获所有读取操作。

• 然后在配置的写入操作次数后将数据写入磁盘。

语法

使用 CachingMiddleware 的语法如下：

from tinydb.storages import JSONStorage
from tinydb.middlewares import CachingMiddleware
db = TinyDB('middleware.json', storage = CachingMiddleware(JSONStorage))
db.close()

示例

以下示例演示了如何在数据库中执行基本中间件过程。

from tinydb import TinyDB
from tinydb.storages import JSONStorage
from tinydb.middlewares import CachingMiddleware
object = TinyDB('storage.json', storage=CachingMiddleware(JSONStorage))
object.all()

输出

它将产生以下输出 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   }
]

关闭数据库以确保所有数据都安全写入。

db.close()

TinyDB - 扩展 TinyDB

可以扩展 TinyDB 并修改其行为。有四种方法可以做到这一点：

• 自定义中间件

• 自定义存储

• 钩子和覆盖

• 对 TinyDB 和表进行子类化

在本章中，让我们详细了解每种方法。

自定义中间件

有时用户不想编写新的存储模块。在这种情况下，用户可以修改现有存储模块的行为。让我们看一个示例，我们将构建一个自定义中间件来过滤掉空项目：

首先，让我们看看将通过自定义中间件的数据：

{
   '_default': {
   1: {'key1': 'value1'},
   2: {'key2': 'value2'},
   ……………,
   N: {'keyN': 'valueN'}
},

现在，让我们看看如何实现自定义中间件：

class RemoveEmptyItemsMiddleware(Middleware):
def __init__(self, storage_cls):
   super(self).__init__(storage_cls)
   def read(self):
      data = self.storage.read()
      for _default in data:
         st_name = data
      for doc_id in table:
         item = st_name
         if item == {}:
            del st_name
         return data
   def close(self):
      self.storage.close()

自定义存储

如前所述，TinyDB 带有两种类型的存储：内存中存储和 JSON 文件存储。除此之外，TinyDB 还提供了一个添加我们自己的自定义存储的选项。在以下示例中，让我们看看如何使用 PyYAML 添加 YAML 存储：

import yaml
class YAMLStorage(Storage):
def __init__(self, db.json):
   self. db.json = db.json 

读取文件：

def read(self):
   with open(self.db.json) as handle:
   try:
      info = yaml.safe_load(handle.read())
      return info

   except yaml.YAMLError:
      return None

写入文件：

def write(self, info):
   with open(self.db.json, 'w+') as handle:
      yaml.dump(info, handle)

关闭文件：

def close(self):
   pass

钩子和覆盖

有时，自定义存储和自定义中间件无法按照您想要的方式工作。在这种情况下，用户可以使用预定义的钩子和覆盖来修改 TinyDB 的行为。例如，我们将配置默认表的名称如下：

TinyDB.default_table_name = 'student_detail'

我们还可以分配缓存容量，如下所示：

TinyDB.table_class.default_query_cache_capacity = 50

对 TinyDB 和表进行子类化

这是我们可以用来修改 TinyDB 行为的最后一种方法。例如，我们将创建一个可以与钩子和覆盖一起使用的子类来覆盖默认类。

Class ExtendTable(Table):
   TinyDB.table_class = student_detail

TinyDB - 扩展

下面是一组可用于各种操作的 TinyDB 扩展：