Въведение в Python SQL библиотеки

Всички софтуерни приложения взаимодействат сданни , най-често чрез система за управление на база данни (СУБД). Някои езици за програмиране идват с модули, които можете да използвате за взаимодействие с СУБД, докато други изискват използването на пакети на трети страни. В този урок ще разгледате различните Python SQL библиотеки които можете да използвате. Ще разработите лесно приложение за взаимодействие с бази данни SQLite, MySQL и PostgreSQL.

В този урок ще научите как да:

• Свързване към различни системи за управление на бази данни с Python SQL библиотеки
• Взаимодействайте с бази данни SQLite, MySQL и PostgreSQL
• Изпълнение често срещани заявки за база данни, използващи приложение на Python
• Разработване приложения в различни бази данни, използващи скрипт на Python

За да извлечете максимума от този урок, трябва да имате познания по основния Python, SQL и работа със системи за управление на бази данни. Освен това трябва да можете да изтегляте и импортирате пакети в Python и да знаете как да инсталирате и стартирате различни сървъри на бази данни локално или отдалечено.

Безплатно изтегляне на PDF: Cheat Sheet за Python 3

Разбиране на схемата на базата данни

В този урок ще разработите много малка база данни за приложение за социални медии. Базата данни ще се състои от четири таблици:

1. users
2. posts
3. comments
4. likes

Диаграма на високо ниво на схемата на базата данни е показана по-долу:

И двамата users и posts ще има връзка един към много, тъй като един потребител може да хареса много публикации. По същия начин един потребител може да публикува много коментари, а една публикация също може да има множество коментари. И така, и двамата users и posts също така ще има връзки едно към много с comments маса. Това важи и за likes таблица, така че и двамата users и posts ще има връзка едно към много с likes таблица.

Използване на Python SQL библиотеки за свързване към база данни

Преди да взаимодействате с която и да е база данни чрез Python SQL библиотека, трябва да се свържете към тази база данни. В този раздел ще видите как да се свържете с бази данни SQLite, MySQL и PostgreSQL от приложение на Python.

Забележка: Ще ви трябват сървърите на MySQL и PostgreSQL да работят и да работят, преди да изпълните скриптовете в секциите на базата данни MySQL и PostgreSQL. За кратко въведение как да стартирате MySQL сървър, вижте секцията MySQL на Стартиране на Django проект. За да научите как да създадете база данни в PostgreSQL, вижте раздела Настройка на база данни на Предотвратяване на атаки с инжектиране на SQL с Python.

Препоръчително е да създадете три различни файла на Python, така че да имате по един за всяка от трите бази данни. Ще изпълните скрипта за всяка база данни в съответния файл.

SQLite

SQLite е може би най-простата база данни за свързване с приложение на Python, тъй като не е необходимо да инсталирате външни Python SQL модули, за да го направите. По подразбиране вашата инсталация на Python съдържа библиотека на Python SQL с име sqlite3 които можете да използвате за взаимодействие с база данни на SQLite.

Нещо повече, SQLite бази данни са безсървърни исамостоятелни , тъй като те четат и записват данни във файл. Това означава, че за разлика от MySQL и PostgreSQL, дори не е необходимо да инсталирате и стартирате SQLite сървър, за да извършвате операции с база данни!

Ето как използвате sqlite3 за да се свържете с база данни на SQLite в Python:

 1import sqlite3
 2from sqlite3 import Error
 3
 4def create_connection(path):
 5    connection = None
 6    try:
 7        connection = sqlite3.connect(path)
 8        print("Connection to SQLite DB successful")
 9    except Error as e:
10        print(f"The error '{e}' occurred")
11
12    return connection

Ето как работи този код:

• Редове 1 и 2 импортирайте sqlite3 и Error на модула клас.
• Ред 4 дефинира функция .create_connection() който приема пътя към базата данни на SQLite.
• Ред 7 използва .connect() от sqlite3 модул и приема пътя към базата данни на SQLite като параметър. Ако базата данни съществува на посоченото място, тогава се установява връзка с базата данни. В противен случай се създава нова база данни на посоченото място и се установява връзка.
• Ред 8 отпечатва състоянието на успешната връзка с базата данни.
• Ред 9 улавя всяко изключение, което може да бъде изхвърлено, ако .connect() не успява да установи връзка.
• Ред 10 показва съобщението за грешка в конзолата.

sqlite3.connect(path) връща connection обект, който от своя страна се връща от create_connection() . Тази connection обектът може да се използва за изпълнение на заявки към база данни на SQLite. Следният скрипт създава връзка с базата данни на SQLite:

connection = create_connection("E:\\sm_app.sqlite")

След като изпълните горния скрипт, ще видите, че файл с база данни sm_app.sqlite се създава в основната директория. Имайте предвид, че можете да промените местоположението, за да съответства на вашата настройка.

MySQL

За разлика от SQLite, няма Python SQL модул по подразбиране, който можете да използвате за свързване към MySQL база данни. Вместо това ще трябва да инсталирате драйвер на Python SQL за MySQL, за да взаимодействате с MySQL база данни от приложение на Python. Един такъв драйвер е mysql-connector-python . Можете да изтеглите този Python SQL модул с pip :

$ pip install mysql-connector-python

Имайте предвид, че MySQL е базиран на сървър система за управление на база данни. Един MySQL сървър може да има множество бази данни. За разлика от SQLite, където създаването на връзка е равносилно на създаване на база данни, MySQL база данни има процес в две стъпки за създаване на база данни:

1. Направете връзка към MySQL сървър.
2. Изпълнете отделна заявка за да създадете базата данни.

Дефинирайте функция, която се свързва със сървъра на базата данни MySQL и връща обекта на връзката:

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection(host_name, user_name, user_password):
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect(
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        )
12        print("Connection to MySQL DB successful")
13    except Error as e:
14        print(f"The error '{e}' occurred")
15
16    return connection
17
18connection = create_connection("localhost", "root", "")

В горния скрипт вие дефинирате функция create_connection() който приема три параметъра:

1. име_хост
2. потребителско_име
3. потребителска_парола

mysql.connector Python SQL модулът съдържа метод .connect() който използвате в ред 7 за свързване към сървър на база данни MySQL. След като връзката бъде установена, connection обектът се връща към извикващата функция. И накрая, в ред 18 извиквате create_connection() с името на хоста, потребителското име и паролата.

Досега сте установили само връзката. Базата данни все още не е създадена. За да направите това, ще дефинирате друга функция create_database() който приема два параметъра:

1. connection е connection обект на сървъра на базата данни, с който искате да взаимодействате.
2. query е заявката, която създава базата данни.

Ето как изглежда тази функция:

def create_database(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Database created successfully")
    except Error as e:
        print(f"The error '{e}' occurred")

За да изпълнявате заявки, използвате cursor обект. query за изпълнение се предава на cursor.execute() в низов формат.

Създайте база данни с име sm_app за вашето приложение за социални медии в сървъра на базата данни MySQL:

create_database_query = "CREATE DATABASE sm_app"
create_database(connection, create_database_query)

Сега сте създали база данни sm_app на сървъра на базата данни. Въпреки това, connection обект, върнат от create_connection() е свързан към сървъра на базата данни MySQL. Трябва да се свържете с sm_app база данни. За да направите това, можете да промените create_connection() както следва:

 1def create_connection(host_name, user_name, user_password, db_name):
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect(
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        )
10        print("Connection to MySQL DB successful")
11    except Error as e:
12        print(f"The error '{e}' occurred")
13
14    return connection

Можете да видите в ред 8, че create_connection() сега приема допълнителен параметър, наречен db_name . Този параметър определя името на базата данни, към която искате да се свържете. Можете да подадете името на базата данни, към която искате да се свържете, когато извикате тази функция:

connection = create_connection("localhost", "root", "", "sm_app")

Горният скрипт успешно извиква create_connection() и се свързва с sm_app база данни.

PostgreSQL

Подобно на MySQL, няма библиотека по подразбиране на Python SQL, която можете да използвате за взаимодействие с PostgreSQL база данни. Вместо това трябва да инсталирате драйвер на Python SQL на трета страна за взаимодействие с PostgreSQL. Един такъв Python SQL драйвер за PostgreSQL е psycopg2 . Изпълнете следната команда на вашия терминал, за да инсталирате psycopg2 Python SQL модул:

$ pip install psycopg2

Подобно на базите данни SQLite и MySQL, вие ще дефинирате create_connection() за да направите връзка с вашата PostgreSQL база данни:

import psycopg2
from psycopg2 import OperationalError

def create_connection(db_name, db_user, db_password, db_host, db_port):
    connection = None
    try:
        connection = psycopg2.connect(
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        )
        print("Connection to PostgreSQL DB successful")
    except OperationalError as e:
        print(f"The error '{e}' occurred")
    return connection

Използвате psycopg2.connect() за да се свържете с PostgreSQL сървър от вашето Python приложение.

След това можете да използвате create_connection() за създаване на връзка с PostgreSQL база данни. Първо, ще направите връзка с базата данни по подразбиране postgres като използвате следния низ:

connection = create_connection(
    "postgres", "postgres", "abc123", "127.0.0.1", "5432"
)

След това трябва да създадете базата данни sm_app вътре в postgres по подразбиране база данни. Можете да дефинирате функция за изпълнение на всяка SQL заявка в PostgreSQL. По-долу дефинирате create_database() за да създадете нова база данни в сървъра на база данни PostgreSQL:

def create_database(connection, query):
    connection.autocommit = True
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Query executed successfully")
    except OperationalError as e:
        print(f"The error '{e}' occurred")

create_database_query = "CREATE DATABASE sm_app"
create_database(connection, create_database_query)

След като стартирате скрипта по-горе, ще видите sm_app база данни във вашия PostgreSQL сървър на база данни.

Преди да изпълните заявки в sm_app база данни, трябва да се свържете с нея:

connection = create_connection(
    "sm_app", "postgres", "abc123", "127.0.0.1", "5432"
)

След като изпълните горния скрипт, ще бъде установена връзка с sm_app база данни, намираща се в postgres сървър на база данни. Тук 127.0.0.1 се отнася до IP адреса на хоста на сървъра на базата данни и 5432 се отнася до номера на порта на сървъра на базата данни.

Създаване на таблици

В предишния раздел видяхте как да се свържете със сървъри на бази данни SQLite, MySQL и PostgreSQL, използвайки различни библиотеки на Python SQL. Вие създадохте sm_app база данни и на трите сървъра за бази данни. В този раздел ще видите как да създавате таблици в тези три бази данни.

Както беше обсъдено по-рано, ще създадете четири таблици:

1. users
2. posts
3. comments
4. likes

Ще започнете със SQLite.

SQLite

За да изпълнявате заявки в SQLite, използвайте cursor.execute() . В този раздел ще дефинирате функция execute_query() който използва този метод. Вашата функция ще приеме connection обект и низ на заявка, които ще предадете на cursor.execute() .

.execute() може да изпълни всяка заявка, предадена към него под формата на низ. Ще използвате този метод за създаване на таблици в този раздел. В предстоящите раздели ще използвате същия метод за изпълнение на заявки за актуализиране и изтриване.

Забележка: Този скрипт трябва да се изпълни в същия файл, в който сте създали връзката за вашата SQLite база данни.

Ето дефиницията на вашата функция:

def execute_query(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        connection.commit()
        print("Query executed successfully")
    except Error as e:
        print(f"The error '{e}' occurred")

Този код се опитва да изпълни дадената query и отпечатва съобщение за грешка, ако е необходимо.

След това напишете своята заявка :

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL,
  age INTEGER,
  gender TEXT,
  nationality TEXT
);
"""

Това казва да създадете таблица users със следните пет колони:

1. id
2. name
3. age
4. gender
5. nationality

Накрая ще извикате execute_query() за създаване на таблицата. Ще предадете connection обект, който сте създали в предишния раздел, заедно с create_users_table низ, който съдържа заявката за създаване на таблица:

execute_query(connection, create_users_table)  

Следната заявка се използва за създаване на posts таблица:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts(
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id)
);
"""

Тъй като има връзка един към много между users и posts , можете да видите външен ключ user_id в posts таблица, която препраща към id колона в users маса. Изпълнете следния скрипт, за да създадете posts таблица:

execute_query(connection, create_posts_table)

И накрая, можете да създадете comments и likes таблици със следния скрипт:

create_comments_table = """
CREATE TABLE IF NOT EXISTS comments (
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  text TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  post_id INTEGER NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id) FOREIGN KEY (post_id) REFERENCES posts (id)
);
"""

create_likes_table = """
CREATE TABLE IF NOT EXISTS likes (
  id INTEGER PRIMARY KEY AUTOINCREMENT, 
  user_id INTEGER NOT NULL, 
  post_id integer NOT NULL, 
  FOREIGN KEY (user_id) REFERENCES users (id) FOREIGN KEY (post_id) REFERENCES posts (id)
);
"""

execute_query(connection, create_comments_table)  
execute_query(connection, create_likes_table)            

Можете да видите, че създаването на таблици в SQLite е много подобно на използването на необработен SQL. Всичко, което трябва да направите, е да съхраните заявката в низова променлива и след това да предадете тази променлива на cursor.execute() .

MySQL

Ще използвате mysql-connector-python Python SQL модул за създаване на таблици в MySQL. Точно както при SQLite, трябва да предадете заявката си на cursor.execute() , което се връща чрез извикване на .cursor() на connection обект. Можете да създадете друга функция execute_query() който приема connection и query низ:

 1def execute_query(connection, query):
 2    cursor = connection.cursor()
 3    try:
 4        cursor.execute(query)
 5        connection.commit()
 6        print("Query executed successfully")
 7    except Error as e:
 8        print(f"The error '{e}' occurred")

В ред 4 предавате query към cursor.execute() .

Сега можете да създадете вашите users таблица, използвайки тази функция:

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id INT AUTO_INCREMENT, 
  name TEXT NOT NULL, 
  age INT, 
  gender TEXT, 
  nationality TEXT, 
  PRIMARY KEY (id)
) ENGINE = InnoDB
"""

execute_query(connection, create_users_table)

Заявката за внедряване на връзката с външен ключ е малко по-различна в MySQL в сравнение с SQLite. Нещо повече, MySQL използва AUTO_INCREMENT ключова дума (в сравнение с SQLite AUTOINCREMENT ключова дума), за да създадете колони, в които стойностите автоматично се увеличават когато се добавят нови записи.

Следният скрипт създава posts таблица, която съдържа външен ключ user_id който препраща към id колона на users таблица:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts (
  id INT AUTO_INCREMENT, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER NOT NULL, 
  FOREIGN KEY fk_user_id (user_id) REFERENCES users(id), 
  PRIMARY KEY (id)
) ENGINE = InnoDB
"""

execute_query(connection, create_posts_table)

По същия начин, за да създадете comments и likes таблици, можете да подадете съответния CREATE заявки към execute_query() .

PostgreSQL

Подобно на SQLite и MySQL бази данни, connection обект, върнат от psycopg2.connect() съдържа cursor обект. Можете да използвате cursor.execute() за изпълнение на Python SQL заявки във вашата PostgreSQL база данни.

Дефинирайте функция execute_query() :

def execute_query(connection, query):
    connection.autocommit = True
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Query executed successfully")
    except OperationalError as e:
        print(f"The error '{e}' occurred")

Можете да използвате тази функция за създаване на таблици, вмъкване на записи, промяна на записи и изтриване на записи във вашата PostgreSQL база данни.

Сега създайте users таблица вътре в sm_app база данни:

create_users_table = """
CREATE TABLE IF NOT EXISTS users (
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL, 
  age INTEGER,
  gender TEXT,
  nationality TEXT
)
"""

execute_query(connection, create_users_table)

Можете да видите, че заявката за създаване на users таблицата в PostgreSQL е малко по-различна от SQLite и MySQL. Тук ключовата дума SERIAL се използва за създаване на колони, които се увеличават автоматично. Припомнете си, че MySQL използва ключовата дума AUTO_INCREMENT .

В допълнение, препратката към външния ключ също е посочена по различен начин, както е показано в следващия скрипт, който създава posts таблица:

create_posts_table = """
CREATE TABLE IF NOT EXISTS posts (
  id SERIAL PRIMARY KEY, 
  title TEXT NOT NULL, 
  description TEXT NOT NULL, 
  user_id INTEGER REFERENCES users(id)
)
"""

execute_query(connection, create_posts_table)

За да създадете comments таблица, ще трябва да напишете CREATE заявка за comments таблица и я предайте на execute_query() . Процесът за създаване на likes масата е същата. Трябва само да промените CREATE заявка за създаване на likes таблица вместо comments таблица.

Вмъкване на записи

В предишния раздел видяхте как да създавате таблици във вашите SQLite, MySQL и PostgreSQL бази данни, като използвате различни Python SQL модули. В този раздел ще видите как да вмъкнете записи във вашите таблици.

SQLite

За да вмъкнете записи във вашата SQLite база данни, можете да използвате същия execute_query() функция, която сте използвали за създаване на таблици. Първо, трябва да съхраните своя INSERT INTO заявка в низ. След това можете да подадете connection обект и query низ към execute_query() . Нека вмъкнем пет записа в users таблица:

create_users = """
INSERT INTO
  users (name, age, gender, nationality)
VALUES
  ('James', 25, 'male', 'USA'),
  ('Leila', 32, 'female', 'France'),
  ('Brigitte', 35, 'female', 'England'),
  ('Mike', 40, 'male', 'Denmark'),
  ('Elizabeth', 21, 'female', 'Canada');
"""

execute_query(connection, create_users)   

Тъй като сте задали id колона за автоматично увеличение, не е необходимо да посочвате стойността на id колона за тези users . users таблицата автоматично ще попълни тези пет записа с id стойности от 1 до 5 .

Сега поставете шест записа в posts таблица:

create_posts = """
INSERT INTO
  posts (title, description, user_id)
VALUES
  ("Happy", "I am feeling very happy today", 1),
  ("Hot Weather", "The weather is very hot today", 2),
  ("Help", "I need some help with my work", 2),
  ("Great News", "I am getting married", 1),
  ("Interesting Game", "It was a fantastic game of tennis", 5),
  ("Party", "Anyone up for a late-night party today?", 3);
"""

execute_query(connection, create_posts)  

Важно е да споменем, че user_id колона на posts таблицата е външен ключ който препраща към id колона на users маса. Това означава, че user_id колоната трябва да съдържа стойност, която вече съществува в id колона на users маса. Ако не съществува, ще видите грешка.

По същия начин, следният скрипт вмъква записи в comments и likes таблици:

create_comments = """
INSERT INTO
  comments (text, user_id, post_id)
VALUES
  ('Count me in', 1, 6),
  ('What sort of help?', 5, 3),
  ('Congrats buddy', 2, 4),
  ('I was rooting for Nadal though', 4, 5),
  ('Help with your thesis?', 2, 3),
  ('Many congratulations', 5, 4);
"""

create_likes = """
INSERT INTO
  likes (user_id, post_id)
VALUES
  (1, 6),
  (2, 3),
  (1, 5),
  (5, 4),
  (2, 4),
  (4, 2),
  (3, 6);
"""

execute_query(connection, create_comments)
execute_query(connection, create_likes)  

И в двата случая съхранявате своя INSERT INTO заявете като низ и го изпълнете с execute_query() .

MySQL

Има два начина за вмъкване на записи в MySQL бази данни от приложение на Python. Първият подход е подобен на SQLite. Можете да съхраните INSERT INTO заявка в низ и след това използвайте cursor.execute() за вмъкване на записи.

По-рано дефинирахте функция за обвивка execute_query() които сте използвали за вмъкване на записи. Можете да използвате същата функция сега, за да вмъкнете записи във вашата MySQL таблица. Следният скрипт вмъква записи в users таблица с помощта на execute_query() :

create_users = """
INSERT INTO
  `users` (`name`, `age`, `gender`, `nationality`)
VALUES
  ('James', 25, 'male', 'USA'),
  ('Leila', 32, 'female', 'France'),
  ('Brigitte', 35, 'female', 'England'),
  ('Mike', 40, 'male', 'Denmark'),
  ('Elizabeth', 21, 'female', 'Canada');
"""

execute_query(connection, create_users)  

Вторият подход използва cursor.executemany() , който приема два параметъра:

1. Заявката низ, съдържащ заместители за записите, които трябва да се вмъкнат
2. Списъкът на записи, които искате да вмъкнете

Вижте следния пример, който вмъква два записа в likes таблица:

sql = "INSERT INTO likes ( user_id, post_id ) VALUES ( %s, %s )"
val = [(4, 5), (3, 4)]

cursor = connection.cursor()
cursor.executemany(sql, val)
connection.commit()

От вас зависи кой подход да изберете за вмъкване на записи във вашата MySQL таблица. Ако сте експерт по SQL, тогава можете да използвате .execute() . Ако не сте много запознати с SQL, тогава може да е по-лесно да използвате .executemany() . С всеки от двата подхода можете успешно да вмъквате записи в posts , comments и likes таблици.

PostgreSQL

В предишния раздел видяхте два подхода за вмъкване на записи в таблици на база данни на SQLite. Първият използва заявка за низове на SQL, а вторият използва .executemany() . psycopg2 следва този втори подход, въпреки че .execute() се използва за изпълнение на заявка, базирана на заместител.

Вие предавате SQL заявката с заместителите и списъка със записи на .execute() . Всеки запис в списъка ще бъде кортеж, където стойностите на кортежа съответстват на стойностите на колоните в таблицата на базата данни. Ето как можете да вмъкнете потребителски записи в users таблица в PostgreSQL база данни:

users = [
    ("James", 25, "male", "USA"),
    ("Leila", 32, "female", "France"),
    ("Brigitte", 35, "female", "England"),
    ("Mike", 40, "male", "Denmark"),
    ("Elizabeth", 21, "female", "Canada"),
]

user_records = ", ".join(["%s"] * len(users))

insert_query = (
    f"INSERT INTO users (name, age, gender, nationality) VALUES {user_records}"
)

connection.autocommit = True
cursor = connection.cursor()
cursor.execute(insert_query, users)

Скриптът по-горе създава списък с users който съдържа пет потребителски записа под формата на кортежи. След това създавате низ за място с пет елемента за място (%s ), които съответстват на петте потребителски записа. Заместващият низ е свързан със заявката, която вмъква записи в users маса. Накрая низът на заявката и потребителските записи се предават на .execute() . Горният скрипт успешно вмъква пет записа в users таблица.

Разгледайте друг пример за вмъкване на записи в PostgreSQL таблица. Следният скрипт вмъква записи в posts таблица:

posts = [
    ("Happy", "I am feeling very happy today", 1),
    ("Hot Weather", "The weather is very hot today", 2),
    ("Help", "I need some help with my work", 2),
    ("Great News", "I am getting married", 1),
    ("Interesting Game", "It was a fantastic game of tennis", 5),
    ("Party", "Anyone up for a late-night party today?", 3),
]

post_records = ", ".join(["%s"] * len(posts))

insert_query = (
    f"INSERT INTO posts (title, description, user_id) VALUES {post_records}"
)

connection.autocommit = True
cursor = connection.cursor()
cursor.execute(insert_query, posts)

Можете да вмъквате записи в comments и likes таблици със същия подход.

Избиране на записи

В този раздел ще видите как да избирате записи от таблици на база данни с помощта на различните модули на Python SQL. По-специално, ще видите как да изпълните SELECT заявки към вашите бази данни SQLite, MySQL и PostgreSQL.

SQLite

За да изберете записи с SQLite, можете отново да използвате cursor.execute() . Въпреки това, след като направите това, ще трябва да извикате .fetchall() . Този метод връща списък с кортежи, където всеки кортеж е съпоставен със съответния ред в извлечените записи.

За да опростите процеса, можете да създадете функция execute_read_query() :

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except Error as e:
        print(f"The error '{e}' occurred")

Тази функция приема connection обект и SELECT заявка и връща избрания запис.

SELECT

Нека сега да изберем всички записи от users таблица:

select_users = "SELECT * from users"
users = execute_read_query(connection, select_users)

for user in users:
    print(user)

В горния скрипт SELECT заявката избира всички потребители от users маса. Това се предава на execute_read_query() , който връща всички записи от users маса. След това записите се преминават и се отпечатват на конзолата.

Забележка: Не се препоръчва използването на SELECT * на големи таблици, тъй като това може да доведе до голям брой I/O операции, които увеличават мрежовия трафик.

Резултатът от горната заявка изглежда така:

(1, 'James', 25, 'male', 'USA')
(2, 'Leila', 32, 'female', 'France')
(3, 'Brigitte', 35, 'female', 'England')
(4, 'Mike', 40, 'male', 'Denmark')
(5, 'Elizabeth', 21, 'female', 'Canada')

По същия начин можете да извлечете всички записи от posts таблица със следния скрипт:

select_posts = "SELECT * FROM posts"
posts = execute_read_query(connection, select_posts)

for post in posts:
    print(post)

Резултатът изглежда така:

(1, 'Happy', 'I am feeling very happy today', 1)
(2, 'Hot Weather', 'The weather is very hot today', 2)
(3, 'Help', 'I need some help with my work', 2)
(4, 'Great News', 'I am getting married', 1)
(5, 'Interesting Game', 'It was a fantastic game of tennis', 5)
(6, 'Party', 'Anyone up for a late-night party today?', 3)

Резултатът показва всички записи в posts таблица.

JOIN

Можете също да изпълнявате сложни заявки, включващи JOIN операциите за извличане на данни от две свързани таблици. Например, следният скрипт връща потребителските идентификатори и имена, заедно с описанието на публикациите, които тези потребители са публикували:

select_users_posts = """
SELECT
  users.id,
  users.name,
  posts.description
FROM
  posts
  INNER JOIN users ON users.id = posts.user_id
"""

users_posts = execute_read_query(connection, select_users_posts)

for users_post in users_posts:
    print(users_post)

Here’s the output:

(1, 'James', 'I am feeling very happy today')
(2, 'Leila', 'The weather is very hot today')
(2, 'Leila', 'I need some help with my work')
(1, 'James', 'I am getting married')
(5, 'Elizabeth', 'It was a fantastic game of tennis')
(3, 'Brigitte', 'Anyone up for a late night party today?')

You can also select data from three related tables by implementing multiple JOIN operators . The following script returns all posts, along with the comments on the posts and the names of the users who posted the comments:

select_posts_comments_users = """
SELECT
  posts.description as post,
  text as comment,
  name
FROM
  posts
  INNER JOIN comments ON posts.id = comments.post_id
  INNER JOIN users ON users.id = comments.user_id
"""

posts_comments_users = execute_read_query(
    connection, select_posts_comments_users
)

for posts_comments_user in posts_comments_users:
    print(posts_comments_user)

The output looks like this:

('Anyone up for a late night party today?', 'Count me in', 'James')
('I need some help with my work', 'What sort of help?', 'Elizabeth')
('I am getting married', 'Congrats buddy', 'Leila')
('It was a fantastic game of tennis', 'I was rooting for Nadal though', 'Mike')
('I need some help with my work', 'Help with your thesis?', 'Leila')
('I am getting married', 'Many congratulations', 'Elizabeth')

You can see from the output that the column names are not being returned by .fetchall() . To return column names, you can use the .description attribute of the cursor обект. For instance, the following list returns all the column names for the above query:

cursor = connection.cursor()
cursor.execute(select_posts_comments_users)
cursor.fetchall()

column_names = [description[0] for description in cursor.description]
print(column_names)

The output looks like this:

['post', 'comment', 'name']

You can see the names of the columns for the given query.

WHERE

Now you’ll execute a SELECT query that returns the post, along with the total number of likes that the post received:

select_post_likes = """
SELECT
  description as Post,
  COUNT(likes.id) as Likes
FROM
  likes,
  posts
WHERE
  posts.id = likes.post_id
GROUP BY
  likes.post_id
"""

post_likes = execute_read_query(connection, select_post_likes)

for post_like in post_likes:
    print(post_like)

The output is as follows:

('The weather is very hot today', 1)
('I need some help with my work', 1)
('I am getting married', 2)
('It was a fantastic game of tennis', 1)
('Anyone up for a late night party today?', 2)

By using a WHERE clause, you’re able to return more specific results.

MySQL

The process of selecting records in MySQL is absolutely identical to selecting records in SQLite. You can use cursor.execute() followed by .fetchall() . The following script creates a wrapper function execute_read_query() that you can use to select records:

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except Error as e:
        print(f"The error '{e}' occurred")

Now select all the records from the users таблица:

select_users = "SELECT * FROM users"
users = execute_read_query(connection, select_users)

for user in users:
    print(user)

The output will be similar to what you saw with SQLite.

PostgreSQL

The process of selecting records from a PostgreSQL table with the psycopg2 Python SQL module is similar to what you did with SQLite and MySQL. Again, you’ll use cursor.execute() followed by .fetchall() to select records from your PostgreSQL table. The following script selects all the records from the users table and prints them to the console:

def execute_read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except OperationalError as e:
        print(f"The error '{e}' occurred")

select_users = "SELECT * FROM users"
users = execute_read_query(connection, select_users)

for user in users:
    print(user)

Again, the output will be similar to what you’ve seen before.

Updating Table Records

In the last section, you saw how to select records from SQLite, MySQL, and PostgreSQL databases. In this section, you’ll cover the process for updating records using the Python SQL libraries for SQLite, PostgresSQL, and MySQL.

SQLite

Updating records in SQLite is pretty straightforward. You can again make use of execute_query() . As an example, you can update the description of the post with an id of 2 . First, SELECT the description of this post:

select_post_description = "SELECT description FROM posts WHERE id = 2"

post_description = execute_read_query(connection, select_post_description)

for description in post_description:
    print(description)

You should see the following output:

('The weather is very hot today',)

The following script updates the description:

update_post_description = """
UPDATE
  posts
SET
  description = "The weather has become pleasant now"
WHERE
  id = 2
"""

execute_query(connection,  update_post_description)

Now, if you execute the SELECT query again, you should see the following result:

('The weather has become pleasant now',)

The output has been updated.

MySQL

The process of updating records in MySQL with mysql-connector-python is also a carbon copy of the sqlite3 Python SQL module. You need to pass the string query to cursor.execute() . For example, the following script updates the description of the post with an id of 2 :

update_post_description = """
UPDATE
  posts
SET
  description = "The weather has become pleasant now"
WHERE
  id = 2
"""

execute_query(connection,  update_post_description)

Again, you’ve used your wrapper function execute_query() to update the post description.

PostgreSQL

The update query for PostgreSQL is similar to what you’ve seen with SQLite and MySQL. You can use the above scripts to update records in your PostgreSQL table.

Deleting Table Records

In this section, you’ll see how to delete table records using the Python SQL modules for SQLite, MySQL, and PostgreSQL databases. The process of deleting records is uniform for all three databases since the DELETE query for the three databases is the same.

SQLite

You can again use execute_query() to delete records from YOUR SQLite database. All you have to do is pass the connection object and the string query for the record you want to delete to execute_query() . Then, execute_query() will create a cursor object using the connection and pass the string query to cursor.execute() , which will delete the records.

As an example, try to delete the comment with an id of 5 :

delete_comment = "DELETE FROM comments WHERE id = 5"
execute_query(connection, delete_comment)

Now, if you select all the records from the comments table, you’ll see that the fifth comment has been deleted.

MySQL

The process for deletion in MySQL is also similar to SQLite, as shown in the following example:

delete_comment = "DELETE FROM comments WHERE id = 2"
execute_query(connection, delete_comment)

Here, you delete the second comment from the sm_app database’s comments table in your MySQL database server.

PostgreSQL

The delete query for PostgreSQL is also similar to SQLite and MySQL. You can write a delete query string by using the DELETE keyword and then passing the query and the connection object to execute_query() . This will delete the specified records from your PostgreSQL database.

Conclusion

In this tutorial, you’ve learned how to use three common Python SQL libraries. sqlite3 , mysql-connector-python , and psycopg2 allow you to connect a Python application to SQLite, MySQL, and PostgreSQL databases, respectively.

Now you can:

• Interact with SQLite, MySQL, or PostgreSQL databases
• Use three different Python SQL modules
• Execute SQL queries on various databases from within a Python application

However, this is just the tip of the iceberg! There are also Python SQL libraries for object-relational mapping , such as SQLAlchemy and Django ORM, that automate the task of database interaction in Python. You’ll learn more about these libraries in other tutorials in our Python databases section.