การเข้าถึงข้อมูล Python - คู่มือฉบับย่อ

มาตรฐาน Python สำหรับอินเทอร์เฟซฐานข้อมูลคือ Python DB-API อินเทอร์เฟซฐานข้อมูล Python ส่วนใหญ่เป็นไปตามมาตรฐานนี้

คุณสามารถเลือกฐานข้อมูลที่เหมาะสมสำหรับแอปพลิเคชันของคุณ Python Database API รองรับเซิร์ฟเวอร์ฐานข้อมูลที่หลากหลายเช่น -

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

นี่คือรายการสินค้าจากอินเตอร์เฟซฐานข้อมูลหลาม: งูหลามการเชื่อมต่อฐานข้อมูลและ API คุณต้องดาวน์โหลดโมดูล DB API แยกต่างหากสำหรับแต่ละฐานข้อมูลที่คุณต้องการเข้าถึง ตัวอย่างเช่นหากคุณต้องการเข้าถึงฐานข้อมูล Oracle และฐานข้อมูล MySQL คุณต้องดาวน์โหลดทั้งโมดูลฐานข้อมูล Oracle และ MySQL

mysql-connector-python คืออะไร?

MySQL Python / Connector เป็นอินเทอร์เฟซสำหรับเชื่อมต่อกับเซิร์ฟเวอร์ฐานข้อมูล MySQL จาก Python ใช้ Python Database API และสร้างขึ้นบน MySQL

ฉันจะติดตั้ง mysql-connector-python ได้อย่างไร

ก่อนอื่นคุณต้องแน่ใจว่าคุณได้ติดตั้ง python ในเครื่องของคุณแล้ว โดยเปิด command prompt แล้วพิมพ์ python จากนั้นกด Enter หากมีการติดตั้ง python ในระบบของคุณแล้วคำสั่งนี้จะแสดงเวอร์ชันดังที่แสดงด้านล่าง -

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.
>>>

ตอนนี้กดctrl + zแล้วกด Enter เพื่อออกจากไพ ธ อนเชลล์และสร้างโฟลเดอร์ (ซึ่งคุณตั้งใจจะติดตั้งตัวเชื่อมต่อ Python-MySQL) ชื่อ Python_MySQL เป็น -

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

ตรวจสอบ PIP

PIP เป็นตัวจัดการแพ็คเกจใน python ซึ่งคุณสามารถติดตั้งโมดูล / แพ็คเกจต่างๆใน Python ดังนั้นในการติดตั้ง Mysql-python mysql-connector-python คุณต้องตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง PIP ไว้ในคอมพิวเตอร์ของคุณและมีการเพิ่มตำแหน่งลงในพา ธ

คุณสามารถทำได้โดยดำเนินการคำสั่ง pip หากคุณไม่มี PIP ในระบบของคุณหรือหากคุณยังไม่ได้เพิ่มตำแหน่งในไฟล์Path ตัวแปรสภาพแวดล้อมคุณจะได้รับข้อความแสดงข้อผิดพลาดเป็น -

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

ในการติดตั้ง PIP ให้ดาวน์โหลดget-pip.pyไปยังโฟลเดอร์ที่สร้างไว้ด้านบนและจากคำสั่งนำทางและติดตั้ง pip ดังนี้ -

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

การติดตั้ง mysql-connector-python

เมื่อคุณติดตั้ง Python และ PIP แล้วให้เปิด command prompt และอัพเกรด pip (ทางเลือก) ดังที่แสดงด้านล่าง -

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

จากนั้นเปิดพร้อมรับคำสั่งในโหมดผู้ดูแลระบบและติดตั้ง python MySQL เชื่อมต่อเป็น -

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

การยืนยัน

เพื่อตรวจสอบการติดตั้งสคริปต์สร้าง python ตัวอย่างโดยมีบรรทัดต่อไปนี้อยู่ในนั้น

import mysql.connector

หากการติดตั้งสำเร็จเมื่อคุณดำเนินการคุณจะไม่ได้รับข้อผิดพลาดใด ๆ -

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

การติดตั้ง python ตั้งแต่เริ่มต้น

หากคุณต้องการติดตั้ง Python ตั้งแต่เริ่มต้น เยี่ยมชมหลามหน้าแรก

คลิกที่ Downloads คุณจะถูกเปลี่ยนเส้นทางไปยังหน้าดาวน์โหลดซึ่งมีลิงก์สำหรับ python เวอร์ชันล่าสุดสำหรับแพลตฟอร์มต่างๆให้เลือกและดาวน์โหลด

ตัวอย่างเช่นเราได้ดาวน์โหลด python-3.7.4.exe (สำหรับ Windows) เริ่มกระบวนการติดตั้งโดยดับเบิลคลิกไฟล์. exe ที่ดาวน์โหลดมา

ตรวจสอบตัวเลือก Add Python 3.7 to Path และดำเนินการติดตั้ง หลังจากเสร็จสิ้นกระบวนการนี้ python จะถูกติดตั้งในระบบของคุณ

ในการเชื่อมต่อกับ MySQL (ทางเดียวคือ) เปิดพรอมต์คำสั่ง MySQL ในระบบของคุณดังที่แสดงด้านล่าง -

ถามรหัสผ่านที่นี่ คุณต้องพิมพ์รหัสผ่านที่คุณตั้งค่าเป็นผู้ใช้เริ่มต้น (รูท) ในขณะติดตั้ง

จากนั้นสร้างการเชื่อมต่อโดย MySQL แสดงข้อความต่อไปนี้ -

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.

คุณสามารถยกเลิกการเชื่อมต่อจากฐานข้อมูล MySQL ได้ตลอดเวลาโดยใช้คำสั่ง exit ที่ mysql> prompt

mysql> exit
Bye

สร้างการเชื่อมต่อกับ MySQL โดยใช้ python

ก่อนสร้างการเชื่อมต่อกับฐานข้อมูล MySQL โดยใช้ python ให้สมมติว่า -

• ว่าเราได้สร้างฐานข้อมูลชื่อ mydb.

• เราได้สร้างตาราง EMPLOYEE โดยมีคอลัมน์ FIRST_NAME, LAST_NAME, AGE, SEX และ INCOME

• ข้อมูลรับรองที่เราใช้เพื่อเชื่อมต่อกับ MySQL คือชื่อผู้ใช้: root, รหัสผ่าน: password.

คุณสามารถสร้างการเชื่อมต่อโดยใช้ไฟล์ connect()ผู้สร้าง สิ่งนี้ยอมรับชื่อผู้ใช้รหัสผ่านโฮสต์และชื่อของฐานข้อมูลที่คุณต้องการเชื่อมต่อ (ทางเลือก) และส่งคืนอ็อบเจ็กต์ของคลาส MySQLConnection

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างการเชื่อมต่อกับฐานข้อมูล 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()

เอาต์พุต

ในการดำเนินการสคริปต์นี้จะสร้างผลลัพธ์ต่อไปนี้ -

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

คุณยังสามารถสร้างการเชื่อมต่อกับ MySQL โดยส่งข้อมูลรับรอง (ชื่อผู้ใช้รหัสผ่านชื่อโฮสต์และชื่อฐานข้อมูล) ไปยัง connection.MySQLConnection() ดังแสดงด้านล่าง -

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

คุณสามารถสร้างฐานข้อมูลใน MYSQL โดยใช้แบบสอบถาม CREATE DATABASE

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของแบบสอบถาม CREATE DATABASE -

CREATE DATABASE name_of_the_database

ตัวอย่าง

คำสั่งต่อไปนี้สร้างฐานข้อมูลที่มีชื่อ mydb ใน MySQL -

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

หากคุณสังเกตรายการฐานข้อมูลโดยใช้คำสั่ง SHOW DATABASES คุณสามารถสังเกตฐานข้อมูลที่สร้างขึ้นใหม่ได้ดังที่แสดงด้านล่าง -

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

การสร้างฐานข้อมูลใน MySQL โดยใช้ python

หลังจากสร้างการเชื่อมต่อกับ MySQL แล้วในการจัดการข้อมูลคุณต้องเชื่อมต่อกับฐานข้อมูล คุณสามารถเชื่อมต่อกับฐานข้อมูลที่มีอยู่หรือสร้างของคุณเอง

คุณจะต้องมีสิทธิพิเศษในการสร้างหรือลบฐานข้อมูล MySQL ดังนั้นหากคุณมีสิทธิ์เข้าถึงผู้ใช้รูทคุณสามารถสร้างฐานข้อมูลใดก็ได้

ตัวอย่าง

ตัวอย่างต่อไปนี้สร้างการเชื่อมต่อกับ MYSQL และสร้างฐานข้อมูลในนั้น

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

เอาต์พุต

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

คำสั่ง CREATE TABLE ใช้เพื่อสร้างตารางในฐานข้อมูล MYSQL ที่นี่คุณต้องระบุชื่อของตารางและคำจำกัดความ (ชื่อและประเภทข้อมูล) ของแต่ละคอลัมน์

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์สำหรับสร้างตารางใน MySQL -

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

ตัวอย่าง

แบบสอบถามต่อไปนี้สร้างตารางชื่อ EMPLOYEE ใน MySQL โดยมีห้าคอลัมน์ ได้แก่ FIRST_NAME LAST_NAME อายุเพศและรายได้

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)

คำสั่ง DESC ให้คำอธิบายของตารางที่ระบุ ใช้สิ่งนี้เพื่อตรวจสอบว่าตารางถูกสร้างขึ้นหรือไม่ดังที่แสดงด้านล่าง -

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)

การสร้างตารางใน MySQL โดยใช้ python

เมธอดชื่อ execute() (เรียกใช้บนวัตถุเคอร์เซอร์) ยอมรับสองตัวแปร -

• ค่าสตริงที่แสดงถึงการสืบค้นที่จะดำเนินการ

• พารามิเตอร์ args ที่เป็นทางเลือกซึ่งอาจเป็นทูเปิลหรือรายการหรือพจนานุกรมแทนพารามิเตอร์ของคิวรี (ค่าของตัวยึดตำแหน่ง)

ส่งคืนค่าจำนวนเต็มแทนจำนวนแถวที่ได้รับผลจากแบบสอบถาม

เมื่อสร้างการเชื่อมต่อฐานข้อมูลแล้วคุณสามารถสร้างตารางโดยส่งแบบสอบถาม CREATE TABLE ไปยังไฟล์ execute() วิธี.

ในระยะสั้นในการสร้างตารางโดยใช้ python 7minus;

• นำเข้า mysql.connector แพ็คเกจ

• สร้างวัตถุการเชื่อมต่อโดยใช้ mysql.connector.connect() วิธีการโดยส่งชื่อผู้ใช้รหัสผ่านโฮสต์ (ค่าดีฟอลต์ทางเลือก: localhost) และฐานข้อมูล (ทางเลือก) เป็นพารามิเตอร์

• สร้างวัตถุเคอร์เซอร์โดยเรียกใช้ไฟล์ cursor() วิธีการบนวัตถุการเชื่อมต่อที่สร้างขึ้นด้านบน

• จากนั้นดำเนินการคำสั่ง CREATE TABLEโดยส่งเป็นพารามิเตอร์ไปยังไฟล์execute() วิธี.

ตัวอย่าง

ตัวอย่างต่อไปนี้สร้างตารางชื่อ Employee ในฐานข้อมูล 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()

คุณสามารถเพิ่มแถวใหม่ลงในตาราง MySQL ที่มีอยู่โดยใช้ไฟล์ INSERT INTOคำให้การ. ในสิ่งนี้คุณต้องระบุชื่อของตารางชื่อคอลัมน์และค่า (ตามลำดับเดียวกันกับชื่อคอลัมน์)

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง INSERT INTO ของ MySQL

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

ตัวอย่าง

แบบสอบถามต่อไปนี้จะแทรกระเบียนลงในตารางชื่อ EMPLOYEE

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

คุณสามารถตรวจสอบบันทึกของตารางหลังจากการดำเนินการแทรกโดยใช้คำสั่ง SELECT เป็น -

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

ไม่จำเป็นต้องระบุชื่อของคอลัมน์เสมอไปหากคุณส่งผ่านค่าของระเบียนในลำดับเดียวกันของคอลัมน์ของตารางคุณสามารถดำเนินการคำสั่ง SELECT โดยไม่มีชื่อคอลัมน์ดังนี้ -

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

การแทรกข้อมูลในตาราง MySQL โดยใช้ python

execute()วิธีการ (เรียกใช้บนวัตถุเคอร์เซอร์) ยอมรับแบบสอบถามเป็นพารามิเตอร์และดำเนินการสืบค้นที่กำหนด ในการแทรกข้อมูลคุณต้องส่งคำสั่ง MySQL INSERT เป็นพารามิเตอร์ไป

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

ในการแทรกข้อมูลลงในตารางใน MySQL โดยใช้ python -

• นำเข้า mysql.connector แพ็คเกจ

• สร้างวัตถุการเชื่อมต่อโดยใช้ mysql.connector.connect() วิธีการโดยส่งชื่อผู้ใช้รหัสผ่านโฮสต์ (ค่าดีฟอลต์ทางเลือก: localhost) และฐานข้อมูล (ทางเลือก) เป็นพารามิเตอร์

• สร้างวัตถุเคอร์เซอร์โดยเรียกใช้ไฟล์ cursor() วิธีการบนวัตถุการเชื่อมต่อที่สร้างขึ้นด้านบน

• จากนั้นเรียกใช้ไฟล์ INSERT คำสั่งโดยส่งเป็นพารามิเตอร์ไปยัง execute() วิธี.

ตัวอย่าง

ตัวอย่างต่อไปนี้เรียกใช้คำสั่ง SQL INSERT เพื่อแทรกเร็กคอร์ดลงในตาราง 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()

การแทรกค่าแบบไดนามิก

คุณยังสามารถใช้“% s” แทนค่าในไฟล์ INSERT แบบสอบถาม MySQL และส่งผ่านค่าไปยังรายการดังที่แสดงด้านล่าง -

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

ตัวอย่าง

ตัวอย่างต่อไปนี้จะแทรกบันทึกลงในตารางพนักงานแบบไดนามิก

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

เอาต์พุต

Data inserted

คุณสามารถดึง / ดึงข้อมูลจากตารางใน MySQL โดยใช้แบบสอบถาม SELECT แบบสอบถาม / คำสั่งนี้ส่งคืนเนื้อหาของตารางที่ระบุในรูปแบบตารางและเรียกว่าเป็นชุดผลลัพธ์

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของแบบสอบถาม SELECT -

SELECT column1, column2, columnN FROM table_name;

ตัวอย่าง

สมมติว่าเราได้สร้างตารางใน MySQL โดยใช้ชื่อ cricketers_data เป็น -

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

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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');

การค้นหาต่อไปนี้จะดึงค่า FIRST_NAME และ Country จากตาราง

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)

คุณยังสามารถดึงค่าทั้งหมดของแต่ละระเบียนโดยใช้ * instated ของชื่อคอลัมน์เป็น -

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)

การอ่านข้อมูลจากตาราง MYSQL โดยใช้ Python

การอ่านการดำเนินการบนฐานข้อมูลหมายถึงการดึงข้อมูลที่เป็นประโยชน์จากฐานข้อมูล คุณสามารถดึงข้อมูลจาก MYSQL โดยใช้ไฟล์fetch() วิธีการจัดทำโดย mysql-connector-python

cursor.MySQLCursorระดับให้สามวิธีคือfetchall(), fetchmany() และ, fetchone() ที่ไหน

• fetchall()วิธีการดึงข้อมูลแถวทั้งหมดในชุดผลลัพธ์ของแบบสอบถามและส่งกลับเป็นรายการสิ่งที่เพิ่มขึ้น (ถ้าเราดำเนินการนี้หลังจากดึงข้อมูลไม่กี่แถวมันจะส่งคืนแถวที่เหลือ)

• fetchone() วิธีการดึงข้อมูลแถวถัดไปในผลลัพธ์ของแบบสอบถามและส่งกลับเป็นทูเพิล

• fetchmany() วิธีการคล้ายกับ fetchone () แต่จะดึงข้อมูลชุดถัดไปของแถวในชุดผลลัพธ์ของแบบสอบถามแทนที่จะเป็นแถวเดียว

Note - ชุดผลลัพธ์คือวัตถุที่ส่งคืนเมื่อวัตถุเคอร์เซอร์ถูกใช้เพื่อสืบค้นตาราง

rowcount - นี่คือแอตทริบิวต์แบบอ่านอย่างเดียวและส่งกลับจำนวนแถวที่ได้รับผลกระทบจากเมธอด execute ()

ตัวอย่าง

ตัวอย่างต่อไปนี้ดึงข้อมูลแถวทั้งหมดของตาราง EMPLOYEE โดยใช้แบบสอบถาม SELECT และจากชุดผลลัพธ์ที่ได้รับในตอนแรกเรากำลังดึงข้อมูลแถวแรกโดยใช้วิธี fetchone () จากนั้นดึงข้อมูลแถวที่เหลือโดยใช้วิธี 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()

เอาต์พุต

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

ตัวอย่างต่อไปนี้ดึงข้อมูลสองแถวแรกของตาราง EMPLOYEE โดยใช้เมธอด fetchmany ()

ตัวอย่าง

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

เอาต์พุต

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

หากคุณต้องการดึงข้อมูลลบหรืออัปเดตแถวเฉพาะของตารางใน MySQL คุณต้องใช้ where clause เพื่อระบุเงื่อนไขเพื่อกรองแถวของตารางสำหรับการดำเนินการ

ตัวอย่างเช่นหากคุณมีคำสั่ง SELECT พร้อมด้วย where clause ระบบจะเรียกเฉพาะแถวที่ตรงตามเงื่อนไขที่ระบุเท่านั้น

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของ WHERE clause -

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

ตัวอย่าง

สมมติว่าเราได้สร้างตารางใน MySQL โดยใช้ชื่อ EMPLOYEES เป็น -

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)

และถ้าเราใส่ 4 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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);

ตามคำสั่ง MySQL จะดึงข้อมูลของพนักงานที่มีรายได้มากกว่า 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)

WHERE อนุประโยคโดยใช้ python

ในการดึงข้อมูลเฉพาะจากตารางโดยใช้โปรแกรม python -

• นำเข้า mysql.connector แพ็คเกจ

• สร้างวัตถุการเชื่อมต่อโดยใช้ mysql.connector.connect() วิธีการโดยส่งชื่อผู้ใช้รหัสผ่านโฮสต์ (ค่าดีฟอลต์ทางเลือก: localhost) และฐานข้อมูล (ทางเลือก) เป็นพารามิเตอร์

• สร้างวัตถุเคอร์เซอร์โดยเรียกใช้ไฟล์ cursor() วิธีการบนวัตถุการเชื่อมต่อที่สร้างขึ้นด้านบน

• จากนั้นดำเนินการคำสั่งSELECTด้วยคำสั่ง WHEREโดยส่งเป็นพารามิเตอร์ไปยังexecute() วิธี.

ตัวอย่าง

ตัวอย่างต่อไปนี้สร้างตารางชื่อพนักงานและเติมข้อมูล จากนั้นใช้คำสั่ง where จะดึงข้อมูลที่มีค่าอายุน้อยกว่า 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()

เอาต์พุต

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

ในขณะที่ดึงข้อมูลโดยใช้แบบสอบถาม SELECT คุณสามารถจัดเรียงผลลัพธ์ตามลำดับที่ต้องการ (จากน้อยไปมากหรือมากไปหาน้อย) โดยใช้คำสั่ง OrderBy ตามค่าเริ่มต้นอนุประโยคนี้จะเรียงลำดับผลลัพธ์จากน้อยไปหามากหากคุณต้องการจัดเรียงจากมากไปหาน้อยคุณจำเป็นต้องใช้ "DESC" อย่างชัดเจน

ไวยากรณ์

ต่อไปนี้เป็นรายการคอลัมน์เลือกไวยากรณ์

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

ตัวอย่าง

สมมติว่าเราได้สร้างตารางใน MySQL โดยใช้ชื่อ EMPLOYEES เป็น -

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)

และถ้าเราใส่ 4 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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);

คำสั่งต่อไปนี้จะดึงเนื้อหาของตารางพนักงานตามลำดับอายุจากน้อยไปมาก

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)

คุณยังสามารถดึงข้อมูลจากมากไปหาน้อยโดยใช้ DESC เป็น -

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)

ORDER BY clause โดยใช้ python

ในการดึงเนื้อหาของตารางตามลำดับที่ระบุให้เรียกใช้ไฟล์ execute() วิธีการบนวัตถุเคอร์เซอร์และส่งผ่านคำสั่ง SELECT พร้อมกับคำสั่ง ORDER BY เป็นพารามิเตอร์ไป

ตัวอย่าง

ในตัวอย่างต่อไปนี้เรากำลังสร้างตารางที่มีชื่อและพนักงานเติมข้อมูลและดึงข้อมูลกลับมาตามลำดับอายุ (จากน้อยไปมาก) โดยใช้คำสั่ง 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()

เอาต์พุต

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

ในทำนองเดียวกันคุณสามารถดึงข้อมูลจากตารางจากมากไปหาน้อยโดยใช้คำสั่ง 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()

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

#Closing the connection
conn.close()

เอาต์พุต

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

UPDATE การดำเนินการกับฐานข้อมูลใด ๆ จะอัปเดตระเบียนตั้งแต่หนึ่งรายการขึ้นไปซึ่งมีอยู่แล้วในฐานข้อมูล คุณสามารถอัปเดตค่าของระเบียนที่มีอยู่ใน MySQL โดยใช้คำสั่ง UPDATE ในการอัปเดตแถวเฉพาะคุณต้องใช้คำสั่ง WHERE ควบคู่ไปด้วย

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง UPDATE ใน MySQL -

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

คุณสามารถรวม N จำนวนเงื่อนไขโดยใช้ตัวดำเนินการ AND หรือ OR

ตัวอย่าง

สมมติว่าเราได้สร้างตารางใน MySQL โดยใช้ชื่อ EMPLOYEES เป็น -

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)

และถ้าเราใส่ 4 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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);

ตามคำสั่ง MySQL จะเพิ่มอายุของพนักงานชายทุกคนขึ้นหนึ่งปี -

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

หากคุณดึงเนื้อหาของตารางคุณจะเห็นค่าที่อัปเดตเป็น -

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)

การอัปเดตเนื้อหาของตารางโดยใช้ Python

หากต้องการอัปเดตระเบียนในตารางใน MySQL โดยใช้ python -

• นำเข้า mysql.connector แพ็คเกจ

• สร้างวัตถุการเชื่อมต่อโดยใช้ mysql.connector.connect() วิธีการโดยส่งชื่อผู้ใช้รหัสผ่านโฮสต์ (ค่าดีฟอลต์ทางเลือก: localhost) และฐานข้อมูล (ทางเลือก) เป็นพารามิเตอร์

• สร้างวัตถุเคอร์เซอร์โดยเรียกใช้ไฟล์ cursor() วิธีการบนวัตถุการเชื่อมต่อที่สร้างขึ้นด้านบน

• จากนั้นรันคำสั่ง UPDATE โดยส่งเป็นพารามิเตอร์ไปยังไฟล์ execute() วิธี.

ตัวอย่าง

ตัวอย่างต่อไปนี้ทำให้อายุของผู้ชายทุกคนเพิ่มขึ้นหนึ่งปี

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

เอาต์พุต

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

ในการลบบันทึกจากตาราง MySQL คุณต้องใช้ไฟล์ DELETE FROMคำให้การ. ในการลบระเบียนเฉพาะคุณต้องใช้ WHERE clause ควบคู่ไปด้วย

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของแบบสอบถาม DELETE ใน MYSQL -

DELETE FROM table_name [WHERE Clause]

ตัวอย่าง

สมมติว่าเราได้สร้างตารางใน MySQL โดยใช้ชื่อ EMPLOYEES เป็น -

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)

และถ้าเราใส่ 4 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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);

การปฏิบัติตามคำสั่ง MySQL จะลบบันทึกของพนักงานด้วย FIRST_NAME” Mac”

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

หากคุณดึงเนื้อหาของตารางคุณจะเห็นเพียง 3 ระเบียนเนื่องจากเราได้ลบไปแล้ว

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)

หากคุณดำเนินการคำสั่ง DELETE โดยไม่มีคำสั่ง WHERE ระเบียนทั้งหมดจากตารางที่ระบุจะถูกลบ

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

หากคุณดึงข้อมูลของตารางคุณจะได้ชุดว่างดังที่แสดงด้านล่าง -

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

การลบบันทึกของตารางโดยใช้ python

จำเป็นต้องดำเนินการ DELETE เมื่อคุณต้องการลบบางระเบียนออกจากฐานข้อมูลของคุณ

ในการลบระเบียนในตาราง -

• นำเข้า mysql.connector แพ็คเกจ

• สร้างวัตถุการเชื่อมต่อโดยใช้ mysql.connector.connect() วิธีการโดยส่งชื่อผู้ใช้รหัสผ่านโฮสต์ (ค่าดีฟอลต์ทางเลือก: localhost) และฐานข้อมูล (ทางเลือก) เป็นพารามิเตอร์

• สร้างวัตถุเคอร์เซอร์โดยเรียกใช้ไฟล์ cursor() วิธีการบนวัตถุการเชื่อมต่อที่สร้างขึ้นด้านบน

• จากนั้นเรียกใช้ไฟล์ DELETE คำสั่งโดยส่งเป็นพารามิเตอร์ไปยัง execute() วิธี.

ตัวอย่าง

โปรแกรมต่อไปนี้จะลบบันทึกทั้งหมดจาก EMPLOYEE ที่มีอายุมากกว่า 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()

เอาต์พุต

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

คุณสามารถลบทั้งตารางโดยใช้ไฟล์ DROP TABLEคำให้การ. คุณเพียงแค่ระบุชื่อของตารางที่คุณต้องการลบ

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง DROP TABLE ใน MySQL -

DROP TABLE table_name;

ตัวอย่าง

ก่อนลบตารางรับรายการตารางโดยใช้คำสั่ง SHOW TABLES ดังนี้ -

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

คำสั่งต่อไปนี้จะลบตารางชื่อตัวอย่างออกจากฐานข้อมูลทั้งหมด -

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

เนื่องจากเราได้ลบตารางชื่อตัวอย่างออกจาก MySQL แล้วหากคุณได้รับรายชื่อตารางอีกครั้งคุณจะไม่พบชื่อตารางในตารางนั้น

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

การลบตารางโดยใช้ python

คุณสามารถวางตารางได้ทุกเมื่อที่ต้องการโดยใช้คำสั่ง DROP ของ MYSQL แต่คุณต้องระมัดระวังให้มากในขณะที่ลบตารางที่มีอยู่เนื่องจากข้อมูลที่สูญหายจะไม่สามารถกู้คืนได้หลังจากลบตาราง

ในการวางตารางจากฐานข้อมูล MYSQL โดยใช้ python ให้เรียกใช้ไฟล์ execute() วิธีการบนวัตถุเคอร์เซอร์และส่งคำสั่ง drop เป็นพารามิเตอร์ไป

ตัวอย่าง

ตารางต่อไปนี้จะดร็อปตารางชื่อ 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()

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

เอาต์พุต

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

วางตารางถ้ามีอยู่เท่านั้น

หากคุณพยายามวางตารางที่ไม่มีอยู่ในฐานข้อมูลข้อผิดพลาดจะเกิดขึ้นเมื่อ -

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

คุณสามารถป้องกันข้อผิดพลาดนี้ได้โดยการตรวจสอบว่ามีตารางอยู่ก่อนที่จะลบหรือไม่โดยการเพิ่ม IF EXISTS ในคำสั่ง 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()

เอาต์พุต

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

ในขณะที่ดึงเร็กคอร์ดหากคุณต้องการ จำกัด ด้วยหมายเลขเฉพาะคุณสามารถทำได้โดยใช้ประโยค LIMIT ของ MYSQL

ตัวอย่าง

สมมติว่าเราได้สร้างตารางใน MySQL โดยใช้ชื่อ EMPLOYEES เป็น -

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)

และถ้าเราใส่ 4 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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);

คำสั่ง SQL ต่อไปนี้จะดึงข้อมูลสองระเบียนแรกของตารางพนักงานโดยใช้ส่วนคำสั่ง 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)

จำกัด ประโยคโดยใช้ python

หากคุณเรียกใช้ไฟล์ execute() วิธีการบนวัตถุเคอร์เซอร์โดยการส่งแบบสอบถาม SELECT พร้อมกับส่วนคำสั่ง LIMIT คุณสามารถเรียกจำนวนระเบียนที่ต้องการ

ในการวางตารางจากฐานข้อมูล MYSQL โดยใช้ python ให้เรียกใช้ไฟล์ execute() วิธีการบนวัตถุเคอร์เซอร์และส่งคำสั่ง drop เป็นพารามิเตอร์ไป

ตัวอย่าง

ตัวอย่าง python ต่อไปนี้จะสร้างและเติมข้อมูลในตารางที่มีชื่อ EMPLOYEE และโดยใช้ส่วน 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'''

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

เอาต์พุต

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

จำกัด ด้วย OFFSET

หากคุณต้องการ จำกัด ระเบียนโดยเริ่มจากระเบียนที่ n (ไม่ใช่ 1 ^st ) คุณสามารถทำได้โดยใช้ OFFSET ร่วมกับ 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()

เอาต์พุต

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

เมื่อคุณแบ่งข้อมูลออกเป็นสองตารางแล้วคุณสามารถดึงเรกคอร์ดที่รวมกันจากสองตารางนี้โดยใช้ Joins

ตัวอย่าง

สมมติว่าเราได้สร้างตารางชื่อ EMPLOYEE และเติมข้อมูลลงในตารางดังที่แสดงด้านล่าง -

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

จากนั้นถ้าเราสร้างตารางอื่นและเติมข้อมูลเป็น -

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

คำสั่งต่อไปนี้ดึงข้อมูลที่รวมค่าในสองตารางนี้ -

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 เข้าร่วมโดยใช้ python

ตัวอย่างต่อไปนี้ดึงข้อมูลจากสองตารางข้างต้นรวมกันโดยคอลัมน์ผู้ติดต่อของตารางพนักงานและคอลัมน์ ID ของตาราง CONTACT

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

เอาต์พุต

[('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 ของ mysql-connector-python (และไลบรารีที่คล้ายกัน) ใช้เพื่อดำเนินการคำสั่งเพื่อสื่อสารกับฐานข้อมูล MySQL

ใช้วิธีการของมันคุณสามารถเรียกใช้คำสั่ง SQL ดึงข้อมูลจากชุดผลลัพธ์ขั้นตอนการโทร

คุณสามารถสร้าง Cursor วัตถุโดยใช้เคอร์เซอร์ () วิธีการของวัตถุ / คลาสการเชื่อมต่อ

ตัวอย่าง

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

วิธีการ

ต่อไปนี้เป็นวิธีการต่างๆที่จัดเตรียมโดยคลาส / อ็อบเจ็กต์ Cursor

ซีเนียร์ No	วิธีการและคำอธิบาย
1	callproc() วิธีนี้ใช้เพื่อเรียกขั้นตอนฐานข้อมูล MySQL ที่มีอยู่
2	close() วิธีนี้ใช้เพื่อปิดวัตถุเคอร์เซอร์ปัจจุบัน
3	Info() วิธีนี้ให้ข้อมูลเกี่ยวกับแบบสอบถามสุดท้าย
4	executemany() วิธีนี้ยอมรับชุดรายการพารามิเตอร์ เตรียมแบบสอบถาม MySQL และดำเนินการกับพารามิเตอร์ทั้งหมด
5	execute() วิธีนี้ยอมรับแบบสอบถาม MySQL เป็นพารามิเตอร์และดำเนินการค้นหาที่กำหนด
6	fetchall() วิธีนี้จะดึงข้อมูลแถวทั้งหมดในชุดผลลัพธ์ของแบบสอบถามและส่งกลับเป็นรายการสิ่งที่เพิ่มขึ้น (หากเราดำเนินการสิ่งนี้หลังจากเรียกข้อมูลไม่กี่แถวมันจะส่งคืนแถวที่เหลือ)
7	fetchone() วิธีนี้ดึงข้อมูลแถวถัดไปจากผลลัพธ์ของคิวรีและส่งกลับเป็นทูเพิล
8	fetchmany() วิธีนี้คล้ายกับ fetchone () แต่จะดึงข้อมูลชุดถัดไปของแถวในชุดผลลัพธ์ของแบบสอบถามแทนที่จะเป็นแถวเดียว
9	etchwarnings() วิธีนี้ส่งคืนคำเตือนที่สร้างขึ้นโดยแบบสอบถามที่เรียกใช้ล่าสุด

คุณสมบัติ

ต่อไปนี้เป็นคุณสมบัติของคลาส Cursor -

ซีเนียร์ No	คุณสมบัติและคำอธิบาย
1	column_names นี่คือคุณสมบัติแบบอ่านอย่างเดียวซึ่งส่งคืนรายการที่มีชื่อคอลัมน์ของชุดผลลัพธ์
2	description นี่เป็นคุณสมบัติแบบอ่านอย่างเดียวซึ่งส่งคืนรายการที่มีคำอธิบายของคอลัมน์ในชุดผลลัพธ์
3	lastrowid นี่เป็นคุณสมบัติแบบอ่านอย่างเดียวหากมีคอลัมน์ที่เพิ่มขึ้นโดยอัตโนมัติในตารางค่านี้จะส่งคืนค่าที่สร้างขึ้นสำหรับคอลัมน์นั้นในการดำเนินการ INSERT หรือ UPDATE ล่าสุด
4	rowcount ส่งคืนจำนวนแถวที่ส่งคืน / อัปเดตในกรณีของการดำเนินการ SELECT และ UPDATE
5	statement คุณสมบัตินี้ส่งคืนคำสั่งที่ดำเนินการล่าสุด

การติดตั้ง

PostgreSQL เป็นระบบฐานข้อมูลเชิงวัตถุสัมพันธ์แบบโอเพ่นซอร์สที่มีประสิทธิภาพ มีระยะการพัฒนาที่ใช้งานมากว่า 15 ปีและสถาปัตยกรรมที่ได้รับการพิสูจน์แล้วซึ่งได้รับชื่อเสียงอย่างมากในด้านความน่าเชื่อถือความสมบูรณ์ของข้อมูลและความถูกต้อง

ในการสื่อสารกับ PostgreSQL โดยใช้ Python คุณต้องติดตั้ง psycopg ซึ่งเป็นอะแดปเตอร์ที่จัดเตรียมไว้สำหรับการเขียนโปรแกรม python เวอร์ชันปัจจุบันคือ psycog2.

Psycopg2 ถูกเขียนขึ้นโดยมีจุดมุ่งหมายให้มีขนาดเล็กและรวดเร็วและมั่นคงเหมือนหิน สามารถใช้ได้ภายใต้ PIP (ตัวจัดการแพ็คเกจของ python)

การติดตั้ง Psycog2 โดยใช้ PIP

ก่อนอื่นตรวจสอบให้แน่ใจว่าได้ติดตั้ง python และ PIP ในระบบของคุณอย่างถูกต้องและ PIP เป็นข้อมูลล่าสุด

ในการอัพเกรด PIP ให้เปิด command prompt และดำเนินการคำสั่งต่อไปนี้ -

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

จากนั้นเปิดพรอมต์คำสั่งในโหมดผู้ดูแลระบบและเรียกใช้ไฟล์ pip install psycopg2-binary คำสั่งดังแสดงด้านล่าง -

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

การยืนยัน

ในการตรวจสอบการติดตั้งให้สร้างสคริปต์ python ตัวอย่างโดยมีบรรทัดต่อไปนี้อยู่ในนั้น

import mysql.connector

หากการติดตั้งสำเร็จเมื่อคุณดำเนินการคุณจะไม่ได้รับข้อผิดพลาดใด ๆ -

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

PostgreSQL มีเชลล์ของตัวเองเพื่อดำเนินการสืบค้น ในการสร้างการเชื่อมต่อกับฐานข้อมูล PostgreSQL ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้งอย่างถูกต้องในระบบของคุณ เปิดพรอมต์เชลล์ PostgreSQL และส่งผ่านรายละเอียดเช่นเซิร์ฟเวอร์ฐานข้อมูลชื่อผู้ใช้และรหัสผ่าน หากรายละเอียดทั้งหมดที่คุณให้มาเหมาะสมการเชื่อมต่อจะถูกสร้างขึ้นกับฐานข้อมูล PostgreSQL

ในขณะที่ส่งรายละเอียดคุณสามารถไปกับเซิร์ฟเวอร์เริ่มต้นฐานข้อมูลพอร์ตและชื่อผู้ใช้ที่เชลล์แนะนำ

การสร้างการเชื่อมต่อโดยใช้ python

คลาสการเชื่อมต่อของ psycopg2แสดง / จัดการอินสแตนซ์ของการเชื่อมต่อ คุณสามารถสร้างการเชื่อมต่อใหม่โดยใช้ไฟล์connect()ฟังก์ชัน สิ่งนี้ยอมรับพารามิเตอร์การเชื่อมต่อพื้นฐานเช่น dbname ผู้ใช้รหัสผ่านโฮสต์พอร์ตและส่งคืนอ็อบเจ็กต์การเชื่อมต่อ เมื่อใช้ฟังก์ชันนี้คุณสามารถสร้างการเชื่อมต่อกับ PostgreSQL

ตัวอย่าง

รหัส Python ต่อไปนี้แสดงวิธีเชื่อมต่อกับฐานข้อมูลที่มีอยู่ ถ้าฐานข้อมูลไม่มีอยู่ฐานข้อมูลนั้นจะถูกสร้างขึ้นและในที่สุดก็จะส่งคืนวัตถุฐานข้อมูล ชื่อของฐานข้อมูลเริ่มต้นของ PostgreSQL เป็นpostrgre ดังนั้นเราจึงจัดหาให้เป็นชื่อฐานข้อมูล

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',
)

เอาต์พุต

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

คุณสามารถสร้างฐานข้อมูลใน PostgreSQL โดยใช้คำสั่ง CREATE DATABASE คุณสามารถเรียกใช้คำสั่งนี้ใน PostgreSQL shell prompt โดยระบุชื่อของฐานข้อมูลที่จะสร้างหลังจากคำสั่ง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง CREATE DATABASE

CREATE DATABASE dbname;

ตัวอย่าง

คำสั่งต่อไปนี้สร้างฐานข้อมูลชื่อ testdb ใน PostgreSQL

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

คุณสามารถแสดงรายการฐานข้อมูลใน PostgreSQL โดยใช้คำสั่ง \ l หากคุณตรวจสอบรายชื่อฐานข้อมูลคุณสามารถค้นหาฐานข้อมูลที่สร้างขึ้นใหม่ได้ดังนี้ -

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)

คุณยังสามารถสร้างฐานข้อมูลใน PostgreSQL จาก command prompt โดยใช้คำสั่งcreatedbซึ่งเป็น wrapper รอบ ๆ คำสั่ง SQL CREATE DATABASE

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

การสร้างฐานข้อมูลโดยใช้ python

คลาสเคอร์เซอร์ของ psycopg2 มีวิธีการต่างๆในการดำเนินการคำสั่ง PostgreSQL ต่างๆเรียกข้อมูลบันทึกและคัดลอกข้อมูล คุณสามารถสร้างวัตถุเคอร์เซอร์โดยใช้เคอร์เซอร์ () วิธีการของคลาส Connection

เมธอด execute () ของคลาสนี้ยอมรับแบบสอบถาม PostgreSQL เป็นพารามิเตอร์และเรียกใช้งาน

ดังนั้นในการสร้างฐานข้อมูลใน PostgreSQL ให้เรียกใช้แบบสอบถาม CREATE DATABASE โดยใช้วิธีนี้

ตัวอย่าง

ตัวอย่าง python ต่อไปนี้สร้างฐานข้อมูลชื่อ mydb ในฐานข้อมูล 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()

เอาต์พุต

Database created successfully........

คุณสามารถสร้างตารางใหม่ในฐานข้อมูลใน PostgreSQL โดยใช้คำสั่ง CREATE TABLE ขณะดำเนินการนี้คุณต้องระบุชื่อของตารางชื่อคอลัมน์และประเภทข้อมูล

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง CREATE TABLE ใน PostgreSQL

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

ตัวอย่าง

ตัวอย่างต่อไปนี้สร้างตารางที่มีชื่อ CRICKETERS ใน 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=#

คุณสามารถรับรายการตารางในฐานข้อมูลใน PostgreSQL โดยใช้คำสั่ง \ dt หลังจากสร้างตารางแล้วหากคุณสามารถตรวจสอบรายชื่อตารางได้คุณสามารถสังเกตตารางที่สร้างขึ้นใหม่ได้ดังนี้ -

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

ในทำนองเดียวกันคุณสามารถรับคำอธิบายของตารางที่สร้างขึ้นโดยใช้ \ d ดังที่แสดงด้านล่าง -

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=#

การสร้างตารางโดยใช้ python

การสร้างตารางโดยใช้หลามคุณจำเป็นต้องดำเนินการตามคำสั่งสร้างตารางโดยใช้รัน () วิธีการเคอร์เซอร์ของpyscopg2

ตัวอย่าง

ตัวอย่าง Python ต่อไปนี้สร้างตารางที่มีพนักงานชื่อ

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

เอาต์พุต

Table created successfully........

คุณสามารถแทรกบันทึกลงในตารางที่มีอยู่ใน PostgreSQL โดยใช้ไฟล์ INSERT INTOคำให้การ. ในขณะดำเนินการนี้คุณต้องระบุชื่อของตารางและค่าสำหรับคอลัมน์ในนั้น

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ที่แนะนำของคำสั่ง INSERT -

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

โดยที่ column1, column2, column3, .. คือชื่อของคอลัมน์ของตารางและ value1, value2, value3, ... คือค่าที่คุณต้องแทรกลงในตาราง

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้คำสั่ง CREATE TABLE ดังที่แสดงด้านล่าง -

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=#

ตามคำสั่ง PostgreSQL จะแทรกแถวในตารางที่สร้างไว้ด้านบน -

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

ในขณะที่แทรกระเบียนโดยใช้คำสั่งINSERT INTOหากคุณข้ามชื่อคอลัมน์ใด ๆ บันทึกจะถูกแทรกโดยเว้นช่องว่างไว้ที่คอลัมน์ที่คุณข้ามไป

postgres=# insert into CRICKETERS (First_Name, Last_Name, Country) 
   values('Jonathan', 'Trott', '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
postgres=#

หลังจากใส่ระเบียนลงในตารางแล้วคุณสามารถตรวจสอบเนื้อหาได้โดยใช้คำสั่ง SELECT ดังที่แสดงด้านล่าง -

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)

การแทรกข้อมูลโดยใช้ python

คลาสเคอร์เซอร์ของ psycopg2 จัดเตรียมเมธอดที่มีเมธอด name execute () วิธีนี้ยอมรับการสืบค้นเป็นพารามิเตอร์และดำเนินการ

ดังนั้นในการแทรกข้อมูลลงในตารางใน PostgreSQL โดยใช้ python -

• นำเข้า psycopg2 แพ็คเกจ

• สร้างวัตถุการเชื่อมต่อโดยใช้ connect() วิธีการโดยส่งชื่อผู้ใช้รหัสผ่านโฮสต์ (ค่าดีฟอลต์ทางเลือก: localhost) และฐานข้อมูล (ทางเลือก) เป็นพารามิเตอร์

• ปิดโหมดการคอมมิตอัตโนมัติโดยตั้งค่าเท็จเป็นค่าให้กับแอตทริบิวต์ autocommit.

• cursor() วิธีการของ Connectionคลาสของไลบรารี psycopg2 ส่งคืนวัตถุเคอร์เซอร์ สร้างวัตถุเคอร์เซอร์โดยใช้วิธีนี้

• จากนั้นรันคำสั่ง INSERT โดยส่ง / พวกเขาเป็นพารามิเตอร์ไปยังเมธอด execute ()

ตัวอย่าง

ต่อไปนี้โปรแกรม Python จะสร้างตารางที่มีชื่อ EMPLOYEE ในฐานข้อมูล PostgreSQL และแทรกระเบียนลงในโดยใช้วิธีการดำเนินการ () -

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

เอาต์พุต

Records inserted........

คุณสามารถดึงเนื้อหาของตารางที่มีอยู่ใน PostgreSQL โดยใช้คำสั่ง SELECT ในคำสั่งนี้คุณต้องระบุชื่อของตารางและส่งคืนเนื้อหาในรูปแบบตารางซึ่งเรียกว่าชุดผลลัพธ์

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง SELECT ใน PostgreSQL -

SELECT column1, column2, columnN FROM table_name;

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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=#

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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

คำค้นหา SELECT ต่อไปนี้จะดึงค่าของคอลัมน์ FIRST_NAME, LAST_NAME และ, COUNTRY จากตาราง 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)

หากคุณต้องการดึงข้อมูลคอลัมน์ทั้งหมดของแต่ละระเบียนคุณต้องแทนที่ชื่อของคอลัมน์ด้วย "*" ดังที่แสดงด้านล่าง -

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=#

การดึงข้อมูลโดยใช้ python

การอ่านการดำเนินการบนฐานข้อมูลหมายถึงการดึงข้อมูลที่เป็นประโยชน์จากฐานข้อมูล คุณสามารถดึงข้อมูลจาก PostgreSQL โดยใช้วิธีการดึงข้อมูล () ที่ Psycopg2 ให้มา

คลาส Cursor มีสามวิธี ได้แก่ fetchall (), fetchmany () และ, fetchone () โดยที่

• วิธี fetchall () ดึงข้อมูลแถวทั้งหมดในชุดผลลัพธ์ของแบบสอบถามและส่งกลับเป็นรายการสิ่งที่เพิ่มขึ้น (หากเราดำเนินการนี้หลังจากดึงข้อมูลไม่กี่แถวระบบจะส่งคืนแถวที่เหลือ)

• วิธีการ fetchone () ดึงข้อมูลแถวถัดไปจากผลลัพธ์ของคิวรีและส่งกลับเป็นทูเพิล

• วิธีการ fetchmany () คล้ายกับ fetchone () แต่จะดึงข้อมูลชุดถัดไปของแถวในชุดผลลัพธ์ของแบบสอบถามแทนที่จะเป็นแถวเดียว

Note - ชุดผลลัพธ์คือวัตถุที่ส่งคืนเมื่อวัตถุเคอร์เซอร์ถูกใช้เพื่อสืบค้นตาราง

ตัวอย่าง

โปรแกรม Python ต่อไปนี้เชื่อมต่อกับฐานข้อมูลชื่อ mydb ของ PostgreSQL และดึงข้อมูลทั้งหมดจากตารางชื่อ 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()

เอาต์พุต

('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)]

ในขณะที่ดำเนินการ SELECT, UPDATE หรือ, DELETE คุณสามารถระบุเงื่อนไขเพื่อกรองเร็กคอร์ดโดยใช้คำสั่ง WHERE การดำเนินการจะดำเนินการกับบันทึกที่ตรงตามเงื่อนไขที่กำหนด

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของ WHERE clause ใน PostgreSQL -

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

คุณสามารถระบุ search_condition โดยใช้ตัวดำเนินการเปรียบเทียบหรือตรรกะ เช่น>, <, =, LIKE, NOT ฯลฯ ตัวอย่างต่อไปนี้จะทำให้แนวคิดนี้ชัดเจน

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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=#

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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

คำสั่ง SELECT ต่อไปนี้จะดึงข้อมูลที่มีอายุมากกว่า 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=#

โดยใช้คำสั่ง python

ในการดึงข้อมูลเฉพาะจากตารางโดยใช้โปรแกรม python ให้เรียกใช้คำสั่ง SELECT ด้วยคำสั่ง WHERE โดยส่งเป็นพารามิเตอร์ไปยัง execute() วิธี.

ตัวอย่าง

ตัวอย่าง python ต่อไปนี้แสดงให้เห็นถึงการใช้คำสั่ง WHERE โดยใช้ 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()

เอาต์พุต

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

โดยปกติถ้าคุณพยายามดึงข้อมูลจากตารางคุณจะได้รับระเบียนในลำดับเดียวกับที่คุณใส่ไว้

ใช้ ORDER BY อนุประโยคในขณะที่เรียกข้อมูลของตารางคุณสามารถเรียงลำดับระเบียนผลลัพธ์ตามลำดับจากน้อยไปมากหรือมากไปหาน้อยตามคอลัมน์ที่ต้องการ

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง ORDER BY ใน PostgreSQL

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

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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=#

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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

คำสั่ง SELECT ต่อไปนี้จะดึงข้อมูลแถวของตาราง CRICKETERS ตามลำดับจากน้อยไปหามาก -

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:

คุณสามารถใช้คอลัมน์มากกว่าหนึ่งคอลัมน์เพื่อจัดเรียงระเบียนของตาราง ต่อไปนี้คำสั่ง SELECT จัดเรียงระเบียนของตาราง CRICKETERS ตามอายุของคอลัมน์และ 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)

โดยค่าเริ่มต้นไฟล์ ORDER BYอนุประโยคจะเรียงลำดับระเบียนของตารางจากน้อยไปมาก คุณสามารถจัดเรียงผลลัพธ์จากมากไปหาน้อยโดยใช้ DESC เป็น -

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)

ORDER BY clause โดยใช้ python

ในการดึงเนื้อหาของตารางตามลำดับที่ระบุให้เรียกใช้เมธอด execute () บนวัตถุเคอร์เซอร์และส่งคำสั่ง SELECT พร้อมกับคำสั่ง ORDER BY เป็นพารามิเตอร์ไป

ตัวอย่าง

ในตัวอย่างต่อไปนี้เรากำลังสร้างตารางที่มีชื่อและพนักงานเติมข้อมูลและดึงข้อมูลกลับมาตามลำดับ (จากน้อยไปมาก) ของอายุโดยใช้คำสั่ง 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()

เอาต์พุต

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

คุณสามารถแก้ไขเนื้อหาของระเบียนที่มีอยู่ของตารางใน PostgreSQL โดยใช้คำสั่ง UPDATE ในการอัปเดตแถวเฉพาะคุณต้องใช้คำสั่ง WHERE ควบคู่ไปด้วย

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง UPDATE ใน PostgreSQL -

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

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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=#

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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

คำสั่งต่อไปนี้ปรับเปลี่ยนอายุของนักคริกเก็ตซึ่งมีชื่อจริงคือ Shikhar -

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

หากคุณดึงข้อมูลที่ FIRST_NAME เป็น Shikhar คุณสังเกตว่าค่าอายุเปลี่ยนเป็น 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=#

หากคุณไม่ได้ใช้คำสั่ง WHERE ค่าของระเบียนทั้งหมดจะได้รับการอัปเดต คำสั่ง UPDATE ต่อไปนี้จะเพิ่มอายุของระเบียนทั้งหมดในตาราง CRICKETERS ขึ้น 1 -

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

หากคุณดึงเนื้อหาของตารางโดยใช้คำสั่ง SELECT คุณจะเห็นค่าที่อัพเดตเป็น -

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)

การอัปเดตระเบียนโดยใช้ python

คลาสเคอร์เซอร์ของ psycopg2 จัดเตรียมเมธอดที่มีเมธอด name execute () วิธีนี้ยอมรับการสืบค้นเป็นพารามิเตอร์และดำเนินการ

ดังนั้นในการแทรกข้อมูลลงในตารางใน PostgreSQL โดยใช้ python -

• นำเข้า psycopg2 แพ็คเกจ

• สร้างวัตถุการเชื่อมต่อโดยใช้ connect() วิธีการโดยส่งชื่อผู้ใช้รหัสผ่านโฮสต์ (ค่าดีฟอลต์ทางเลือก: localhost) และฐานข้อมูล (ทางเลือก) เป็นพารามิเตอร์

• ปิดโหมดการคอมมิตอัตโนมัติโดยตั้งค่าเท็จเป็นค่าให้กับแอตทริบิวต์ autocommit.

• cursor() วิธีการของ Connectionคลาสของไลบรารี psycopg2 ส่งคืนวัตถุเคอร์เซอร์ สร้างวัตถุเคอร์เซอร์โดยใช้วิธีนี้

• จากนั้นรันคำสั่ง UPDATE โดยส่งเป็นพารามิเตอร์ไปยังเมธอด execute ()

ตัวอย่าง

การติดตามโค้ด 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()

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

เอาต์พุต

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

คุณสามารถลบระเบียนในตารางที่มีอยู่โดยใช้ไฟล์ DELETE FROMคำสั่งของฐานข้อมูล PostgreSQL ในการลบระเบียนเฉพาะคุณต้องใช้ WHERE clause ควบคู่ไปด้วย

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของแบบสอบถาม DELETE ใน PostgreSQL -

DELETE FROM table_name [WHERE Clause]

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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=#

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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

คำสั่งต่อไปนี้จะลบบันทึกของนักคริกเก็ตที่มีนามสกุล 'Sangakkara' -

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

หากคุณดึงเนื้อหาของตารางโดยใช้คำสั่ง SELECT คุณจะเห็นเพียง 4 ระเบียนเนื่องจากเราได้ลบไปแล้ว

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)

หากคุณดำเนินการคำสั่ง DELETE FROM โดยไม่มีคำสั่ง WHERE ระเบียนทั้งหมดจากตารางที่ระบุจะถูกลบ

postgres=# DELETE FROM CRICKETERS;
DELETE 4

เนื่องจากคุณได้ลบบันทึกทั้งหมดแล้วหากคุณพยายามดึงเนื้อหาของตาราง CRICKETERS โดยใช้คำสั่ง SELECT คุณจะได้ผลลัพธ์ที่ว่างเปล่าตามที่แสดงด้านล่าง -

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

การลบข้อมูลโดยใช้ python

คลาสเคอร์เซอร์ของ psycopg2 จัดเตรียมเมธอดที่มีเมธอด name execute () วิธีนี้ยอมรับการสืบค้นเป็นพารามิเตอร์และดำเนินการ

ดังนั้นในการแทรกข้อมูลลงในตารางใน PostgreSQL โดยใช้ python -

• นำเข้า psycopg2 แพ็คเกจ

• สร้างวัตถุการเชื่อมต่อโดยใช้ connect() วิธีการโดยส่งชื่อผู้ใช้รหัสผ่านโฮสต์ (ค่าดีฟอลต์ทางเลือก: localhost) และฐานข้อมูล (ทางเลือก) เป็นพารามิเตอร์

• ปิดโหมดการคอมมิตอัตโนมัติโดยตั้งค่าเท็จเป็นค่าให้กับแอตทริบิวต์ autocommit.

• cursor()วิธีการของคลาสการเชื่อมต่อของไลบรารี psycopg2 ส่งคืนวัตถุเคอร์เซอร์ สร้างวัตถุเคอร์เซอร์โดยใช้วิธีนี้

• จากนั้นรันคำสั่ง UPDATE โดยส่งเป็นพารามิเตอร์ไปยังเมธอด execute ()

ตัวอย่าง

รหัส Python ต่อไปนี้จะลบบันทึกของตาราง EMPLOYEE ที่มีค่าอายุมากกว่า 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()

เอาต์พุต

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

คุณสามารถวางตารางจากฐานข้อมูล PostgreSQL โดยใช้คำสั่ง DROP TABLE

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง DROP TABLE ใน PostgreSQL -

DROP TABLE table_name;

ตัวอย่าง

สมมติว่าเราได้สร้างตารางสองตารางที่มีชื่อ CRICKETERS และ EMPLOYEES โดยใช้คำค้นหาต่อไปนี้ -

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=#

ตอนนี้ถ้าคุณตรวจสอบรายการตารางโดยใช้คำสั่ง“ \ dt” คุณจะเห็นตารางที่สร้างไว้ด้านบนเป็น -

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

คำสั่งต่อไปนี้จะลบตารางชื่อพนักงานออกจากฐานข้อมูล -

postgres=# DROP table employee;
DROP TABLE

เนื่องจากคุณได้ลบตารางพนักงานไปแล้วหากคุณเรียกดูรายการตารางอีกครั้งคุณสามารถสังเกตได้เพียงตารางเดียวในตารางนั้น

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

หากคุณพยายามลบตารางพนักงานอีกครั้งเนื่องจากคุณได้ลบไปแล้วคุณจะได้รับข้อผิดพลาดว่า“ ไม่มีตาราง” ดังที่แสดงด้านล่าง -

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

ในการแก้ไขปัญหานี้คุณสามารถใช้คำสั่ง IF EXISTS ร่วมกับคำสั่ง DELTE สิ่งนี้จะลบตารางหากมีอยู่มิฉะนั้นจะข้ามการดำเนินการ DLETE

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

การลบทั้งตารางโดยใช้ Python

คุณสามารถวางตารางได้ทุกเมื่อที่ต้องการโดยใช้คำสั่ง DROP แต่คุณต้องระมัดระวังให้มากในขณะที่ลบตารางที่มีอยู่เนื่องจากข้อมูลที่สูญหายจะไม่สามารถกู้คืนได้หลังจากลบตาราง

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

เอาต์พุต

#Table dropped...

ในขณะที่เรียกใช้คำสั่ง PostgreSQL SELECT คุณสามารถ จำกัด จำนวนระเบียนในผลลัพธ์โดยใช้ประโยค LIMIT

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของประโยค LMIT ใน PostgreSQL -

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

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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=#

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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

คำสั่งต่อไปนี้ดึงข้อมูล 3 ระเบียนแรกของตาราง Cricketers โดยใช้ประโยค 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)

หากคุณต้องการรับเรกคอร์ดโดยเริ่มจากเร็กคอร์ดเฉพาะ (ออฟเซ็ต) คุณสามารถทำได้โดยใช้คำสั่ง OFFSET พร้อมกับ 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=#

จำกัด ประโยคโดยใช้ python

ตัวอย่าง python ต่อไปนี้จะดึงเนื้อหาของตารางชื่อ EMPLOYEE โดย จำกัด จำนวนระเบียนในผลลัพธ์ไว้ที่ 2 -

ตัวอย่าง

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

เอาต์พุต

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

เมื่อคุณแบ่งข้อมูลออกเป็นสองตารางแล้วคุณสามารถดึงเรกคอร์ดที่รวมกันจากสองตารางนี้โดยใช้ Joins

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS และใส่ 5 ระเบียนลงในตารางดังที่แสดงด้านล่าง -

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'
);

และถ้าเราสร้างตารางอื่นที่มีชื่อ OdiStats และใส่ 5 ระเบียนเข้าไปในชื่อ -

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);

คำสั่งต่อไปนี้ดึงข้อมูลที่รวมค่าในสองตารางนี้ -

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=#

เข้าร่วมโดยใช้ python

เมื่อคุณแบ่งข้อมูลออกเป็นสองตารางแล้วคุณสามารถดึงเรกคอร์ดที่รวมกันจากสองตารางนี้โดยใช้ Joins

ตัวอย่าง

ต่อไปนี้โปรแกรม python แสดงให้เห็นถึงการใช้คำสั่ง 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()

เอาต์พุต

[('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')]

คลาสเคอร์เซอร์ของไลบรารีpsycopgมีวิธีการดำเนินการคำสั่ง PostgreSQL ในฐานข้อมูลโดยใช้รหัสไพ ธ อน

ใช้วิธีการของมันคุณสามารถเรียกใช้คำสั่ง SQL ดึงข้อมูลจากชุดผลลัพธ์ขั้นตอนการโทร

คุณสามารถสร้าง Cursor วัตถุโดยใช้เคอร์เซอร์ () วิธีการของวัตถุ / คลาสการเชื่อมต่อ

ตัวอย่าง

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

วิธีการ

ต่อไปนี้เป็นวิธีการต่างๆที่จัดเตรียมโดยคลาส / อ็อบเจ็กต์ Cursor

ซีเนียร์ No	วิธีการและคำอธิบาย
1	callproc() วิธีนี้ใช้เพื่อเรียกโพรซีเดอร์ฐานข้อมูล PostgreSQL ที่มีอยู่
2	close() วิธีนี้ใช้เพื่อปิดวัตถุเคอร์เซอร์ปัจจุบัน
3	executemany() วิธีนี้ยอมรับชุดรายการพารามิเตอร์ เตรียมแบบสอบถาม MySQL และดำเนินการกับพารามิเตอร์ทั้งหมด
4	execute() วิธีนี้ยอมรับแบบสอบถาม MySQL เป็นพารามิเตอร์และดำเนินการค้นหาที่กำหนด
5	fetchall() วิธีนี้จะดึงข้อมูลแถวทั้งหมดในชุดผลลัพธ์ของแบบสอบถามและส่งกลับเป็นรายการสิ่งที่เพิ่มขึ้น (หากเราดำเนินการสิ่งนี้หลังจากเรียกข้อมูลไม่กี่แถวมันจะส่งคืนแถวที่เหลือ)
6	fetchone() วิธีนี้ดึงข้อมูลแถวถัดไปจากผลลัพธ์ของคิวรีและส่งกลับเป็นทูเพิล
7	fetchmany() วิธีนี้คล้ายกับ fetchone () แต่จะดึงข้อมูลชุดถัดไปของแถวในชุดผลลัพธ์ของแบบสอบถามแทนที่จะเป็นแถวเดียว

คุณสมบัติ

ต่อไปนี้เป็นคุณสมบัติของคลาส Cursor -

ซีเนียร์ No	คุณสมบัติและคำอธิบาย
1	description นี่เป็นคุณสมบัติแบบอ่านอย่างเดียวซึ่งส่งคืนรายการที่มีคำอธิบายของคอลัมน์ในชุดผลลัพธ์
2	astrowid นี่เป็นคุณสมบัติแบบอ่านอย่างเดียวหากมีคอลัมน์ที่เพิ่มขึ้นโดยอัตโนมัติในตารางค่านี้จะส่งคืนค่าที่สร้างขึ้นสำหรับคอลัมน์นั้นในการดำเนินการ INSERT หรือ UPDATE ล่าสุด
3	rowcount ส่งคืนจำนวนแถวที่ส่งคืน / อัปเดตในกรณีของการดำเนินการ SELECT และ UPDATE
4	closed คุณสมบัตินี้ระบุว่าเคอร์เซอร์ถูกปิดหรือไม่ถ้าเป็นเช่นนั้นจะส่งคืนจริงหรือเท็จ
5	connection สิ่งนี้ส่งคืนการอ้างอิงไปยังออบเจ็กต์การเชื่อมต่อที่ใช้สร้างเคอร์เซอร์นี้
6	name คุณสมบัตินี้ส่งคืนชื่อของเคอร์เซอร์
7	scrollable คุณสมบัตินี้ระบุว่าเคอร์เซอร์หนึ่งสามารถเลื่อนได้หรือไม่

การติดตั้ง

SQLite3 สามารถรวมเข้ากับ Python โดยใช้โมดูล sqlite3 ซึ่งเขียนโดย Gerhard Haring มีอินเทอร์เฟซ SQL ที่สอดคล้องกับข้อกำหนด DB-API 2.0 ที่อธิบายโดย PEP 249 คุณไม่จำเป็นต้องติดตั้งโมดูลนี้แยกต่างหากเนื่องจากมีการจัดส่งโดยค่าเริ่มต้นพร้อมกับ Python เวอร์ชัน 2.5.x เป็นต้นไป

ในการใช้โมดูล sqlite3 ก่อนอื่นคุณต้องสร้างวัตถุการเชื่อมต่อที่แสดงถึงฐานข้อมูลจากนั้นคุณสามารถสร้างวัตถุเคอร์เซอร์ซึ่งจะช่วยคุณในการเรียกใช้คำสั่ง SQL ทั้งหมด

Python sqlite3 โมดูล API

ต่อไปนี้เป็นรูทีนโมดูล sqlite3 ที่สำคัญซึ่งสามารถเพียงพอต่อความต้องการของคุณในการทำงานกับฐานข้อมูล SQLite จากโปรแกรม Python ของคุณ หากคุณกำลังมองหาแอปพลิเคชันที่ซับซ้อนมากขึ้นคุณสามารถดูเอกสารอย่างเป็นทางการของโมดูล Python sqlite3

ซีเนียร์	API และคำอธิบาย
1	sqlite3.connect(database [,timeout ,other optional arguments]) API นี้เปิดการเชื่อมต่อกับไฟล์ฐานข้อมูล SQLite คุณสามารถใช้ ": memory:" เพื่อเปิดการเชื่อมต่อฐานข้อมูลกับฐานข้อมูลที่อยู่ใน RAM แทนบนดิสก์ หากเปิดฐานข้อมูลสำเร็จจะส่งคืนวัตถุการเชื่อมต่อ
2	connection.cursor([cursorClass]) กิจวัตรนี้จะสร้างไฟล์ cursorซึ่งจะใช้ตลอดการเขียนโปรแกรมฐานข้อมูลของคุณด้วย Python วิธีนี้ยอมรับ cursorClass พารามิเตอร์ทางเลือกเดียว หากให้มาต้องเป็นคลาสเคอร์เซอร์แบบกำหนดเองที่ขยาย sqlite3.Cursor
3	cursor.execute(sql [, optional parameters]) รูทีนนี้รันคำสั่ง SQL คำสั่ง SQL อาจถูกกำหนดพารามิเตอร์ (เช่นตัวยึดแทนตัวอักษร SQL) โมดูล sqlite3 รองรับตัวยึดตำแหน่งสองประเภท: เครื่องหมายคำถามและตัวยึดตำแหน่งที่ระบุชื่อ (สไตล์ที่ระบุชื่อ) For example - cursor.execute ("แทรกในค่าคน (?,?)", (ใครอายุ))
4	connection.execute(sql [, optional parameters]) รูทีนนี้เป็นทางลัดของวิธีการดำเนินการข้างต้นที่จัดเตรียมโดยวัตถุเคอร์เซอร์และจะสร้างวัตถุเคอร์เซอร์กลางโดยเรียกวิธีการเคอร์เซอร์จากนั้นเรียกวิธีการดำเนินการของเคอร์เซอร์ด้วยพารามิเตอร์ที่กำหนด
5	cursor.executemany(sql, seq_of_parameters) รูทีนนี้เรียกใช้คำสั่ง SQL กับลำดับพารามิเตอร์หรือการแม็พทั้งหมดที่พบในลำดับ sql
6	connection.executemany(sql[, parameters]) รูทีนนี้เป็นทางลัดที่สร้างวัตถุเคอร์เซอร์กลางโดยเรียกใช้วิธีเคอร์เซอร์จากนั้นเรียกวิธีการดำเนินการเคอร์เซอร์หลายวิธีด้วยพารามิเตอร์ที่กำหนด
7	cursor.executescript(sql_script) รูทีนนี้รันคำสั่ง SQL หลายคำสั่งพร้อมกันในรูปแบบของสคริปต์ มันออกคำสั่ง COMMIT ก่อนจากนั้นเรียกใช้สคริปต์ SQL ที่ได้รับเป็นพารามิเตอร์ คำสั่ง SQL ทั้งหมดควรคั่นด้วยเซมิโคลอน (;)
8	connection.executescript(sql_script) รูทีนนี้เป็นทางลัดที่สร้างวัตถุเคอร์เซอร์กลางโดยเรียกวิธีการเคอร์เซอร์จากนั้นเรียกเมธอด executescript ของเคอร์เซอร์ด้วยพารามิเตอร์ที่กำหนด
9	connection.total_changes() รูทีนนี้จะส่งคืนจำนวนแถวฐานข้อมูลทั้งหมดที่ถูกแก้ไขแทรกหรือลบไปตั้งแต่เปิดการเชื่อมต่อฐานข้อมูล
10	connection.commit() วิธีนี้ทำธุรกรรมปัจจุบัน หากคุณไม่เรียกใช้เมธอดนี้สิ่งที่คุณทำตั้งแต่การเรียกครั้งสุดท้ายเพื่อกระทำ () จะมองไม่เห็นจากการเชื่อมต่อฐานข้อมูลอื่น
11	connection.rollback() วิธีนี้ย้อนกลับการเปลี่ยนแปลงใด ๆ ในฐานข้อมูลตั้งแต่การเรียกครั้งสุดท้ายเพื่อกระทำ ()
12	connection.close() วิธีนี้จะปิดการเชื่อมต่อฐานข้อมูล โปรดทราบว่าสิ่งนี้ไม่ได้เรียกใช้การกระทำ () โดยอัตโนมัติ หากคุณเพียงแค่ปิดการเชื่อมต่อฐานข้อมูลโดยไม่เรียกคอมมิต () ก่อนการเปลี่ยนแปลงของคุณจะสูญหาย!
13	cursor.fetchone() วิธีนี้ดึงข้อมูลแถวถัดไปของชุดผลลัพธ์คิวรีส่งคืนลำดับเดียวหรือไม่มีเมื่อไม่มีข้อมูลเพิ่มเติม
14	cursor.fetchmany([size = cursor.arraysize]) รูทีนนี้ดึงข้อมูลชุดถัดไปของผลลัพธ์คิวรีโดยส่งคืนรายการ รายการว่างจะถูกส่งกลับเมื่อไม่มีแถวเพิ่มเติม วิธีนี้พยายามดึงข้อมูลหลายแถวตามที่ระบุโดยพารามิเตอร์ขนาด
15	cursor.fetchall() รูทีนนี้ดึงข้อมูลแถวทั้งหมด (ที่เหลือ) ของผลลัพธ์คิวรีโดยส่งคืนรายการ รายการว่างจะถูกส่งกลับเมื่อไม่มีแถว

ในการสร้างการเชื่อมต่อกับพรอมต์คำสั่ง SQLite Open ให้เรียกดูตำแหน่งที่คุณติดตั้ง SQLite และดำเนินการคำสั่ง sqlite3 ดังแสดงด้านล่าง -

การสร้างการเชื่อมต่อโดยใช้ python

คุณสามารถสื่อสารกับฐานข้อมูล SQLite2 โดยใช้โมดูล SQLite3 python ในการทำเช่นนั้นก่อนอื่นคุณต้องสร้างการเชื่อมต่อ (สร้างวัตถุการเชื่อมต่อ)

ในการสร้างการเชื่อมต่อกับฐานข้อมูล SQLite3 โดยใช้ python คุณต้อง -

• นำเข้าโมดูล sqlite3 โดยใช้คำสั่ง import

• เมธอด connect () ยอมรับชื่อของฐานข้อมูลที่คุณต้องการเชื่อมต่อเป็นพารามิเตอร์และส่งคืนอ็อบเจ็กต์ Connection

ตัวอย่าง

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

เอาต์พุต

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

การใช้คำสั่ง SQLite CREATE TABLE คุณสามารถสร้างตารางในฐานข้อมูลได้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์สำหรับสร้างตารางในฐานข้อมูล SQLite -

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

ตัวอย่าง

ต่อไปนี้แบบสอบถาม / คำสั่ง SQLite สร้างตารางที่มีชื่อ CRICKETERS ในฐานข้อมูล SQLite -

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

ให้เราสร้าง OdiStats อีกหนึ่งตารางที่อธิบายสถิติคริกเก็ตหนึ่งวันของผู้เล่นแต่ละคนในตาราง CRICKETERS

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

คุณสามารถรับรายการตารางในฐานข้อมูลในฐานข้อมูล SQLite โดยใช้ไฟล์ .tablesคำสั่ง หลังจากสร้างตารางแล้วหากคุณสามารถตรวจสอบรายชื่อตารางได้คุณสามารถสังเกตตารางที่สร้างขึ้นใหม่ในรูปแบบ -

sqlite> . tables
CRICKETERS ODIStats
sqlite>

การสร้างตารางโดยใช้ python

วัตถุเคอร์เซอร์มีวิธีการทั้งหมดในการเรียกใช้งานและดึงข้อมูลเป็นต้นวิธีการเคอร์เซอร์ของคลาสการเชื่อมต่อจะส่งคืนวัตถุเคอร์เซอร์

ดังนั้นในการสร้างตารางในฐานข้อมูล SQLite โดยใช้ python -

• สร้างการเชื่อมต่อกับฐานข้อมูลโดยใช้เมธอด connect ()

• สร้างวัตถุเคอร์เซอร์โดยเรียกใช้ cursor () วิธีการบนวัตถุการเชื่อมต่อที่สร้างไว้ด้านบน

• ตอนนี้ดำเนินการคำสั่ง CREATE TABLE โดยใช้เมธอด execute () ของคลาส Cursor

ตัวอย่าง

ต่อไปนี้โปรแกรม Python สร้างตารางชื่อ Employee ใน 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()

เอาต์พุต

Table created successfully........

คุณสามารถเพิ่มแถวใหม่ในตาราง SQLite ที่มีอยู่โดยใช้คำสั่ง INSERT INTO ในสิ่งนี้คุณต้องระบุชื่อของตารางชื่อคอลัมน์และค่า (ตามลำดับเดียวกันกับชื่อคอลัมน์)

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ที่แนะนำของคำสั่ง INSERT -

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

โดยที่ column1, column2, column3, .. คือชื่อของคอลัมน์ของตารางและ value1, value2, value3, ... คือค่าที่คุณต้องแทรกลงในตาราง

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้คำสั่ง CREATE TABLE ดังที่แสดงด้านล่าง -

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

ตามคำสั่ง PostgreSQL จะแทรกแถวในตารางที่สร้างไว้ด้านบน

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

ในขณะที่แทรกระเบียนโดยใช้คำสั่ง INSERT INTO หากคุณข้ามชื่อคอลัมน์ใด ๆ บันทึกนี้จะถูกแทรกโดยเว้นช่องว่างไว้ที่คอลัมน์ที่คุณข้ามไป

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

คุณยังสามารถแทรกระเบียนลงในตารางได้โดยไม่ต้องระบุชื่อคอลัมน์หากลำดับของค่าที่คุณส่งผ่านเหมือนกับชื่อคอลัมน์ตามลำดับในตาราง

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>

หลังจากใส่ระเบียนลงในตารางแล้วคุณสามารถตรวจสอบเนื้อหาได้โดยใช้คำสั่ง SELECT ดังที่แสดงด้านล่าง -

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>

การแทรกข้อมูลโดยใช้ python

ในการเพิ่มระเบียนลงในตารางที่มีอยู่ในฐานข้อมูล SQLite -

• นำเข้าแพ็คเกจ sqlite3

• สร้างอ็อบเจ็กต์การเชื่อมต่อโดยใช้เมธอด connect () โดยส่งชื่อของฐานข้อมูลเป็นพารามิเตอร์ไป

• cursor()วิธีการส่งคืนวัตถุเคอร์เซอร์ที่คุณสามารถสื่อสารกับ SQLite3 สร้างวัตถุเคอร์เซอร์โดยเรียกใช้เคอร์เซอร์ () วัตถุบนวัตถุการเชื่อมต่อ (สร้างด้านบน)

• จากนั้นเรียกใช้เมธอด execute () บนวัตถุเคอร์เซอร์โดยส่งคำสั่ง INSERT เป็นพารามิเตอร์ไป

ตัวอย่าง

ตัวอย่าง python ต่อไปนี้จะแทรกระเบียนลงในตารางชื่อ 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()

เอาต์พุต

Records inserted........

คุณสามารถดึงข้อมูลจากตาราง SQLite โดยใช้แบบสอบถาม SELCT แบบสอบถาม / คำสั่งนี้ส่งคืนเนื้อหาของความสัมพันธ์ที่ระบุ (ตาราง) ในรูปแบบตารางและเรียกว่าเป็นชุดผลลัพธ์

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง SELECT ใน SQLite -

SELECT column1, column2, columnN FROM table_name;

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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>

คำค้นหา SELECT ต่อไปนี้จะดึงค่าของคอลัมน์ FIRST_NAME, LAST_NAME และ, COUNTRY จากตาราง 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>

ตามที่คุณสังเกตคำสั่ง SELECT ของฐานข้อมูล SQLite จะส่งคืนระเบียนของตารางที่ระบุ ในการรับเอาต์พุตที่จัดรูปแบบคุณต้องตั้งค่าไฟล์headerและ mode โดยใช้คำสั่งที่เกี่ยวข้องก่อนคำสั่ง SELECT ดังที่แสดงด้านล่าง -

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>

หากคุณต้องการดึงข้อมูลคอลัมน์ทั้งหมดของแต่ละระเบียนคุณต้องแทนที่ชื่อของคอลัมน์ด้วย "*" ดังที่แสดงด้านล่าง -

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>

ในSQLiteโดยค่าเริ่มต้นความกว้างของคอลัมน์คือ 10 ค่าความกว้างเกินกว่านี้จะสับ (สังเกตคอลัมน์ของประเทศ 2 ^{ครั้ง}แถวในตารางข้างต้น) คุณสามารถตั้งค่าความกว้างของแต่ละคอลัมน์เป็นค่าที่ต้องการโดยใช้.width ก่อนที่จะดึงเนื้อหาของตารางดังที่แสดงด้านล่าง -

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>

การดึงข้อมูลโดยใช้ python

การอ่านการดำเนินการบนฐานข้อมูลหมายถึงการดึงข้อมูลที่เป็นประโยชน์จากฐานข้อมูล คุณสามารถดึงข้อมูลจาก MYSQL โดยใช้วิธีการดึงข้อมูล () ที่จัดเตรียมโดยโมดูล sqlite python

คลาส sqlite3.Cursor มีสามวิธี ได้แก่ fetchall (), fetchmany () และ, fetchone () โดยที่

• วิธี fetchall () ดึงข้อมูลแถวทั้งหมดในชุดผลลัพธ์ของแบบสอบถามและส่งกลับเป็นรายการสิ่งที่เพิ่มขึ้น (ถ้าเราดำเนินการนี้หลังจากดึงข้อมูลไม่กี่แถวมันจะส่งคืนแถวที่เหลือ)

• วิธีการ fetchone () ดึงข้อมูลแถวถัดไปจากผลลัพธ์ของคิวรีและส่งกลับเป็นทูเพิล

• วิธีการ fetchmany () คล้ายกับ fetchone () แต่จะดึงข้อมูลชุดถัดไปของแถวในชุดผลลัพธ์ของแบบสอบถามแทนที่จะเป็นแถวเดียว

Note - ชุดผลลัพธ์คือวัตถุที่ส่งคืนเมื่อวัตถุเคอร์เซอร์ถูกใช้เพื่อสืบค้นตาราง

ตัวอย่าง

ตัวอย่างต่อไปนี้ดึงข้อมูลแถวทั้งหมดของตาราง EMPLOYEE โดยใช้แบบสอบถาม SELECT และจากชุดผลลัพธ์ที่ได้รับในตอนแรกเรากำลังดึงข้อมูลแถวแรกโดยใช้วิธี fetchone () จากนั้นดึงข้อมูลแถวที่เหลือโดยใช้วิธี fetchall ()

โปรแกรม Python ต่อไปนี้จะแสดงวิธีการดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ที่สร้างขึ้นในตัวอย่างข้างต้น

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

เอาต์พุต

('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)
]

หากคุณต้องการดึงข้อมูลลบหรืออัปเดตแถวเฉพาะของตารางใน SQLite คุณต้องใช้ where clause เพื่อระบุเงื่อนไขเพื่อกรองแถวของตารางสำหรับการดำเนินการ

ตัวอย่างเช่นหากคุณมีคำสั่ง SELECT พร้อมด้วย where clause ระบบจะเรียกเฉพาะแถวที่ตรงตามเงื่อนไขที่ระบุเท่านั้น

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของ WHERE clause ใน SQLite -

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

คุณสามารถระบุ search_condition โดยใช้ตัวดำเนินการเปรียบเทียบหรือตรรกะ เช่น>, <, =, LIKE, NOT ฯลฯ ตัวอย่างต่อไปนี้จะทำให้แนวคิดนี้ชัดเจน

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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>

คำสั่ง SELECT ต่อไปนี้จะดึงข้อมูลที่มีอายุมากกว่า 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>

โดยใช้คำสั่ง python

วัตถุ / คลาสของเคอร์เซอร์มีวิธีการทั้งหมดในการดำเนินการสืบค้นและดึงข้อมูลเป็นต้นวิธีการเคอร์เซอร์ของคลาสการเชื่อมต่อจะส่งคืนวัตถุเคอร์เซอร์

ดังนั้นในการสร้างตารางในฐานข้อมูล SQLite โดยใช้ python -

• สร้างการเชื่อมต่อกับฐานข้อมูลโดยใช้เมธอด connect ()

• สร้างวัตถุเคอร์เซอร์โดยเรียกใช้ cursor () วิธีการบนวัตถุการเชื่อมต่อที่สร้างไว้ด้านบน

• ตอนนี้ดำเนินการคำสั่ง CREATE TABLE โดยใช้เมธอด execute () ของคลาส Cursor

ตัวอย่าง

ตัวอย่างต่อไปนี้สร้างตารางชื่อพนักงานและเติมข้อมูล จากนั้นใช้คำสั่ง where จะดึงข้อมูลที่มีค่าอายุน้อยกว่า 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()

เอาต์พุต

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

ในขณะที่ดึงข้อมูลโดยใช้แบบสอบถาม SELECT คุณจะได้รับระเบียนในลำดับเดียวกับที่คุณแทรกไว้

คุณสามารถจัดเรียงผลลัพธ์ตามลำดับที่ต้องการ (จากน้อยไปมากหรือมากไปหาน้อย) โดยใช้ไฟล์ Order Byอนุประโยค ตามค่าเริ่มต้นอนุประโยคนี้จะเรียงลำดับผลลัพธ์จากน้อยไปหามากหากคุณต้องการจัดเรียงจากมากไปหาน้อยคุณจำเป็นต้องใช้ "DESC" อย่างชัดเจน

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง ORDER BY ใน SQLite

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

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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>

คำสั่ง SELECT ต่อไปนี้จะดึงข้อมูลแถวของตาราง CRICKETERS ตามลำดับจากน้อยไปหามาก -

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>

คุณสามารถใช้คอลัมน์มากกว่าหนึ่งคอลัมน์เพื่อจัดเรียงระเบียนของตาราง ต่อไปนี้งบเลือกเรียงลำดับระเบียนของตารางไส่ตามคอลัมน์อายุและ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>

โดยค่าเริ่มต้นไฟล์ ORDER BY อนุประโยคจัดเรียงระเบียนของตารางจากน้อยไปหามากคุณสามารถจัดเรียงผลลัพธ์จากมากไปหาน้อยโดยใช้ DESC เป็น -

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>

ORDER BY clause โดยใช้ python

ในการดึงเนื้อหาของตารางตามลำดับที่ระบุให้เรียกใช้เมธอด execute () บนวัตถุเคอร์เซอร์และส่งคำสั่ง SELECT พร้อมกับคำสั่ง ORDER BY เป็นพารามิเตอร์ไป

ตัวอย่าง

ในตัวอย่างต่อไปนี้เรากำลังสร้างตารางที่มีชื่อและพนักงานเติมข้อมูลและดึงข้อมูลกลับมาตามลำดับอายุ (จากน้อยไปมาก) โดยใช้คำสั่ง 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()

เอาต์พุต

[('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)]

การดำเนินการ UPDATE บนฐานข้อมูลใด ๆ หมายถึงการปรับเปลี่ยนค่าของระเบียนของตารางหนึ่งรายการขึ้นไปซึ่งมีอยู่แล้วในฐานข้อมูล คุณสามารถอัปเดตค่าของระเบียนที่มีอยู่ใน SQLite โดยใช้คำสั่ง UPDATE

ในการอัปเดตแถวเฉพาะคุณต้องใช้คำสั่ง WHERE ควบคู่ไปด้วย

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง UPDATE ใน SQLite -

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

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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>

คำชี้แจงต่อไปนี้แก้ไขอายุของนักคริกเก็ตซึ่งมีชื่อจริงคือ Shikhar -

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

หากคุณดึงข้อมูลที่ FIRST_NAME เป็น Shikhar คุณสังเกตว่าค่าอายุเปลี่ยนเป็น 45 -

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

หากคุณไม่ได้ใช้ค่าคำสั่ง WHERE ของระเบียนทั้งหมดจะได้รับการอัปเดต คำสั่ง UPDATE ต่อไปนี้จะเพิ่มอายุของระเบียนทั้งหมดในตาราง CRICKETERS ขึ้น 1 -

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

หากคุณดึงเนื้อหาของตารางโดยใช้คำสั่ง SELECT คุณจะเห็นค่าที่อัพเดตเป็น -

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>

การอัปเดตบันทึกที่มีอยู่โดยใช้ python

ในการเพิ่มระเบียนลงในตารางที่มีอยู่ในฐานข้อมูล SQLite -

• นำเข้าแพ็คเกจ sqlite3

• สร้างอ็อบเจ็กต์การเชื่อมต่อโดยใช้เมธอดconnect ()โดยส่งชื่อของฐานข้อมูลเป็นพารามิเตอร์ไป

• cursor()วิธีการส่งคืนวัตถุเคอร์เซอร์ที่คุณสามารถสื่อสารกับ SQLite3 สร้างวัตถุเคอร์เซอร์โดยเรียกใช้เคอร์เซอร์ () วัตถุบนวัตถุการเชื่อมต่อ (สร้างด้านบน)

• จากนั้นเรียกใช้เมธอด execute () บนวัตถุเคอร์เซอร์โดยส่งคำสั่ง UPDATE เป็นพารามิเตอร์ไป

ตัวอย่าง

ทำตามตัวอย่าง Python สร้างตารางที่มีชื่อ EMPLOYEE แทรก 5 ระเบียนเข้าไปและเพิ่มอายุของพนักงานชายทั้งหมด 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()

เอาต์พุต

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

ในการลบระเบียนจากตาราง SQLite คุณต้องใช้คำสั่ง DELETE FROM ในการลบระเบียนเฉพาะคุณต้องใช้ WHERE clause ควบคู่ไปด้วย

ในการอัปเดตแถวเฉพาะคุณต้องใช้คำสั่ง WHERE ควบคู่ไปด้วย

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของแบบสอบถาม DELETE ใน SQLite -

DELETE FROM table_name [WHERE Clause]

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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>

คำสั่งต่อไปนี้จะลบบันทึกของนักคริกเก็ตที่มีนามสกุล 'Sangakkara'

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

หากคุณดึงเนื้อหาของตารางโดยใช้คำสั่ง SELECT คุณจะเห็นเพียง 4 ระเบียนเนื่องจากเราได้ลบไปแล้ว

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>

หากคุณดำเนินการคำสั่ง DELETE FROM โดยไม่มีคำสั่ง WHERE ระเบียนทั้งหมดจากตารางที่ระบุจะถูกลบ

sqlite> DELETE FROM CRICKETERS;
sqlite>

เนื่องจากคุณได้ลบบันทึกทั้งหมดแล้วหากคุณพยายามดึงเนื้อหาของตาราง CRICKETERS โดยใช้คำสั่ง SELECT คุณจะได้ผลลัพธ์ที่ว่างเปล่าตามที่แสดงด้านล่าง -

sqlite> SELECT * FROM CRICKETERS;
sqlite>

การลบข้อมูลโดยใช้ python

ในการเพิ่มระเบียนลงในตารางที่มีอยู่ในฐานข้อมูล SQLite -

• นำเข้าแพ็คเกจ sqlite3

• สร้างอ็อบเจ็กต์การเชื่อมต่อโดยใช้เมธอดconnect ()โดยส่งชื่อของฐานข้อมูลเป็นพารามิเตอร์ไป

• cursor()วิธีการส่งคืนวัตถุเคอร์เซอร์ที่คุณสามารถสื่อสารกับ SQLite3 สร้างวัตถุเคอร์เซอร์โดยเรียกใช้เคอร์เซอร์ () วัตถุบนวัตถุการเชื่อมต่อ (สร้างด้านบน)

• จากนั้นเรียกใช้เมธอด execute () บนวัตถุเคอร์เซอร์โดยส่งคำสั่ง DELETE เป็นพารามิเตอร์ไป

ตัวอย่าง

ตัวอย่าง python ต่อไปนี้จะลบบันทึกจากตาราง EMPLOYEE ที่มีค่าอายุมากกว่า 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()

เอาต์พุต

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

คุณสามารถลบทั้งตารางโดยใช้คำสั่ง DROP TABLE คุณเพียงแค่ระบุชื่อของตารางที่คุณต้องการลบ

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง DROP TABLE ใน PostgreSQL -

DROP TABLE table_name;

ตัวอย่าง

สมมติว่าเราได้สร้างตารางสองตารางที่มีชื่อ CRICKETERS และ EMPLOYEES โดยใช้คำค้นหาต่อไปนี้ -

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>

ตอนนี้ถ้าคุณตรวจสอบรายการตารางโดยใช้ไฟล์ .tables คำสั่งคุณสามารถดูตารางที่สร้างไว้ด้านบน (รายการ) เป็น -

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

คำสั่งต่อไปนี้จะลบตารางชื่อพนักงานออกจากฐานข้อมูล -

sqlite> DROP table employee;
sqlite>

เนื่องจากคุณได้ลบตารางพนักงานไปแล้วหากคุณเรียกดูรายการตารางอีกครั้งคุณสามารถสังเกตได้เพียงตารางเดียวในตารางนั้น

sqlite> .tables
CRICKETERS
sqlite>

หากคุณพยายามลบตารางพนักงานอีกครั้งเนื่องจากคุณได้ลบไปแล้วคุณจะได้รับข้อผิดพลาดว่า“ ไม่มีตารางดังกล่าว” ดังที่แสดงด้านล่าง -

sqlite> DROP table employee;
Error: no such table: employee
sqlite>

ในการแก้ไขปัญหานี้คุณสามารถใช้คำสั่ง IF EXISTS ร่วมกับคำสั่ง DELTE สิ่งนี้จะลบตารางหากมีอยู่มิฉะนั้นจะข้ามการดำเนินการ DLETE

sqlite> DROP table IF EXISTS employee;
sqlite>

การวางตารางโดยใช้ Python

คุณสามารถวางตารางได้ทุกเมื่อที่ต้องการโดยใช้คำสั่ง DROP ของ MYSQL แต่คุณต้องระมัดระวังให้มากในขณะที่ลบตารางที่มีอยู่เนื่องจากข้อมูลที่สูญหายจะไม่สามารถกู้คืนได้หลังจากลบตาราง

ตัวอย่าง

ในการวางตารางจากฐานข้อมูล SQLite3 โดยใช้ python ให้เรียกใช้ไฟล์ execute() วิธีการบนวัตถุเคอร์เซอร์และส่งคำสั่ง drop เป็นพารามิเตอร์ไป

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

เอาต์พุต

Table dropped...

ในขณะที่ดึงเร็กคอร์ดหากคุณต้องการ จำกัด ด้วยจำนวนเฉพาะคุณสามารถทำได้โดยใช้ประโยค LIMIT ของ SQLite

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของ LIMIT clause ใน SQLite -

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

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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

และถ้าเราใส่ 5 ระเบียนเข้าไปโดยใช้คำสั่ง INSERT เป็น -

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>

คำสั่งต่อไปนี้ดึงข้อมูล 3 ระเบียนแรกของตาราง Cricketers โดยใช้ประโยค 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 (ไม่ใช่ลำดับที่ 1) คุณสามารถทำได้โดยใช้ OFFSET ร่วมกับ 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>

LIMIT ประโยคโดยใช้ Python

หากคุณเรียกใช้เมธอด execute () บนวัตถุเคอร์เซอร์โดยส่งแบบสอบถาม SELECT พร้อมกับประโยค LIMIT คุณสามารถดึงข้อมูลตามจำนวนที่ต้องการได้

ตัวอย่าง

ตัวอย่าง python ต่อไปนี้จะดึงข้อมูลสองระเบียนแรกของตาราง EMPLOYEE โดยใช้ประโยค 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()

เอาต์พุต

[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0)]

เมื่อคุณแบ่งข้อมูลออกเป็นสองตารางแล้วคุณสามารถดึงเรกคอร์ดที่รวมกันจากสองตารางนี้โดยใช้ Joins

ตัวอย่าง

สมมติว่าเราได้สร้างตารางที่มีชื่อ CRICKETERS โดยใช้แบบสอบถามต่อไปนี้ -

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

ให้เราสร้าง OdiStats อีกหนึ่งตารางที่อธิบายสถิติคริกเก็ตหนึ่งวันของผู้เล่นแต่ละคนในตาราง CRICKETERS

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

คำสั่งต่อไปนี้ดึงข้อมูลที่รวมค่าในสองตารางนี้ -

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>

เข้าร่วมประโยคโดยใช้ python

ต่อไปนี้ตัวอย่าง SQLite แสดงส่วนคำสั่ง JOIN โดยใช้ 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()

เอาต์พุต

[('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')]

คลาส sqlite3.Cursor เป็นอินสแตนซ์ที่คุณสามารถเรียกใช้เมธอดที่รันคำสั่ง SQLite ดึงข้อมูลจากชุดผลลัพธ์ของคิวรี คุณสามารถสร้างCursor วัตถุโดยใช้เคอร์เซอร์ () วิธีการของวัตถุ / คลาสการเชื่อมต่อ

ตัวอย่าง

import sqlite3

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

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

วิธีการ

ต่อไปนี้เป็นวิธีการต่างๆที่จัดเตรียมโดยคลาส / อ็อบเจ็กต์ Cursor

ซีเนียร์ No	วิธีการและคำอธิบาย
1	execute() รูทีนนี้รันคำสั่ง SQL คำสั่ง SQL อาจถูกกำหนดพารามิเตอร์ (เช่นตัวยึดแทนตัวอักษร SQL) โมดูล psycopg2 รองรับตัวยึดตำแหน่งโดยใช้เครื่องหมาย% s ตัวอย่างเช่น cursor.execute ("insert into people values ​​(% s,% s)", (who, age))
2	executemany() รูทีนนี้เรียกใช้คำสั่ง SQL กับลำดับพารามิเตอร์หรือการแม็พทั้งหมดที่พบในลำดับ sql
3	fetchone() วิธีนี้ดึงข้อมูลแถวถัดไปของชุดผลลัพธ์คิวรีส่งคืนลำดับเดียวหรือไม่มีเมื่อไม่มีข้อมูลเพิ่มเติม
4	fetchmany() รูทีนนี้ดึงข้อมูลชุดถัดไปของผลลัพธ์คิวรีโดยส่งคืนรายการ รายการว่างจะถูกส่งกลับเมื่อไม่มีแถวเพิ่มเติม วิธีนี้พยายามดึงข้อมูลหลายแถวตามที่ระบุโดยพารามิเตอร์ขนาด
5	fetchall() รูทีนนี้ดึงข้อมูลแถวทั้งหมด (ที่เหลือ) ของผลลัพธ์คิวรีโดยส่งคืนรายการ รายการว่างจะถูกส่งกลับเมื่อไม่มีแถว

คุณสมบัติ

ต่อไปนี้เป็นคุณสมบัติของคลาส Cursor -

ซีเนียร์ No	วิธีการและคำอธิบาย
1	arraySize นี่คือคุณสมบัติอ่าน / เขียนที่คุณสามารถกำหนดจำนวนแถวที่ส่งคืนโดยวิธีการ fetchmany ()
2	description นี่เป็นคุณสมบัติแบบอ่านอย่างเดียวซึ่งส่งคืนรายการที่มีคำอธิบายของคอลัมน์ในชุดผลลัพธ์
3	lastrowid นี่เป็นคุณสมบัติแบบอ่านอย่างเดียวหากมีคอลัมน์ที่เพิ่มขึ้นโดยอัตโนมัติในตารางค่านี้จะส่งคืนค่าที่สร้างขึ้นสำหรับคอลัมน์นั้นในการดำเนินการ INSERT หรือ UPDATE ล่าสุด
4	rowcount ส่งคืนจำนวนแถวที่ส่งคืน / อัปเดตในกรณีของการดำเนินการ SELECT และ UPDATE
5	connection แอตทริบิวต์แบบอ่านอย่างเดียวนี้จัดเตรียมการเชื่อมต่อฐานข้อมูล SQLite ที่ใช้โดยวัตถุเคอร์เซอร์

Pymongo เป็นการกระจาย python ซึ่งมีเครื่องมือในการทำงานกับ MongoDB ซึ่งเป็นวิธีที่ต้องการมากที่สุดในการสื่อสารกับฐานข้อมูล MongoDB จาก python

การติดตั้ง

ในการติดตั้ง pymongo ก่อนอื่นตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง python3 (พร้อมกับ PIP) และ MongoDB อย่างถูกต้อง จากนั้นดำเนินการคำสั่งต่อไปนี้

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

การยืนยัน

เมื่อคุณติดตั้ง pymongo แล้วให้เปิดเอกสารข้อความใหม่วางบรรทัดต่อไปนี้และบันทึกเป็น test.py

import pymongo

หากคุณติดตั้ง pymongo อย่างถูกต้องหากคุณดำเนินการ test.py ตามที่แสดงด้านล่างคุณจะไม่พบปัญหาใด ๆ

D:\Python_MongoDB>test.py
D:\Python_MongoDB>

ซึ่งแตกต่างจากฐานข้อมูลอื่น ๆ MongoDB ไม่มีคำสั่งแยกต่างหากเพื่อสร้างฐานข้อมูล

โดยทั่วไปคำสั่ง use ใช้เพื่อเลือก / สลับไปยังฐานข้อมูลเฉพาะ คำสั่งนี้ในขั้นต้นจะตรวจสอบว่าฐานข้อมูลที่เราระบุมีอยู่หรือไม่ถ้าเป็นเช่นนั้นก็จะเชื่อมต่อกับฐานข้อมูลนั้น ถ้าฐานข้อมูลที่เราระบุด้วยคำสั่ง use ไม่มีอยู่ฐานข้อมูลใหม่จะถูกสร้างขึ้น

ดังนั้นคุณสามารถสร้างฐานข้อมูลใน MongoDB โดยใช้ไฟล์ Use คำสั่ง

ไวยากรณ์

ไวยากรณ์พื้นฐานของ use DATABASE คำสั่งมีดังนี้ -

use DATABASE_NAME

ตัวอย่าง

คำสั่งต่อไปนี้สร้างฐานข้อมูลชื่อใน mydb

>use mydb
switched to db mydb

คุณสามารถตรวจสอบการสร้างของคุณโดยใช้คำสั่ง db ซึ่งจะแสดงฐานข้อมูลปัจจุบัน

>db
mydb

การสร้างฐานข้อมูลโดยใช้ python

ในการเชื่อมต่อกับ MongoDB โดยใช้ pymongo คุณต้องนำเข้าและสร้าง MongoClient จากนั้นคุณจะสามารถเข้าถึงฐานข้อมูลที่คุณต้องการสร้างได้โดยตรงจากความหลงใหลในแอตทริบิวต์

ตัวอย่าง

ตัวอย่างต่อไปนี้สร้างฐานข้อมูลใน 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())

เอาต์พุต

Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']

คุณยังสามารถระบุพอร์ตและชื่อโฮสต์ในขณะสร้าง MongoClient และสามารถเข้าถึงฐานข้อมูลในรูปแบบพจนานุกรม

ตัวอย่าง

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

เอาต์พุต

Database created........

คอลเลกชันใน MongoDB มีชุดเอกสารซึ่งคล้ายกับตารางในฐานข้อมูลเชิงสัมพันธ์

คุณสามารถสร้างคอลเลกชันโดยใช้ไฟล์ createCollection()วิธี. วิธีนี้ยอมรับค่าสตริงที่แสดงชื่อของคอลเล็กชันที่จะสร้างและพารามิเตอร์อ็อพชัน (ทางเลือก)

โดยใช้สิ่งนี้คุณสามารถระบุสิ่งต่อไปนี้ -

• ขนาดของคอลเลกชัน
• จำนวนเอกสารสูงสุดที่อนุญาตในคอลเล็กชันต่อยอด
• คอลเลกชันที่เราสร้างควรจะต่อยอดคอลเลกชัน (คอลเลกชันขนาดคงที่) หรือไม่
• คอลเลกชันที่เราสร้างควรได้รับการจัดทำดัชนีอัตโนมัติหรือไม่

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์สำหรับสร้างคอลเลกชันใน MongoDB

db.createCollection("CollectionName")

ตัวอย่าง

วิธีการต่อไปนี้สร้างคอลเลกชันชื่อ ExampleCollection

> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>

ในทำนองเดียวกันต่อไปนี้เป็นแบบสอบถามที่สร้างคอลเล็กชันโดยใช้ตัวเลือกของเมธอด createCollection ()

>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>

การสร้างคอลเลกชันโดยใช้ python

ตัวอย่าง python ต่อไปนี้เชื่อมต่อกับฐานข้อมูลใน MongoDB (mydb) และสร้างคอลเล็กชันในนั้น

ตัวอย่าง

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........")

เอาต์พุต

Collection created........

คุณสามารถจัดเก็บเอกสารลงใน MongoDB โดยใช้เมธอดinsert () วิธีนี้ยอมรับเอกสาร JSON เป็นพารามิเตอร์

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการแทรก

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

ตัวอย่าง

> 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 })
>

ในทำนองเดียวกันคุณยังสามารถแทรกเอกสารหลายฉบับโดยใช้ไฟล์ insert() วิธี.

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

การสร้างคอลเลกชันโดยใช้ python

Pymongo จัดเตรียมเมธอดชื่อ insert_one () เพื่อแทรกเอกสารใน MangoDB วิธีนี้เราต้องส่งเอกสารในรูปแบบพจนานุกรม

ตัวอย่าง

ตัวอย่างต่อไปนี้แทรกเอกสารในคอลเล็กชันชื่อตัวอย่าง

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

เอาต์พุต

{
   '_id': ObjectId('5d63ad6ce043e2a93885858b'), 
   'name': 'Ram', 
   'age': '26', 
   'city': 'Hyderabad'
}

ในการแทรกเอกสารหลายชุดลงใน MongoDB โดยใช้ pymongo คุณต้องเรียกใช้เมธอด 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)

เอาต์พุต

Data inserted ......
['101', '102', '103']

คุณสามารถอ่าน / ดึงเอกสารที่เก็บไว้จาก MongoDB โดยใช้ไฟล์ find()วิธี. วิธีนี้ดึงและแสดงเอกสารทั้งหมดใน MongoDB ด้วยวิธีที่ไม่มีโครงสร้าง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของ find() วิธี.

>db.CollectionName.find()

ตัวอย่าง

สมมติว่าเราได้แทรกเอกสาร 3 ชุดลงในฐานข้อมูลชื่อ testDB ในคอลเล็กชันที่มีชื่อตัวอย่างโดยใช้แบบสอบถามต่อไปนี้ -

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

คุณสามารถดึงเอกสารที่แทรกโดยใช้เมธอด find () เป็น -

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

คุณยังสามารถดึงเอกสารแรกในคอลเล็กชันโดยใช้เมธอด findOne () เป็น -

> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

การดึงข้อมูล (ค้นหา) โดยใช้ python

find_One() วิธีการของ pymongo ใช้ในการดึงเอกสารเดียวตามแบบสอบถามของคุณในกรณีที่ไม่ตรงกับวิธีนี้จะไม่คืนค่าอะไรเลยและหากคุณไม่ใช้แบบสอบถามใด ๆ ระบบจะส่งคืนเอกสารแรกของคอลเล็กชัน

วิธีนี้มีประโยชน์เมื่อใดก็ตามที่คุณต้องการดึงเอกสารผลลัพธ์เพียงเอกสารเดียวหรือหากคุณแน่ใจว่าแบบสอบถามของคุณส่งคืนเอกสารเพียงฉบับเดียว

ตัวอย่าง

ตามตัวอย่าง python ดึงเอกสารแรกของคอลเล็กชัน -

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

เอาต์พุต

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

หากต้องการรับเอกสารหลายชุดในแบบสอบถามเดียว (วิธีการค้นหาการโทรครั้งเดียว) คุณสามารถใช้ไฟล์ find()วิธีการของ pymongo หากไม่ได้ผ่านการสืบค้นใด ๆ สิ่งนี้จะส่งคืนเอกสารทั้งหมดของคอลเลกชันและหากคุณส่งแบบสอบถามไปยังวิธีนี้ระบบจะส่งคืนเอกสารที่ตรงกันทั้งหมด

ตัวอย่าง

#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)

เอาต์พุต

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

ขณะดึงข้อมูลโดยใช้ find()วิธีการคุณสามารถกรองเอกสารโดยใช้วัตถุแบบสอบถาม คุณสามารถส่งแบบสอบถามที่ระบุเงื่อนไขสำหรับเอกสารที่ต้องการเป็นพารามิเตอร์ไปยังวิธีนี้

ตัวดำเนินการ

ต่อไปนี้เป็นรายชื่อตัวดำเนินการที่ใช้ในการสืบค้นใน MongoDB

การดำเนินการ	ไวยากรณ์	ตัวอย่าง
ความเท่าเทียมกัน	{"key": "value"}	db.mycol.find ({"by": "tutorials point"})
น้อยกว่า	{"คีย์": {$ lt: "value"}}	db.mycol.find ({"likes": {$ lt: 50}})
น้อยกว่าเท่ากับ	{"key": {$ lte: "value"}}	db.mycol.find ({"ชอบ": {$ lte: 50}})
มากกว่า	{"key": {$ gt: "value"}}	db.mycol.find ({"ชอบ": {$ gt: 50}})
มากกว่าที่เท่าเทียมกัน	{"คีย์" {$ gte: "value"}}	db.mycol.find ({"likes": {$ gte: 50}})
ไม่เท่ากับ	{"key": {$ ne: "value"}}	db.mycol.find ({"likes": {$ ne: 50}})

ตัวอย่าง 1

ตัวอย่างต่อไปนี้ดึงเอกสารในคอลเลกชันที่มีชื่อ 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)

เอาต์พุต

Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}

ตัวอย่าง 2

ตัวอย่างต่อไปนี้ดึงเอกสารในคอลเล็กชันที่มีค่าอายุมากกว่า 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)

เอาต์พุต

Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

ในขณะที่ดึงเนื้อหาของคอลเล็กชันคุณสามารถจัดเรียงและจัดเรียงตามลำดับจากน้อยไปมากหรือมากไปหาน้อยโดยใช้ไฟล์ sort() วิธี.

ด้วยวิธีนี้คุณสามารถส่งผ่านฟิลด์และลำดับการจัดเรียงซึ่งเป็น 1 หรือ -1 โดยที่ 1 คือลำดับจากน้อยไปมากและ -1 คือลำดับจากมากไปหาน้อย

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของการจัดเรียง ()วิธีการ

>db.COLLECTION_NAME.find().sort({KEY:1})

ตัวอย่าง

สมมติว่าเราได้สร้างคอลเลคชันและใส่เอกสาร 5 ชุดลงไปดังที่แสดงด้านล่าง

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

บรรทัดต่อไปนี้จะดึงเอกสารทั้งหมดของคอลเลกชันซึ่งเรียงลำดับจากน้อยไปมากตามอายุ

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

การจัดเรียงเอกสารโดยใช้ python

ในการเรียงลำดับผลลัพธ์ของแบบสอบถามจากน้อยไปหามากหรือจากมากไปหาน้อย pymongo จะให้ไฟล์ sort()วิธี. สำหรับวิธีนี้ให้ส่งค่าตัวเลขที่แสดงจำนวนเอกสารที่คุณต้องการในผลลัพธ์

ตามค่าเริ่มต้นวิธีนี้จะเรียงลำดับเอกสารจากน้อยไปหามากตามฟิลด์ที่ระบุ หากคุณต้องการเรียงลำดับจากมากไปหาน้อยให้ส่ง -1 พร้อมกับชื่อฟิลด์ -

coll.find().sort("age",-1)

ตัวอย่าง

ตัวอย่างต่อไปนี้ดึงเอกสารทั้งหมดของคอลเลกชันที่จัดเรียงตามค่าอายุจากน้อยไปมาก -

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)

เอาต์พุต

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

คุณสามารถลบเอกสารในคอลเลกชันโดยใช้ไฟล์ remove()วิธีการของ MongoDB วิธีนี้ยอมรับพารามิเตอร์ทางเลือกสองตัว -

• เกณฑ์การลบระบุเงื่อนไขในการลบเอกสาร

• เพียงรายการเดียวหากคุณส่งพารามิเตอร์ true หรือ 1 เป็นวินาทีเอกสารจะถูกลบออกเพียงชุดเดียว

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธี remove () -

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

ตัวอย่าง

สมมติว่าเราได้สร้างคอลเลคชันและใส่เอกสาร 5 ชุดลงไปดังที่แสดงด้านล่าง

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

การค้นหาต่อไปนี้จะลบเอกสารของคอลเล็กชันซึ่งมีค่าชื่อเป็น 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" }

ถ้าคุณเรียก remove() โดยไม่ผ่านเกณฑ์การลบเอกสารทั้งหมดในคอลเล็กชันจะถูกลบ

> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()

การลบเอกสารโดยใช้ python

หากต้องการลบเอกสารออกจากคอลเล็กชัน MangoDB คุณสามารถลบเอกสารจากคอลเลกชันโดยใช้วิธีการ delete_one() และ delete_many() วิธีการ

วิธีการเหล่านี้ยอมรับออบเจ็กต์แบบสอบถามที่ระบุเงื่อนไขในการลบเอกสาร

วิธี detele_one () จะลบเอกสารเดียวในกรณีที่ตรงกัน หากไม่มีการระบุแบบสอบถามวิธีนี้จะลบเอกสารแรกในคอลเล็กชัน

ตัวอย่าง

ตัวอย่าง python ต่อไปนี้จะลบเอกสารในคอลเล็กชันซึ่งมีค่า id เป็น 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)

เอาต์พุต

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

ในทำนองเดียวกัน delete_many() วิธีการ pymongo จะลบเอกสารทั้งหมดที่ตรงตามเงื่อนไขที่ระบุ

ตัวอย่าง

ตัวอย่างต่อไปนี้จะลบเอกสารทั้งหมดในคอลเล็กชันที่มีค่าอายุมากกว่า 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)

เอาต์พุต

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

หากคุณเรียกใช้เมธอด delete_many () โดยไม่ส่งแบบสอบถามใด ๆ วิธีนี้จะลบเอกสารทั้งหมดในคอลเลกชัน

coll.delete_many({})

คุณสามารถลบคอลเลกชันโดยใช้ drop() วิธีการของ MongoDB

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของ drop () วิธีการ -

db.COLLECTION_NAME.drop()

ตัวอย่าง

ต่อไปนี้ตัวอย่างหยดคอลเลกชันที่มีชื่อตัวอย่าง -

> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myColl

การทิ้งคอลเลกชันโดยใช้ python

คุณสามารถปล่อย / ลบคอลเล็กชันจากฐานข้อมูลปัจจุบันได้โดยเรียกใช้เมธอด drop ()

ตัวอย่าง

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)

เอาต์พุต

List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myColl

คุณสามารถอัปเดตเนื้อหาของเอกสารที่มีอยู่โดยใช้ไฟล์ update() วิธีการหรือ save() วิธี.

วิธีการอัพเดตแก้ไขเอกสารที่มีอยู่ในขณะที่วิธีการบันทึกจะแทนที่เอกสารที่มีอยู่ด้วยเอกสารใหม่

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการ update () และ save () ของ MangoDB -

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

ตัวอย่าง

สมมติว่าเราได้สร้างคอลเลกชันในฐานข้อมูลและแทรก 3 ระเบียนในนั้นตามที่แสดงด้านล่าง -

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

วิธีการต่อไปนี้จะอัปเดตค่าเมืองของเอกสารด้วย 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" }

ในทำนองเดียวกันคุณสามารถแทนที่เอกสารด้วยข้อมูลใหม่ได้โดยบันทึกด้วย id เดียวกันโดยใช้เมธอด 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" }

การอัปเดตเอกสารโดยใช้ python

คล้ายกับเมธอด find_one () ที่ดึงเอกสารเดี่ยวเมธอด update_one () ของ pymongo จะอัปเดตเอกสารเดียว

วิธีนี้ยอมรับแบบสอบถามที่ระบุเอกสารที่จะอัปเดตและการดำเนินการอัปเดต

ตัวอย่าง

ตัวอย่าง python ต่อไปนี้จะอัพเดตค่าตำแหน่งของเอกสารในคอลเล็กชัน

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)

เอาต์พุต

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

ในทำนองเดียวกัน update_many() วิธีการของ pymongo จะอัพเดตเอกสารทั้งหมดที่ตรงตามเงื่อนไขที่ระบุ

ตัวอย่าง

ตัวอย่างต่อไปนี้จะอัปเดตค่าตำแหน่งในเอกสารทั้งหมดในคอลเลกชัน (เงื่อนไขว่างเปล่า) -

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)

เอาต์พุต

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

ในขณะที่ดึงเนื้อหาของคอลเล็กชันคุณสามารถ จำกัด จำนวนเอกสารในผลลัพธ์ได้โดยใช้วิธีการ จำกัด () วิธีนี้ยอมรับค่าตัวเลขที่แสดงจำนวนเอกสารที่คุณต้องการในผลลัพธ์

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการ จำกัด () -

>db.COLLECTION_NAME.find().limit(NUMBER)

ตัวอย่าง

สมมติว่าเราได้สร้างคอลเลคชันและใส่เอกสาร 5 ชุดลงไปดังที่แสดงด้านล่าง

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

บรรทัดต่อไปนี้จะดึงเอกสาร 3 ชุดแรกของคอลเล็กชัน

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

การ จำกัด เอกสารโดยใช้ python

ในการ จำกัด ผลลัพธ์ของแบบสอบถามไว้ที่เอกสารจำนวนหนึ่ง pymongo ให้ไฟล์ limit()วิธี. วิธีนี้ส่งค่าตัวเลขที่แสดงจำนวนเอกสารที่คุณต้องการในผลลัพธ์

ตัวอย่าง

ตัวอย่างต่อไปนี้ดึงเอกสารสามชุดแรกในคอลเลกชัน

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)

เอาต์พุต

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