Truy cập dữ liệu Python - Hướng dẫn nhanh

Tiêu chuẩn Python cho giao diện cơ sở dữ liệu là Python DB-API. Hầu hết các giao diện cơ sở dữ liệu Python đều tuân theo tiêu chuẩn này.

Bạn có thể chọn cơ sở dữ liệu phù hợp cho ứng dụng của mình. API cơ sở dữ liệu Python hỗ trợ nhiều loại máy chủ cơ sở dữ liệu như -

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• Oracle
• Sybase

Đây là danh sách các giao diện cơ sở dữ liệu Python có sẵn: Giao diện cơ sở dữ liệu Python và API . Bạn phải tải xuống mô-đun API DB riêng biệt cho mỗi cơ sở dữ liệu bạn cần truy cập. Ví dụ: nếu bạn cần truy cập cơ sở dữ liệu Oracle cũng như cơ sở dữ liệu MySQL, bạn phải tải xuống cả mô-đun cơ sở dữ liệu Oracle và MySQL.

Mysql-connector-python là gì?

MySQL Python / Connector là một giao diện để kết nối với máy chủ cơ sở dữ liệu MySQL từ Python. Nó triển khai API cơ sở dữ liệu Python và được xây dựng trên MySQL.

Làm cách nào để cài đặt mysql-connector-python?

Trước hết, bạn cần đảm bảo rằng bạn đã cài đặt python trong máy của mình. Để làm như vậy, hãy mở dấu nhắc lệnh và nhập python vào đó rồi nhấn Enter. Nếu python đã được cài đặt trong hệ thống của bạn, lệnh này sẽ hiển thị phiên bản của nó như hình dưới đây:

C:\Users\Tutorialspoint>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Bây giờ nhấn ctrl + z rồi Enter để thoát khỏi trình bao python và tạo một thư mục (trong đó bạn dự định cài đặt trình kết nối Python-MySQL) có tên Python_MySQL là -

>>> ^Z
C:\Users\Tutorialspoint>d:
D:\>mkdir Python_MySQL

Xác minh PIP

PIP là một trình quản lý gói trong python, bằng cách sử dụng nó, bạn có thể cài đặt các mô-đun / gói khác nhau bằng Python. Do đó, để cài đặt Mysql-python mysql-connector-python, bạn cần đảm bảo rằng bạn đã cài đặt PIP trong máy tính và đã thêm vị trí của nó vào đường dẫn.

Bạn có thể làm như vậy bằng cách thực hiện lệnh pip. Nếu bạn không có PIP trong hệ thống của mình hoặc nếu bạn chưa thêm vị trí của nó trongPath biến môi trường, bạn sẽ nhận được thông báo lỗi là -

D:\Python_MySQL>pip
'pip' is not recognized as an internal or external command,
operable program or batch file.

Để cài đặt PIP, hãy tải xuống get-pip.py vào thư mục đã tạo ở trên và từ lệnh điều hướng nó và cài đặt pip như sau:

D:\>cd Python_MySQL
D:\Python_MySQL>python get-pip.py
Collecting pip
Downloading https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl (1.4MB)
|████████████████████████████████| 1.4MB 1.3MB/s
Collecting wheel
Downloading https://files.pythonhosted.org/packages/00/83/b4a77d044e78ad1a45610eb88f745be2fd2c6d658f9798a15e384b7d57c9/wheel-0.33.6-py2.py3-none-any.whl
Installing collected packages: pip, wheel
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
Successfully installed pip-19.2.2 wheel-0.33.6

Cài đặt mysql-connector-python

Khi bạn đã cài đặt Python và PIP, hãy mở dấu nhắc lệnh và nâng cấp pip (tùy chọn) như hình dưới đây -

C:\Users\Tutorialspoint>python -m pip install --upgrade pip
Collecting pip
Using cached https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Python Data Access
4
Installing collected packages: pip
Found existing installation: pip 19.0.3
Uninstalling pip-19.0.3:
Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

Sau đó, mở dấu nhắc lệnh ở chế độ quản trị và cài đặt python MySQL kết nối như -

C:\WINDOWS\system32>pip install mysql-connector-python
Collecting mysql-connector-python
Using cached https://files.pythonhosted.org/packages/99/74/f41182e6b7aadc62b038b6939dce784b7f9ec4f89e2ae14f9ba8190dc9ab/mysql_connector_python-8.0.17-py2.py3-none-any.whl
Collecting protobuf>=3.0.0 (from mysql-connector-python)
Using cached https://files.pythonhosted.org/packages/09/0e/614766ea191e649216b87d331a4179338c623e08c0cca291bcf8638730ce/protobuf-3.9.1-cp37-cp37m-win32.whl
Collecting six>=1.9 (from protobuf>=3.0.0->mysql-connector-python)
Using cached https://files.pythonhosted.org/packages/73/fb/00a976f728d0d1fecfe898238ce23f502a721c0ac0ecfedb80e0d88c64e9/six-1.12.0-py2.py3-none-any.whl
Requirement already satisfied: setuptools in c:\program files (x86)\python37-32\lib\site-packages (from protobuf>=3.0.0->mysql-connector-python) (40.8.0)
Installing collected packages: six, protobuf, mysql-connector-python
Successfully installed mysql-connector-python-8.0.17 protobuf-3.9.1 six-1.12.0

xác minh

Để xác minh việc cài đặt, hãy tạo một tập lệnh python mẫu với dòng sau trong đó.

import mysql.connector

Nếu cài đặt thành công, khi bạn thực hiện nó, bạn sẽ không gặp bất kỳ lỗi nào -

D:\Python_MySQL>python test.py
D:\Python_MySQL>

Cài đặt python từ đầu

Đơn giản, nếu bạn cần cài đặt Python từ đầu. Truy cập Trang chủ Python .

Bấm vào Downloads , bạn sẽ được chuyển hướng đến trang tải xuống cung cấp liên kết cho phiên bản mới nhất của python cho các nền tảng khác nhau, chọn một và tải xuống.

Ví dụ: chúng tôi đã tải xuống python-3.7.4.exe (dành cho windows). Bắt đầu quá trình cài đặt bằng cách nhấp đúp vào tệp .exe đã tải xuống .

Đánh dấu vào tùy chọn Add Python 3.7 to Path và tiến hành cài đặt. Sau khi hoàn thành quá trình này, python sẽ được cài đặt trong hệ thống của bạn.

Để kết nối với MySQL, (một cách là) mở dấu nhắc lệnh MySQL trong hệ thống của bạn như hình dưới đây:

Nó yêu cầu mật khẩu ở đây; bạn cần nhập mật khẩu bạn đã đặt cho người dùng mặc định (root) tại thời điểm cài đặt.

Sau đó, một kết nối được thiết lập với MySQL hiển thị thông báo sau:

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4
Server version: 5.7.12-log MySQL Community Server (GPL)

Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

Bạn có thể ngắt kết nối khỏi cơ sở dữ liệu MySQL bất kỳ lúc nào bằng cách sử dụng lệnh thoát tại dấu nhắc mysql>.

mysql> exit
Bye

Thiết lập kết nối với MySQL bằng python

Trước khi thiết lập kết nối với cơ sở dữ liệu MySQL bằng python, hãy giả sử:

• Đó là chúng tôi đã tạo một cơ sở dữ liệu với tên mydb.

• Chúng tôi đã tạo một bảng EMPLOYEE với các cột FIRST_NAME, LAST_NAME, AGE, SEX và THU NHẬP.

• Thông tin đăng nhập chúng tôi đang sử dụng để kết nối với MySQL là tên người dùng: root, mật khẩu: password.

Bạn có thể thiết lập kết nối bằng cách sử dụng connect()constructor. Điều này chấp nhận tên người dùng, mật khẩu, máy chủ lưu trữ và tên của cơ sở dữ liệu bạn cần kết nối (tùy chọn) và trả về một đối tượng của lớp MySQLConnection.

Thí dụ

Sau đây là ví dụ về kết nối với cơ sở dữ liệu MySQL "mydb".

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Executing an MYSQL function using the execute() method
cursor.execute("SELECT DATABASE()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Connection established to: ",data)

#Closing the connection
conn.close()

Đầu ra

Khi thực thi, tập lệnh này tạo ra kết quả sau:

D:\Python_MySQL>python EstablishCon.py
Connection established to: ('mydb',)

Bạn cũng có thể thiết lập kết nối với MySQL bằng cách chuyển thông tin xác thực (tên người dùng, mật khẩu, tên máy chủ và tên cơ sở dữ liệu) tới connection.MySQLConnection() như hình dưới đây -

from mysql.connector import (connection)

#establishing the connection
conn = connection.MySQLConnection(user='root', password='password', host='127.0.0.1', database='mydb')

#Closing the connection
conn.close()

Bạn có thể tạo cơ sở dữ liệu trong MYSQL bằng cách sử dụng truy vấn TẠO CƠ SỞ DỮ LIỆU.

Cú pháp

Sau đây là cú pháp của truy vấn TẠO CƠ SỞ DỮ LIỆU:

CREATE DATABASE name_of_the_database

Thí dụ

Câu lệnh sau tạo một cơ sở dữ liệu với tên mydb trong MySQL:

mysql> CREATE DATABASE mydb;
Query OK, 1 row affected (0.04 sec)

Nếu bạn quan sát danh sách cơ sở dữ liệu bằng câu lệnh SHOW DATABASES, bạn có thể quan sát cơ sở dữ liệu mới được tạo trong đó như hình dưới đây:

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| logging            |
| mydatabase         |
| mydb               |
| performance_schema |
| students           |
| sys                |
+--------------------+
26 rows in set (0.15 sec)

Tạo cơ sở dữ liệu trong MySQL bằng python

Sau khi thiết lập kết nối với MySQL, để thao tác dữ liệu trong đó, bạn cần kết nối với cơ sở dữ liệu. Bạn có thể kết nối với cơ sở dữ liệu hiện có hoặc tạo của riêng bạn.

Bạn sẽ cần các đặc quyền đặc biệt để tạo hoặc xóa cơ sở dữ liệu MySQL. Vì vậy, nếu bạn có quyền truy cập vào người dùng gốc, bạn có thể tạo bất kỳ cơ sở dữ liệu nào.

Thí dụ

Ví dụ sau thiết lập kết nối với MYSQL và tạo cơ sở dữ liệu trong đó.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping database MYDATABASE if already exists.
cursor.execute("DROP database IF EXISTS MyDatabase")

#Preparing query to create a database
sql = "CREATE database MYDATABASE";

#Creating a database
cursor.execute(sql)

#Retrieving the list of databases
print("List of databases: ")
cursor.execute("SHOW DATABASES")
print(cursor.fetchall())

#Closing the connection
conn.close()

Đầu ra

List of databases:
[('information_schema',), ('dbbug61332',), ('details',), ('exampledatabase',), ('mydatabase',), ('mydb',), ('mysql',), ('performance_schema',)]

Câu lệnh CREATE TABLE được sử dụng để tạo bảng trong cơ sở dữ liệu MYSQL. Ở đây, bạn cần chỉ định tên của bảng và định nghĩa (tên và kiểu dữ liệu) của mỗi cột.

Cú pháp

Sau đây là cú pháp để tạo một bảng trong MySQL:

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

Thí dụ

Truy vấn sau tạo một bảng có tên EMPLOYEE trong MySQL với năm cột là FIRST_NAME, LAST_NAME, AGE, SEX và INCOME.

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.42 sec)

Câu lệnh DESC cung cấp cho bạn mô tả của bảng được chỉ định. Sử dụng điều này, bạn có thể xác minh xem bảng đã được tạo hay chưa như hình dưới đây -

mysql> Desc Employee;
+------------+----------+------+-----+---------+-------+
| Field      | Type     | Null | Key | Default | Extra |
+------------+----------+------+-----+---------+-------+
| FIRST_NAME | char(20) | NO   |     | NULL    |       |
| LAST_NAME  | char(20) | YES  |     | NULL    |       |
| AGE        | int(11)  | YES  |     | NULL    |       |
| SEX        | char(1)  | YES  |     | NULL    |       |
| INCOME     | float    | YES  |     | NULL    |       |
+------------+----------+------+-----+---------+-------+
5 rows in set (0.07 sec)

Tạo bảng trong MySQL bằng python

Phương thức có tên execute() (được gọi trên đối tượng con trỏ) chấp nhận hai biến -

• Giá trị chuỗi đại diện cho truy vấn sẽ được thực thi.

• Tham số args tùy chọn có thể là một bộ hoặc, danh sách hoặc, từ điển, đại diện cho các tham số của truy vấn (giá trị của trình giữ chỗ).

Nó trả về một giá trị số nguyên đại diện cho số hàng được thực hiện bởi truy vấn.

Khi kết nối cơ sở dữ liệu được thiết lập, bạn có thể tạo bảng bằng cách chuyển truy vấn CREATE TABLE tới execute() phương pháp.

Nói tóm lại, để tạo bảng bằng python 7minus;

• Nhập khẩu mysql.connector gói hàng.

• Tạo một đối tượng kết nối bằng cách sử dụng mysql.connector.connect() bằng cách chuyển tên người dùng, mật khẩu, máy chủ (mặc định tùy chọn: localhost) và, cơ sở dữ liệu (tùy chọn) làm tham số cho nó.

• Tạo một đối tượng con trỏ bằng cách gọi cursor() trên đối tượng kết nối đã tạo ở trên.

• Sau đó, thực hiện câu lệnh CREATE TABLE bằng cách chuyển nó làm tham số choexecute() phương pháp.

Thí dụ

Ví dụ sau tạo một bảng có tên Employee trong cơ sở dữ liệu mydb.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Dropping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Closing the connection
conn.close()

Bạn có thể thêm các hàng mới vào một bảng hiện có của MySQL bằng cách sử dụng INSERT INTOtuyên bố. Trong phần này, bạn cần chỉ định tên bảng, tên cột và giá trị (theo thứ tự như tên cột).

Cú pháp

Sau đây là cú pháp của câu lệnh INSERT INTO của MySQL.

INSERT INTO TABLE_NAME (column1, column2,column3,...columnN)
VALUES (value1, value2, value3,...valueN);

Thí dụ

Truy vấn sau sẽ chèn một bản ghi vào bảng có tên EMPLOYEE.

INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES ('
   Mac', 'Mohan', 20, 'M', 2000
);

Bạn có thể xác minh các bản ghi của bảng sau khi thao tác chèn bằng cách sử dụng câu lệnh SELECT dưới dạng:

mysql> select * from Employee;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Mac        | Mohan     | 20   | M    | 2000   | 
+------------+-----------+------+------+--------+
1 row in set (0.00 sec)

Không bắt buộc phải chỉ định luôn tên của các cột, nếu bạn chuyển các giá trị của một bản ghi theo cùng thứ tự của các cột trong bảng, bạn có thể thực hiện câu lệnh SELECT mà không có tên cột như sau:

INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000);

Chèn dữ liệu vào bảng MySQL bằng python

Các execute()phương thức (được gọi trên đối tượng con trỏ) chấp nhận một truy vấn làm tham số và thực hiện truy vấn đã cho. Để chèn dữ liệu, bạn cần chuyển câu lệnh MySQL INSERT làm tham số cho nó.

cursor.execute("""INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)""")

Để chèn dữ liệu vào bảng trong MySQL bằng python -

• nhập khẩu mysql.connector gói hàng.

• Tạo một đối tượng kết nối bằng cách sử dụng mysql.connector.connect() bằng cách chuyển tên người dùng, mật khẩu, máy chủ (mặc định tùy chọn: localhost) và, cơ sở dữ liệu (tùy chọn) làm tham số cho nó.

• Tạo một đối tượng con trỏ bằng cách gọi cursor() phương thức trên đối tượng kết nối được tạo ở trên

• Sau đó, thực hiện INSERT bằng cách chuyển nó dưới dạng một tham số cho execute() phương pháp.

Thí dụ

Ví dụ sau thực hiện câu lệnh SQL INSERT để chèn một bản ghi vào bảng EMPLOYEE -

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""

try:
   # Executing the SQL command
   cursor.execute(sql)

   # Commit your changes in the database
   conn.commit()

except:
   # Rolling back in case of error
   conn.rollback()

# Closing the connection
conn.close()

Chèn giá trị động

Bạn cũng có thể sử dụng “% s” thay vì các giá trị trong INSERT truy vấn MySQL và chuyển các giá trị cho chúng dưới dạng danh sách như hình dưới đây -

cursor.execute("""INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000)""", 
   ('Ramya', 'Ramapriya', 25, 'F', 5000))

Thí dụ

Ví dụ sau sẽ chèn động một bản ghi vào bảng Nhân viên.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL query to INSERT a record into the database.
insert_stmt = (
   "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)"
   "VALUES (%s, %s, %s, %s, %s)"
)
data = ('Ramya', 'Ramapriya', 25, 'F', 5000)

try:
   # Executing the SQL command
   cursor.execute(insert_stmt, data)
   
   # Commit your changes in the database
   conn.commit()

except:
   # Rolling back in case of error
   conn.rollback()

print("Data inserted")

# Closing the connection
conn.close()

Đầu ra

Data inserted

Bạn có thể truy xuất / tìm nạp dữ liệu từ một bảng trong MySQL bằng cách sử dụng truy vấn SELECT. Truy vấn / câu lệnh này trả về nội dung của bảng được chỉ định ở dạng bảng và nó được gọi là tập kết quả.

Cú pháp

Sau đây là cú pháp của truy vấn SELECT:

SELECT column1, column2, columnN FROM table_name;

Thí dụ

Giả sử chúng ta đã tạo một bảng trong MySQL với tên cricketers_data là -

CREATE TABLE cricketers_data(
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Date_Of_Birth date,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

insert into cricketers_data values(
   'Shikhar', 'Dhawan', DATE('1981-12-05'), 'Delhi', 'India');
insert into cricketers_data values(
   'Jonathan', 'Trott', DATE('1981-04-22'), 'CapeTown', 'SouthAfrica');
insert into cricketers_data values(
   'Kumara', 'Sangakkara', DATE('1977-10-27'), 'Matale', 'Srilanka');
insert into cricketers_data values(
   'Virat', 'Kohli', DATE('1988-11-05'), 'Delhi', 'India');
insert into cricketers_data values(
   'Rohit', 'Sharma', DATE('1987-04-30'), 'Nagpur', 'India');

Truy vấn sau truy xuất các giá trị FIRST_NAME và Quốc gia từ bảng.

mysql> select FIRST_NAME, Country from cricketers_data;
+------------+-------------+
| FIRST_NAME | Country     |
+------------+-------------+
| Shikhar    | India       |
| Jonathan   | SouthAfrica |
| Kumara     | Srilanka    |
| Virat      | India       |
| Rohit      | India       |
+------------+-------------+
5 rows in set (0.00 sec)

Bạn cũng có thể truy xuất tất cả các giá trị của mỗi bản ghi bằng cách sử dụng * thể hiện tên của các cột là -

mysql> SELECT * from cricketers_data;
+------------+------------+---------------+----------------+-------------+
| First_Name | Last_Name  | Date_Of_Birth | Place_Of_Birth | Country     |
+------------+------------+---------------+----------------+-------------+
| Shikhar    | Dhawan     | 1981-12-05    | Delhi          | India       |
| Jonathan   | Trott      | 1981-04-22    | CapeTown       | SouthAfrica |
| Kumara     | Sangakkara | 1977-10-27    | Matale         | Srilanka    |
| Virat      | Kohli      | 1988-11-05    | Delhi          | India       |
| Rohit      | Sharma     | 1987-04-30    | Nagpur         | India       |
+------------+------------+---------------+----------------+-------------+
5 rows in set (0.00 sec)

Đọc dữ liệu từ bảng MYSQL bằng Python

ĐỌC Hoạt động trên bất kỳ cơ sở dữ liệu nào có nghĩa là lấy một số thông tin hữu ích từ cơ sở dữ liệu. Bạn có thể tìm nạp dữ liệu từ MYSQL bằng cách sử dụngfetch() được cung cấp bởi mysql-connector-python.

Lớp cursor.MySQLCursor cung cấp ba phương thức cụ thể làfetchall(), fetchmany() và, fetchone() Ở đâu,

• Các fetchall()phương thức truy xuất tất cả các hàng trong tập kết quả của một truy vấn và trả về chúng dưới dạng danh sách các bộ giá trị. (Nếu chúng ta thực hiện điều này sau khi truy xuất một vài hàng, nó sẽ trả về những hàng còn lại).

• Các fetchone() phương thức tìm nạp hàng tiếp theo trong kết quả của một truy vấn và trả về nó dưới dạng một bộ giá trị.

• Các fetchmany() phương thức tương tự như fetchone () nhưng, nó truy xuất tập hợp các hàng tiếp theo trong tập kết quả của một truy vấn, thay vì một hàng duy nhất.

Note - Tập kết quả là một đối tượng được trả về khi một đối tượng con trỏ được sử dụng để truy vấn bảng.

rowcount - Đây là thuộc tính chỉ đọc và trả về số hàng đã bị ảnh hưởng bởi phương thức execute ().

Thí dụ

Ví dụ sau tìm nạp tất cả các hàng của bảng EMPLOYEE bằng cách sử dụng truy vấn SELECT và từ tập kết quả thu được ban đầu, chúng ta đang truy xuất hàng đầu tiên bằng phương thức fetchone () và sau đó tìm nạp các hàng còn lại bằng phương thức fetchall ().

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

Đầu ra

('Krishna', 'Sharma', 19, 'M', 2000.0)
[('Raj', 'Kandukuri', 20, 'M', 7000.0), ('Ramya', 'Ramapriya', 25, 'M', 5000.0)]

Ví dụ sau truy xuất hai hàng đầu tiên của bảng EMPLOYEE bằng phương thức fetchmany ().

Thí dụ

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchmany(size =2);
print(result)

#Closing the connection
conn.close()

Đầu ra

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

Nếu bạn muốn tìm nạp, xóa hoặc cập nhật các hàng cụ thể của bảng trong MySQL, bạn cần sử dụng mệnh đề where để chỉ định điều kiện để lọc các hàng của bảng cho hoạt động.

Ví dụ, nếu bạn có một câu lệnh SELECT với mệnh đề where, chỉ những hàng thỏa mãn điều kiện đã chỉ định mới được truy xuất.

Cú pháp

Sau đây là cú pháp của mệnh đề WHERE:

SELECT column1, column2, columnN
FROM table_name
WHERE [condition]

Thí dụ

Giả sử chúng ta đã tạo một bảng trong MySQL với tên EMPLOYEES là -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

Và nếu chúng ta đã chèn 4 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

Sau câu lệnh MySQL truy xuất bản ghi của những nhân viên có thu nhập lớn hơn 4000.

mysql> SELECT * FROM EMPLOYEE WHERE INCOME > 4000;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Raj        | Kandukuri | 20   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

Mệnh đề WHERE sử dụng python

Để tìm nạp các bản ghi cụ thể từ một bảng bằng chương trình python -

• nhập khẩu mysql.connector gói hàng.

• Tạo một đối tượng kết nối bằng cách sử dụng mysql.connector.connect() bằng cách chuyển tên người dùng, mật khẩu, máy chủ (mặc định tùy chọn: localhost) và, cơ sở dữ liệu (tùy chọn) làm tham số cho nó.

• Tạo một đối tượng con trỏ bằng cách gọi cursor() trên đối tượng kết nối đã tạo ở trên.

• Sau đó, thực hiện câu lệnh SELECT với mệnh đề WHERE , bằng cách chuyển nó dưới dạng tham số choexecute() phương pháp.

Thí dụ

Ví dụ sau tạo một bảng có tên Nhân viên và điền vào bảng đó. Sau đó, sử dụng mệnh đề where, nó truy xuất các bản ghi có giá trị tuổi nhỏ hơn 23.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES (%s, %s, %s, %s, %s)"

data = [('Krishna', 'Sharma', 19, 'M', 2000), ('Raj', 'Kandukuri', 20, 'M', 7000),
('Ramya', 'Ramapriya', 25, 'F', 5000),('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Closing the connection
conn.close()

Đầu ra

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

Trong khi tìm nạp dữ liệu bằng truy vấn SELECT, bạn có thể sắp xếp kết quả theo thứ tự mong muốn (tăng dần hoặc giảm dần) bằng mệnh đề OrderBy. Theo mặc định, mệnh đề này sắp xếp các kết quả theo thứ tự tăng dần, nếu bạn cần sắp xếp chúng theo thứ tự giảm dần, bạn cần sử dụng “DESC” một cách rõ ràng.

Cú pháp

Sau đây là cú pháp CHỌN cột-danh sách

FROM table_name
[WHERE condition]
[ORDER BY column1, column2,.. columnN] [ASC | DESC]; of the ORDER BY clause:

Thí dụ

Giả sử chúng ta đã tạo một bảng trong MySQL với tên EMPLOYEES là -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

Và nếu chúng ta đã chèn 4 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

Câu lệnh sau truy xuất nội dung của bảng EMPLOYEE theo thứ tự tăng dần của độ tuổi.

mysql> SELECT * FROM EMPLOYEE ORDER BY AGE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |   19 |    M |   2000 |
| Raj        | Kandukuri |   20 |    M |   7000 |
| Ramya      | Ramapriya |   25 |    F |   5000 |
| Mac        | Mohan     |   26 |    M |   2000 |
+------------+-----------+------+------+--------+
4 rows in set (0.04 sec)

Bạn cũng có thể truy xuất dữ liệu theo thứ tự giảm dần bằng cách sử dụng DESC dưới dạng:

mysql> SELECT * FROM EMPLOYEE ORDER BY FIRST_NAME, INCOME DESC;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |   19 |    M |   2000 |
| Mac        | Mohan     |   26 |    M |   2000 |
| Raj        | Kandukuri |   20 |    M |   7000 |
| Ramya      | Ramapriya |   25 |    F |   5000 |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

Mệnh đề ORDER BY sử dụng python

Để truy xuất nội dung của một bảng theo thứ tự cụ thể, hãy gọi execute() trên đối tượng con trỏ và, chuyển câu lệnh SELECT cùng với mệnh đề ORDER BY, làm tham số cho nó.

Thí dụ

Trong ví dụ sau, chúng ta đang tạo một bảng có tên và Nhân viên, điền nó vào và lấy lại các bản ghi của nó theo thứ tự (tăng dần) tuổi của chúng, sử dụng mệnh đề ORDER BY.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES (%s, %s, %s, %s, %s)"

data = [('Krishna', 'Sharma', 26, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 29, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())

#Closing the connection
conn.close()

Đầu ra

[('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0)
]

Theo cách tương tự, bạn có thể lấy dữ liệu từ một bảng theo thứ tự giảm dần bằng mệnh đề ORDER BY.

Thí dụ

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving specific records using the ORDERBY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY INCOME DESC")
print(cursor.fetchall())

#Closing the connection
conn.close()

Đầu ra

[('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0)
]

CẬP NHẬT Thao tác trên bất kỳ cơ sở dữ liệu nào cũng cập nhật một hoặc nhiều bản ghi đã có sẵn trong cơ sở dữ liệu. Bạn có thể cập nhật giá trị của các bản ghi hiện có trong MySQL bằng cách sử dụng câu lệnh UPDATE. Để cập nhật các hàng cụ thể, bạn cần sử dụng mệnh đề WHERE cùng với nó.

Cú pháp

Sau đây là cú pháp của câu lệnh UPDATE trong MySQL:

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Bạn có thể kết hợp N số điều kiện bằng cách sử dụng toán tử VÀ hoặc HOẶC.

Thí dụ

Giả sử chúng ta đã tạo một bảng trong MySQL với tên EMPLOYEES là -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

Và nếu chúng ta đã chèn 4 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

Sau tuyên bố MySQL tăng tuổi của tất cả nhân viên nam thêm một tuổi -

mysql> UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M';
Query OK, 3 rows affected (0.06 sec)
Rows matched: 3 Changed: 3 Warnings: 0

Nếu bạn truy xuất nội dung của bảng, bạn có thể thấy các giá trị được cập nhật dưới dạng:

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 20   | M    | 2000   |
| Raj        | Kandukuri | 21   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
| Mac        | Mohan     | 27   | M    | 2000   |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

Cập nhật nội dung của bảng bằng Python

Để cập nhật các bản ghi trong bảng trong MySQL bằng python -

• nhập khẩu mysql.connector gói hàng.

• Tạo một đối tượng kết nối bằng cách sử dụng mysql.connector.connect() bằng cách chuyển tên người dùng, mật khẩu, máy chủ (mặc định tùy chọn: localhost) và, cơ sở dữ liệu (tùy chọn) làm tham số cho nó.

• Tạo một đối tượng con trỏ bằng cách gọi cursor() trên đối tượng kết nối đã tạo ở trên.

• Sau đó, thực hiện câu lệnh UPDATE bằng cách chuyển nó làm tham số cho execute() phương pháp.

Thí dụ

Ví dụ sau đây làm tăng tuổi của tất cả nam giới thêm một tuổi.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Preparing the query to update the records
sql = '''UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M' '''
try:
   # Execute the SQL command
   cursor.execute(sql)
   
   # Commit your changes in the database
   conn.commit()
except:
   # Rollback in case there is any error
   conn.rollback()
   
#Retrieving data
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Displaying the result
print(cursor.fetchall())

#Closing the connection
conn.close()

Đầu ra

[('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0)
]

Để xóa bản ghi khỏi bảng MySQL, bạn cần sử dụng DELETE FROMtuyên bố. Để xóa các bản ghi cụ thể, bạn cần sử dụng mệnh đề WHERE cùng với nó.

Cú pháp

Sau đây là cú pháp của truy vấn DELETE trong MYSQL:

DELETE FROM table_name [WHERE Clause]

Thí dụ

Giả sử chúng ta đã tạo một bảng trong MySQL với tên EMPLOYEES là -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

Và nếu chúng ta đã chèn 4 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

Sau câu lệnh MySQL xóa bản ghi của nhân viên với FIRST_NAME ”Mac”.

mysql> DELETE FROM EMPLOYEE WHERE FIRST_NAME = 'Mac';
Query OK, 1 row affected (0.12 sec)

Nếu bạn truy xuất nội dung của bảng, bạn chỉ có thể thấy 3 bản ghi vì chúng tôi đã xóa một bản ghi.

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 20   | M    | 2000   |
| Raj        | Kandukuri | 21   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
+------------+-----------+------+------+--------+
3 rows in set (0.00 sec)

Nếu bạn thực hiện câu lệnh DELETE mà không có mệnh đề WHERE, tất cả các bản ghi từ bảng được chỉ định sẽ bị xóa.

mysql> DELETE FROM EMPLOYEE;
Query OK, 3 rows affected (0.09 sec)

Nếu bạn truy xuất nội dung của bảng, bạn sẽ nhận được một tập hợp trống như hình dưới đây -

mysql> select * from EMPLOYEE;
Empty set (0.00 sec)

Xóa bản ghi của bảng bằng python

Thao tác DELETE là bắt buộc khi bạn muốn xóa một số bản ghi khỏi cơ sở dữ liệu của mình.

Để xóa các bản ghi trong bảng -

• nhập khẩu mysql.connector gói hàng.

• Tạo một đối tượng kết nối bằng cách sử dụng mysql.connector.connect() bằng cách chuyển tên người dùng, mật khẩu, máy chủ (mặc định tùy chọn: localhost) và, cơ sở dữ liệu (tùy chọn) làm tham số cho nó.

• Tạo một đối tượng con trỏ bằng cách gọi cursor() trên đối tượng kết nối đã tạo ở trên.

• Sau đó, thực hiện DELETE bằng cách chuyển nó dưới dạng một tham số cho execute() phương pháp.

Thí dụ

Chương trình sau sẽ xóa tất cả các bản ghi khỏi NHÂN VIÊN có TUỔI trên 20 -

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
print("Contents of the table: ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Preparing the query to delete records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (25)

try:
   # Execute the SQL command
   cursor.execute(sql)
   
   # Commit your changes in the database
   conn.commit()
except:
   # Roll back in case there is any error
   conn.rollback()

#Retrieving data
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Closing the connection
conn.close()

Đầu ra

Contents of the table:
[('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0), 
   ('Ramya', 'Rama priya', 27, 'F', 9000.0)]

Contents of the table after delete operation:
[('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0)]

Bạn có thể xóa toàn bộ bảng bằng cách sử dụng DROP TABLEtuyên bố. Bạn chỉ cần xác định tên bảng mà bạn cần xóa.

Cú pháp

Sau đây là cú pháp của câu lệnh DROP TABLE trong MySQL:

DROP TABLE table_name;

Thí dụ

Trước khi xóa một bảng, hãy lấy danh sách các bảng bằng câu lệnh SHOW TABLES như sau:

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data |
| employee        |
| sample          |
| tutorials       |
+-----------------+
5 rows in set (0.00 sec)

Câu lệnh sau loại bỏ hoàn toàn bảng có tên mẫu khỏi cơ sở dữ liệu:

mysql> DROP TABLE sample;
Query OK, 0 rows affected (0.29 sec)

Vì chúng tôi đã xóa mẫu có tên bảng khỏi MySQL, nếu bạn lấy lại danh sách các bảng, bạn sẽ không tìm thấy mẫu tên bảng trong đó.

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data |
| employee        |
| tutorials       |
+-----------------+
4 rows in set (0.00 sec)

Xóa bảng bằng python

Bạn có thể bỏ một bảng bất cứ khi nào bạn cần, bằng cách sử dụng câu lệnh DROP của MYSQL, nhưng bạn cần phải rất cẩn thận khi xóa bất kỳ bảng nào hiện có vì dữ liệu bị mất sẽ không được phục hồi sau khi xóa một bảng.

Để thả một bảng từ cơ sở dữ liệu MYSQL bằng cách sử dụng python, hãy gọi execute() trên đối tượng con trỏ và chuyển câu lệnh drop làm tham số cho nó.

Thí dụ

Bảng sau đây loại bỏ một bảng có tên EMPLOYEE từ cơ sở dữ liệu.

import mysql.connector

#establishing the connection conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method 
cursor = conn.cursor()

#Retrieving the list of tables print("List of tables in the database: ") 
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Doping EMPLOYEE table if already exists cursor.execute
   ("DROP TABLE EMPLOYEE") print("Table dropped... ")

#Retrieving the list of tables print(
   "List of tables after dropping the EMPLOYEE table: ") 
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Closing the connection conn.close()

Đầu ra

List of tables in the database:
[('employee',), ('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',), ('tutorials',)]

Chỉ thả bảng nếu tồn tại

Nếu bạn cố gắng bỏ một bảng không tồn tại trong cơ sở dữ liệu, một lỗi sẽ xảy ra như sau:

mysql.connector.errors.ProgrammingError: 1051 (42S02): 
   Unknown table 'mydb.employee'

Bạn có thể ngăn lỗi này bằng cách xác minh xem bảng có tồn tại hay không trước khi xóa, bằng cách thêm IF TỒN TẠI vào câu lệnh DELETE.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving the list of tables
print("List of tables in the database: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
print("Table dropped... ")

#Retrieving the list of tables
print("List of tables after dropping the EMPLOYEE table: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Closing the connection
conn.close()

Đầu ra

List of tables in the database:
[('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',),
('tutorials',)]

Trong khi tìm nạp các bản ghi nếu bạn muốn giới hạn chúng bằng một số cụ thể, bạn có thể làm như vậy bằng cách sử dụng mệnh đề LIMIT của MYSQL.

Thí dụ

Giả sử chúng ta đã tạo một bảng trong MySQL với tên EMPLOYEES là -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

Và nếu chúng ta đã chèn 4 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

Câu lệnh SQL sau truy xuất hai bản ghi đầu tiên của bảng Nhân viên bằng cách sử dụng mệnh đề LIMIT.

SELECT * FROM EMPLOYEE LIMIT 2;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 19   | M    | 2000   |
| Raj        | Kandukuri | 20   | M    | 7000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

Điều khoản giới hạn sử dụng python

Nếu bạn gọi execute() trên đối tượng con trỏ bằng cách chuyển truy vấn SELECT cùng với mệnh đề LIMIT, bạn có thể truy xuất số lượng bản ghi cần thiết.

Để thả một bảng từ cơ sở dữ liệu MYSQL bằng cách sử dụng python, hãy gọi execute() trên đối tượng con trỏ và chuyển câu lệnh drop làm tham số cho nó.

Thí dụ

Ví dụ python sau tạo và điền vào một bảng có tên EMPLOYEE và bằng cách sử dụng mệnh đề LIMIT, nó tìm nạp hai bản ghi đầu tiên của nó.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

Đầu ra

[('Krishna', 'Sharma', 26, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

LIMIT với OFFSET

Nếu bạn cần giới hạn các bản ghi bắt đầu từ bản ghi thứ n (không phải ^thứ 1 ), bạn có thể làm như vậy bằng cách sử dụng OFFSET cùng với LIMIT.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

Đầu ra

[('Ramya', 'Ramapriya', 29, 'F', 5000.0), ('Mac', 'Mohan', 26, 'M', 2000.0)]

Khi bạn đã chia dữ liệu trong hai bảng, bạn có thể tìm nạp các bản ghi kết hợp từ hai bảng này bằng cách sử dụng Kết hợp.

Thí dụ

Giả sử chúng ta đã tạo một bảng với tên EMPLOYEE và nhập dữ liệu vào nó như hình dưới đây:

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT,
   CONTACT INT
);
Query OK, 0 rows affected (0.36 sec)
INSERT INTO Employee VALUES ('Ramya', 'Rama Priya', 27, 'F', 9000, 101), 
   ('Vinay', 'Bhattacharya', 20, 'M', 6000, 102), 
   ('Sharukh', 'Sheik', 25, 'M', 8300, 103), 
   ('Sarmista', 'Sharma', 26, 'F', 10000, 104), 
   ('Trupthi', 'Mishra', 24, 'F', 6000, 105);
Query OK, 5 rows affected (0.08 sec)
Records: 5 Duplicates: 0 Warnings: 0

Sau đó, nếu chúng ta đã tạo một bảng khác và điền nó là -

CREATE TABLE CONTACT(
   ID INT NOT NULL,
   EMAIL CHAR(20) NOT NULL,
   PHONE LONG,
   CITY CHAR(20)
);
Query OK, 0 rows affected (0.49 sec)

INSERT INTO CONTACT (ID, EMAIL, CITY) VALUES 
   (101, '[email protected]', 'Hyderabad'), 
   (102, '[email protected]', 'Vishakhapatnam'), 
   (103, '[email protected]', 'Pune'), 
   (104, '[email protected]', 'Mumbai');
Query OK, 4 rows affected (0.10 sec)
Records: 4 Duplicates: 0 Warnings: 0

Câu lệnh sau truy xuất dữ liệu kết hợp các giá trị trong hai bảng này:

mysql> SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID;
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| FIRST_NAME | LAST_NAME    | AGE  | SEX  | INCOME | CONTACT | ID  | EMAIL              | PHONE | CITY           |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| Ramya      | Rama Priya   | 27   | F    | 9000   | 101     | 101 | [email protected] | NULL  | Hyderabad      |
| Vinay      | Bhattacharya | 20   | M    | 6000   | 102     | 102 | [email protected]    | NULL  | Vishakhapatnam |
| Sharukh    | Sheik        | 25   | M    | 8300   | 103     | 103 | [email protected] | NULL  | Pune           |
| Sarmista   | Sharma       | 26   | F    | 10000  | 104     | 104 | [email protected]    | NULL  | Mumbai         |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
4 rows in set (0.00 sec)

MYSQL JOIN bằng python

Ví dụ sau lấy dữ liệu từ hai bảng trên được kết hợp bởi cột liên hệ của bảng NHÂN VIÊN và cột ID của bảng LIÊN HỆ.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

Đầu ra

[('Krishna', 'Sharma', 26, 'M', 2000, 101, 101, '[email protected]', 9848022338, 'Hyderabad'), 
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102, 102, '[email protected]', 9848022339, 'Vishakhapatnam'), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103, 103, '[email protected]', 9848022337, 'Pune'), 
   ('Mac', 'Mohan', 26, 'M', 2000, 104, 104, '[email protected]', 9848022330, 'Mumbai')]

MySQLCursor của mysql-connector-python (và các thư viện tương tự) được sử dụng để thực thi các câu lệnh để giao tiếp với cơ sở dữ liệu MySQL.

Sử dụng các phương thức của nó, bạn có thể thực thi các câu lệnh SQL, tìm nạp dữ liệu từ các tập kết quả, gọi các thủ tục.

Bạn có thể tạo Cursor sử dụng phương thức con trỏ () của đối tượng / lớp Connection.

Thí dụ

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

Phương pháp

Sau đây là các phương thức khác nhau được cung cấp bởi lớp / đối tượng Cursor.

Sr.No	Phương pháp & Mô tả
1	callproc() Phương thức này được sử dụng để gọi cơ sở dữ liệu MySQL thủ tục hiện có.
2	close() Phương thức này được sử dụng để đóng đối tượng con trỏ hiện tại.
3	Info() Phương pháp này cung cấp thông tin về truy vấn cuối cùng.
4	executemany() Phương thức này chấp nhận một chuỗi danh sách các tham số. Chuẩn bị một truy vấn MySQL và thực thi nó với tất cả các tham số.
5	execute() Phương thức này chấp nhận một truy vấn MySQL làm tham số và thực hiện truy vấn đã cho.
6	fetchall() Phương thức này truy xuất tất cả các hàng trong tập kết quả của một truy vấn và trả về chúng dưới dạng danh sách các bộ giá trị. (Nếu chúng ta thực hiện điều này sau khi lấy một vài hàng, nó sẽ trả về những hàng còn lại)
7	fetchone() Phương thức này tìm nạp hàng tiếp theo trong kết quả của một truy vấn và trả về nó dưới dạng một bộ giá trị.
số 8	fetchmany() Phương thức này tương tự như fetchone () nhưng, nó truy xuất tập hợp các hàng tiếp theo trong tập kết quả của một truy vấn, thay vì một hàng.
9	etchwarnings() Phương thức này trả về các cảnh báo được tạo bởi truy vấn được thực thi cuối cùng.

Tính chất

Sau đây là các thuộc tính của lớp Cursor:

Sr.No	Kê khai tài sản
1	column_names Đây là thuộc tính chỉ đọc trả về danh sách chứa các tên cột của tập hợp kết quả.
2	description Đây là thuộc tính chỉ đọc trả về danh sách chứa mô tả các cột trong tập kết quả.
3	lastrowid Đây là thuộc tính chỉ đọc, nếu có bất kỳ cột nào được tăng tự động trong bảng, thì nó sẽ trả về giá trị được tạo cho cột đó trong thao tác INSERT hoặc UPDATE cuối cùng.
4	rowcount Điều này trả về số hàng được trả về / cập nhật trong trường hợp hoạt động CHỌN và CẬP NHẬT.
5	statement Thuộc tính này trả về câu lệnh được thực thi cuối cùng.

Cài đặt

PostgreSQL là một hệ thống cơ sở dữ liệu quan hệ đối tượng mã nguồn mở, mạnh mẽ. Nó có hơn 15 năm trong giai đoạn phát triển tích cực và một kiến ​​trúc đã được chứng minh đã mang lại cho nó một danh tiếng mạnh mẽ về độ tin cậy, tính toàn vẹn của dữ liệu và tính đúng đắn.

Để giao tiếp với PostgreSQL bằng Python, bạn cần cài đặt psycopg, một bộ điều hợp được cung cấp cho lập trình python, phiên bản hiện tại của cái này là psycog2.

psycopg2 được viết với mục đích rất nhỏ và nhanh, ổn định như một tảng đá. Nó có sẵn trong PIP (trình quản lý gói của python)

Cài đặt Psycog2 bằng PIP

Trước hết, hãy đảm bảo rằng python và PIP được cài đặt đúng cách trong hệ thống của bạn và PIP được cập nhật.

Để nâng cấp PIP, hãy mở dấu nhắc lệnh và thực hiện lệnh sau:

C:\Users\Tutorialspoint>python -m pip install --upgrade pip
Collecting pip
Using cached https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Installing collected packages: pip
Found existing installation: pip 19.0.3
Uninstalling pip-19.0.3:
Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

Sau đó, mở dấu nhắc lệnh ở chế độ quản trị và thực hiện pip install psycopg2-binary lệnh như hình dưới đây -

C:\WINDOWS\system32>pip install psycopg2-binary
Collecting psycopg2-binary
Using cached https://files.pythonhosted.org/packages/80/79/d0d13ce4c2f1addf4786f4a2ded802c2df66ddf3c1b1a982ed8d4cb9fc6d/psycopg2_binary-2.8.3-cp37-cp37m-win32.whl
Installing collected packages: psycopg2-binary
Successfully installed psycopg2-binary-2.8.3

xác minh

Để xác minh cài đặt, hãy tạo một tập lệnh python mẫu với dòng sau trong đó.

import mysql.connector

Nếu cài đặt thành công, khi bạn thực hiện nó, bạn sẽ không gặp bất kỳ lỗi nào -

D:\Python_PostgreSQL>import psycopg2
D:\Python_PostgreSQL>

PostgreSQL cung cấp trình bao của riêng nó để thực thi các truy vấn. Để thiết lập kết nối với cơ sở dữ liệu PostgreSQL, hãy đảm bảo rằng bạn đã cài đặt nó đúng cách trong hệ thống của mình. Mở lời nhắc trình bao PostgreSQL và chuyển các chi tiết như Máy chủ, Cơ sở dữ liệu, tên người dùng và mật khẩu. Nếu tất cả các chi tiết bạn đã cung cấp là phù hợp, kết nối sẽ được thiết lập với cơ sở dữ liệu PostgreSQL.

Trong khi chuyển các chi tiết, bạn có thể đi với máy chủ, cơ sở dữ liệu, cổng và tên người dùng mặc định do shell đề xuất.

Thiết lập kết nối bằng python

Lớp kết nối của psycopg2đại diện / xử lý một phiên bản của kết nối. Bạn có thể tạo kết nối mới bằng cách sử dụngconnect()chức năng. Điều này chấp nhận các tham số kết nối cơ bản như dbname, user, password, host, port và trả về một đối tượng kết nối. Sử dụng chức năng này, bạn có thể thiết lập kết nối với PostgreSQL.

Thí dụ

Đoạn mã Python sau đây cho thấy cách kết nối với cơ sở dữ liệu hiện có. Nếu cơ sở dữ liệu không tồn tại, thì nó sẽ được tạo và cuối cùng một đối tượng cơ sở dữ liệu sẽ được trả về. Tên của cơ sở dữ liệu mặc định của PostgreSQL là postrgre . Do đó, chúng tôi đang cung cấp nó làm tên cơ sở dữ liệu.

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Executing an MYSQL function using the execute() method
cursor.execute("select version()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Connection established to: ",data)

#Closing the connection
conn.close()
Connection established to: (
   'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)

Đầu ra

Connection established to: (
   'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)

Bạn có thể tạo cơ sở dữ liệu trong PostgreSQL bằng cách sử dụng câu lệnh CREATE DATABASE. Bạn có thể thực hiện câu lệnh này trong dấu nhắc trình bao PostgreSQL bằng cách chỉ định tên của cơ sở dữ liệu sẽ được tạo sau lệnh.

Cú pháp

Sau đây là cú pháp của câu lệnh CREATE DATABASE.

CREATE DATABASE dbname;

Thí dụ

Câu lệnh sau tạo một cơ sở dữ liệu có tên testdb trong PostgreSQL.

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

Bạn có thể liệt kê cơ sở dữ liệu trong PostgreSQL bằng lệnh \ l. Nếu bạn xác minh danh sách cơ sở dữ liệu, bạn có thể tìm thấy cơ sở dữ liệu mới được tạo như sau:

postgres=# \l
                                           List of databases
Name       | Owner    | Encoding | Collate                    | Ctype       |
-----------+----------+----------+----------------------------+-------------+
mydb       | postgres | UTF8     | English_United States.1252 | ........... |
postgres   | postgres | UTF8     | English_United States.1252 | ........... |
template0  | postgres | UTF8     | English_United States.1252 | ........... |
template1  | postgres | UTF8     | English_United States.1252 | ........... |
testdb     | postgres | UTF8     | English_United States.1252 | ........... |
(5 rows)

Bạn cũng có thể tạo cơ sở dữ liệu trong PostgreSQL từ dấu nhắc lệnh bằng cách sử dụng lệnh createb , một trình bao bọc xung quanh câu lệnh SQL CREATE DATABASE.

C:\Program Files\PostgreSQL\11\bin> createdb -h localhost -p 5432 -U postgres sampledb
Password:

Tạo cơ sở dữ liệu bằng python

Lớp con trỏ của psycopg2 cung cấp các phương thức khác nhau để thực thi các lệnh PostgreSQL khác nhau, tìm nạp các bản ghi và sao chép dữ liệu. Bạn có thể tạo một đối tượng con trỏ bằng cách sử dụng phương thức con trỏ () của lớp Kết nối.

Phương thức execute () của lớp này chấp nhận một truy vấn PostgreSQL làm tham số và thực thi nó.

Do đó, để tạo cơ sở dữ liệu trong PostgreSQL, hãy thực hiện truy vấn TẠO CƠ SỞ DỮ LIỆU bằng phương pháp này.

Thí dụ

Ví dụ về python sau tạo một cơ sở dữ liệu có tên mydb trong cơ sở dữ liệu PostgreSQL.

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Preparing query to create a database
sql = '''CREATE database mydb''';

#Creating a database
cursor.execute(sql)
print("Database created successfully........")

#Closing the connection
conn.close()

Đầu ra

Database created successfully........

Bạn có thể tạo một bảng mới trong cơ sở dữ liệu trong PostgreSQL bằng cách sử dụng câu lệnh CREATE TABLE. Trong khi thực hiện điều này, bạn cần chỉ định tên bảng, tên cột và kiểu dữ liệu của chúng.

Cú pháp

Sau đây là cú pháp của câu lệnh CREATE TABLE trong PostgreSQL.

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

Thí dụ

Ví dụ sau tạo một bảng với tên CRICKETERS trong PostgreSQL.

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age INT,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
CREATE TABLE
postgres=#

Bạn có thể lấy danh sách các bảng trong cơ sở dữ liệu trong PostgreSQL bằng lệnh \ dt. Sau khi tạo bảng, nếu bạn có thể xác minh danh sách các bảng, bạn có thể quan sát bảng mới tạo trong đó như sau:

postgres=# \dt
            List of relations
Schema  | Name       | Type  | Owner
--------+------------+-------+----------
public  | cricketers | table | postgres
(1 row)
postgres=#

Theo cách tương tự, bạn có thể lấy mô tả của bảng đã tạo bằng cách sử dụng \ d như hình dưới đây -

postgres=# \d cricketers
               Table "public.cricketers"
Column          | Type                   | Collation | Nullable | Default
----------------+------------------------+-----------+----------+---------
first_name      | character varying(255) |           |          |
last_name       | character varying(255) |           |          |
age             | integer                |           |          |
place_of_birth  | character varying(255) |           |          |
country         | character varying(255) |           |          |
postgres=#

Tạo bảng bằng python

Để tạo một bảng bằng python, bạn cần thực hiện câu lệnh CREATE TABLE bằng cách sử dụng phương thức execute () của Con trỏ của pyscopg2 .

Thí dụ

Ví dụ Python sau đây tạo một bảng với tên nhân viên.

import psycopg2

#Establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
print("Table created successfully........")

#Closing the connection
conn.close()

Đầu ra

Table created successfully........

Bạn có thể chèn bản ghi vào một bảng hiện có trong PostgreSQL bằng cách sử dụng INSERT INTOtuyên bố. Trong khi thực hiện điều này, bạn cần chỉ định tên của bảng và giá trị cho các cột trong đó.

Cú pháp

Sau đây là cú pháp được khuyến nghị của câu lệnh INSERT:

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);

Trong đó, column1, column2, column3, .. là tên của các cột trong bảng và value1, value2, value3, ... là các giá trị bạn cần chèn vào bảng.

Thí dụ

Giả sử chúng ta đã tạo một bảng với tên CRICKETERS bằng cách sử dụng câu lệnh CREATE TABLE như hình dưới đây -

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age INT,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
CREATE TABLE
postgres=#

Sau câu lệnh PostgreSQL chèn một hàng trong bảng đã tạo ở trên:

postgres=# insert into CRICKETERS (
   First_Name, Last_Name, Age, Place_Of_Birth, Country) 
   values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=#

Trong khi chèn bản ghi bằng câu lệnh INSERT INTO , nếu bạn bỏ qua bất kỳ cột nào, tên cột Bản ghi sẽ được chèn để lại khoảng trống tại các cột mà bạn đã bỏ qua.

postgres=# insert into CRICKETERS (First_Name, Last_Name, Country) 
   values('Jonathan', 'Trott', 'SouthAfrica');
INSERT 0 1

Bạn cũng có thể chèn các bản ghi vào bảng mà không cần chỉ định tên cột, nếu thứ tự của các giá trị bạn chuyển giống với tên cột tương ứng của chúng trong bảng.

postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1
postgres=#

Sau khi chèn các bản ghi vào một bảng, bạn có thể xác minh nội dung của nó bằng cách sử dụng câu lệnh SELECT như hình dưới đây:

postgres=# SELECT * from CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      |     |                | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(5 rows)

Chèn dữ liệu bằng python

Lớp con trỏ của psycopg2 cung cấp một phương thức có tên là phương thức execute (). Phương thức này chấp nhận truy vấn như một tham số và thực thi nó.

Do đó, để chèn dữ liệu vào một bảng trong PostgreSQL bằng cách sử dụng python -

• Nhập khẩu psycopg2 gói hàng.

• Tạo một đối tượng kết nối bằng cách sử dụng connect() bằng cách chuyển tên người dùng, mật khẩu, máy chủ (mặc định tùy chọn: localhost) và, cơ sở dữ liệu (tùy chọn) làm tham số cho nó.

• Tắt chế độ cam kết tự động bằng cách đặt giá trị false cho thuộc tính autocommit.

• Các cursor() phương pháp của Connectionlớp của thư viện psycopg2 trả về một đối tượng con trỏ. Tạo một đối tượng con trỏ bằng phương pháp này.

• Sau đó, thực thi (các) câu lệnh INSERT bằng cách chuyển nó / chúng dưới dạng tham số cho phương thức execute ().

Thí dụ

Chương trình Python sau tạo một bảng với tên EMPLOYEE trong cơ sở dữ liệu PostgreSQL và chèn các bản ghi vào đó bằng phương thức execute () -

import psycopg2

#Establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Ramya', 'Rama priya', 27, 'F', 9000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Vinay', 'Battacharya', 20, 'M', 6000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Sharukh', 'Sheik', 25, 'M', 8300)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Sarmista', 'Sharma', 26, 'F', 10000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Tripthi', 'Mishra', 24, 'F', 6000)''')

# Commit your changes in the database
conn.commit()
print("Records inserted........")

# Closing the connection
conn.close()

Đầu ra

Records inserted........

Bạn có thể truy xuất nội dung của một bảng hiện có trong PostgreSQL bằng cách sử dụng câu lệnh SELECT. Tại câu lệnh này, bạn cần chỉ định tên của bảng và nó trả về nội dung của nó ở định dạng bảng được gọi là tập kết quả.

Cú pháp

Sau đây là cú pháp của câu lệnh SELECT trong PostgreSQL:

SELECT column1, column2, columnN FROM table_name;

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

Sau khi truy vấn SELECT truy xuất giá trị của các cột FIRST_NAME, LAST_NAME và, COUNTRY từ bảng CRICKETERS.

postgres=# SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
first_name  | last_name  | country
------------+------------+-------------
Shikhar     | Dhawan     | India
Jonathan    | Trott      | SouthAfrica
Kumara      | Sangakkara | Srilanka
Virat       | Kohli      | India
Rohit       | Sharma     | India
(5 rows)

Nếu bạn muốn truy xuất tất cả các cột của mỗi bản ghi, bạn cần thay thế tên của các cột bằng "*" như hình dưới đây -

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(5 rows)
postgres=#

Truy xuất dữ liệu bằng python

ĐỌC Hoạt động trên bất kỳ cơ sở dữ liệu nào có nghĩa là lấy một số thông tin hữu ích từ cơ sở dữ liệu. Bạn có thể tìm nạp dữ liệu từ PostgreSQL bằng phương thức fetch () được cung cấp bởi psycopg2.

Lớp Cursor cung cấp ba phương thức cụ thể là fetchall (), fetchmany () và, fetchone () trong đó,

• Phương thức fetchall () truy xuất tất cả các hàng trong tập kết quả của một truy vấn và trả về chúng dưới dạng danh sách các bộ giá trị. (Nếu chúng ta thực hiện điều này sau khi truy xuất một vài hàng, nó sẽ trả về những hàng còn lại).

• Phương thức fetchone () tìm nạp hàng tiếp theo trong kết quả của một truy vấn và trả về nó dưới dạng một bộ giá trị.

• Phương thức fetchmany () tương tự như fetchone () nhưng, nó truy xuất tập hợp các hàng tiếp theo trong tập kết quả của một truy vấn, thay vì một hàng.

Note - Tập kết quả là một đối tượng được trả về khi một đối tượng con trỏ được sử dụng để truy vấn bảng.

Thí dụ

Chương trình Python sau kết nối với cơ sở dữ liệu có tên mydb của PostgreSQL và truy xuất tất cả các bản ghi từ một bảng có tên EMPLOYEE.

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Trong khi thực hiện các thao tác SELECT, UPDATE hoặc, DELETE, bạn có thể chỉ định điều kiện để lọc các bản ghi bằng mệnh đề WHERE. Thao tác sẽ được thực hiện trên các bản ghi thỏa mãn điều kiện đã cho.

Cú pháp

Sau đây là cú pháp của mệnh đề WHERE trong PostgreSQL:

SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]

Bạn có thể chỉ định điều kiện tìm kiếm bằng cách sử dụng các toán tử so sánh hoặc logic. like>, <, =, LIKE, NOT, vv Các ví dụ sau đây sẽ làm rõ khái niệm này.

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

Câu lệnh SELECT sau truy xuất các bản ghi có tuổi lớn hơn 35 -

postgres=# SELECT * FROM CRICKETERS WHERE AGE > 35;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(2 rows)
postgres=#

Mệnh đề where sử dụng python

Để tìm nạp các bản ghi cụ thể từ một bảng bằng cách sử dụng chương trình python, hãy thực hiện câu lệnh SELECT với mệnh đề WHERE, bằng cách chuyển nó dưới dạng tham số cho execute() phương pháp.

Thí dụ

Ví dụ về python sau minh họa cách sử dụng lệnh WHERE bằng python.

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES (%s, %s, %s, %s, %s)"
data = [('Krishna', 'Sharma', 19, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'M', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

Thông thường, nếu bạn cố gắng truy xuất dữ liệu từ một bảng, bạn sẽ nhận được các bản ghi theo cùng thứ tự mà bạn đã chèn chúng.

Sử dụng ORDER BY , trong khi truy xuất các bản ghi của một bảng, bạn có thể sắp xếp các bản ghi kết quả theo thứ tự tăng dần hoặc giảm dần dựa trên cột mong muốn.

Cú pháp

Sau đây là cú pháp của mệnh đề ORDER BY trong PostgreSQL.

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

Câu lệnh SELECT sau truy xuất các hàng của bảng CRICKETERS theo thứ tự tăng dần của độ tuổi của chúng -

postgres=# SELECT * FROM CRICKETERS ORDER BY AGE;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(5 rows)es:

Bạn có thể sử dụng nhiều hơn một cột để sắp xếp các bản ghi của bảng. Các câu lệnh SELECT sau đây sắp xếp các bản ghi của bảng CRICKETERS dựa trên độ tuổi của cột và FIRST_NAME.

postgres=# SELECT * FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(5 rows)

Theo mặc định, ORDER BYmệnh đề sắp xếp các bản ghi của một bảng theo thứ tự tăng dần. Bạn có thể sắp xếp các kết quả theo thứ tự giảm dần bằng cách sử dụng DESC như sau:

postgres=# SELECT * FROM CRICKETERS ORDER BY AGE DESC;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Shikhar     | Dhawan     | 33  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Virat       | Kohli      | 30  | Delhi          | India
(5 rows)

Mệnh đề ORDER BY sử dụng python

Để truy xuất nội dung của một bảng theo thứ tự cụ thể, hãy gọi phương thức execute () trên đối tượng con trỏ và chuyển câu lệnh SELECT cùng với mệnh đề ORDER BY, làm tham số cho nó.

Thí dụ

Trong ví dụ sau, chúng ta đang tạo một bảng có tên và Nhân viên, điền nó vào và lấy lại các bản ghi của nó theo thứ tự (tăng dần) tuổi của chúng, sử dụng mệnh đề ORDER BY.

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT, SEX CHAR(1),
   INCOME INT,
   CONTACT INT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME, CONTACT) VALUES 
   (%s, %s, %s, %s, %s, %s)"
data = [('Krishna', 'Sharma', 26, 'M', 2000, 101), 
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102),
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103),
   ('Mac', 'Mohan', 26, 'M', 2000, 104)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]

Bạn có thể sửa đổi nội dung của các bản ghi hiện có của một bảng trong PostgreSQL bằng cách sử dụng câu lệnh UPDATE. Để cập nhật các hàng cụ thể, bạn cần sử dụng mệnh đề WHERE cùng với nó.

Cú pháp

Sau đây là cú pháp của câu lệnh UPDATE trong PostgreSQL:

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

Câu lệnh sau sửa đổi tuổi của người chơi cricket, có tên đầu tiên là Shikhar -

postgres=# UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
UPDATE 1
postgres=#

Nếu bạn truy xuất bản ghi có FIRST_NAME là Shikhar, bạn thấy rằng giá trị tuổi đã được thay đổi thành 45 -

postgres=# SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
Shikhar     | Dhawan    | 45  | Delhi          | India
(1 row)
postgres=#

Nếu bạn chưa sử dụng mệnh đề WHERE, giá trị của tất cả các bản ghi sẽ được cập nhật. Sau câu lệnh UPDATE tăng tuổi của tất cả các bản ghi trong bảng CRICKETERS lên 1 -

postgres=# UPDATE CRICKETERS SET AGE = AGE+1;
UPDATE 5

Nếu bạn truy xuất nội dung của bảng bằng lệnh SELECT, bạn có thể thấy các giá trị được cập nhật dưới dạng:

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan    | Trott      | 39  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 42  | Matale         | Srilanka
Virat       | Kohli      | 31  | Delhi          | India
Rohit       | Sharma     | 33  | Nagpur         | India
Shikhar     | Dhawan     | 46  | Delhi          | India
(5 rows)

Cập nhật hồ sơ bằng python

Lớp con trỏ của psycopg2 cung cấp một phương thức có tên là phương thức execute (). Phương thức này chấp nhận truy vấn như một tham số và thực thi nó.

Do đó, để chèn dữ liệu vào một bảng trong PostgreSQL bằng cách sử dụng python -

• Nhập khẩu psycopg2 gói hàng.

• Tạo một đối tượng kết nối bằng cách sử dụng connect() bằng cách chuyển tên người dùng, mật khẩu, máy chủ (mặc định tùy chọn: localhost) và, cơ sở dữ liệu (tùy chọn) làm tham số cho nó.

• Tắt chế độ cam kết tự động bằng cách đặt giá trị false cho thuộc tính autocommit.

• Các cursor() phương pháp của Connectionlớp của thư viện psycopg2 trả về một đối tượng con trỏ. Tạo một đối tượng con trỏ bằng phương pháp này.

• Sau đó, thực hiện câu lệnh UPDATE bằng cách chuyển nó dưới dạng tham số cho phương thức execute ().

Thí dụ

Sau mã Python cập nhật nội dung của bảng Nhân viên và truy xuất kết quả:

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Fetching all the rows before the update
print("Contents of the Employee table: ")
sql = '''SELECT * from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())

#Updating the records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M'"
cursor.execute(sql)
print("Table updated...... ")

#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
sql = '''SELECT * from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0)]

Bạn có thể xóa các bản ghi trong bảng hiện có bằng cách sử dụng DELETE FROMtuyên bố của cơ sở dữ liệu PostgreSQL. Để xóa các bản ghi cụ thể, bạn cần sử dụng mệnh đề WHERE cùng với nó.

Cú pháp

Sau đây là cú pháp của truy vấn DELETE trong PostgreSQL:

DELETE FROM table_name [WHERE Clause]

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

Tuyên bố sau đây xóa kỷ lục của vận động viên cricket có họ là 'Sangakkara'. -

postgres=# DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
DELETE 1

Nếu bạn truy xuất nội dung của bảng bằng cách sử dụng câu lệnh SELECT, bạn chỉ có thể thấy 4 bản ghi vì chúng tôi đã xóa một bản ghi.

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+-------------
Jonathan    | Trott     | 39  | CapeTown       | SouthAfrica
Virat       | Kohli     | 31  | Delhi          | India
Rohit       | Sharma    | 33  | Nagpur         | India
Shikhar     | Dhawan    | 46  | Delhi          | India
(4 rows)

Nếu bạn thực hiện câu lệnh DELETE FROM mà không có mệnh đề WHERE, tất cả các bản ghi từ bảng được chỉ định sẽ bị xóa.

postgres=# DELETE FROM CRICKETERS;
DELETE 4

Vì bạn đã xóa tất cả các bản ghi, nếu bạn cố gắng truy xuất nội dung của bảng CRICKETERS, bằng cách sử dụng câu lệnh SELECT, bạn sẽ nhận được một tập hợp kết quả trống như hình dưới đây:

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
(0 rows)

Xóa dữ liệu bằng python

Lớp con trỏ của psycopg2 cung cấp một phương thức có tên là phương thức execute (). Phương thức này chấp nhận truy vấn như một tham số và thực thi nó.

Do đó, để chèn dữ liệu vào một bảng trong PostgreSQL bằng cách sử dụng python -

• Nhập khẩu psycopg2 gói hàng.

• Tạo một đối tượng kết nối bằng cách sử dụng connect() bằng cách chuyển tên người dùng, mật khẩu, máy chủ (mặc định tùy chọn: localhost) và, cơ sở dữ liệu (tùy chọn) làm tham số cho nó.

• Tắt chế độ cam kết tự động bằng cách đặt giá trị false cho thuộc tính autocommit.

• Các cursor()phương thức của lớp Kết nối của thư viện psycopg2 trả về một đối tượng con trỏ. Tạo một đối tượng con trỏ bằng phương pháp này.

• Sau đó, thực hiện câu lệnh UPDATE bằng cách chuyển nó dưới dạng tham số cho phương thức execute ().

Thí dụ

Sau mã Python sẽ xóa các bản ghi của bảng EMPLOYEE có giá trị tuổi lớn hơn 25 -

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')

#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0)]
Contents of the table after delete operation:
[('Tripthi', 'Mishra', 24, 'F', 6000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0)]

Bạn có thể xóa một bảng từ cơ sở dữ liệu PostgreSQL bằng cách sử dụng câu lệnh DROP TABLE.

Cú pháp

Sau đây là cú pháp của câu lệnh DROP TABLE trong PostgreSQL:

DROP TABLE table_name;

Thí dụ

Giả sử chúng ta đã tạo hai bảng có tên CRICKETERS và EMPLOYEES bằng các truy vấn sau:

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#
postgres=# CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT, 
   SEX CHAR(1), INCOME FLOAT
);
CREATE TABLE
postgres=#

Bây giờ nếu bạn xác minh danh sách các bảng bằng lệnh “\ dt”, bạn có thể thấy các bảng đã tạo ở trên là:

postgres=# \dt;
List of relations
Schema  | Name       | Type  | Owner
--------+------------+-------+----------
public  | cricketers | table | postgres
public  | employee   | table | postgres
(2 rows)
postgres=#

Câu lệnh sau xóa bảng có tên Nhân viên khỏi cơ sở dữ liệu -

postgres=# DROP table employee;
DROP TABLE

Vì bạn đã xóa bảng Nhân viên, nếu bạn truy xuất lại danh sách các bảng, bạn chỉ có thể quan sát một bảng trong đó.

postgres=# \dt;
List of relations
Schema  | Name       | Type  | Owner
--------+------------+-------+----------
public  | cricketers | table | postgres
(1 row)
postgres=#

Nếu bạn cố gắng xóa lại bảng Nhân viên, vì bạn đã xóa nó rồi, bạn sẽ gặp lỗi "bảng không tồn tại" như hình dưới đây -

postgres=# DROP table employee;
ERROR: table "employee" does not exist
postgres=#

Để giải quyết vấn đề này, bạn có thể sử dụng mệnh đề IF EXISTS cùng với câu lệnh DELTE. Thao tác này sẽ xóa bảng nếu nó tồn tại, nếu không thì sẽ bỏ qua thao tác DLETE.

postgres=# DROP table IF EXISTS employee;
NOTICE: table "employee" does not exist, skipping
DROP TABLE
postgres=#

Xóa toàn bộ bảng bằng Python

Bạn có thể bỏ một bảng bất cứ khi nào bạn cần, bằng cách sử dụng câu lệnh DROP. Nhưng bạn cần phải rất cẩn thận trong khi xóa bất kỳ bảng nào hiện có vì dữ liệu bị mất sẽ không được phục hồi sau khi xóa bảng.

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

#Table dropped...

Trong khi thực thi một câu lệnh PostgreSQL SELECT, bạn có thể giới hạn số lượng bản ghi trong kết quả của nó bằng mệnh đề LIMIT.

Cú pháp

Sau đây là cú pháp của mệnh đề LMIT trong PostgreSQL:

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

Câu lệnh sau truy xuất 3 bản ghi đầu tiên của bảng Cricketers bằng cách sử dụng mệnh đề LIMIT -

postgres=# SELECT * FROM CRICKETERS LIMIT 3;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(3 rows)

Nếu bạn muốn lấy các bản ghi bắt đầu từ một bản ghi cụ thể (bù đắp), bạn có thể làm như vậy bằng cách sử dụng mệnh đề OFFSET cùng với LIMIT.

postgres=# SELECT * FROM CRICKETERS LIMIT 3 OFFSET 2;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+----------
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(3 rows)
postgres=#

Điều khoản giới hạn sử dụng python

Ví dụ python sau truy xuất nội dung của bảng có tên EMPLOYEE, giới hạn số bản ghi trong kết quả là 2 -

Thí dụ

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]

Khi bạn đã chia dữ liệu trong hai bảng, bạn có thể tìm nạp các bản ghi kết hợp từ hai bảng này bằng cách sử dụng Kết hợp.

Thí dụ

Giả sử chúng ta đã tạo một bảng với tên CRICKETERS và chèn 5 bản ghi vào đó như hình dưới đây -

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
postgres=# insert into CRICKETERS values (
   'Shikhar', 'Dhawan', 33, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
   'Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica'
);
postgres=# insert into CRICKETERS values (
   'Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka'
);
postgres=# insert into CRICKETERS values (
   'Virat', 'Kohli', 30, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
   'Rohit', 'Sharma', 32, 'Nagpur', 'India'
);

Và, nếu chúng ta đã tạo một bảng khác với tên OdiStats và chèn 5 bản ghi vào đó dưới dạng:

postgres=# CREATE TABLE ODIStats (
   First_Name VARCHAR(255), Matches INT, Runs INT, AVG FLOAT, 
   Centuries INT, HalfCenturies INT
);
postgres=# insert into OdiStats values ('Shikhar', 133, 5518, 44.5, 17, 27);
postgres=# insert into OdiStats values ('Jonathan', 68, 2819, 51.25, 4, 22);
postgres=# insert into OdiStats values ('Kumara', 404, 14234, 41.99, 25, 93);
postgres=# insert into OdiStats values ('Virat', 239, 11520, 60.31, 43, 54);
postgres=# insert into OdiStats values ('Rohit', 218, 8686, 48.53, 24, 42);

Câu lệnh sau truy xuất dữ liệu kết hợp các giá trị trong hai bảng này:

postgres=# SELECT
Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
first_name  | last_name  | country     | matches | runs  | centuries | halfcenturies
------------+------------+-------------+---------+-------+-----------+---------------
Shikhar     | Dhawan     | India       | 133     | 5518  | 17        | 27
Jonathan    | Trott      | SouthAfrica | 68      | 2819  | 4         | 22
Kumara      | Sangakkara | Srilanka    | 404     | 14234 | 25        | 93
Virat       | Kohli      | India       | 239     | 11520 | 43        | 54
Rohit       | Sharma     | India       | 218     | 8686  | 24        | 42
(5 rows)
postgres=#

Tham gia bằng python

Khi bạn đã chia dữ liệu trong hai bảng, bạn có thể tìm nạp các bản ghi kết hợp từ hai bảng này bằng cách sử dụng Kết hợp.

Thí dụ

Chương trình python sau minh họa cách sử dụng mệnh đề JOIN:

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, '[email protected]', 'Hyderabad'), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102, '[email protected]', 'Vishakhapatnam'), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected] ', 'Pune'), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]

Lớp Cursor của thư viện psycopg cung cấp các phương thức để thực thi các lệnh PostgreSQL trong cơ sở dữ liệu bằng cách sử dụng mã python.

Sử dụng các phương thức của nó, bạn có thể thực thi các câu lệnh SQL, tìm nạp dữ liệu từ các tập kết quả, gọi các thủ tục.

Bạn có thể tạo Cursor sử dụng phương thức con trỏ () của đối tượng / lớp Connection.

Thí dụ

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

Phương pháp

Sau đây là các phương thức khác nhau được cung cấp bởi lớp / đối tượng Cursor.

Sr.No	Phương pháp & Mô tả
1	callproc() Phương thức này được sử dụng để gọi các thủ tục hiện có trong cơ sở dữ liệu PostgreSQL.
2	close() Phương thức này được sử dụng để đóng đối tượng con trỏ hiện tại.
3	executemany() Phương thức này chấp nhận một chuỗi danh sách các tham số. Chuẩn bị một truy vấn MySQL và thực thi nó với tất cả các tham số.
4	execute() Phương thức này chấp nhận một truy vấn MySQL làm tham số và thực hiện truy vấn đã cho.
5	fetchall() Phương thức này truy xuất tất cả các hàng trong tập kết quả của một truy vấn và trả về chúng dưới dạng danh sách các bộ giá trị. (Nếu chúng ta thực hiện điều này sau khi lấy một vài hàng, nó sẽ trả về những hàng còn lại)
6	fetchone() Phương thức này tìm nạp hàng tiếp theo trong kết quả của một truy vấn và trả về nó dưới dạng một bộ giá trị.
7	fetchmany() Phương thức này tương tự như fetchone () nhưng, nó truy xuất tập hợp các hàng tiếp theo trong tập kết quả của một truy vấn, thay vì một hàng.

Tính chất

Sau đây là các thuộc tính của lớp Cursor:

Sr.No	Kê khai tài sản
1	description Đây là thuộc tính chỉ đọc trả về danh sách chứa mô tả các cột trong tập kết quả.
2	astrowid Đây là thuộc tính chỉ đọc, nếu có bất kỳ cột nào được tăng tự động trong bảng, thì nó sẽ trả về giá trị được tạo cho cột đó trong thao tác INSERT hoặc UPDATE cuối cùng.
3	rowcount Điều này trả về số hàng được trả về / cập nhật trong trường hợp hoạt động CHỌN và CẬP NHẬT.
4	closed Thuộc tính này chỉ định xem một con trỏ có được đóng hay không, nếu vậy nó trả về true, ngược lại là false.
5	connection Điều này trả về một tham chiếu đến đối tượng kết nối bằng cách sử dụng con trỏ này.
6	name Thuộc tính này trả về tên của con trỏ.
7	scrollable Thuộc tính này chỉ định liệu một con trỏ cụ thể có thể cuộn được hay không.

Cài đặt

SQLite3 có thể được tích hợp với Python bằng cách sử dụng mô-đun sqlite3, được viết bởi Gerhard Haring. Nó cung cấp giao diện SQL tuân thủ đặc tả DB-API 2.0 được mô tả bởi PEP 249. Bạn không cần cài đặt riêng mô-đun này vì nó được vận chuyển theo mặc định cùng với phiên bản Python 2.5.x trở đi.

Để sử dụng mô-đun sqlite3, trước tiên bạn phải tạo một đối tượng kết nối đại diện cho cơ sở dữ liệu và sau đó tùy ý bạn có thể tạo một đối tượng con trỏ, đối tượng này sẽ giúp bạn thực thi tất cả các câu lệnh SQL.

API mô-đun sqlite3 của Python

Sau đây là các quy trình quan trọng của mô-đun sqlite3, có thể đủ yêu cầu của bạn để làm việc với cơ sở dữ liệu SQLite từ chương trình Python của bạn. Nếu bạn đang tìm kiếm một ứng dụng phức tạp hơn, thì bạn có thể xem tài liệu chính thức của mô-đun Python sqlite3.

Sr.No.	API & Mô tả
1	sqlite3.connect(database [,timeout ,other optional arguments]) API này mở một kết nối đến tệp cơ sở dữ liệu SQLite. Bạn có thể sử dụng ": memory:" để mở kết nối cơ sở dữ liệu tới cơ sở dữ liệu nằm trong RAM thay vì trên đĩa. Nếu cơ sở dữ liệu được mở thành công, nó sẽ trả về một đối tượng kết nối.
2	connection.cursor([cursorClass]) Quy trình này tạo ra một cursorsẽ được sử dụng trong suốt quá trình lập trình cơ sở dữ liệu của bạn với Python. Phương thức này chấp nhận một tham số tùy chọn duy nhất là cursorClass. Nếu được cung cấp, đây phải là lớp con trỏ tùy chỉnh mở rộng sqlite3.Cursor.
3	cursor.execute(sql [, optional parameters]) Quy trình này thực thi một câu lệnh SQL. Câu lệnh SQL có thể được tham số hóa (tức là trình giữ chỗ thay vì các ký tự SQL). Mô-đun sqlite3 hỗ trợ hai loại trình giữ chỗ: dấu chấm hỏi và trình giữ chỗ được đặt tên (kiểu được đặt tên). For example - cursor.execute ("chèn vào giá trị người (?,?)", (Ai, tuổi))
4	connection.execute(sql [, optional parameters]) Quy trình này là một lối tắt của phương thức thực thi ở trên được cung cấp bởi đối tượng con trỏ và nó tạo ra một đối tượng con trỏ trung gian bằng cách gọi phương thức con trỏ, sau đó gọi phương thức thực thi của con trỏ với các tham số đã cho.
5	cursor.executemany(sql, seq_of_parameters) Quy trình này thực thi một lệnh SQL chống lại tất cả các chuỗi tham số hoặc ánh xạ được tìm thấy trong chuỗi sql.
6	connection.executemany(sql[, parameters]) Quy trình này là một lối tắt tạo đối tượng con trỏ trung gian bằng cách gọi phương thức con trỏ, sau đó gọi phương thức thực thi cursor.s với các tham số đã cho.
7	cursor.executescript(sql_script) Quy trình này thực thi nhiều câu lệnh SQL cùng một lúc được cung cấp dưới dạng tập lệnh. Nó đưa ra một câu lệnh COMMIT trước, sau đó thực thi tập lệnh SQL mà nó nhận được như một tham số. Tất cả các câu lệnh SQL phải được phân tách bằng dấu chấm phẩy (;).
số 8	connection.executescript(sql_script) Quy trình này là một lối tắt tạo đối tượng con trỏ trung gian bằng cách gọi phương thức con trỏ, sau đó gọi phương thức thực thi của con trỏ với các tham số đã cho.
9	connection.total_changes() Quy trình này trả về tổng số hàng cơ sở dữ liệu đã được sửa đổi, chèn hoặc xóa kể từ khi kết nối cơ sở dữ liệu được mở.
10	connection.commit() Phương thức này cam kết giao dịch hiện tại. Nếu bạn không gọi phương thức này, bất kỳ điều gì bạn đã làm kể từ lần gọi cuối cùng tới commit () sẽ không hiển thị từ các kết nối cơ sở dữ liệu khác.
11	connection.rollback() Phương thức này sẽ quay trở lại bất kỳ thay đổi nào đối với cơ sở dữ liệu kể từ lần gọi cuối cùng tới commit ().
12	connection.close() Phương thức này đóng kết nối cơ sở dữ liệu. Lưu ý rằng điều này không tự động gọi commit (). Nếu bạn chỉ đóng kết nối cơ sở dữ liệu của mình mà không gọi commit () trước, các thay đổi của bạn sẽ bị mất!
13	cursor.fetchone() Phương thức này tìm nạp hàng tiếp theo của tập hợp kết quả truy vấn, trả về một chuỗi duy nhất hoặc Không có khi không có thêm dữ liệu.
14	cursor.fetchmany([size = cursor.arraysize]) Quy trình này tìm nạp tập hợp các hàng tiếp theo của kết quả truy vấn, trả về một danh sách. Một danh sách trống được trả về khi không còn hàng nào nữa. Phương thức cố gắng tìm nạp nhiều hàng như được chỉ ra bởi tham số kích thước.
15	cursor.fetchall() Quy trình này tìm nạp tất cả (còn lại) các hàng của kết quả truy vấn, trả về một danh sách. Một danh sách trống được trả về khi không có hàng nào.

Để thiết lập kết nối với SQLite Mở dấu nhắc lệnh, hãy duyệt qua vị trí nơi bạn đã cài đặt SQLite và chỉ cần thực hiện lệnh sqlite3 như hình dưới đây -

Thiết lập kết nối bằng python

Bạn có thể giao tiếp với cơ sở dữ liệu SQLite2 bằng mô-đun python SQLite3. Để làm như vậy, trước hết bạn cần thiết lập kết nối (tạo đối tượng kết nối).

Để thiết lập kết nối với cơ sở dữ liệu SQLite3 bằng python, bạn cần -

• Nhập mô-đun sqlite3 bằng cách sử dụng câu lệnh nhập.

• Phương thức connect () chấp nhận tên của cơ sở dữ liệu bạn cần kết nối làm tham số và trả về đối tượng Kết nối.

Thí dụ

import sqlite3
conn = sqlite3.connect('example.db')

Đầu ra

print("Connection established ..........")

Sử dụng câu lệnh SQLite CREATE TABLE, bạn có thể tạo một bảng trong cơ sở dữ liệu.

Cú pháp

Sau đây là cú pháp để tạo một bảng trong cơ sở dữ liệu SQLite:

CREATE TABLE database_name.table_name(
   column1 datatype PRIMARY KEY(one or more columns),
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype
);

Thí dụ

Sau khi truy vấn / câu lệnh SQLite tạo một bảng có tên CRICKETERS trong cơ sở dữ liệu SQLite -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Hãy để chúng tôi tạo thêm một bảng OdiStats mô tả thống kê cricket trong một ngày của mỗi người chơi trong bảng CRICKETERS.

sqlite> CREATE TABLE ODIStats (
   First_Name VARCHAR(255),
   Matches INT,
   Runs INT,
   AVG FLOAT,
   Centuries INT,
   HalfCenturies INT
);
sqlite

Bạn có thể lấy danh sách các bảng trong cơ sở dữ liệu trong cơ sở dữ liệu SQLite bằng cách sử dụng .tableschỉ huy. Sau khi tạo bảng, nếu bạn có thể xác minh danh sách các bảng, bạn có thể quan sát bảng mới được tạo trong đó là:

sqlite> . tables
CRICKETERS ODIStats
sqlite>

Tạo bảng bằng python

Đối tượng Con trỏ chứa tất cả các phương thức để thực thi lệnh quires và tìm nạp dữ liệu, v.v ... Phương thức con trỏ của lớp kết nối trả về một đối tượng con trỏ.

Do đó, để tạo một bảng trong cơ sở dữ liệu SQLite bằng python -

• Thiết lập kết nối với cơ sở dữ liệu bằng phương thức connect ().

• Tạo đối tượng con trỏ bằng cách gọi phương thức con trỏ () trên đối tượng kết nối đã tạo ở trên.

• Bây giờ thực thi câu lệnh CREATE TABLE bằng phương thức execute () của lớp Con trỏ.

Thí dụ

Chương trình Python sau tạo một bảng có tên Nhân viên trong SQLite3:

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
print("Table created successfully........")

# Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

Table created successfully........

Bạn có thể thêm các hàng mới vào bảng SQLite hiện có bằng cách sử dụng câu lệnh INSERT INTO. Trong phần này, bạn cần chỉ định tên bảng, tên cột và giá trị (theo thứ tự như tên cột).

Cú pháp

Sau đây là cú pháp được khuyến nghị của câu lệnh INSERT:

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);

Trong đó, column1, column2, column3, .. là tên các cột của bảng và value1, value2, value3, ... là các giá trị bạn cần chèn vào bảng.

Thí dụ

Giả sử chúng ta đã tạo một bảng với tên CRICKETERS bằng cách sử dụng câu lệnh CREATE TABLE như hình dưới đây -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Sau câu lệnh PostgreSQL chèn một hàng trong bảng đã tạo ở trên.

sqlite> insert into CRICKETERS 
   (First_Name, Last_Name, Age, Place_Of_Birth, Country) values
   ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite>

Trong khi chèn bản ghi bằng câu lệnh INSERT INTO, nếu bạn bỏ qua bất kỳ tên cột nào, bản ghi này sẽ được chèn để lại khoảng trống tại các cột mà bạn đã bỏ qua.

sqlite> insert into CRICKETERS 
   (First_Name, Last_Name, Country) values 
   ('Jonathan', 'Trott', 'SouthAfrica');
sqlite>

Bạn cũng có thể chèn các bản ghi vào bảng mà không cần chỉ định tên cột, nếu thứ tự của các giá trị bạn chuyển giống với tên cột tương ứng của chúng trong bảng.

sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

Sau khi chèn các bản ghi vào một bảng, bạn có thể xác minh nội dung của nó bằng cách sử dụng câu lệnh SELECT như hình dưới đây:

sqlite> select * from cricketers;
Shikhar  | Dhawan     | 33 | Delhi  | India
Jonathan | Trott      |    |        | SouthAfrica
Kumara   | Sangakkara | 41 | Matale | Srilanka
Virat    | Kohli      | 30 | Delhi  | India
Rohit    | Sharma     | 32 | Nagpur | India
sqlite>

Chèn dữ liệu bằng python

Để thêm bản ghi vào bảng hiện có trong cơ sở dữ liệu SQLite -

• Nhập gói sqlite3.

• Tạo một đối tượng kết nối bằng phương thức connect () bằng cách chuyển tên của cơ sở dữ liệu làm tham số cho nó.

• Các cursor()phương thức trả về một đối tượng con trỏ sử dụng mà bạn có thể giao tiếp với SQLite3. Tạo một đối tượng con trỏ bằng cách gọi đối tượng con trỏ () trên đối tượng Kết nối (đã tạo ở trên).

• Sau đó, gọi phương thức execute () trên đối tượng con trỏ, bằng cách chuyển câu lệnh INSERT làm tham số cho nó.

Thí dụ

Ví dụ về python sau sẽ chèn các bản ghi vào một bảng có tên EMPLOYEE -

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama Priya', 27, 'F', 9000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Vinay', 'Battacharya', 20, 'M', 6000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sharukh', 'Sheik', 25, 'M', 8300)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sarmista', 'Sharma', 26, 'F', 10000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')

# Commit your changes in the database
conn.commit()
print("Records inserted........")

# Closing the connection
conn.close()

Đầu ra

Records inserted........

Bạn có thể truy xuất dữ liệu từ bảng SQLite bằng truy vấn SELCT. Truy vấn / câu lệnh này trả về nội dung của quan hệ được chỉ định (bảng) ở dạng bảng và nó được gọi là tập kết quả.

Cú pháp

Sau đây là cú pháp của câu lệnh SELECT trong SQLite:

SELECT column1, column2, columnN FROM table_name;

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

Sau khi truy vấn SELECT truy xuất giá trị của các cột FIRST_NAME, LAST_NAME và, COUNTRY từ bảng CRICKETERS.

sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
Shikhar  |Dhawan     |India
Jonathan |Trott      |SouthAfrica
Kumara   |Sangakkara |Srilanka
Virat    |Kohli      |India
Rohit    |Sharma     |India
sqlite>

Khi bạn quan sát, câu lệnh SELECT của cơ sở dữ liệu SQLite chỉ trả về các bản ghi của các bảng được chỉ định. Để nhận được đầu ra được định dạng, bạn cần đặtheadervà mode bằng cách sử dụng các lệnh tương ứng trước câu lệnh SELECT như hình dưới đây -

sqlite> .header on
sqlite> .mode column
sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
First_Name Last_Name            Country
---------- -------------------- ----------
Shikhar    Dhawan               India
Jonathan   Trott                SouthAfric
Kumara     Sangakkara           Srilanka
Virat      Kohli                India
Rohit      Sharma               India
sqlite>

Nếu bạn muốn truy xuất tất cả các cột của mỗi bản ghi, bạn cần thay thế tên của các cột bằng "*" như hình dưới đây -

sqlite> .header on
sqlite> .mode column
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age        Place_Of_Birth Country
---------- ---------- ---------- -------------- ----------
Shikhar    Dhawan     33         Delhi          India
Jonathan   Trott      38         CapeTown       SouthAfric
Kumara     Sangakkara 41         Matale         Srilanka
Virat      Kohli      30         Delhi          India
Rohit      Sharma     32         Nagpur         India
sqlite>

Trong SQLite theo mặc định, chiều rộng của các cột là 10 giá trị ngoài chiều rộng này được cắt nhỏ (quan sát cột quốc gia của hàng ^{thứ 2} trong bảng trên). Bạn có thể đặt chiều rộng của mỗi cột thành giá trị bắt buộc bằng cách sử dụng.width trước khi truy xuất nội dung của bảng như hình dưới đây -

sqlite> .width 10, 10, 4, 10, 13
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
sqlite>

Truy xuất dữ liệu bằng python

ĐỌC Hoạt động trên bất kỳ cơ sở dữ liệu nào có nghĩa là lấy một số thông tin hữu ích từ cơ sở dữ liệu. Bạn có thể tìm nạp dữ liệu từ MYSQL bằng phương thức fetch () được cung cấp bởi mô-đun python sqlite.

Lớp sqlite3.Cursor cung cấp ba phương thức cụ thể là fetchall (), fetchmany () và, fetchone () trong đó,

• Phương thức fetchall () truy xuất tất cả các hàng trong tập kết quả của một truy vấn và trả về chúng dưới dạng danh sách các bộ giá trị. (Nếu chúng ta thực hiện điều này sau khi truy xuất một vài hàng, nó sẽ trả về những hàng còn lại).

• Phương thức fetchone () tìm nạp hàng tiếp theo trong kết quả của một truy vấn và trả về nó dưới dạng một bộ giá trị.

• Phương thức fetchmany () tương tự như fetchone () nhưng, nó truy xuất tập hợp các hàng tiếp theo trong tập kết quả của một truy vấn, thay vì một hàng.

Note - Tập kết quả là một đối tượng được trả về khi một đối tượng con trỏ được sử dụng để truy vấn bảng.

Thí dụ

Ví dụ sau tìm nạp tất cả các hàng của bảng EMPLOYEE bằng cách sử dụng truy vấn SELECT và từ tập kết quả thu được ban đầu, chúng ta đang truy xuất hàng đầu tiên bằng phương thức fetchone () và sau đó tìm nạp các hàng còn lại bằng phương thức fetchall ().

Chương trình Python sau đây cho thấy cách tìm nạp và hiển thị các bản ghi từ bảng COMPANY được tạo trong ví dụ trên.

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
   ('Sharukh', 'Sheik', 25, 'M', 8300.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)
]

Nếu bạn muốn tìm nạp, xóa hoặc cập nhật các hàng cụ thể của bảng trong SQLite, bạn cần sử dụng mệnh đề where để chỉ định điều kiện để lọc các hàng của bảng cho thao tác.

Ví dụ, nếu bạn có một câu lệnh SELECT với mệnh đề where, chỉ những hàng thỏa mãn điều kiện đã chỉ định mới được truy xuất.

Cú pháp

Sau đây là cú pháp của mệnh đề WHERE trong SQLite:

SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]

Bạn có thể chỉ định điều kiện tìm kiếm bằng cách sử dụng các toán tử so sánh hoặc logic. like>, <, =, LIKE, NOT, vv Các ví dụ sau đây sẽ làm rõ khái niệm này.

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

Câu lệnh SELECT sau truy xuất các bản ghi có tuổi lớn hơn 35 -

sqlite> SELECT * FROM CRICKETERS WHERE AGE > 35;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

Mệnh đề where sử dụng python

Đối tượng / lớp con trỏ chứa tất cả các phương thức để thực thi truy vấn và tìm nạp dữ liệu, v.v ... Phương thức con trỏ của lớp kết nối trả về một đối tượng con trỏ.

Do đó, để tạo một bảng trong cơ sở dữ liệu SQLite bằng python -

• Thiết lập kết nối với cơ sở dữ liệu bằng phương thức connect ().

• Tạo đối tượng con trỏ bằng cách gọi phương thức con trỏ () trên đối tượng kết nối đã tạo ở trên.

• Bây giờ thực thi câu lệnh CREATE TABLE bằng phương thức execute () của lớp Con trỏ.

Thí dụ

Ví dụ sau tạo một bảng có tên Nhân viên và điền vào bảng đó. Sau đó, sử dụng mệnh đề where, nó truy xuất các bản ghi có giá trị tuổi nhỏ hơn 23.

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000)''')

cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Vinay', 'Battacharya', 20, 'M', 6000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sharukh', 'Sheik', 25, 'M', 8300)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sarmista', 'Sharma', 26, 'F', 10000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

[('Vinay', 'Battacharya', 20, 'M', 6000.0)]

Trong khi tìm nạp dữ liệu bằng cách sử dụng truy vấn SELECT, bạn sẽ nhận được các bản ghi theo cùng thứ tự mà bạn đã chèn chúng.

Bạn có thể sắp xếp kết quả theo thứ tự mong muốn (tăng dần hoặc giảm dần) bằng cách sử dụng Order Bymệnh đề. Theo mặc định, mệnh đề này sắp xếp các kết quả theo thứ tự tăng dần, nếu bạn cần sắp xếp chúng theo thứ tự giảm dần, bạn cần sử dụng “DESC” một cách rõ ràng.

Cú pháp

Sau đây là cú pháp của mệnh đề ORDER BY trong SQLite.

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

Câu lệnh SELECT sau truy xuất các hàng của bảng CRICKETERS theo thứ tự tăng dần của độ tuổi của chúng -

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

Bạn có thể sử dụng nhiều hơn một cột để sắp xếp các bản ghi của bảng. Các câu lệnh SELECT sau đây sắp xếp các bản ghi của bảng CRICKETERS dựa trên các cột AGE và FIRST_NAME .

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

Theo mặc định, ORDER BY mệnh đề sắp xếp các bản ghi của một bảng theo thứ tự tăng dần, bạn có thể sắp xếp các kết quả theo thứ tự giảm dần bằng cách sử dụng DESC như sau:

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE DESC;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara     Sangakkara 41   Matale     Srilanka
Jonathan   Trott      38   CapeTown   SouthAfrica
Shikhar    Dhawan     33   Delhi      India
Rohit      Sharma     32   Nagpur     India
Virat      Kohli      30   Delhi      India
sqlite>

Mệnh đề ORDER BY sử dụng python

Để truy xuất nội dung của một bảng theo thứ tự cụ thể, hãy gọi phương thức execute () trên đối tượng con trỏ và chuyển câu lệnh SELECT cùng với mệnh đề ORDER BY, làm tham số cho nó.

Thí dụ

Trong ví dụ sau, chúng ta đang tạo một bảng có tên và Nhân viên, điền nó vào và lấy lại các bản ghi của nó theo thứ tự (tăng dần) tuổi của chúng, sử dụng mệnh đề ORDER BY.

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT, SEX CHAR(1),
   INCOME INT,
   CONTACT INT
)'''
cursor.execute(sql)

#Populating the table
#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000), 
   ('Sharukh', 'Sheik', 25, 'M', 8300), 
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

[('Vinay', 'Battacharya', 20, 'M', 6000, None),
   ('Tripthi', 'Mishra', 24, 'F', 6000, None),
   ('Sharukh', 'Sheik', 25, 'M', 8300, None),
   ('Sarmista', 'Sharma', 26, 'F', 10000, None),
   ('Ramya', 'Rama priya', 27, 'F', 9000, None)]

CẬP NHẬT Hoạt động trên bất kỳ cơ sở dữ liệu nào ngụ ý sửa đổi các giá trị của một hoặc nhiều bản ghi của bảng, các bản ghi này đã có sẵn trong cơ sở dữ liệu. Bạn có thể cập nhật giá trị của các bản ghi hiện có trong SQLite bằng cách sử dụng câu lệnh UPDATE.

Để cập nhật các hàng cụ thể, bạn cần sử dụng mệnh đề WHERE cùng với nó.

Cú pháp

Sau đây là cú pháp của câu lệnh UPDATE trong SQLite:

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

Câu lệnh sau sửa đổi tuổi của người chơi cricket, có tên đầu tiên là Shikhar -

sqlite> UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
sqlite>

Nếu bạn truy xuất bản ghi có FIRST_NAME là Shikhar, bạn thấy rằng giá trị tuổi đã được thay đổi thành 45 -

sqlite> SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
First_Name Last_Name  Age Place_Of_B  Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     45   Delhi      India
sqlite>

Nếu bạn chưa sử dụng, các giá trị mệnh đề WHERE của tất cả các bản ghi sẽ được cập nhật. Sau câu lệnh UPDATE tăng tuổi của tất cả các bản ghi trong bảng CRICKETERS lên 1 -

sqlite> UPDATE CRICKETERS SET AGE = AGE+1;
sqlite>

Nếu bạn truy xuất nội dung của bảng bằng lệnh SELECT, bạn có thể thấy các giá trị được cập nhật dưới dạng:

sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     46   Delhi      India
Jonathan   Trott      39   CapeTown   SouthAfrica
Kumara     Sangakkara 42   Matale     Srilanka
Virat      Kohli      31   Delhi      India
Rohit      Sharma     33   Nagpur     India
sqlite>

Cập nhật bản ghi hiện có bằng python

Để thêm bản ghi vào bảng hiện có trong cơ sở dữ liệu SQLite -

• Nhập gói sqlite3.

• Tạo một đối tượng kết nối bằng phương thức connect () bằng cách chuyển tên của cơ sở dữ liệu làm tham số cho nó.

• Các cursor()phương thức trả về một đối tượng con trỏ sử dụng mà bạn có thể giao tiếp với SQLite3. Tạo một đối tượng con trỏ bằng cách gọi đối tượng con trỏ () trên đối tượng Kết nối (đã tạo ở trên).

• Sau đó, gọi phương thức execute () trên đối tượng con trỏ, bằng cách chuyển một câu lệnh UPDATE làm tham số cho nó.

Thí dụ

Theo ví dụ Python, tạo một bảng với tên EMPLOYEE, chèn 5 bản ghi vào đó và tăng tuổi của tất cả nhân viên nam lên 1 -

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Inserting data
cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000), 
   ('Sharukh', 'Sheik', 25, 'M', 8300), 
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

#Fetching all the rows before the update
print("Contents of the Employee table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Updating the records
sql = '''UPDATE EMPLOYEE SET AGE=AGE+1 WHERE SEX = 'M' '''
cursor.execute(sql)
print("Table updated...... ")

#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Để xóa bản ghi khỏi bảng SQLite, bạn cần sử dụng câu lệnh DELETE FROM. Để xóa các bản ghi cụ thể, bạn cần sử dụng mệnh đề WHERE cùng với nó.

Để cập nhật các hàng cụ thể, bạn cần sử dụng mệnh đề WHERE cùng với nó.

Cú pháp

Sau đây là cú pháp của truy vấn DELETE trong SQLite:

DELETE FROM table_name [WHERE Clause]

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

Tuyên bố sau đây xóa kỷ lục của vận động viên cricket có họ là 'Sangakkara'.

sqlite> DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
sqlite>

Nếu bạn truy xuất nội dung của bảng bằng cách sử dụng câu lệnh SELECT, bạn chỉ có thể thấy 4 bản ghi vì chúng tôi đã xóa một bản ghi.

sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     46   Delhi      India
Jonathan   Trott      39   CapeTown   SouthAfrica
Virat      Kohli      31   Delhi      India
Rohit      Sharma     33   Nagpur     India
sqlite>

Nếu bạn thực hiện câu lệnh DELETE FROM mà không có mệnh đề WHERE, tất cả các bản ghi từ bảng được chỉ định sẽ bị xóa.

sqlite> DELETE FROM CRICKETERS;
sqlite>

Vì bạn đã xóa tất cả các bản ghi, nếu bạn cố gắng truy xuất nội dung của bảng CRICKETERS, bằng cách sử dụng câu lệnh SELECT, bạn sẽ nhận được một tập hợp kết quả trống như hình dưới đây:

sqlite> SELECT * FROM CRICKETERS;
sqlite>

Xóa dữ liệu bằng python

Để thêm bản ghi vào bảng hiện có trong cơ sở dữ liệu SQLite -

• Nhập gói sqlite3.

• Tạo một đối tượng kết nối bằng phương thức connect () bằng cách chuyển tên của cơ sở dữ liệu làm tham số cho nó.

• Các cursor()phương thức trả về một đối tượng con trỏ sử dụng mà bạn có thể giao tiếp với SQLite3. Tạo một đối tượng con trỏ bằng cách gọi đối tượng con trỏ () trên đối tượng Kết nối (đã tạo ở trên).

• Sau đó, gọi phương thức execute () trên đối tượng con trỏ, bằng cách chuyển câu lệnh DELETE làm tham số cho nó.

Thí dụ

Ví dụ về python sau sẽ xóa các bản ghi khỏi bảng EMPLOYEE có giá trị tuổi lớn hơn 25.

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')

#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Contents of the table after delete operation
[('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Bạn có thể xóa toàn bộ bảng bằng câu lệnh DROP TABLE. Bạn chỉ cần xác định tên bảng mà bạn cần xóa.

Cú pháp

Sau đây là cú pháp của câu lệnh DROP TABLE trong PostgreSQL:

DROP TABLE table_name;

Thí dụ

Giả sử chúng ta đã tạo hai bảng có tên CRICKETERS và EMPLOYEES bằng các truy vấn sau:

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
sqlite> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT, 
   SEX CHAR(1), INCOME FLOAT
);
sqlite>

Bây giờ nếu bạn xác minh danh sách các bảng bằng cách sử dụng .tables , bạn có thể thấy các bảng đã tạo ở trên trong đó (danh sách) dưới dạng:

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

Câu lệnh sau xóa bảng có tên Nhân viên khỏi cơ sở dữ liệu -

sqlite> DROP table employee;
sqlite>

Vì bạn đã xóa bảng Nhân viên, nếu bạn truy xuất lại danh sách các bảng, bạn chỉ có thể quan sát một bảng trong đó.

sqlite> .tables
CRICKETERS
sqlite>

Nếu bạn cố gắng xóa bảng Nhân viên một lần nữa, vì bạn đã xóa nó, bạn sẽ gặp lỗi nói "không có bảng như vậy" như hình dưới đây -

sqlite> DROP table employee;
Error: no such table: employee
sqlite>

Để giải quyết vấn đề này, bạn có thể sử dụng mệnh đề IF EXISTS cùng với câu lệnh DELTE. Thao tác này sẽ xóa bảng nếu nó tồn tại, nếu không thì sẽ bỏ qua thao tác DLETE.

sqlite> DROP table IF EXISTS employee;
sqlite>

Bỏ bảng bằng Python

Bạn có thể bỏ một bảng bất cứ khi nào bạn cần, bằng cách sử dụng câu lệnh DROP của MYSQL, nhưng bạn cần phải rất cẩn thận khi xóa bất kỳ bảng nào hiện có vì dữ liệu bị mất sẽ không được phục hồi sau khi xóa một bảng.

Thí dụ

Để thả một bảng từ cơ sở dữ liệu SQLite3 bằng cách sử dụng python, hãy gọi execute() trên đối tượng con trỏ và chuyển câu lệnh drop làm tham số cho nó.

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

Table dropped...

Trong khi tìm nạp các bản ghi nếu bạn muốn giới hạn chúng bằng một số cụ thể, bạn có thể làm như vậy bằng cách sử dụng mệnh đề LIMIT của SQLite.

Cú pháp

Sau đây là cú pháp của mệnh đề LIMIT trong SQLite:

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Và nếu chúng ta đã chèn 5 bản ghi vào nó bằng cách sử dụng câu lệnh INSERT như -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

Câu lệnh sau truy xuất 3 bản ghi đầu tiên của bảng Cricketers bằng cách sử dụng mệnh đề LIMIT -

sqlite> SELECT * FROM CRICKETERS LIMIT 3;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

Nếu bạn cần giới hạn các bản ghi bắt đầu từ bản ghi thứ n (không phải bản ghi đầu tiên), bạn có thể làm như vậy, sử dụng OFFSET cùng với LIMIT.

sqlite> SELECT * FROM CRICKETERS LIMIT 3 OFFSET 2;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara     Sangakkara 41   Matale     Srilanka
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
sqlite>

Mệnh đề LIMIT sử dụng Python

Nếu bạn gọi phương thức execute () trên đối tượng con trỏ bằng cách chuyển truy vấn SELECT cùng với mệnh đề LIMIT, bạn có thể truy xuất số lượng bản ghi cần thiết.

Thí dụ

Ví dụ python sau truy xuất hai bản ghi đầu tiên của bảng EMPLOYEE bằng cách sử dụng mệnh đề LIMIT.

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 3'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0)]

Khi bạn đã chia dữ liệu trong hai bảng, bạn có thể tìm nạp các bản ghi kết hợp từ hai bảng này bằng cách sử dụng Kết hợp.

Thí dụ

Giả sử chúng ta đã tạo một bảng có tên CRICKETERS bằng truy vấn sau:

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Hãy để chúng tôi tạo thêm một bảng OdiStats mô tả thống kê cricket trong một ngày của mỗi người chơi trong bảng CRICKETERS.

sqlite> CREATE TABLE ODIStats (
   First_Name VARCHAR(255),
   Matches INT,
   Runs INT,
   AVG FLOAT,
   Centuries INT,
   HalfCenturies INT
);
sqlite>

Câu lệnh sau truy xuất dữ liệu kết hợp các giá trị trong hai bảng này:

sqlite> SELECT
   Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
   OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
   from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
First_Name Last_Name    Country  Matches    Runs          Centuries  HalfCenturies
---------- ----------   -------  ---------- ------------- ---------- ----------
Shikhar    Dhawan       Indi     133        5518          17         27
Jonathan   Trott        Sout     68         2819          4          22
Kumara     Sangakkara   Sril     404        14234         25         93
Virat      Kohli        Indi     239        11520         43         54
Rohit      Sharma       Indi     218        8686          24         42
sqlite>

Tham gia mệnh đề bằng python

Sau ví dụ SQLite, minh họa mệnh đề JOIN bằng python -

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Đầu ra

[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, '[email protected]', 'Hyderabad'), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102,'[email protected]', 'Vishakhapatnam'), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected]', 'Pune'), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]

Lớp sqlite3.Cursor là một thể hiện mà bạn có thể gọi các phương thức thực thi câu lệnh SQLite, tìm nạp dữ liệu từ các tập kết quả của các truy vấn. Bạn có thể tạoCursor sử dụng phương thức con trỏ () của đối tượng / lớp Connection.

Thí dụ

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

Phương pháp

Sau đây là các phương thức khác nhau được cung cấp bởi lớp / đối tượng Cursor.

Sr.No	Phương pháp & Mô tả
1	execute() Quy trình này thực thi một câu lệnh SQL. Câu lệnh SQL có thể được tham số hóa (tức là trình giữ chỗ thay vì các ký tự SQL). Mô-đun psycopg2 hỗ trợ trình giữ chỗ sử dụng ký hiệu% s Ví dụ: cursor.execute ("chèn vào người các giá trị (% s,% s)", (ai, tuổi))
2	executemany() Quy trình này thực thi một lệnh SQL chống lại tất cả các chuỗi tham số hoặc ánh xạ được tìm thấy trong chuỗi sql.
3	fetchone() Phương thức này tìm nạp hàng tiếp theo của tập hợp kết quả truy vấn, trả về một chuỗi duy nhất hoặc Không có khi không có thêm dữ liệu.
4	fetchmany() Quy trình này tìm nạp tập hợp các hàng tiếp theo của kết quả truy vấn, trả về một danh sách. Một danh sách trống được trả về khi không còn hàng nào nữa. Phương thức cố gắng tìm nạp nhiều hàng như được chỉ ra bởi tham số kích thước.
5	fetchall() Quy trình này tìm nạp tất cả (còn lại) các hàng của kết quả truy vấn, trả về một danh sách. Một danh sách trống được trả về khi không có hàng nào.

Tính chất

Sau đây là các thuộc tính của lớp Cursor:

Sr.No	Phương pháp & Mô tả
1	arraySize Đây là một thuộc tính đọc / ghi mà bạn có thể đặt số hàng được trả về bởi phương thức fetchmany ().
2	description Đây là thuộc tính chỉ đọc trả về danh sách chứa mô tả các cột trong tập kết quả.
3	lastrowid Đây là thuộc tính chỉ đọc, nếu có bất kỳ cột nào được tăng tự động trong bảng, thì nó sẽ trả về giá trị được tạo cho cột đó trong thao tác INSERT hoặc UPDATE cuối cùng.
4	rowcount Điều này trả về số hàng được trả về / cập nhật trong trường hợp hoạt động CHỌN và CẬP NHẬT.
5	connection Thuộc tính chỉ đọc này cung cấp Kết nối cơ sở dữ liệu SQLite được sử dụng bởi đối tượng Con trỏ.

Pymongo là một bản phân phối python cung cấp các công cụ để làm việc với MongoDB, đây là cách được ưu tiên nhất để giao tiếp với cơ sở dữ liệu MongoDB từ python.

Cài đặt

Để cài đặt pymongo, trước hết hãy đảm bảo rằng bạn đã cài đặt python3 (cùng với PIP) và MongoDB đúng cách. Sau đó thực hiện lệnh sau.

C:\WINDOWS\system32>pip install pymongo
Collecting pymongo
Using cached https://files.pythonhosted.org/packages/cb/a6/b0ae3781b0ad75825e00e29dc5489b53512625e02328d73556e1ecdf12f8/pymongo-3.9.0-cp37-cp37m-win32.whl
Installing collected packages: pymongo
Successfully installed pymongo-3.9.0

xác minh

Khi bạn đã cài đặt xong pymongo, hãy mở một tài liệu văn bản mới, dán dòng sau vào đó và lưu nó dưới dạng test.py.

import pymongo

Nếu bạn đã cài đặt pymongo đúng cách, nếu bạn thực thi test.py như hình dưới đây, bạn sẽ không gặp bất kỳ sự cố nào.

D:\Python_MongoDB>test.py
D:\Python_MongoDB>

Không giống như các cơ sở dữ liệu khác, MongoDB không cung cấp lệnh riêng biệt để tạo cơ sở dữ liệu.

Nói chung, lệnh sử dụng được sử dụng để chọn / chuyển sang cơ sở dữ liệu cụ thể. Lệnh này ban đầu xác minh xem cơ sở dữ liệu chúng tôi chỉ định có tồn tại hay không, nếu có, nó sẽ kết nối với nó. Nếu cơ sở dữ liệu, chúng tôi chỉ định bằng lệnh sử dụng không tồn tại, một cơ sở dữ liệu mới sẽ được tạo.

Do đó, bạn có thể tạo cơ sở dữ liệu trong MongoDB bằng cách sử dụng Use chỉ huy.

Cú pháp

Cú pháp cơ bản của use DATABASE tuyên bố như sau:

use DATABASE_NAME

Thí dụ

Lệnh sau tạo một cơ sở dữ liệu có tên trong mydb.

>use mydb
switched to db mydb

Bạn có thể xác minh sáng tạo của mình bằng cách sử dụng lệnh db, lệnh này sẽ hiển thị cơ sở dữ liệu hiện tại.

>db
mydb

Tạo cơ sở dữ liệu bằng python

Để kết nối với MongoDB bằng pymongo, bạn cần nhập và tạo MongoClient, sau đó bạn có thể truy cập trực tiếp vào cơ sở dữ liệu bạn cần tạo trong thuộc tính đam mê.

Thí dụ

Ví dụ sau tạo một cơ sở dữ liệu trong MangoDB.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

#Verification
print("List of databases after creating new one")
print(client.list_database_names())

Đầu ra

Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']

Bạn cũng có thể chỉ định cổng và tên máy chủ trong khi tạo MongoClient và có thể truy cập cơ sở dữ liệu theo kiểu từ điển.

Thí dụ

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

Đầu ra

Database created........

Một bộ sưu tập trong MongoDB chứa một bộ tài liệu, nó tương tự như một bảng trong cơ sở dữ liệu quan hệ.

Bạn có thể tạo một bộ sưu tập bằng cách sử dụng createCollection()phương pháp. Phương thức này chấp nhận một giá trị Chuỗi đại diện cho tên của tập hợp sẽ được tạo và một tham số tùy chọn (tùy chọn).

Sử dụng điều này, bạn có thể chỉ định những điều sau:

• Kích thước của bộ sưu tập.
• Số lượng tài liệu tối đa được phép trong bộ sưu tập có giới hạn.
• Liệu bộ sưu tập chúng tôi tạo có phải là bộ sưu tập giới hạn (bộ sưu tập có kích thước cố định) hay không.
• Liệu bộ sưu tập chúng tôi tạo có được tự động lập chỉ mục hay không.

Cú pháp

Sau đây là cú pháp để tạo một bộ sưu tập trong MongoDB.

db.createCollection("CollectionName")

Thí dụ

Phương thức sau tạo một bộ sưu tập có tên là ExampleCollection.

> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>

Tương tự, sau đây là một truy vấn tạo một bộ sưu tập bằng cách sử dụng các tùy chọn của phương thức createCollection ().

>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>

Tạo bộ sưu tập bằng python

Ví dụ về python sau kết nối với cơ sở dữ liệu trong MongoDB (mydb) và tạo một bộ sưu tập trong đó.

Thí dụ

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
collection = db['example']
print("Collection created........")

Đầu ra

Collection created........

Bạn có thể lưu trữ tài liệu vào MongoDB bằng phương thức insert () . Phương thức này chấp nhận một tài liệu JSON làm tham số.

Cú pháp

Sau đây là cú pháp của phương thức chèn.

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

Thí dụ

> use mydb
switched to db mydb
> db.createCollection("sample")
{ "ok" : 1 }
> doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
{ "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
> db.sample.insert(doc1)
WriteResult({ "nInserted" : 1 })
>

Tương tự, bạn cũng có thể chèn nhiều tài liệu bằng cách sử dụng insert() phương pháp.

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = 
[
   {
      "_id": "1001", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   }, 
   {
      "_id": "1002", 
      "name" : "Rahim", 
      "age" : 27, 
      "city" : "Bangalore" 
   }, 
   {
      "_id": "1003", 
      "name" : "Robert", 
      "age" : 28, 
      "city" : "Mumbai" 
   }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.sample.insert(data)
BulkWriteResult
({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 3,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})
>

Tạo bộ sưu tập bằng python

Pymongo cung cấp một phương thức có tên insert_one () để chèn tài liệu vào MangoDB. Đối với phương pháp này, chúng ta cần chuyển tài liệu ở định dạng từ điển.

Thí dụ

Ví dụ sau sẽ chèn một tài liệu trong ví dụ có tên bộ sưu tập.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
coll.insert_one(doc1)
print(coll.find_one())

Đầu ra

{
   '_id': ObjectId('5d63ad6ce043e2a93885858b'), 
   'name': 'Ram', 
   'age': '26', 
   'city': 'Hyderabad'
}

Để chèn nhiều tài liệu vào MongoDB bằng pymongo, bạn cần gọi phương thức insert_many ().

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = 
[
   {
      "_id": "101", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   },
   {
      "_id": "102", 
      "name": "Rahim", 
      "age": "27", 
      "city": "Bangalore"
   },
   {
      "_id": "103", 
      "name": "Robert", 
      "age": "28", 
      "city": "Mumbai"
   }
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

Đầu ra

Data inserted ......
['101', '102', '103']

Bạn có thể đọc / truy xuất các tài liệu đã lưu trữ từ MongoDB bằng cách sử dụng find()phương pháp. Phương thức này truy xuất và hiển thị tất cả các tài liệu trong MongoDB theo cách không có cấu trúc.

Cú pháp

Sau đây là cú pháp của find() phương pháp.

>db.CollectionName.find()

Thí dụ

Giả sử chúng ta đã chèn 3 tài liệu vào cơ sở dữ liệu có tên testDB trong một bộ sưu tập có tên mẫu bằng cách sử dụng các truy vấn sau:

> use testDB
> db.createCollection("sample")
> data = [
   {"_id": "1001", "name" : "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
> db.sample.insert(data)

Bạn có thể truy xuất các tài liệu đã chèn bằng phương thức find () như sau:

> use testDB
switched to db testDB
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
>

Bạn cũng có thể truy xuất tài liệu đầu tiên trong bộ sưu tập bằng phương thức findOne () dưới dạng:

> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

Truy xuất dữ liệu (tìm) bằng python

Các find_One() phương thức pymongo được sử dụng để truy xuất một tài liệu dựa trên truy vấn của bạn, trong trường hợp không khớp, phương thức này không trả về kết quả nào và nếu bạn không sử dụng bất kỳ truy vấn nào, nó sẽ trả về tài liệu đầu tiên của bộ sưu tập.

Phương pháp này hữu ích bất cứ khi nào bạn chỉ cần truy xuất một tài liệu của một kết quả hoặc nếu bạn chắc chắn rằng truy vấn của mình chỉ trả về một tài liệu.

Thí dụ

Sau ví dụ python truy xuất tài liệu đầu tiên của một bộ sưu tập -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydatabase']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

#Retrieving the first record using the find_one() method
print("First record of the collection: ")
print(coll.find_one())

#Retrieving a record with is 103 using the find_one() method
print("Record whose id is 103: ")
print(coll.find_one({"_id": "103"}))

Đầu ra

Data inserted ......
['101', '102', '103']
First record of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
Record whose id is 103:
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Để nhận nhiều tài liệu trong một truy vấn (phương pháp tìm od gọi duy nhất), bạn có thể sử dụng find()phương pháp pymongo. Nếu chưa vượt qua bất kỳ truy vấn nào, nó sẽ trả về tất cả các tài liệu của một bộ sưu tập và nếu bạn đã chuyển một truy vấn đến phương thức này, nó sẽ trả về tất cả các tài liệu phù hợp.

Thí dụ

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Records of the collection: ")
for doc1 in coll.find():
print(doc1)

#Retrieving records with age greater than 26 using the find() method
print("Record whose age is more than 26: ")
for doc2 in coll.find({"age":{"$gt":"26"}}):
print(doc2)

Đầu ra

Data inserted ......
Records of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Record whose age is more than 26:
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Trong khi truy xuất bằng cách sử dụng find(), bạn có thể lọc tài liệu bằng đối tượng truy vấn. Bạn có thể chuyển truy vấn chỉ định điều kiện cho các tài liệu bắt buộc dưới dạng tham số cho phương thức này.

Các nhà khai thác

Sau đây là danh sách các toán tử được sử dụng trong các truy vấn trong MongoDB.

Hoạt động	Cú pháp	Thí dụ
Bình đẳng	{"giá trị cốt lõi"}	db.mycol.find ({"theo": "điểm hướng dẫn"})
Ít hơn	{"key": {$ lt: "value"}}	db.mycol.find ({"lượt thích": {$ lt: 50}})
Nhỏ hơn bằng	{"key": {$ lte: "value"}}	db.mycol.find ({"thích": {$ lte: 50}})
Lớn hơn	{"key": {$ gt: "value"}}	db.mycol.find ({"lượt thích": {$ gt: 50}})
Lớn hơn bằng	{"key" {$ gte: "value"}}	db.mycol.find ({"thích": {$ gte: 50}})
Không bằng	{"key": {$ ne: "value"}}	db.mycol.find ({"thích": {$ ne: 50}})

Ví dụ 1

Ví dụ sau lấy tài liệu trong một tập hợp có tên là sarmista.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sdsegf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc1 in coll.find({"name":"Sarmista"}):
   print(doc1)

Đầu ra

Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}

Ví dụ2

Ví dụ sau lấy tài liệu trong một bộ sưu tập có giá trị tuổi lớn hơn 26.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['ghhj']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc in coll.find({"age":{"$gt":"26"}}):
   print(doc)

Đầu ra

Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Trong khi truy xuất nội dung của một bộ sưu tập, bạn có thể sắp xếp và sắp xếp chúng theo thứ tự tăng dần hoặc giảm dần bằng cách sử dụng sort() phương pháp.

Đối với phương pháp này, bạn có thể chuyển (các) trường và thứ tự sắp xếp là 1 hoặc -1. Trong đó, 1 là thứ tự tăng dần và -1 là thứ tự giảm dần.

Cú pháp

Sau đây là cú pháp của phương thức sort () .

>db.COLLECTION_NAME.find().sort({KEY:1})

Thí dụ

Giả sử chúng tôi đã tạo một bộ sưu tập và chèn 5 tài liệu vào nó như hình dưới đây -

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Dòng sau lấy tất cả các tài liệu của bộ sưu tập được sắp xếp theo thứ tự tăng dần dựa trên độ tuổi.

> db.sample.find().sort({age:1})
{ "_id" : "1005", "name" : "Sarmista", "age" : 23, "city" : "Delhi" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

Sắp xếp tài liệu bằng python

Để sắp xếp kết quả của một truy vấn theo thứ tự tăng dần hoặc giảm dần pymongo cung cấp sort()phương pháp. Đối với phương pháp này, hãy chuyển một giá trị số đại diện cho số lượng tài liệu bạn cần trong kết quả.

Theo mặc định, phương pháp này sắp xếp các tài liệu theo thứ tự tăng dần dựa trên trường được chỉ định. Nếu bạn cần sắp xếp theo thứ tự giảm dần, hãy chuyển -1 cùng với tên trường -

coll.find().sort("age",-1)

Thí dụ

Ví dụ sau truy xuất tất cả các tài liệu của một bộ sưu tập được sắp xếp theo các giá trị tuổi theo thứ tự tăng dần -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['b_mydb']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("List of documents (sorted in ascending order based on age): ")

for doc1 in coll.find().sort("age"):
   print(doc1)

Đầu ra

Data inserted ......
List of documents (sorted in ascending order based on age):
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1006', 'name': 'Rasajna', 'age': 26, 'city': 'Chennai'}
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Bạn có thể xóa tài liệu trong bộ sưu tập bằng cách sử dụng remove()phương thức của MongoDB. Phương thức này chấp nhận hai tham số tùy chọn -

• tiêu chí xóa xác định điều kiện để xóa tài liệu.

• chỉ một, nếu bạn chuyển true hoặc 1 làm tham số thứ hai, thì chỉ một tài liệu sẽ bị xóa.

Cú pháp

Sau đây là cú pháp của phương thức remove ():

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

Thí dụ

Giả sử chúng tôi đã tạo một bộ sưu tập và chèn 5 tài liệu vào nó như hình dưới đây -

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Truy vấn sau sẽ xóa (các) tài liệu của bộ sưu tập có giá trị tên là Sarmista.

> db.sample.remove({"name": "Sarmista"})
WriteResult({ "nRemoved" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }

Nếu bạn gọi remove() mà không vượt qua tiêu chí xóa, tất cả các tài liệu trong bộ sưu tập sẽ bị xóa.

> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()

Xóa tài liệu bằng python

Để xóa tài liệu khỏi bộ sưu tập MangoDB, bạn có thể xóa tài liệu khỏi bộ sưu tập bằng các phương pháp delete_one() và delete_many() các phương pháp.

Các phương thức này chấp nhận một đối tượng truy vấn xác định điều kiện để xóa tài liệu.

Phương thức detele_one () xóa một tài liệu duy nhất, trong trường hợp trùng khớp. Nếu không có truy vấn nào được chỉ định, phương pháp này sẽ xóa tài liệu đầu tiên trong bộ sưu tập.

Thí dụ

Ví dụ python sau sẽ xóa tài liệu trong bộ sưu tập có giá trị id là 1006.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['lpaksgf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting one document
coll.delete_one({"_id" : "1006"})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Đầu ra

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}

Tương tự, delete_many() Phương pháp pymongo xóa tất cả các tài liệu thỏa mãn điều kiện đã chỉ định.

Thí dụ

Ví dụ sau sẽ xóa tất cả các tài liệu trong bộ sưu tập có giá trị tuổi lớn hơn 26 -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sampleDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting multiple documents
coll.delete_many({"age":{"$gt":"26"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Đầu ra

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1004', 'name': 'Romeo', 'age': '25', 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
{'_id': '1006', 'name': 'Rasajna', 'age': '26', 'city': 'Chennai'}

Nếu bạn gọi phương thức delete_many () mà không chuyển bất kỳ truy vấn nào, phương thức này sẽ xóa tất cả các tài liệu trong bộ sưu tập.

coll.delete_many({})

Bạn có thể xóa bộ sưu tập bằng cách sử dụng drop() phương thức của MongoDB.

Cú pháp

Sau đây là cú pháp của phương thức drop ():

db.COLLECTION_NAME.drop()

Thí dụ

Ví dụ sau bộ sưu tập giọt với tên mẫu -

> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myColl

Bỏ bộ sưu tập bằng python

Bạn có thể xóa / xóa một bộ sưu tập khỏi cơ sở dữ liệu hiện tại bằng cách gọi phương thức drop ().

Thí dụ

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['example2']

#Creating a collection
col1 = db['collection']
col1.insert_one({"name": "Ram", "age": "26", "city": "Hyderabad"})
col2 = db['coll']
col2.insert_one({"name": "Rahim", "age": "27", "city": "Bangalore"})
col3 = db['myColl']
col3.insert_one({"name": "Robert", "age": "28", "city": "Mumbai"})
col4 = db['data']
col4.insert_one({"name": "Romeo", "age": "25", "city": "Pune"})

#List of collections
print("List of collections:")
collections = db.list_collection_names()
for coll in collections:
print(coll)

#Dropping a collection
col1.drop()
col4.drop()
print("List of collections after dropping two of them: ")

#List of collections
collections = db.list_collection_names()

for coll in collections:
   print(coll)

Đầu ra

List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myColl

Bạn có thể cập nhật nội dung của tài liệu hiện có bằng cách sử dụng update() phương pháp hoặc save() phương pháp.

Phương thức cập nhật sửa đổi tài liệu hiện có trong khi phương thức lưu thay thế tài liệu hiện có bằng tài liệu mới.

Cú pháp

Sau đây là cú pháp của phương thức update () và save () của MangoDB:

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

Thí dụ

Giả sử chúng ta đã tạo một bộ sưu tập trong cơ sở dữ liệu và chèn 3 bản ghi vào đó như hình dưới đây -

> use testdatabase
switched to db testdatabase
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   ... {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.createCollection("sample")
{ "ok" : 1 }
> db.sample.insert(data)

Phương thức sau cập nhật giá trị thành phố của tài liệu với id 1002.

> db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Tương tự, bạn có thể thay thế tài liệu bằng dữ liệu mới bằng cách lưu nó với cùng một id bằng phương thức save ().

> db.sample.save(
   { "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Cập nhật tài liệu bằng python

Tương tự như phương thức find_one () truy xuất một tài liệu, phương thức update_one () của pymongo cập nhật một tài liệu.

Phương thức này chấp nhận một truy vấn chỉ định tài liệu nào cần cập nhật và thao tác cập nhật.

Thí dụ

Ví dụ về python sau cập nhật giá trị vị trí của tài liệu trong bộ sưu tập.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_one({"_id":"102"},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Đầu ra

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Tương tự, update_many() method of pymongo cập nhật tất cả các tài liệu thỏa mãn điều kiện quy định.

Thí dụ

Ví dụ sau cập nhật giá trị vị trí trong tất cả các tài liệu trong bộ sưu tập (điều kiện trống) -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_many({},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Đầu ra

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Visakhapatnam'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Visakhapatnam'}

Trong khi truy xuất nội dung của một tập hợp, bạn có thể giới hạn số lượng tài liệu trong kết quả bằng cách sử dụng phương thức limit (). Phương thức này chấp nhận một giá trị số đại diện cho số lượng tài liệu bạn muốn trong kết quả.

Cú pháp

Sau đây là cú pháp của phương thức limit ():

>db.COLLECTION_NAME.find().limit(NUMBER)

Thí dụ

Giả sử chúng tôi đã tạo một bộ sưu tập và chèn 5 tài liệu vào nó như hình dưới đây -

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Dòng sau lấy 3 tài liệu đầu tiên của bộ sưu tập.

> db.sample.find().limit(3)
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Giới hạn tài liệu bằng python

Để hạn chế kết quả của một truy vấn đối với một số tài liệu cụ thể, pymongo cung cấp limit()phương pháp. Đối với phương pháp này, hãy chuyển một giá trị số đại diện cho số lượng tài liệu bạn cần trong kết quả.

Thí dụ

Ví dụ sau lấy ba tài liệu đầu tiên trong một bộ sưu tập.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['l']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("First 3 documents in the collection: ")

for doc1 in coll.find().limit(3):
   print(doc1)

Đầu ra

Data inserted ......
First 3 documents in the collection:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}