Wprowadzenie do bibliotek Pythona SQL

Wszystkie aplikacje wchodzą w interakcję z danymi , najczęściej poprzez system zarządzania bazą danych (DBMS). Niektóre języki programowania są dostarczane z modułami, których można używać do interakcji z systemem DBMS, podczas gdy inne wymagają użycia pakietów innych firm. W tym samouczku poznasz różne biblioteki Pythona SQL którego możesz użyć. Opracujesz prostą aplikację do interakcji z bazami danych SQLite, MySQL i PostgreSQL.

W tym samouczku dowiesz się, jak:

• Połącz do różnych systemów zarządzania bazami danych z bibliotekami Python SQL
• Interakcja z bazami danych SQLite, MySQL i PostgreSQL
• Wykonaj typowe zapytania do bazy danych przy użyciu aplikacji Pythona
• Rozwijaj aplikacje w różnych bazach danych za pomocą skryptu Pythona

Aby jak najlepiej wykorzystać ten samouczek, powinieneś znać podstawy Pythona, SQL i pracę z systemami zarządzania bazami danych. Powinieneś także być w stanie pobierać i importować pakiety w Pythonie oraz wiedzieć, jak instalować i uruchamiać różne serwery baz danych lokalnie lub zdalnie.

Bezpłatne pobieranie plików PDF: Ściągawka do Pythona 3

Zrozumienie schematu bazy danych

W tym samouczku opracujesz bardzo małą bazę danych dla aplikacji mediów społecznościowych. Baza danych będzie się składać z czterech tabel:

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

Diagram wysokiego poziomu schematu bazy danych jest pokazany poniżej:

Obaj users i posts będzie miał relację jeden-do-wielu, ponieważ jeden użytkownik może polubić wiele postów. Podobnie jeden użytkownik może publikować wiele komentarzy, a jeden post może mieć wiele komentarzy. Tak więc obaj users i posts będzie miał również relacje jeden-do-wielu z comments stół. Dotyczy to również likes tabeli, więc obaj users i posts będzie miał relację jeden-do-wielu z likes tabela.

Korzystanie z bibliotek Pythona SQL do łączenia się z bazą danych

Zanim wejdziesz w interakcję z jakąkolwiek bazą danych za pośrednictwem biblioteki Python SQL, musisz połączyć się do tej bazy danych. W tej sekcji zobaczysz, jak połączyć się z bazami danych SQLite, MySQL i PostgreSQL z poziomu aplikacji Pythona.

Uwaga: Będziesz potrzebować serwerów MySQL i PostgreSQL, które będą działać, zanim wykonasz skrypty w sekcjach bazy danych MySQL i PostgreSQL. Aby uzyskać krótkie wprowadzenie, jak uruchomić serwer MySQL, zapoznaj się z sekcją MySQL w temacie Uruchamianie projektu Django. Aby dowiedzieć się, jak utworzyć bazę danych w PostgreSQL, zapoznaj się z sekcją Konfigurowanie bazy danych w sekcji Zapobieganie atakom typu SQL Injection za pomocą Pythona.

Zaleca się utworzenie trzech różnych plików Pythona, więc masz po jednym dla każdej z trzech baz danych. Skrypt wykonasz dla każdej bazy danych w odpowiednim pliku.

SQLite

SQLite jest prawdopodobnie najprostszą bazą danych do łączenia się z aplikacją Pythona, ponieważ nie musisz w tym celu instalować żadnych zewnętrznych modułów Python SQL. Domyślnie twoja instalacja Pythona zawiera bibliotekę Pythona SQL o nazwie sqlite3 którego możesz użyć do interakcji z bazą danych SQLite.

Co więcej, bazy danych SQLite są bezserwerowe i samodzielny , ponieważ odczytują i zapisują dane do pliku. Oznacza to, że w przeciwieństwie do MySQL i PostgreSQL, nie musisz nawet instalować i uruchamiać serwera SQLite, aby wykonywać operacje na bazie danych!

Oto jak używasz sqlite3 aby połączyć się z bazą danych SQLite w Pythonie:

 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

Oto jak działa ten kod:

• Linie 1 i 2 importuj sqlite3 i Error modułu klasa.
• Wiersz 4 definiuje funkcję .create_connection() który akceptuje ścieżkę do bazy danych SQLite.
• Wiersz 7 używa .connect() z sqlite3 i przyjmuje jako parametr ścieżkę bazy danych SQLite. Jeśli baza danych istnieje w określonej lokalizacji, nawiązywane jest połączenie z bazą danych. W przeciwnym razie w określonej lokalizacji tworzona jest nowa baza danych i nawiązywane jest połączenie.
• Linia 8 wyświetla stan pomyślnego połączenia z bazą danych.
• Linia 9 przechwytuje każdy wyjątek, który może zostać zgłoszony, jeśli .connect() nie może nawiązać połączenia.
• Linia 10 wyświetla komunikat o błędzie w konsoli.

sqlite3.connect(path) zwraca connection obiekt, który z kolei jest zwracany przez create_connection() . To connection obiekt może być używany do wykonywania zapytań w bazie danych SQLite. Poniższy skrypt tworzy połączenie z bazą danych SQLite:

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

Po wykonaniu powyższego skryptu zobaczysz, że plik bazy danych sm_app.sqlite jest tworzony w katalogu głównym. Pamiętaj, że możesz zmienić lokalizację, aby dopasować ją do konfiguracji.

MySQL

W przeciwieństwie do SQLite, nie ma domyślnego modułu Python SQL, którego można użyć do połączenia z bazą danych MySQL. Zamiast tego musisz zainstalować sterownik Pythona SQL dla MySQL w celu interakcji z bazą danych MySQL z poziomu aplikacji Pythona. Jednym z takich sterowników jest mysql-connector-python . Możesz pobrać ten moduł Pythona SQL za pomocą pip :

$ pip install mysql-connector-python

Pamiętaj, że MySQL jest serwerem system zarządzania bazą danych. Jeden serwer MySQL może mieć wiele baz danych. W przeciwieństwie do SQLite, gdzie utworzenie połączenia jest równoznaczne z utworzeniem bazy danych, baza danych MySQL ma dwuetapowy proces tworzenia bazy danych:

1. Nawiąż połączenie na serwer MySQL.
2. Wykonaj osobne zapytanie aby utworzyć bazę danych.

Zdefiniuj funkcję, która łączy się z serwerem bazy danych MySQL i zwraca obiekt połączenia:

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

W powyższym skrypcie definiujesz funkcję create_connection() który akceptuje trzy parametry:

1. nazwa_hosta
2. nazwa_użytkownika
3. hasło_użytkownika

mysql.connector Moduł Pythona SQL zawiera metodę .connect() którego używasz w wierszu 7, aby połączyć się z serwerem bazy danych MySQL. Po nawiązaniu połączenia connection obiekt jest zwracany do funkcji wywołującej. Na koniec, w linii 18. wywołujesz create_connection() z nazwą hosta, nazwą użytkownika i hasłem.

Do tej pory tylko nawiązałeś połączenie. Baza danych nie została jeszcze utworzona. Aby to zrobić, zdefiniujesz inną funkcję create_database() który akceptuje dwa parametry:

1. connection jest connection obiekt do serwera bazy danych, z którym chcesz współpracować.
2. query to zapytanie, które tworzy bazę danych.

Oto jak wygląda ta funkcja:

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

Aby wykonać zapytania, użyj cursor obiekt. query do wykonania jest przekazywany do cursor.execute() w formacie ciągu.

Utwórz bazę danych o nazwie sm_app dla Twojej aplikacji społecznościowej na serwerze bazy danych MySQL:

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

Teraz utworzyłeś bazę danych sm_app na serwerze bazy danych. Jednak connection obiekt zwrócony przez create_connection() jest podłączony do serwera bazy danych MySQL. Musisz połączyć się z sm_app Baza danych. Aby to zrobić, możesz zmodyfikować create_connection() w następujący sposób:

 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

Możesz zobaczyć w wierszu 8, że create_connection() przyjmuje teraz dodatkowy parametr o nazwie db_name . Ten parametr określa nazwę bazy danych, z którą chcesz się połączyć. Możesz podać nazwę bazy danych, z którą chcesz się połączyć, gdy wywołasz tę funkcję:

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

Powyższy skrypt pomyślnie wywołuje metodę create_connection() i łączy się z sm_app baza danych.

PostgreSQL

Podobnie jak MySQL, nie ma domyślnej biblioteki Python SQL, której można użyć do interakcji z bazą danych PostgreSQL. Zamiast tego musisz zainstalować sterownik Python SQL innej firmy do interakcji z PostgreSQL. Jednym z takich sterowników Pythona SQL dla PostgreSQL jest psycopg2 . Wykonaj następujące polecenie na swoim terminalu, aby zainstalować psycopg2 Moduł Pythona SQL:

$ pip install psycopg2

Podobnie jak w przypadku baz danych SQLite i MySQL, zdefiniujesz create_connection() aby nawiązać połączenie z bazą danych 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

Używasz psycopg2.connect() aby połączyć się z serwerem PostgreSQL z poziomu twojej aplikacji Pythona.

Następnie możesz użyć create_connection() aby utworzyć połączenie z bazą danych PostgreSQL. Najpierw nawiążesz połączenie z domyślną bazą danych postgres za pomocą następującego ciągu:

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

Następnie musisz utworzyć bazę danych sm_app wewnątrz domyślnego postgres Baza danych. Możesz zdefiniować funkcję do wykonania dowolnego zapytania SQL w PostgreSQL. Poniżej definiujesz create_database() aby utworzyć nową bazę danych na serwerze baz danych 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)

Po uruchomieniu powyższego skryptu zobaczysz sm_app bazy danych na serwerze bazy danych PostgreSQL.

Zanim wykonasz zapytania w sm_app bazy danych, musisz się z nią połączyć:

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

Po wykonaniu powyższego skryptu zostanie nawiązane połączenie z sm_app baza danych znajdująca się w postgres Serwer bazy danych. Tutaj, 127.0.0.1 odnosi się do adresu IP hosta serwera bazy danych, a 5432 odnosi się do numeru portu serwera bazy danych.

Tworzenie tabel

W poprzedniej sekcji widziałeś, jak połączyć się z serwerami baz danych SQLite, MySQL i PostgreSQL przy użyciu różnych bibliotek Python SQL. Utworzyłeś sm_app bazy danych na wszystkich trzech serwerach baz danych. W tej sekcji zobaczysz, jak tworzyć tabele wewnątrz tych trzech baz danych.

Jak wspomniano wcześniej, utworzysz cztery tabele:

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

Zaczniesz od SQLite.

SQLite

Aby wykonać zapytania w SQLite, użyj cursor.execute() . W tej sekcji zdefiniujesz funkcję execute_query() który korzysta z tej metody. Twoja funkcja zaakceptuje connection obiekt i ciąg zapytania, który przekażesz do cursor.execute() .

.execute() może wykonać dowolne zapytanie przekazane do niego w postaci ciągu. Użyjesz tej metody do tworzenia tabel w tej sekcji. W nadchodzących sekcjach użyjesz tej samej metody do wykonywania aktualizacji i usuwania zapytań.

Uwaga: Ten skrypt powinien zostać wykonany w tym samym pliku, w którym utworzyłeś połączenie z bazą danych SQLite.

Oto twoja definicja funkcji:

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

Ten kod próbuje wykonać podane query i wyświetla komunikat o błędzie, jeśli to konieczne.

Następnie napisz swoje zapytanie :

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

To mówi, aby utworzyć tabelę users z następującymi pięcioma kolumnami:

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

Na koniec wywołasz execute_query() stworzyć tabelę. Zdasz connection obiekt, który utworzyłeś w poprzedniej sekcji, wraz z create_users_table ciąg zawierający zapytanie o utworzenie tabeli:

execute_query(connection, create_users_table)  

Poniższe zapytanie służy do tworzenia posts tabela:

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

Ponieważ istnieje relacja jeden-do-wielu między users i posts , możesz zobaczyć klucz obcy user_id w posts tabela, która odwołuje się do id kolumna w users stół. Wykonaj następujący skrypt, aby utworzyć posts tabela:

execute_query(connection, create_posts_table)

Na koniec możesz utworzyć comments i likes tabele z następującym skryptem:

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)            

Widać, że tworzenie tabel w SQLite jest bardzo podobny do używania surowego SQL. Wszystko, co musisz zrobić, to zapisać zapytanie w zmiennej ciągu, a następnie przekazać tę zmienną do cursor.execute() .

MySQL

Użyjesz mysql-connector-python Moduł Pythona SQL do tworzenia tabel w MySQL. Podobnie jak w przypadku SQLite, musisz przekazać zapytanie do cursor.execute() , który jest zwracany przez wywołanie .cursor() na connection obiekt. Możesz utworzyć inną funkcję execute_query() który akceptuje connection i query ciąg:

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

W linii 4 przekazujesz query do cursor.execute() .

Teraz możesz tworzyć swoich users tabela korzystająca z tej funkcji:

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)

Zapytanie o zaimplementowanie relacji klucza obcego jest nieco inne w MySQL w porównaniu do SQLite. Co więcej, MySQL używa AUTO_INCREMENT słowo kluczowe (w porównaniu do SQLite AUTOINCREMENT słowo kluczowe), aby utworzyć kolumny, w których wartości są automatycznie zwiększane po wstawieniu nowych rekordów.

Poniższy skrypt tworzy posts tabela, która zawiera klucz obcy user_id który odwołuje się do id kolumna users tabela:

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)

Podobnie, aby utworzyć comments i likes tabele, możesz przekazać odpowiednie CREATE zapytania do execute_query() .

PostgreSQL

Podobnie jak w przypadku baz danych SQLite i MySQL, connection obiekt zwracany przez psycopg2.connect() zawiera cursor obiekt. Możesz użyć cursor.execute() do wykonywania zapytań Python SQL w bazie danych PostgreSQL.

Zdefiniuj funkcję 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")

Możesz użyć tej funkcji do tworzenia tabel, wstawiania rekordów, modyfikowania rekordów i usuwania rekordów w bazie danych PostgreSQL.

Teraz utwórz users tabela wewnątrz sm_app baza danych:

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)

Widać, że zapytanie do utworzenia users tabela w PostgreSQL jest nieco inna niż SQLite i MySQL. Tutaj słowo kluczowe SERIAL służy do tworzenia kolumn, które zwiększają się automatycznie. Przypomnij sobie, że MySQL używa słowa kluczowego AUTO_INCREMENT .

Ponadto odwoływanie się do klucza obcego jest również określane w inny sposób, jak pokazano w poniższym skrypcie, który tworzy posts tabela:

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)

Aby utworzyć comments tabeli, będziesz musiał napisać CREATE zapytanie o comments tabeli i przekaż ją do execute_query() . Proces tworzenia likes tabela jest taka sama. Musisz tylko zmodyfikować CREATE zapytanie, aby utworzyć likes tabela zamiast comments tabela.

Wstawianie rekordów

W poprzedniej sekcji zobaczyłeś, jak tworzyć tabele w bazach danych SQLite, MySQL i PostgreSQL przy użyciu różnych modułów Python SQL. W tej sekcji zobaczysz, jak wstawiać rekordy na swoje stoły.

SQLite

Aby wstawić rekordy do bazy danych SQLite, możesz użyć tej samej metody execute_query() funkcja używana do tworzenia tabel. Najpierw musisz zapisać swoje INSERT INTO zapytanie w ciągu. Następnie możesz przekazać connection obiekt i query ciąg do execute_query() . Wstawmy pięć rekordów do users tabela:

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)   

Ponieważ ustawiłeś id kolumna do automatycznego zwiększania, nie musisz określać wartości id kolumna dla tych users . users tabela automatycznie wypełni te pięć rekordów wartością id wartości z 1 do 5 .

Teraz wstaw sześć rekordów do posts tabela:

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)  

Należy wspomnieć, że user_id kolumna posts tabela jest kluczem obcym który odwołuje się do id kolumna users stół. Oznacza to, że user_id kolumna musi zawierać wartość, która już istnieje w id kolumna users stół. Jeśli nie istnieje, zobaczysz błąd.

Podobnie, poniższy skrypt wstawia rekordy do comments i likes stoły:

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)  

W obu przypadkach przechowujesz swoje INSERT INTO zapytanie jako ciąg i wykonaj je za pomocą execute_query() .

MySQL

Istnieją dwa sposoby wstawiania rekordów do baz danych MySQL z aplikacji Pythona. Pierwsze podejście jest podobne do SQLite. Możesz przechowywać INSERT INTO zapytanie w ciągu, a następnie użyj cursor.execute() aby wstawić rekordy.

Wcześniej zdefiniowałeś funkcję opakowującą execute_query() używany do wstawiania rekordów. Możesz teraz użyć tej samej funkcji, aby wstawić rekordy do tabeli MySQL. Poniższy skrypt wstawia rekordy do users tabela przy użyciu 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)  

Drugie podejście wykorzystuje cursor.executemany() , który przyjmuje dwa parametry:

1. Zapytanie ciąg zawierający symbole zastępcze dla rekordów do wstawienia
2. Lista rekordów, które chcesz wstawić

Spójrz na poniższy przykład, który wstawia dwa rekordy do likes tabela:

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

To od Ciebie zależy, które podejście wybierzesz, aby wstawić rekordy do tabeli MySQL. Jeśli jesteś ekspertem w SQL, możesz użyć .execute() . Jeśli nie znasz się zbytnio na SQL, prostsze może być użycie .executemany() . Za pomocą jednego z dwóch podejść możesz z powodzeniem wstawiać rekordy do posts , comments i likes tabele.

PostgreSQL

W poprzedniej sekcji widziałeś dwa podejścia do wstawiania rekordów do tabel bazy danych SQLite. Pierwsza używa zapytania SQL, a druga używa .executemany() . psycopg2 podąża za tym drugim podejściem, chociaż .execute() służy do wykonywania zapytania opartego na symbolach zastępczych.

Przekazujesz zapytanie SQL z symbolami zastępczymi i listą rekordów do .execute() . Każdy rekord na liście będzie krotką, gdzie wartości krotek odpowiadają wartościom kolumn w tabeli bazy danych. Oto jak wstawić rekordy użytkowników do users tabela w bazie danych 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)

Powyższy skrypt tworzy listę users który zawiera pięć rekordów użytkownika w postaci krotek. Następnie utwórz ciąg znaków zastępczych z pięcioma elementami zastępczymi (%s ), które odpowiadają pięciu rekordom użytkownika. Ciąg znaków zastępczych jest łączony z zapytaniem, które wstawia rekordy do users stół. Na koniec ciąg zapytania i rekordy użytkownika są przekazywane do .execute() . Powyższy skrypt pomyślnie wstawia pięć rekordów do users tabela.

Spójrz na inny przykład wstawiania rekordów do tabeli PostgreSQL. Poniższy skrypt wstawia rekordy do posts tabela:

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)

Możesz wstawiać rekordy do comments i likes tabele z tym samym podejściem.

Wybieranie rekordów

W tej sekcji zobaczysz, jak wybierać rekordy z tabel bazy danych za pomocą różnych modułów Python SQL. W szczególności zobaczysz, jak wykonać SELECT zapytania do baz danych SQLite, MySQL i PostgreSQL.

SQLite

Aby wybrać rekordy za pomocą SQLite, możesz ponownie użyć cursor.execute() . Jednak po wykonaniu tej czynności musisz wywołać .fetchall() . Ta metoda zwraca listę krotek, w których każda krotka jest mapowana na odpowiedni wiersz w pobranych rekordach.

Aby uprościć ten proces, możesz utworzyć funkcję 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")

Ta funkcja akceptuje connection obiekt i SELECT zapytanie i zwraca wybrany rekord.

SELECT

Wybierzmy teraz wszystkie rekordy od users tabela:

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

for user in users:
    print(user)

W powyższym skrypcie SELECT zapytanie wybiera wszystkich użytkowników z grupy users stół. Jest to przekazywane do execute_read_query() , który zwraca wszystkie rekordy od users stół. Rekordy są następnie przeszukiwane i drukowane w konsoli.

Uwaga: Nie zaleca się używania SELECT * na dużych tabelach, ponieważ może to skutkować dużą liczbą operacji we/wy, które zwiększają ruch w sieci.

Wynik powyższego zapytania wygląda tak:

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

W ten sam sposób możesz pobrać wszystkie rekordy z posts tabela z poniższym skryptem:

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

for post in posts:
    print(post)

Wynik wygląda tak:

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

Wynik pokazuje wszystkie rekordy w posts tabela.

JOIN

Możesz także wykonywać złożone zapytania obejmujące JOIN operacje aby pobrać dane z dwóch powiązanych tabel. Na przykład poniższy skrypt zwraca identyfikatory i nazwy użytkowników wraz z opisem postów opublikowanych przez tych użytkowników:

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 obiekt. 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 tabela:

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