Tinydb 简明教程
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 is easily extensible either by writing new storages or by modifying the behaviour of storages.
Advantages of TinyDB
TinyDB provide various benefits for students, users, and developers.
-
TinyDB is open-sourced database aand it does not require any external configirations.
-
It is quite easy-to-use, and the user can effortlessly handle documents.
-
It automatically stores documents in the database.
-
TinyDB is ideal in case of personal projects where we need to install some data.
-
It is suitable for small applications that would be blown away by large databases like SQL or an external DB server.
-
It uses a simple command line and query to operate data.
-
There is 100% test coverage i.e., no explanation needed.
Limitatations of TinyDB
TinyDB will not be the right choice for your project if you need to −
-
create indexes for tables,
-
manage relationships between tables,
-
use an HTTP server, or
-
access from multiple processors.
Comparison with Other Databases
The following table highlights how TinyDB is different from MySQL and Oracle databases −
Comparison Basis |
MySQL |
Oracle |
TinyDB |
Configurations |
Several Configurations |
Several Configurations |
Less Configurations, lightweight database |
Complicated |
Yes |
Yes |
No, easy-to-use and hustle-free |
Affordable |
No |
No |
Affordable than other databases |
Manageable |
Big database, hence difficult to manage |
Big database, hence difficult to manage |
Small and manageable |
TinyDB - Environmental Setup
Prerequisite for TinyDB setup
To install TinyDB, you must have Python 3.6 or newer installed in your system. You can go to the link www.python.org and select the latest version for your OS, i.e., Windows and Linux/Unix. We have a comprehensive tutorial on Python, which you can refer at www.tutorialspoint.com
Installing TinyDB
You can install TinyDB in three different ways: using the Pack Manager, from its Source, or from GitHub.
Using the Package Manager
The latest release versions of TinyDB are available over both the package managers, pip and conda. Let us check how you can use them to install TinyDB −
To install TinyDB using pip, you can use the following command −
pip install tinydb
To install TinyDB via conda-forge, you can use the following command −
conda install -c conda-forge tinydb
From Source
You can also install TinyDB from source distribution. Go to link https://pypi.org/project/tinydb/#files to download the files and building it from source.
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:
6
让我们输入 one more record :
db.insert({
'roll_number': 7,
'st_name':'karan',
'mark':290,
'subject':'NoSQL',
'address':'chennai'
})
它将返回新创建的对象的 ID:
7
如果您想要检查数据库中存储的条目,请按如下方式使用 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"
}
]
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"
}
]
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')
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"
}
]
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"
}
]
TinyDB - The where Clause
TinyDB 提供了 "where" 子句,你可以在检索特定数据时使用它。通过过滤掉不需要数据,"where" 子句能够提供帮助。借助 "where" 子句,你可以快速访问指定数据。
在使用 'where' 子句之前,我们需要先导入它。'where' 子句的 syntax 如下所示 −
from tinydb import where
db.search(where('field') == 'value')
我们通过几个示例来理解如何使用 'where' 子句。
The Student Database
For the examples, we will use the following student database.
[
{
"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
Let’s use the "where" clause for the subject field −
db.search(where('subject') == 'MySQL')
This query will fetch all the rows where the "subject" field is "MySQL".
[{
'roll_number': 4,
'st_name': 'lakan',
'mark': 200,
'subject': 'MySQL',
'address': 'mumbai'
}]
Example 2
Let’s see another use of the "where" clause with the "not equal to" condition −
db.search(where('mark') != 275)
This query will fetch all the rows where the "mark" field is not equal to "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 provides an advanced query called exists() that checks the existence of data in a JSON file. The exists() query actually tests the availability of a subfield data from a JSON file. The exists() query works on the basis of a Boolean condition. If the subfield exists (i.e., BOOLEAN TRUE), it will fetch the data accordingly from the JSON file, otherwise it will return a blank value.
Syntax
The syntax of TinyDB exists() is as follows −
db.search(Query().field.exists())
Here, field represents the part of data that we want to access. Query() is the object created from the JSON table student.
We will use the same student database that we have used in all the previous chapters.
Example 1
Let’s use the TinyDB exists() query for the field named 'subject' −
db.search(student.subject.exists())
This query will fetch all the rows because all the rows have the "subject" field −
[
{
"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
Now let’s use the exists() query for the 'address' field −
db.search(student.address.exists())
It will fetch the following rows −
[
{
"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 matches() Query
The matches() query matches the data from a JSON file with a given condition (in the form of a regular expression) and returns the results accordingly. It will return a blank value if the condition does not match with the data in the file.
Syntax
The syntax of TinyDB matches() is as follows −
db.search(Query().field.matches(regular expression))
Here, field represents the part of data that we want to access. Query() is the object created of our JSON table named student.
Let’s understand how it works with the help of a couple of examples. We will use the same student database that we have used in all the previous chapters.
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'
}]
TinyDB - The test() Query
test() 查询会测试给定参数是否与表中的数据匹配。如果它与数据匹配,它会返回已匹配的数据,否则它会返回一个空值。首先,我们需要定义一个 test 函数及其参数,然后它会搜索给定数据库中的项目。
Syntax
TinyDB test() 的语法如下 -
db.search(Query().field.test(function or condition, *arguments))
Here, field represents the part of data that we want to access. Query() is the object created of our JSON table named student.
我们可以创建自定义测试函数,如下 -
object = lambda t: t == 'value'
此处 lamba 关键字对于创建自定义测试函数很重要。
Let’s understand how it works with the help of a couple of examples. We will use the same student database that we have used in all the previous chapters.
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)
Here, field represents the part of data that we want to access. Query() is the object created of our JSON table named student.
-
如果我们将 query 作为 any() 方法的参数提供,它将匹配其中列表字段中的至少一个文档与给定查询匹配的所有文档。
-
另一方面,如果我们提供 list 作为 any() 方法的参数,它将匹配所有文档,其中列表字段中的至少一个文档出现在给定列表中。
Let’s understand how it works with the help of a couple of examples. We will use the same student database that we have used in all the previous chapters.
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)
Here, field represents the part of data that we want to access. Query() is the object created of our JSON table named student.
-
如果我们提供 query 作为 all() 方法的参数,它将匹配列表字段中的所有文档都与给定查询匹配的所有文档。
-
另一方面,如果我们提供 list 作为 all() 方法的参数,它将匹配列表字段中的所有文档都出现在给定列表中的所有文档。
Let’s understand how it works with the help of a couple of examples. We will use the same student database that we have used in all the previous chapters.
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 的记录。
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 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'
}
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'
}
TinyDB - Tables
在 TinyDB 中,我们可以使用多张表。这些表的属性与 TinyDB 类相同。让我们看看如何在 TinyDB 中创建表并在其上应用各种操作 −
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'}
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'
}]
TinyDB - Caching Query
查询缓存是 TinyDB 的一项高级功能,可以以此将查询结果缓存起来,以便优化性能。通过这种方式,当我们再次运行相同的查询时,TinyDB 不需要从存储中读取数据。我们可以将 cache_size 传递给表函数以优化查询缓存大小。
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
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 这也是一个实验性的数据库扩展。顾名思义,它用于对数据库的数据进行索引。 |