TinyDB 快速指南

---

---

TinyDB - 簡介

什麼是 TinyDB？

TinyDB，用純 Python 程式語言編寫，是一個小型且輕量級的文件型資料庫，沒有外部依賴項。它提供簡單的 API，使其易於使用。我們可以將 TinyDB 資料庫用於小型專案應用程式，無需任何配置。

TinyDB 模組，作為 Python 程式的第三方模組可用，可用於儲存、檢索和修改 JSON 格式的資料。

TinyDB 的特性

TinyDB 是一個乾淨且輕鬆的資料庫，可以操作多種格式的文件。它具有以下特性。

• 非常小巧 − TinyDB 資料庫本質上非常小巧，只有 1800 行程式碼和 1600 行測試。

• 易於使用 − 由於其簡單且乾淨的 API，TinyDB 易於使用。

• 面向文件 − 在 TinyDB 中，我們可以儲存任何文件。文件將表示為字典。

• 獨立 − TinyDB 資料庫獨立於任何外部伺服器和來自 PyPI 的外部依賴項。

• 相容 Python 3.6 或更高版本 − TinyDB 已在 Python 3.6 及更高版本上進行了測試，並與之相容。它也適用於 PyPY3。

• 可擴充套件 − TinDB 可以透過編寫新的儲存或修改儲存的行為來輕鬆擴充套件。

TinyDB 的優勢

TinyDB 為學生、使用者和開發人員提供各種好處。

• TinyDB 是開源資料庫，不需要任何外部配置。

• 它非常易於使用，使用者可以輕鬆處理文件。

• 它會自動將文件儲存在資料庫中。

• TinyDB 非常適合個人專案，我們需要在其中安裝一些資料。

• 它適用於小型應用程式，這些應用程式會被大型資料庫（如 SQL 或外部資料庫伺服器）所淘汰。

• 它使用簡單的命令列和查詢來操作資料。

• 程式碼覆蓋率達 100%，無需解釋。

TinyDB 的侷限性

如果您需要以下功能，TinyDB 將不是您專案的正確選擇：

• 為表格建立索引，

• 管理表格之間的關係，

• 使用 HTTP 伺服器，或

• 從多個處理器訪問。

與其他資料庫的比較

下表突出顯示了 TinyDB 與 MySQL 和 Oracle 資料庫的不同之處：

TinyDB - 環境設定

TinyDB 設定的先決條件

要安裝 TinyDB，您的系統中必須安裝 Python 3.6 或更高版本。您可以訪問連結 www.python.org 並選擇適合您的作業系統的最新版本，即 Windows 和 Linux/Unix。我們有一個關於 Python 的綜合教程，您可以在 www.tutorialspoint.com 參考。

安裝 TinyDB

您可以透過三種不同的方式安裝 TinyDB：使用包管理器、從原始碼安裝或從 GitHub 安裝。

使用包管理器

TinyDB 的最新發布版本在兩個包管理器pip 和conda 上都可用。讓我們檢查一下如何使用它們來安裝 TinyDB：

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

pip install tinydb

要透過conda-forge 安裝 TinyDB，您可以使用以下命令：

conda install -c conda-forge tinydb

從原始碼安裝

您還可以從原始碼分發版安裝 TinyDB。訪問連結 https://pypi.org/project/tinydb/#files 下載檔案並從原始碼構建。

從 GitHub 安裝

要使用 GitHub 安裝 TinyDB，請獲取最新的開發版本，解壓縮檔案，並使用以下命令安裝它：

pip install

設定 TinyDB

安裝完成後，請按照以下步驟設定 TinyDB 資料庫。

步驟 1：匯入 TinyDB 及其查詢

首先，我們需要匯入 TinyDB 及其查詢。使用以下命令：

from tinydb import TinyDB, Query

步驟 2：建立檔案

TinyDB 資料庫可以以多種格式儲存資料，例如 XML、JSON 等。我們將使用以下檔案建立一個 JSON 檔案：

db = TinyDB('Leekha.json')

上述命令將建立一個 TinyDB 類的例項，並將檔案 Leekha.Json 傳遞給它。這是我們將資料儲存到的檔案。現在，TinyDB 資料庫已設定就緒，您可以對其進行操作了。我們現在可以插入資料並在資料庫中操作值了。

解除安裝 TinyDB

如果需要解除安裝 TinyDB，可以使用以下命令：

pip uninstall tinydb

TinyDB - 插入資料

我們建立了 TinyDB 的例項，並將一個 JSON 檔案傳遞給它，我們的資料將儲存在其中。現在是時候將專案插入到我們的資料庫中了。資料應採用 Python 字典的形式。

語法

要插入專案，可以使用insert() 方法，其語法如下所示：

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

我們也可以先建立一個字典，然後使用 insert() 方法將資料插入到我們的資料庫中。

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

執行上述命令後，insert() 方法將返回新建立物件的 ID。並且，我們的 JSON 檔案將如下所示：

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

檢視上表條目：'default' 是表的名稱，'1' 是新建立物件的 ID，值是我們剛剛插入的資料。

示例：插入單個專案

讓我們藉助示例來理解上述概念。假設我們有一個數據庫，其中包含學生資訊，顯示學號、姓名、分數、科目和地址。以下是儲存在資料庫中的資訊：

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

在上述資料庫中，如果要插入新的學生記錄（即單個專案），請使用以下命令：

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

它將返回新建立物件的 ID：

6

讓我們再輸入一條記錄：

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

它將返回新建立物件的 ID：

7

如果要檢查資料庫中儲存的專案，請使用all() 方法，如下所示：

db.all()

它將產生以下輸出：

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

您可以觀察到它在 JSON 檔案中添加了兩個新的資料項。

示例：一次插入多個專案

您也可以一次在 TinyDB 資料庫中插入多個專案。為此，您需要使用insert_multiple() 方法。讓我們看一個例子：

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

現在，使用 all() 方法檢查資料庫中儲存的專案，如下所示：

db.all()

它將產生以下輸出：

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

您可以觀察到它在 JSON 檔案中添加了兩個新的資料項。您還可以跳過資料項中的一些鍵值（就像我們所做的那樣）在新增最後兩個專案時。我們跳過了“mark”和“address”。

TinyDB - 檢索資料

有許多方法可以幫助您從 TinyDB 資料庫中檢索資料。但是要使用這些方法，您首先需要建立一個 Query 類的例項，如下所示：

from tinydb import Query
Student = Query()

這裡，Student 是資料庫的名稱。

讓我們檢查從 TinyDB 資料庫中檢索資訊的不同方法。

使用 Search() 方法檢索資料

search() 方法顧名思義，返回與我們提供的查詢匹配的專案列表，否則將返回空列表。

對於此示例和其他示例，我們將使用以下學生資料庫資料：

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

讓我們舉一個例子來理解 search() 方法：

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

上述查詢將從學生資料庫中檢索以下輸出：

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

使用 get() 方法檢索資料

與 search() 方法相反，get() 方法僅返回一個匹配的文件。否則將返回 None。例如，讓我們看以下程式碼：

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

上述查詢將從學生資料庫中檢索以下資料。

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

使用 all() 方法檢索資料

all() 方法返回資料庫中的所有文件。例如，

db.all()

它將從學生資料庫中檢索所有資料。

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

使用 for 迴圈檢索資料

for 迴圈也返回資料庫中的所有文件。例如，

for info in db:
   print(info)

與 all() 方法一樣，它將從學生資料庫中檢索所有行。

TinyDB - 更新資料

TinyDB 可以以多種格式儲存資料，我們可以使用各種方法輕鬆檢索儲存的資料。但有時我們需要更新資料，為此我們可以使用update() 方法。

要更新資料庫，我們首先需要建立一個Query 類的例項。您可以為此目的使用以下命令：

from tinydb import Query
Student = Query()

這裡，Student 是我們資料庫的名稱。

update() 方法

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

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

讓我們舉一個例子來理解 update() 方法是如何工作的。對於此示例，我們將使用以下學生資料庫：

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

根據給定資料，學號為“1”的學生姓名為“elen”。以下查詢將學生姓名更新為“Adam”：

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

它將返回已更新物件的 id：

[1]

現在，您可以使用 all() 方法檢視已更新的資料庫：

db.all()

它將顯示已更新的資料：

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

有時，我們需要更新資料庫中所有文件的一個或多個欄位。為此，我們可以直接使用update() 方法，而無需編寫查詢引數。以下查詢將所有學生的地址更改為'College_Hostel'：

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

它將返回已更新物件的 id：

[1,2,3,4,5]

同樣，您可以使用 all() 方法檢視已更新的資料庫。

db.all()

它將顯示已更新的資料：

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

觀察到所有行的地址欄位都具有相同的資料，即'College_Hostel'。

TinyDB - 刪除資料

如果您需要從 TinyDB 資料庫中永久刪除特定資料集，您可以使用remove() 方法來執行此操作。與檢索和更新資料一樣，您首先需要建立一個Query 類的例項才能刪除資料。您可以為此目的使用以下命令：

from tinydb import Query
Student = Query()

這裡，Student 是我們資料庫的名稱。

remove() 方法

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

db.remove( Query() field regex )

remove() 方法接受可選條件以及可選的文件 ID 列表。

學生資料庫

我們將使用以下學生資料庫作為本章示例。

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

示例：刪除單行資料

讓我們舉個例子來理解remove()方法。

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

以上查詢將刪除學生學號為5的資料。它將返回已刪除物件的ID -

[5]

現在，我們可以使用all()方法檢視更新後的資料庫。

db.all()

它將顯示更新後的資料庫中的資料 -

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

示例：刪除多行資料

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

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

它將返回已刪除物件的ID

[3,4]

使用all()方法檢視更新後的資料庫。

db.all()

它將顯示更新後的資料庫中的資料 -

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

示例：刪除所有資料

如果您想刪除資料庫中的所有資料，可以使用truncate()方法，如下所示 -

db.truncate()

接下來，使用all()方法檢視更新後的資料庫。

db.all()

它將顯示一個空資料庫作為輸出 -

[]

TinyDB - 查詢

TinyDB 有一套豐富的查詢。我們有多種構建查詢的方法：第一種方法類似於 ORM 工具的語法，第二種是使用“Where”子句的傳統方法。

在本章中，讓我們瞭解在 TinyDB 資料庫中構建查詢的這兩種方法。

第一種方法：匯入查詢

第一種方法類似於 ORM 工具的語法，其中首先需要在命令提示符中匯入查詢。匯入後，可以使用查詢物件操作 TinyDB 資料庫。語法如下所示 -

from tinydb import Query
student = Query()

這裡，“student”是我們資料庫的名稱。在示例中，我們將使用以下student資料庫。

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

示例

以下是從student資料庫中檢索資料的查詢，其中學生的roll_no小於3 -

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

或者，

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

上述搜尋查詢將產生以下結果 -

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

有時檔名不是有效的 Python 識別符號。在這種情況下，我們將無法訪問該欄位。對於此類情況，我們需要切換到字典訪問表示法，如下所示 -

student = Query();

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

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

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

第二種方法是使用“where”子句構建查詢的傳統方法。語法如下所示 -

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

示例

TinyDB where 子句用於subject欄位 -

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

以上查詢將產生以下輸出 -

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

TinyDB - 搜尋

TinyDB 提供了search()方法來幫助您從文件中搜索任何資料。除了query()物件之外，search()方法還可以用於在 JSON 檔案中查詢資料。我們可以透過多種方式在 TinyDB 資料庫上使用 search() 方法。

方法 1：TinyDB search() 與欄位的存在

我們可以根據欄位的存在從資料庫中搜索資料。讓我們用一個例子來理解它。對於這個和其他示例，我們將使用以下student資料庫。

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

示例

基於欄位存在性的搜尋查詢如下所示 -

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

以上查詢將從student檔案中檢索以下資料 -

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

方法 2：TinyDB search() 與正則表示式

我們可以使用正則表示式 (Regex) 從資料庫中搜索特定資料。讓我們瞭解它如何通過幾個示例工作。

示例 1

與正則表示式匹配的完整專案搜尋 -

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

此查詢將產生以下輸出 -

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

示例 2

使用正則表示式的區分大小寫搜尋 -

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

它將產生以下輸出 -

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

示例 3

與正則表示式匹配的專案的任何部分 -

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

此查詢將產生以下輸出 -

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

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

我們也可以在從 TinyDB 資料庫搜尋特定資料時使用子字串。讓我們瞭解它如何通過幾個示例工作 -

示例 1

看看這個查詢；它將獲取“address”欄位為“delhi”的所有行。

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

它將產生以下輸出：

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

示例 2

在此查詢中，我們對 search() 方法使用了略微不同的語法。

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

它將獲取“address”欄位為“mumbai”的所有行。

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

TinyDB - where 子句

TinyDB 提供了“where”子句，您可以在搜尋特定資料時使用它。“where”子句透過過濾掉不需要的資料來提供幫助。藉助“where”子句，您可以快速訪問特定資料。

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

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

讓我們通過幾個示例瞭解“where”子句的使用。

學生資料庫

在示例中，我們將使用以下student資料庫。

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

示例 1

讓我們對subject欄位使用“where”子句 -

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

此查詢將獲取“subject”欄位為“MySQL”的所有行。

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

示例 2

讓我們看看“where”子句與“不等於”條件的另一種用法 -

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

此查詢將獲取“mark”欄位不等於“275”的所有行 -

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

TinyDB - exists() 查詢

TinyDB 提供了一個名為exists()的高階查詢，用於檢查 JSON 檔案中資料的存在。exists()查詢實際上測試了從 JSON 檔案中獲取子欄位資料的可用性。exists()查詢基於布林條件工作。如果子欄位存在（即 BOOLEAN TRUE），它將相應地從 JSON 檔案中獲取資料，否則它將返回一個空值。

語法

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

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

這裡，field表示我們要訪問的資料部分。Query()是從 JSON 表student建立的物件。

我們將使用我們在所有先前章節中使用的相同student資料庫。

示例 1

讓我們對名為“subject”的欄位使用 TinyDB exists()查詢 -

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

此查詢將獲取所有行，因為所有行都具有“subject”欄位 -

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

示例 2

現在讓我們對“address”欄位使用exists()查詢 -

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

它將獲取以下行 -

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

示例 3

現在，讓我們嘗試對不存在的欄位使用exists()查詢 -

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

由於給定表中的任何行都沒有名為“city”的欄位，因此上述 exists() 查詢將返回一個空值 -

[]

TinyDB - matches() 查詢

matches() 查詢將 JSON 檔案中的資料與給定條件（以正則表示式的形式）匹配，並相應地返回結果。如果條件與檔案中的資料不匹配，它將返回一個空值。

語法

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

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

這裡，field表示我們要訪問的資料部分。Query()是我們名為student的 JSON 表建立的物件。

讓我們通過幾個示例瞭解它如何工作。我們將使用我們在所有先前章節中使用的相同student資料庫。

示例 1

讓我們看看如何對完整專案搜尋使用matches()。

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

此查詢將獲取所有行 -

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

示例 2

讓我們看看如何對區分大小寫搜尋使用 matches()。

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

此查詢將獲取學生姓名與字串“ram”匹配的行。請注意，我們使用了標誌在匹配字串時忽略大小寫。

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

示例 3

讓我們看看如何對特定專案使用 matches()。

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

此查詢將獲取地址與字串“keral”匹配的行。

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

示例 4

讓我們看看當 matches() 找不到特定專案時會返回什麼 -

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

沒有“address”欄位與字串“Ratlam”匹配的行，因此它將返回一個空值 -

[]

TinyDB - test() 查詢

test()查詢將測試給定的引數是否與表中的資料匹配。如果它與資料匹配，它將返回匹配的資料，否則它將返回空白。首先，我們需要定義一個test函式及其引數，然後它將在給定的資料庫中搜索專案。

語法

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

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

這裡，field表示我們要訪問的資料部分。Query()是我們名為student的 JSON 表建立的物件。

我們可以建立自定義測試函式，如下所示 -

object = lambda t: t == 'value'

這裡lamba關鍵字對於建立自定義測試函式很重要。

讓我們通過幾個示例瞭解它如何工作。我們將使用我們在所有先前章節中使用的相同student資料庫。

示例 1

我們將首先建立一個測試函式，然後在我們的student表中使用它 -

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

它將獲取“mark”欄位具有值[250, 280]的行 -

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

示例 2

在此示例中，我們將在測試函式中使用“subject”欄位 -

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

此查詢將獲取“subject”欄位值為“TinyDB”的所有行 -

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

TinyDB - any() 查詢

為了搜尋包含列表的欄位，TinyDB 提供了一個名為any()的方法。此方法匹配資料庫中至少一個給定的值。它根據提供的查詢查詢整個列表或至少一個值。

語法

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

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

這裡，field表示我們要訪問的資料部分。Query()是我們名為student的 JSON 表建立的物件。

• 如果我們將query作為any()方法的引數提供，它將匹配列表欄位中至少一個文件與給定查詢匹配的所有文件。

• 另一方面，如果我們將list作為any()方法的引數提供，它將匹配列表欄位中至少一個文件存在於給定列表中的所有文件。

讓我們通過幾個示例瞭解它如何工作。我們將使用我們在所有先前章節中使用的相同student資料庫。

示例 1

讓我們看看如何找到我們的學生表中主題是 TinyDB 或 MySQL 或 SQL 或任意兩個或三個組合的欄位 -

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

以上查詢將獲取“subject”欄位包含以下任何值的全部行：“TinyDB”、“MySQL”或“oracle” -

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

示例 2

讓我們看看當any()方法與給定列表中的任何內容不匹配時會發生什麼 -

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

此查詢將返回一個空值，因為沒有“subject”為“Oracle”的行。

[]

示例 3

請注意，它是區分大小寫的。“subject”欄位沒有“Oracle”，但它確實有“oracle”。嘗試以下查詢 -

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

它將獲取以下行 -

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

由於它是區分大小寫的，因此在前面的示例中返回了一個空值，因為沒有“subject”為“Oracle”的行。

TinyDB - all() 查詢

TinyDB 提供了一個名為all()的方法，該方法根據提供的查詢查詢值的整個列表。讓我們舉個例子，找出它是如何工作的。

語法

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

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

這裡，field表示我們要訪問的資料部分。Query()是我們名為student的 JSON 表建立的物件。

• 如果我們將query作為all()方法的引數提供，它將匹配列表欄位中所有文件都與給定查詢匹配的所有文件。

• 另一方面，如果我們將list作為all()方法的引數提供，它將匹配列表欄位中所有文件都存在於給定列表中的所有文件。

讓我們通過幾個示例瞭解它如何工作。我們將使用我們在所有先前章節中使用的相同student資料庫。

示例 1

讓我們看看如何找到我們的學生表中主題同時為 TinyDB 和 MySQL 的欄位 -

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

此查詢將獲取以下行 -

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

示例 2

讓我們看看如何使用all()從資料庫中獲取所有資料 -

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

它將獲取連結資料庫中的所有行 -

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

TinyDB - one_of() 查詢

為了匹配子欄位資料，TinyDB 提供了一種名為one_of()的方法。此方法搜尋單個類別並獲取至少一個相似值。如果欄位包含在提供的列表中，則將匹配。

語法

TinyDB one_of()的語法如下 -

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

這裡，field表示我們要訪問的資料部分。Query()是我們名為student的 JSON 表建立的物件。它將獲取一個類別的單個或多個值。

讓我們藉助幾個示例瞭解其工作原理。我們將使用前面所有章節中使用過的相同student資料庫。

示例 1

讓我們看看如何查詢student表中address為“delhi”或“pune”的欄位 -

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

它將獲取“address”欄位包含“delhi”或“pune”的所有行。

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

示例 2

讓我們用'subject'欄位再看一個例子 -

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

它將獲取“subject”欄位包含“TinyDB”或“MySQL”的所有行。

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

TinyDB - 邏輯非

邏輯非作為反向邏輯閘工作。它將匹配與給定查詢不匹配的文件。簡單來說，它將顯示給定命令的反義。

語法

TinyDB 邏輯非的語法如下 -

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

這裡，field表示我們要訪問的資料部分。Query()是我們名為student的 JSON 表建立的物件。它將獲取表示給定命令反義的資料。

讓我們舉幾個例子，看看它是如何工作的。我們將使用前面所有章節中使用過的相同student資料庫。

示例 1

讓我們看看如何查詢student表中學生姓名不為'elen'的欄位 -

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

以上查詢將獲取學生姓名不為“elen”的所有行。

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

示例 2

讓我們看看如何使用邏輯非避免特定地址 -

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

此查詢將獲取“address”欄位不包含“keral”或“delhi”的所有行。

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

TinyDB - 邏輯與

“邏輯與”運算子組合多個條件，如果所有條件都滿足，則評估為 True。TinyDB 邏輯與作用於資料庫的兩個查詢。如果兩個查詢都為 True，則 TinyDB 將獲取所需資料。另一方面，如果其中任何一個查詢為 False，它將返回一個空值。

語法

TinyDB 邏輯與的語法如下 -

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

這裡，field表示我們要訪問的資料部分。Query()是我們名為student的 JSON 表建立的物件。如果兩個條件都滿足，它將獲取資料，否則將返回一個空值。

讓我們舉幾個例子，看看 Logial AND 是如何工作的。我們將使用前面所有章節中使用過的相同student資料庫。

示例 1

讓我們看看當我們在“st_name=lakhan”和“subject=MYSQL”欄位上應用邏輯與時，我們的 TinyDB Student 資料庫返回什麼 -

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

此查詢將僅獲取學生姓名為“lakhan”且“subject”為“MySQL”的行。

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

示例 2

在此示例中，讓我們在“subject”和“roll_number”欄位上應用邏輯與 -

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

此查詢將獲取“roll_number”小於“4”且“subject”以字母“M”開頭的所有行。

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

TinyDB - 邏輯或

“邏輯或”運算子組合多個條件，僅當其中任何一個條件滿足時才評估為 True。TinyDB 邏輯或作用於資料庫的兩個查詢。如果其中任何一個查詢為 True，則 TinyDB 將獲取所需資料。另一方面，如果兩個查詢都為 False，它將返回一個空值。

語法

TinyDB 邏輯或的語法如下 -

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

這裡，field表示我們要訪問的資料部分。Query()是我們名為student的 JSON 表建立的物件。如果其中任何一個條件滿足，它將獲取資料，否則將返回一個空值。

讓我們舉幾個例子，看看它是如何工作的。我們將使用前面所有章節中使用過的相同student資料庫。

示例 1

讓我們看看當我們在“st_name”和“subject”欄位上應用邏輯或並檢查以下條件：“st_name=lakhan”和“subject=TinyDB”時，我們的 TinyDB Student 資料庫返回什麼 -

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

此查詢將獲取以下行 -

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

示例 2

在此示例中，讓我們在“subject”和“roll_number”欄位上應用邏輯或 -

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

此查詢將獲取“subject”欄位以字母“M”開頭或“roll_number”小於“5”的所有行。

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

TinyDB - 處理資料查詢

TinyDB - 儲存多個數據

我們已經討論瞭如何使用'insert'查詢將資料儲存在資料庫中。類似地，您可以使用'insert_multiple'查詢同時儲存多個數據項。以下是 TinyDB 中'insert_multiple'查詢的語法

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

讓我們舉幾個例子來演示“insert_multiple”查詢是如何工作的。我們將使用前面所有章節中使用過的相同student資料庫。

示例 1

讓我們看看如何使用insert_multiple查詢在我們的'student'表中插入兩條學生記錄 -

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

它將顯示新儲存記錄的文件 ID -

[6, 7]

讓我們檢查新記錄是否已儲存到資料庫中？使用all()方法，如下所示 -

db.all()

它將顯示給定表中儲存的所有記錄 -

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

您可以看到兩條新的students記錄已儲存到資料庫中。

示例 2

讓我們看看如何使用insert_multiple和for迴圈同時在表中插入多個值。使用以下程式碼 -

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

它將返回新儲存記錄的文件 ID -

[8, 9, 10]

再次，使用all()方法驗證新記錄是否已儲存到資料庫中？

db.all()

它將獲取給定student表中儲存的所有記錄 -

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

注意最後三行。我們使用了帶for迴圈的insert_multiple方法插入了三個新條目。

TinyDB - 修改資料

我們已經討論了update查詢，藉助它我們可以修改值以及處理資料庫中的資料。但是update查詢（例如db.update(fields, query)）允許我們透過新增或覆蓋其值來更新文件。

但有時，我們想刪除一個欄位或需要增加其值。在這種情況下，我們可以傳遞一個函式而不是欄位。我們可以將以下操作與更新查詢一起使用 -

增量查詢

增量查詢顧名思義，用於增加資料庫中鍵的值。增量查詢的語法如下 -

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

新增查詢

新增查詢用於向鍵的值新增值。它也適用於字串。新增查詢的語法如下 -

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

設定查詢

此查詢用於將鍵設定為資料的值。設定查詢的語法如下 -

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

遞減查詢

遞減查詢用於遞減鍵的值。遞減查詢的語法如下 -

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

減法查詢

減法查詢用於從鍵的值中減去值。減法查詢的語法如下 -

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

刪除查詢

刪除查詢用於從文件中刪除鍵。刪除查詢的語法如下 -

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

讓我們舉幾個例子來演示如何將這些操作與update查詢一起使用。我們將使用前面所有章節中使用過的相同student資料庫。

示例 1

讓我們看看如何增加student表中某個學生的成績 -

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

它將產生以下輸出：

[5]

以上輸出顯示它已更新文件 ID 為 5 的記錄。

示例 2

讓我們看看如何新增5 分到student表中某個學生的成績 -

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

它將產生以下輸出：

[4]

以上輸出顯示它已更新文件 ID 為 4 的記錄。

示例 3

讓我們看看如何在student表中將某個學生的成績從 250 設定為 259 -

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

它將產生以下輸出：

[1]

以上輸出顯示它已更新文件 ID 為 1 的記錄。

示例 4

讓我們看看如何減少student表中某個學生的成績 -

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

它將產生以下輸出：

[4]

以上輸出顯示它已更新文件 ID 為 4 的記錄。

示例 5

讓我們看看如何從student表中某個學生的成績中減去5 分 -

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

它將產生以下輸出：

[4]

以上輸出顯示它已更新文件 ID 為 4 的記錄。

示例 6

讓我們看看如何從 student 表中某個學生的成績中減去5 分 -

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

它將產生以下輸出：

[4]

以上輸出顯示它已更新文件 ID 為 4 的記錄。它將從資料庫中刪除值為 209 的 mark 欄位。

示例 7

讓我們看看如何使用單個查詢更新表中的多個值 -

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

它將產生以下輸出：

[1,2]

以上輸出顯示它已更新文件 ID 為 1 和 2 的兩條記錄。

TinyDB - Upsert 資料

我們討論了update和insert查詢，但有時我們需要將兩者結合起來使用。在這種情況下，TinyDB 提供了一個獨特的upsert查詢。此查詢幫助我們根據條件一次性插入和更新資料。它以兩種方式工作 -

• 如果資料可用，則選擇update操作。

• 如果資料不可用，則選擇insert操作。

語法

upsert查詢的語法如下 -

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

讓我們舉幾個例子來演示如何在 TinyDB 中使用此upsert查詢。我們將使用前面所有章節中使用過的相同student資料庫。

示例 1

讓我們看看如何使用upsert查詢將學號為 2 的學生的地址更改為“surat”。在這種情況下，我們有一個匹配的使用者，因此它將更新地址，並將登入狀態設定為 True -

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

它將產生以下輸出，這意味著記錄號“2”已更新。

[2]

使用以下程式碼驗證記錄號“2”是否已更新 -

db.get(doc_id=2)

它將顯示已更新的資料：

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

示例 2

讓我們看看如何在表中對不可用資料使用upsert查詢 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.upsert({'E-mail':'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 - 檢索資料

建立資料庫後，我們需要頻繁地從該資料庫中檢索資料。以下是我們可以從資料庫中檢索資料的方法 -

len() 查詢

藉助此查詢，我們可以獲取資料庫中的文件數量。其語法如下 -

len(db)

get 查詢

get 查詢用於檢索與查詢匹配的特定文件。其語法如下所示：

db.get(query)

contains 查詢

contains 查詢用於檢查資料庫是否包含匹配的值。其語法如下所示：

db.contains(query)

count 查詢

count 查詢用於從資料庫中檢索匹配文件的數量。其語法如下所示：

db.count(query)

讓我們透過一些示例來了解這些查詢在 TinyDB 中是如何工作的。我們將使用在前面所有章節中使用過的相同學生資料庫。

示例 1

讓我們看看如何使用len() 查詢獲取資料庫中文件的數量：

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

它將顯示指定資料庫中存在的文件數量：

Number of documents in student db: 5

示例 2

讓我們看看如何使用get() 查詢從資料庫中獲取特定文件：

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

此查詢將獲取“address”欄位值為“delhi”的行。

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

示例 3

讓我們看看如何使用contains() 查詢驗證我們的資料庫是否包含特定值：

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

contains() 查詢根據指定值在給定資料庫中是否存在返回布林值。在本例中，它將返回“True”，因為我們的資料庫確實有一個值為“delhi”的“address”鍵。

True

示例 4

讓我們看看如何使用count() 查詢獲取給定條件為 True 的文件數量：

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

它將返回以下輸出：

3

這意味著資料庫中有 3 個文件的“subject”鍵值為“NoSQL”。

TinyDB - 文件 ID

TinyDB 使用文件 ID（用doc_id表示）來訪問和修改資料庫中文件的值。在這裡，我們將看到如何將此 document_id 用於各種操作。

使用文件 ID 顯示資料

我們可以在get() 方法中使用doc_id 來顯示資料庫中的資料。其語法如下所示：

db.get(doc_id = value)

檢查資料庫中的文件

我們可以在contains() 方法中使用doc_id 來檢查文件是否存在於資料庫中。其語法如下所示：

db.contains(doc_id = value)

更新所有文件

我們可以在update() 方法中使用doc_id 來更新資料庫中所有具有給定文件 ID 的文件。以下是其語法：

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

刪除文件

我們可以在remove() 方法中使用doc_id 來刪除特定文件或資料庫中所有具有給定文件 ID 的文件。其語法如下所示：

db.remove(doc_ids = […])

讓我們透過一些示例來演示如何在 TinyDB 中使用這些方法中的doc_id。我們將使用在前面所有章節中使用過的相同學生資料庫。

示例 1

讓我們看看如何使用doc_id 獲取資料庫中特定文件的資料：

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

它將獲取文件 ID 為“5”的文件中的資料。

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

示例 2

讓我們看看如何使用doc_id 檢查資料庫是否包含具有特定 ID 的文件：

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

根據文件的可用性，它將返回 True 或 False。在本例中，我們的資料庫沒有文件 ID 為“15”的文件。因此，它返回 False。

False

示例 3

讓我們看看如何使用doc_id 更新資料庫的文件：

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

在這裡，我們更新了文件 ID 為“4”的文件的“marks”欄位。要檢查更新後的資料，請使用以下查詢：

print(db.get(doc_id=4))

它將顯示文件 ID 為“4”的文件的更新後的資料：

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

示例 4

讓我們看看如何使用doc_id 從資料庫中刪除特定文件：

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

在這裡，我們刪除了文件 ID 為“3”和“4”的兩個文件。要進行驗證，請使用以下get() 查詢：

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

它將顯示以下輸出：

None
None

這意味著我們已成功刪除了文件 ID 為“3”和“4”的文件。

TinyDB - 表格

在 TinyDB 中，我們可以使用多個表。這些表與 TinyDB 類具有相同的屬性。讓我們看看如何在 TinyDB 中建立表並在其上應用各種操作：

建立表

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

table_object = db.table('table name')

在表中插入值

要在特定表中插入資料，請使用以下語法：

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

從表中檢索值

要從表中檢索值，請使用以下查詢：

table_object.all()

從資料庫中刪除表

要從資料庫中刪除表，請使用 drop_table() 查詢。以下是其語法：

db.drop_table('table name')

從資料庫中刪除多個表

要從資料庫中刪除多個表，請使用以下查詢：

db.drop_tables()

讓我們瞭解如何透過一些示例來使用這些查詢。我們將使用在前面所有章節中使用過的相同學生資料庫。

示例 1

使用以下程式碼建立一個名為Student_Detail的新表：

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

示例 2

接下來，讓我們在這個新的Student_Detail表中插入值：

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

它將返回插入到表中的記錄的 doc_id。

[1]

要進行驗證，請使用以下程式碼：

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

它將顯示 Student_Detail 表中包含的資料：

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

示例 3

要檢視資料庫中存在的所有表，請使用以下查詢：

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

“student.json”中有兩個表。它將顯示這兩個表的名稱：

{'Student_Detail', '_default'}

示例 4

讓我們看看如何從表中檢索所有值：

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

它將顯示以下輸出：

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

示例 5

讓我們看看如何從資料庫中刪除表：

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

它將從資料庫中刪除“Student_Detail”表。要刪除資料庫中的所有表，請使用“drop_tables()”查詢：

db.drop_tables()

它將刪除資料庫中的所有表。

TinyDB - 預設表格

TinyDB 提供了一個預設表，它會自動儲存和修改資料。我們也可以將一個表設定為預設表。基本查詢、方法和操作將在該預設表上執行。在本章中，讓我們看看如何檢視資料庫中的表以及如何將我們選擇的表設定為預設表：

顯示資料庫中的表

要獲取資料庫中所有表的列表，請使用以下程式碼：

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

它將產生以下輸出：我們在“student.json”中有兩個表，因此它將顯示這兩個表的名稱：

{'Student_Detail', '_default'}

輸出顯示我們的資料庫中有兩個表，一個是“Student_Detail”，另一個是“_default”。

顯示預設表的值

如果您使用all() 查詢，它將顯示預設表的內容：

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

要顯示“Student_Detail”表的內容，請使用以下查詢：

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

它將顯示“Student_Detail”表的內容：

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

設定預設表

您可以將您選擇的表設定為預設表。為此，您需要使用以下程式碼：

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

它將“Student_Detail”表設定為我們資料庫的預設表。

TinyDB - 快取查詢

快取查詢是 TinyDB 的一項高階功能，它可以快取查詢結果以最佳化效能。這樣，當我們再次執行相同的查詢時，TinyDB 不需要從儲存中讀取資料。我們可以將cache_size傳遞給 table 函式以最佳化查詢快取大小。

語法

TinyDB 查詢快取的語法如下所示：

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

示例

TinyDB 在給定的表中建立快取大小的記憶體。

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

它將產生以下輸出。請注意，快取大小不會影響表值。

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

我們可以透過設定“cache_size = None”來設定無限快取大小。

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

我們也可以透過設定“cache_size = 0”來停用快取大小。

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

要清除快取大小，請使用以下查詢：

db.clear_cache()

TinyDB - 儲存型別

TinyDB 有兩種型別的儲存：JSON 和記憶體中儲存。TinyDB 預設情況下將資料儲存在 JSON 檔案中。在建立資料庫時，您需要指定在計算機上儲存 JSON 檔案的路徑。

將資料儲存在 JSON 檔案中

首先，讓我們看看如何使用 JSON 檔案來儲存資料：

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

示例 1

在本例中，我們演示瞭如何將多個文件插入 JSON 檔案：

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

在這裡，我們在“storage.json”中插入了 5 個文件。要驗證記錄，請使用以下查詢：

db.all()

它將顯示“storage.json”檔案的內容：

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

使用記憶體中儲存來儲存資料

現在，讓我們看看如何使用“記憶體中儲存”來儲存資料：

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

示例 2

以下示例演示瞭如何將多個文件插入預設儲存記憶體：

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

要驗證文件是否已插入，請使用以下查詢：

object.all()

以下輸出顯示了插入的資料：

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

TinyDB - 中介軟體

TinyDB 中介軟體透過包裝現有儲存來幫助我們自定義資料庫儲存行為。此中介軟體提高了資料庫的效能。

快取中介軟體

顧名思義，此中介軟體透過減少磁碟 I/O 來提高資料庫的速度。CachingMiddleware 的工作原理如下：

• 首先，它捕獲所有讀取操作。

• 然後在配置的寫入操作次數後將資料寫入磁碟。

語法

使用 CachingMiddleware 的語法如下：

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

示例

以下示例演示瞭如何在資料庫中執行基本中介軟體過程。

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

輸出

它將產生以下輸出 -

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

關閉資料庫以確保所有資料都安全寫入。

db.close()

TinyDB - 擴充套件 TinyDB

可以擴充套件 TinyDB 並修改其行為。有四種方法可以做到這一點：

• 自定義中介軟體

• 自定義儲存

• 鉤子和覆蓋

• 對 TinyDB 和表進行子類化

在本章中，讓我們詳細瞭解每種方法。

自定義中介軟體

有時使用者不想編寫新的儲存模組。在這種情況下，使用者可以修改現有儲存模組的行為。讓我們看一個示例，我們將構建一個自定義中介軟體來過濾掉空專案：

首先，讓我們看看將透過自定義中介軟體的資料：

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

現在，讓我們看看如何實現自定義中介軟體：

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

自定義儲存

如前所述，TinyDB 帶有兩種型別的儲存：記憶體中儲存和 JSON 檔案儲存。除此之外，TinyDB 還提供了一個新增我們自己的自定義儲存的選項。在以下示例中，讓我們看看如何使用 PyYAML 新增 YAML 儲存：

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

讀取檔案：

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

   except yaml.YAMLError:
      return None

寫入檔案：

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

關閉檔案：

def close(self):
   pass

鉤子和覆蓋

有時，自定義儲存和自定義中介軟體無法按照您想要的方式工作。在這種情況下，使用者可以使用預定義的鉤子和覆蓋來修改 TinyDB 的行為。例如，我們將配置預設表的名稱如下：

TinyDB.default_table_name = 'student_detail'

我們還可以分配快取容量，如下所示：

TinyDB.table_class.default_query_cache_capacity = 50

對 TinyDB 和表進行子類化

這是我們可以用來修改 TinyDB 行為的最後一種方法。例如，我們將建立一個可以與鉤子和覆蓋一起使用的子類來覆蓋預設類。

Class ExtendTable(Table):
   TinyDB.table_class = student_detail

TinyDB - 擴充套件

下面是一組可用於各種操作的 TinyDB 擴充套件：