Tinydb 简明教程

TinyDB - Quick Guide

TinyDB - Introduction

What is TinyDB?

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

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

Features of TinyDB

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

Really tiny − TinyDB 数据库本质上非常小，只有 1800 行代码和 1600 行测试。
Easy to use − TinyDB 易于使用，因为它具有简单且清晰的 API。
Document oriented − 在 TinyDB 中，我们可以存储任何文档。该文档将表示为 dict。
Independent − TinyDB 数据库独立于任何外部服务器和 PyPI 的外部依赖关系。
Compatible with Python 3.6 or latest − TinyDB 已通过测试，并与 Python 3.6 及更高版本兼容。它还可以与 PyPY3 很好地兼容。
Extensible − TinDB 通过编写新的存储或修改存储的行为，可以轻松扩展。

Advantages of TinyDB

TinyDB 为学生、用户和开发人员提供了许多好处。

TinyDB 是开源数据库，并且不需要任何外部配置。
它非常易于使用，用户可以轻松处理文档。
它自动将文档存储在数据库中。
在我们需要安装一些数据的个人项目中，TinyDB 是理想的选择。
它适用于小型应用程序，这些应用程序会被像 SQL 或外部 DB 服务器这样的大型数据库所取代。
它使用简单的命令行和查询来操作数据。
有 100% 的测试覆盖率，即不需要解释。

Limitatations of TinyDB

如果您需要以下内容，TinyDB 不是您项目的正确选择 −

create indexes for tables,
manage relationships between tables,
使用 HTTP 服务器，或
access from multiple processors.

Comparison with Other Databases

下表重点介绍了 TinyDB 与 MySQL 和 Oracle 数据库的不同之处 −

Comparison Basis

MySQL

Oracle

TinyDB

Configurations

Several Configurations

Less Configurations, lightweight database

Complicated

Yes

No, easy-to-use and hustle-free

Affordable

Affordable than other databases

Manageable

数据库较大，因此难以管理

Small and manageable

TinyDB - Environmental Setup

Prerequisite for TinyDB setup

要安装 TinyDB，系统中必须安装 Python 3.6 或更高版本。你可以访问链接 www.python.org ，为你的操作系统（例如 Windows 和 Linux/Unix）选择最新版本。我们提供了一个全面的 Python 教程，你可以在 www.tutorialspoint.com 参阅。

Installing TinyDB

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

Using the Package Manager

最新版本的 TinyDB 可通过包管理器 pip 和 conda 获得。让我们检查一下如何使用它们安装 TinyDB−

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

pip install tinydb

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

conda install -c conda-forge tinydb

From Source

你还可以从源码包安装 TinyDB。转到链接 https://pypi.org/project/tinydb/#files 下载文件并从源代码构建。

From GitHub

要使用 GitHub 安装 TinyDB，请获取最新的开发版本，解压文件，然后使用以下命令进行安装：

pip install

Setting up TinyDB

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

Step 1: Import TinyDB and its Query

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

from tinydb import TinyDB, Query

Step 2: Create a file

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

db = TinyDB('Leekha.json')

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

Uinstalling TinyDB

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

pip uninstall tinydb

TinyDB - Insert Data

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

Syntax

要插入条目，您可以使用下面语法所示的方法 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，' values ' 是我们刚刚插入的数据。

Example: Inserting a Single Item

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

[
   {
      "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：

让我们输入 one more record ：

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

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

如果您想要检查数据库中存储的条目，请按如下方式使用 all() 方法：

db.all()

它将生成以下 output −

[
   {
      "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 文件中添加了两个新数据条目。

Example: Inserting Multiple items at a Time

您还可以在 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()

它将生成以下 output −

[
   {
      "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 - Retrieve Data

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

from tinydb import Query
Student = Query()

此处， Student 是数据库的名称。

让我们探索从 TinyDB 数据库检索信息的各种方式。

Data Retrieval Using the Search() Method

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"
   }
]

让我们举一个 example 来理解 search() 方法 -

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

上述查询将从 student 数据库中检索以下 output -

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

Data Retrieval Using the get() Method

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

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

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

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

Data Retrieval using the all() Method

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"
   }
]

Data Retrieval Using the for Loop

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

for info in db:
   print(info)

就像 all() 方法一样，它将从 student 数据库中检索所有行。

TinyDB - Update Data

TinyDB 可以以多种格式存储数据，我们可以使用多种方法轻松地重新访问存储的数据。但有时，我们需要更新数据，我们可以使用 update() 方法来更新数据。

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

from tinydb import Query
Student = Query()

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

The update() Method

下面是 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"
   }
]

根据给定的数据，roll_number 为“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 - Delete Data

如果您需要从 TinyDB 数据库中永久删除特定数据的话，您可以使用 remove() 方法来完成。与返回和更新数据类似，您首先需要创建一个 Query 类的实例来删除数据。您可以为此目的使用以下命令 -

from tinydb import Query
Student = Query()

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

The remove() Method

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

db.remove( Query() field regex )

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

The student Database

对于本章的示例，我们将使用以下 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"
   }
]

Example: Deleting a Single Row of Data

我们举一个例子来了解 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"
   }
]

Example: Deleting Multiple Rows of Data

如果您一次想要删除多行，您可以按如下所示使用 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"
   }
]

Example: Deleting the Entire Data

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

db.truncate()

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

db.all()

它将显示一个空数据库作为 output −

[]

TinyDB - Querying

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

在本章节中，我们来理解在 TinyDB 数据库中构造查询的这两种方法。

The First Method: Importing a Query

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

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"
   }
]

Example

以下是查询从 student 数据库中获取数据，其中学生的 roll_no 小于 3 −

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

Or,

>>> 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 标识符。在这种情况下，我们将无法访问该字段。对于这种情况，我们需要按如下所示切换到 dict access notation −

student = Query();

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

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

The Second Method: Using the "where" Clause

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

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

Example

TinyDB 的 where 用于字段 subject 的子句 −

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

上述查询会生成以下 output −

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

TinyDB - Searching

TinyDB 提供了 search() 方法来帮助你从文档中检索任何数据。配合使用 query() 对象，search() 方法可用于在 JSON 文件中查找数据。有好多种方法可以在 TinyDB 数据库上使用 search() 方法。

Method 1: TinyDB search() with Existence of a Field

我们可以根据字段的存在情况从数据库中检索数据。我们通过一个例子来理解这一点。对于此示例以及其他示例，我们将使用以下 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"
   }
]

Example

基于字段的存在情况进行的搜索查询如下所示 −

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"
   }
]

Method 2: TinyDB search() with Regular Expression

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

Example 1

与正则表达式配对的完整项目搜索 −

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

此查询会生成以下 output −

[
   {
      "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"
   }
]

Example-2

区分大小写的正则表达式搜索 −

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

它会生成以下 output −

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

Example-3

与正则表达式配对的项目部分 −

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

此查询会生成以下 output −

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

Method 3: TinyDB search() using a Substring

在从 TinyDB 数据库中检索特定数据时，我们还可以使用子字符串。我们通过几个示例来理解它是如何工作的 −

Example-1

看一下此查询；它将获取 "address" 字段为 "delhi" 的所有行。

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

它将生成以下 output −

[
   {
      "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"
   }
]

Example-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 - The where Clause

TinyDB 提供了 "where" 子句，你可以在检索特定数据时使用它。通过过滤掉不需要数据，"where" 子句能够提供帮助。借助 "where" 子句，你可以快速访问指定数据。

在使用 'where' 子句之前，我们需要先导入它。'where' 子句的 syntax 如下所示 −

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

我们通过几个示例来理解如何使用 'where' 子句。

The Student Database

对于示例，我们将使用以下 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"
   }
]

Example 1

我们给 subject 字段使用 " where " 子句 -

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

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

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

Example 2

让我们看另一个与 " not equal to " 条件一起使用 " 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 - The exists() Query

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

Syntax

TinyDB exists() 的语法如下 -

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

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

我们将使用我们在所有前一章中都曾使用过的相同的 student 数据库。

Example 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"
   }
]

Example 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"
   }
]

Example 3

现在，让我们给一个不可用的字段尝试 exists() 查询 -

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

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

[]

TinyDB - The matches() Query

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

Syntax

TinyDB matches() 的语法如下 -

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

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

让我们借助几个例子来了解它是如何工作的。我们将使用我们在所有前一章中都曾使用过的相同的 student 数据库。

Example 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"
   }
]

Example 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'
}]

Example 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'}]

Example 4

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

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

没有其中 "address" 字段与字符串 "Ratlam" 匹配的行，因此它会返回一个空值 -

[]

TinyDB - The test() Query

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

Syntax

TinyDB test() 的语法如下 -

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

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

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

object = lambda t: t == 'value'

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

让我们借助几个例子来了解它是如何工作的。我们将使用我们在所有前一章中都曾使用过的相同的 student 数据库。

Example 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'}]

Example 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 - The any() Query

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

Syntax

TinyDB any () 的语法如下 -

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

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

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

让我们借助几个例子来了解它是如何工作的。我们将使用我们在所有前一章中都曾使用过的相同的 student 数据库。

Example 1

让我们看看如何从我们的 student 表中查找 subject 为 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"
   }
]

Example 2

让我们看看当 any() 方法在给定列表中没有匹配任何内容时如何做出反应 −

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

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

[]

Example 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 - The all() Query

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

Syntax

TinyDB all() 的语法如下 −

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

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

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

让我们借助几个例子来了解它是如何工作的。我们将使用我们在所有前一章中都曾使用过的相同的 student 数据库。

Example 1

让我们看看如何从我们的 student 表中查找 subject 同时为 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'
}]

Example 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 - The one_of() Query

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

Syntax

TinyDB one_of() 的语法如下 −

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

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

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

Example 1

让我们看看如何从我们的 student 表中查找 address 字段为“德里”或“浦那”的行 −

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().address.one_of(['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"
   }
]

Example 2

让我们看另一个带有 ' subject ' 字段的示例 −

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

它将获取所有“主题”字段包含“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 - Logical Negate

逻辑否定作为一种反逻辑门起作用。它将匹配与给定查询不匹配的文档。简而言之，它将显示给定命令的相反含义。

Syntax

TinyDB Logical Negate 的语法如下 −

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

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

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

Example 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"
   }
]

Example 2

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

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

此查询将获取“地址”字段不包含“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 - Logical AND

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

Syntax

TinyDB Logical AND 的语法如下 −

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

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

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

Example 1

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

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'
}]

Example 2

此示例中，让我们对“subject”和“roll_number”字段应用逻辑 AND −

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 - Logical OR

“逻辑 OR”运算符结合多个条件，且仅在满足任一条件时才计算为 True。TinyDB 逻辑 OR 对数据库的两个查询进行操作。如果其中任何一个查询为真，则 TinyDB 将获取所需的数据。另一方面，如果两个查询都为假，则它将返回一个空值。

Syntax

TinyDB Logical OR 的语法如下所示 −

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

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

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

Example 1

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

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"
   }
]

Example 2

此示例中，让我们对“subject”和“roll_number”字段应用逻辑 AND −

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 - Handling Data Query

TinyDB - Storing Multiple Data

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

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

我们来看几个示例，以演示“insert_multiple”查询的工作原理。我们将使用在之前的章节中使用的相同的 student 数据库。

Example 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 的两条新记录已保存到数据库中。

Example 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
   }
]

请注意最后三行。我们已将 insert_multiple 方法与 for 循环配合使用，以插入三个新条目。

TinyDB - Modifying the Data

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

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

The Increment Query

顾名思义，增量查询用于增量数据库中键的值。 syntax 增量查询如下所示 -

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

The Add Query

加法查询用于将值添加到键的值。它也适用于字符串。 syntax 加法查询如下所示 -

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

The Set Query

此查询用于将键设置为数据的值。 syntax 设置查询如下所示 -

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

The Decrement Query

减量查询用于减量键的值。 syntax 减量查询如下所示 -

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

The Subtract Query

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

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

The Delete Query

删除查询用于从文档中删除键。 syntax 删除查询如下所示 -

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

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

Example 1

让我们看看如何在我们的 student 表中 increment 学生的成绩 -

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

它将生成以下 output −

[5]

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

Example 2

让我们看看如何在我们的 student 表中 add 学生的成绩 5 分 -

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

它将生成以下 output −

[4]

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

Example 3

让我们看看如何在我们的 student 表中将分数 set 为 259 的分数设置为 250 -

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

它将生成以下 output −

[1]

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

Example 4

让我们看看如何在我们的 student 表中 decrement 学生分数 -

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

它将生成以下 output −

[4]

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

Example 5

让我们看看如何在我们的 student 表中 subtract 学生的成绩 5 分 -

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

它将生成以下 output −

[4]

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

Example 6

让我们看看如何向我们学生表中的学生成绩中 subtract 增加 5 分−

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

它将生成以下 output −

[4]

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

Example 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)
])

它将生成以下 output −

[1,2]

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

TinyDB - Upserting Data

我们讨论了 update 和 insert 查询，但有时，我们需要更新和插入的混合。在这种情况下，TinyDB 提供了一个独特的 upsert 查询。此查询有助于我们根据条件一次插入和更新数据。它有两种工作方式 −

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

Syntax

upsert 查询的语法如下 −

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

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

Example 1

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

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

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

[2]

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

db.get(doc_id=2)

它将显示更新后的数据-

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

Example 2

让我们看看如何将 upsert 查询用于我们表中不可用的数据 −

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.upsert({'E-mail':'ram@gmail.com','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":"ram@gmail.com"
}

请注意，我们使用 upsert 查询创建了一个新键（ E-mail ）（该键不存在），并为其提供了值“ * ram@gmail.com* ”。

TinyDB - Retrieving Data

创建数据库后，我们需要经常从该数据库检索数据。以下是我们可以从数据库检索数据的方法 −

The len() Query

借助此查询，我们可以获取数据库中的文档数。它的 syntax 如下 −

len(db)

The get Query

get 查询用于检索与查询匹配的特定文档。它的 syntax 如下 −

db.get(query)

The contains Query

contains 查询用于检查数据库是否包含匹配的值。其 syntax 如下 −

db.contains(query)

The count Query

count 查询用于检索数据库中匹配文档的数量。其 syntax 如下 −

db.count(query)

我们举几个例子来理解如何在 TinyDB 中使用这些查询。我们将使用与前几章中相同的 student 数据库。

Example 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

Example 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'
}

Example 3

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

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

contains() 查询基于给定数据库中是否存在指定值，返回一个布尔值。在本例中，它将返回 "True"，因为我们的数据库具有 "address" 键，其值为 "delhi"。

True

Example 4

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

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

它将返回以下 output −

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

TinyDB - Document ID

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

Display Data using Document ID

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

db.get(doc_id = value)

Check for a Document in a Database

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

db.contains(doc_id = value)

Update All Documents

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

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

Remove a Document

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

db.remove(doc_ids = […])

我们举几个例子来说明如何在 TinyDB 中使用这些方法的 doc_id 。我们将使用与前几章中相同的 student 数据库。

Example 1

我们来看看如何使用 doc_id 从数据库的特定文档中获取数据 −

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

它会从 doc_id 为“5”的文档中获取数据。

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

Example 2

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

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

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

False

Example 3

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

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

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

print(db.get(doc_id=4))

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

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

Example 4

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

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

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

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

它将显示以下输出 −

None
None

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

TinyDB - Tables

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

Creating Tables

在 TinyDB 中创建表非常容易。以下是它的语法 −

table_object = db.table('table name')

Inserting Values in a Table

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

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

Retreiving Values from a Table

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

table_object.all()

Deleting a Table from a Database

若要从数据库中删除表，请使用 drop_table() 查询。以下是其 syntax −

db.drop_table('table name')

Delete Multiple Tables from a Database

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

db.drop_tables()

让我们借助一些示例了解如何使用这些查询。我们将使用我们在所有前几章中使用的相同 student 数据库。

Example 1

使用以下代码创建名为 Student_Detail 的新表 −

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

Example 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'}

Example 3

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

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

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

{'Student_Detail', '_default'}

Example 4

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

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

它将显示以下内容 output ：

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

Example 5

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

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

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

db.drop_tables()

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

TinyDB - Default Table

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

Showing the Tables in a Database

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

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

它将产生以下内容 output ：我们有两个表位于 "student.json" 中，因此它将显示这两个表的名称：

{'Student_Detail', '_default'}

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

Displaying the Values of the Default Table

如果您使用 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'
}]

Setting a Default Table

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

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

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

TinyDB - Caching Query

查询缓存是 TinyDB 的一项高级功能，可以以此将查询结果缓存起来，以便优化性能。通过这种方式，当我们再次运行相同的查询时，TinyDB 不需要从存储中读取数据。我们可以将 cache_size 传递给表函数以优化查询缓存大小。

Syntax

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

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

Example

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

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

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

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

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

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

我们也可以通过指定“cahce_size = 0”来禁用缓存大小。

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

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

db.clear_cache()

TinyDB - Storage Types

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

Storing Data in a JSON File

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

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

Example 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"
   }
]

Using in-memory to Store Data

现在，让我们看看如何使用“ in-memory ”存储数据 −

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

Example 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()

以下 output 显示了已插入数据 −

[
   {
      "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 - Middleware

TinyDB 中间件通过在现有存储周围进行封装来帮助我们自定义数据库存储行为。此中间件可提高数据库的性能。

Caching Middleware

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

首先，它会捕获所有读取操作。
然后，它会在配置的写入操作次数后将数据写入磁盘。

Syntax

使用 CachingMiddleware 的语法如下：

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

Example

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

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

Output

它将生成如下输出：

[
   {
      "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 - Extend TinyDB

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

Custom middleware
Custom storages
Hooks and overrides
Subclassing TinyDB and table

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

Custom Middleware

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

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

{
   '_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()

Custom Storage

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

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

To read the file −

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

   except yaml.YAMLError:
      return None

To write the file −

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

To close the file −

def close(self):
   pass

Hooks and Overrides

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

TinyDB.default_table_name = 'student_detail'

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

TinyDB.table_class.default_query_cache_capacity = 50

Subclassing TinyDB and Table

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

Class ExtendTable(Table):
   TinyDB.table_class = student_detail

TinyDB - Extensions

下面给出一组 TinyDB 扩展，可用于各种操作：

Sr.No.	Operation & Description
1	TinyDBTimestamps 这是一个实验性扩展，可用于自动添加和更新 TinyDB 文档中的时间戳。
2	aiotinydb这是一个稳定的扩展，它使我们能够在异步意识上下文中使用 TinyDB，而不会降低同步输入/输出 (I/O) 的速度。
3	tinydb - smartcache它也是一个稳定的扩展。它为用户提供了一个智能查询缓存。它会自动更新查询缓存，以便在插入、更新或删除任何文档后不会使缓存失效。
4	tinydb - serialization这是一个稳定的扩展，它提供了数据库对象的序列化。
5	tinydb - appengine 它提供了 App Engine 的存储。它也是一个稳定的扩展。
6	Tinyrecord 一个稳定的扩展，它为 TinyDB NoSQL DB 实现实验性原子事务支持。
7	TinyMP 它也是用于基于 MessagePack 的存储的稳定扩展。
8	Tinymongo 这是一个实验性扩展，用于替换 MongoDB。
9	Tinyindex 这也是一个实验性的数据库扩展。顾名思义，它用于对数据库的数据进行索引。