Pengantar Pustaka Python SQL

Semua aplikasi perangkat lunak berinteraksi dengan data , paling sering melalui sistem manajemen basis data (DBMS). Beberapa bahasa pemrograman dilengkapi dengan modul yang dapat Anda gunakan untuk berinteraksi dengan DBMS, sementara yang lain memerlukan penggunaan paket pihak ketiga. Dalam tutorial ini, Anda akan menjelajahi berbagai pustaka Python SQL yang dapat Anda gunakan. Anda akan mengembangkan aplikasi langsung untuk berinteraksi dengan database SQLite, MySQL, dan PostgreSQL.

Dalam tutorial ini, Anda akan mempelajari cara:

• Hubungkan ke sistem manajemen basis data yang berbeda dengan pustaka Python SQL
• Berinteraksi dengan database SQLite, MySQL, dan PostgreSQL
• Lakukan kueri basis data umum menggunakan aplikasi Python
• Kembangkan aplikasi di database yang berbeda menggunakan skrip Python

Untuk mendapatkan hasil maksimal dari tutorial ini, Anda harus memiliki pengetahuan dasar Python, SQL, dan bekerja dengan sistem manajemen basis data. Anda juga harus dapat mengunduh dan mengimpor paket dengan Python dan mengetahui cara menginstal dan menjalankan server basis data yang berbeda secara lokal atau jarak jauh.

Unduh PDF Gratis: Lembar Cheat Python 3

Memahami Skema Basis Data

Dalam tutorial ini, Anda akan mengembangkan database yang sangat kecil untuk aplikasi media sosial. Basis data akan terdiri dari empat tabel:

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

Diagram tingkat tinggi dari skema database ditunjukkan di bawah ini:

Kedua users dan posts akan memiliki hubungan satu-ke-banyak karena satu pengguna dapat menyukai banyak posting. Demikian pula, satu pengguna dapat memposting banyak komentar, dan satu posting juga dapat memiliki banyak komentar. Jadi, keduanya users dan posts juga akan memiliki hubungan satu-ke-banyak dengan comments meja. Ini juga berlaku untuk likes tabel, jadi keduanya users dan posts akan memiliki hubungan satu-ke-banyak dengan likes tabel.

Menggunakan Pustaka Python SQL untuk Menghubungkan ke Database

Sebelum Anda berinteraksi dengan database apa pun melalui Pustaka Python SQL, Anda harus menghubungkan ke basis data itu. Di bagian ini, Anda akan melihat cara menghubungkan ke database SQLite, MySQL, dan PostgreSQL dari dalam aplikasi Python.

Catatan: Anda harus mengaktifkan dan menjalankan server MySQL dan PostgreSQL sebelum Anda menjalankan skrip di bagian database MySQL dan PostgreSQL. Untuk pengenalan singkat tentang cara memulai server MySQL, periksa bagian MySQL dari Memulai Proyek Django. Untuk mempelajari cara membuat database di PostgreSQL, lihat bagian Menyiapkan Database dari Mencegah Serangan Injeksi SQL Dengan Python.

Anda disarankan untuk membuat tiga file Python yang berbeda, sehingga Anda memiliki satu untuk masing-masing dari tiga database. Anda akan menjalankan skrip untuk setiap database dalam file yang sesuai.

SQLite

SQLite mungkin merupakan database yang paling mudah untuk terhubung dengan aplikasi Python karena Anda tidak perlu menginstal modul Python SQL eksternal untuk melakukannya. Secara default, instalasi Python Anda berisi pustaka Python SQL bernama sqlite3 yang dapat Anda gunakan untuk berinteraksi dengan database SQLite.

Terlebih lagi, database SQLite tanpa server dan mandiri , karena mereka membaca dan menulis data ke file. Artinya, tidak seperti MySQL dan PostgreSQL, Anda bahkan tidak perlu menginstal dan menjalankan server SQLite untuk melakukan operasi database!

Inilah cara Anda menggunakan sqlite3 untuk terhubung ke database SQLite dengan 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

Begini cara kerja kode ini:

• Baris 1 dan 2 impor sqlite3 dan modul Error kelas.
• Baris 4 mendefinisikan fungsi .create_connection() yang menerima jalur ke database SQLite.
• Baris 7 menggunakan .connect() dari sqlite3 modul dan mengambil jalur database SQLite sebagai parameter. Jika database ada di lokasi yang ditentukan, maka koneksi ke database dibuat. Jika tidak, database baru dibuat di lokasi yang ditentukan, dan koneksi dibuat.
• Baris 8 mencetak status koneksi database yang berhasil.
• Baris 9 menangkap pengecualian apa pun yang mungkin dilemparkan jika .connect() gagal membuat koneksi.
• Baris 10 menampilkan pesan kesalahan di konsol.

sqlite3.connect(path) mengembalikan connection objek, yang pada gilirannya dikembalikan oleh create_connection() . connection ini objek dapat digunakan untuk mengeksekusi kueri pada database SQLite. Skrip berikut membuat koneksi ke database SQLite:

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

Setelah Anda menjalankan skrip di atas, Anda akan melihat bahwa file database sm_app.sqlite dibuat di direktori root. Perhatikan bahwa Anda dapat mengubah lokasi agar sesuai dengan penyiapan Anda.

MySQL

Tidak seperti SQLite, tidak ada modul Python SQL default yang dapat Anda gunakan untuk terhubung ke database MySQL. Sebagai gantinya, Anda harus menginstal driver Python SQL untuk MySQL untuk berinteraksi dengan database MySQL dari dalam aplikasi Python. Salah satu driver tersebut adalah mysql-connector-python . Anda dapat mengunduh modul Python SQL ini dengan pip :

$ pip install mysql-connector-python

Perhatikan bahwa MySQL adalah berbasis server sistem manajemen basis data. Satu server MySQL dapat memiliki beberapa database. Tidak seperti SQLite, di mana membuat koneksi sama dengan membuat database, database MySQL memiliki proses dua langkah untuk pembuatan database:

1. Buat koneksi ke server MySQL.
2. Jalankan kueri terpisah untuk membuat database.

Tentukan fungsi yang terhubung ke server database MySQL dan mengembalikan objek koneksi:

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

Dalam skrip di atas, Anda mendefinisikan fungsi create_connection() yang menerima tiga parameter:

1. nama_host
2. nama_pengguna
3. sandi_pengguna

mysql.connector Modul Python SQL berisi metode .connect() yang Anda gunakan pada baris 7 untuk terhubung ke server database MySQL. Setelah koneksi dibuat, connection objek dikembalikan ke fungsi panggilan. Terakhir, pada baris 18 Anda memanggil create_connection() dengan nama host, nama pengguna, dan sandi.

Sejauh ini, Anda hanya membuat koneksi. Basis data belum dibuat. Untuk melakukan ini, Anda akan menentukan fungsi lain create_database() yang menerima dua parameter:

1. connection adalah connection objek ke server database yang ingin Anda gunakan untuk berinteraksi.
2. query adalah kueri yang membuat database.

Berikut tampilan fungsi ini:

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

Untuk mengeksekusi kueri, Anda menggunakan cursor obyek. query yang akan dieksekusi diteruskan ke cursor.execute() dalam format string.

Buat database bernama sm_app untuk aplikasi media sosial Anda di server database MySQL:

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

Sekarang Anda telah membuat database sm_app pada server basis data. Namun, connection objek yang dikembalikan oleh create_connection() terhubung ke server database MySQL. Anda harus terhubung ke sm_app basis data. Untuk melakukannya, Anda dapat memodifikasi create_connection() sebagai berikut:

 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

Anda dapat melihat di baris 8 bahwa create_connection() sekarang menerima parameter tambahan yang disebut db_name . Parameter ini menentukan nama database yang ingin Anda sambungkan. Anda dapat memasukkan nama database yang ingin Anda sambungkan saat Anda memanggil fungsi ini:

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

Skrip di atas berhasil memanggil create_connection() dan terhubung ke sm_app basis data.

PostgreSQL

Seperti MySQL, tidak ada pustaka Python SQL default yang dapat Anda gunakan untuk berinteraksi dengan database PostgreSQL. Sebagai gantinya, Anda perlu menginstal driver Python SQL pihak ketiga untuk berinteraksi dengan PostgreSQL. Salah satu driver Python SQL untuk PostgreSQL adalah psycopg2 . Jalankan perintah berikut di terminal Anda untuk menginstal psycopg2 Modul Python SQL:

$ pip install psycopg2

Seperti halnya database SQLite dan MySQL, Anda akan mendefinisikan create_connection() untuk membuat koneksi dengan database PostgreSQL Anda:

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

Anda menggunakan psycopg2.connect() untuk terhubung ke server PostgreSQL dari dalam aplikasi Python Anda.

Anda kemudian dapat menggunakan create_connection() untuk membuat koneksi ke database PostgreSQL. Pertama, Anda akan membuat koneksi dengan database default postgres dengan menggunakan string berikut:

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

Selanjutnya, Anda harus membuat database sm_app di dalam postgres default basis data. Anda dapat menentukan fungsi untuk mengeksekusi kueri SQL apa pun di PostgreSQL. Di bawah ini, Anda mendefinisikan create_database() untuk membuat database baru di server 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)

Setelah Anda menjalankan skrip di atas, Anda akan melihat sm_app database di server database PostgreSQL Anda.

Sebelum Anda menjalankan kueri di sm_app database, Anda perlu menghubungkannya:

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

Setelah Anda menjalankan skrip di atas, koneksi akan dibuat dengan sm_app database terletak di postgres server basis data. Di sini, 127.0.0.1 mengacu pada alamat IP host server database, dan 5432 mengacu pada nomor port server database.

Membuat Tabel

Di bagian sebelumnya, Anda melihat cara menghubungkan ke server database SQLite, MySQL, dan PostgreSQL menggunakan pustaka Python SQL yang berbeda. Anda membuat sm_app database pada ketiga server database. Di bagian ini, Anda akan melihat cara membuat tabel di dalam tiga database ini.

Seperti yang telah dibahas sebelumnya, Anda akan membuat empat tabel:

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

Anda akan mulai dengan SQLite.

SQLite

Untuk mengeksekusi query di SQLite, gunakan cursor.execute() . Di bagian ini, Anda akan mendefinisikan fungsi execute_query() yang menggunakan metode ini. Fungsi Anda akan menerima connection objek dan string kueri, yang akan Anda teruskan ke cursor.execute() .

.execute() dapat mengeksekusi kueri apa pun yang diteruskan ke dalamnya dalam bentuk string. Anda akan menggunakan metode ini untuk membuat tabel di bagian ini. Di bagian yang akan datang, Anda juga akan menggunakan metode yang sama untuk menjalankan pembaruan dan menghapus kueri.

Catatan: Skrip ini harus dijalankan dalam file yang sama tempat Anda membuat koneksi untuk database SQLite Anda.

Berikut definisi fungsi Anda:

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

Kode ini mencoba mengeksekusi query yang diberikan dan mencetak pesan kesalahan jika perlu.

Selanjutnya, tulis kueri . Anda :

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

Ini mengatakan untuk membuat tabel users dengan lima kolom berikut:

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

Terakhir, Anda akan memanggil execute_query() untuk membuat tabel. Anda akan memasukkan connection objek yang Anda buat di bagian sebelumnya, bersama dengan create_users_table string yang berisi kueri buat tabel:

execute_query(connection, create_users_table)  

Kueri berikut digunakan untuk membuat posts tabel:

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

Karena ada hubungan satu-ke-banyak antara users dan posts , Anda dapat melihat kunci asing user_id di posts tabel yang mereferensikan id kolom di users meja. Jalankan script berikut untuk membuat posts tabel:

execute_query(connection, create_posts_table)

Terakhir, Anda dapat membuat comments dan likes tabel dengan skrip berikut:

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)            

Anda dapat melihat bahwa membuat tabel di SQLite sangat mirip dengan menggunakan SQL mentah. Yang harus Anda lakukan adalah menyimpan kueri dalam variabel string dan kemudian meneruskan variabel itu ke cursor.execute() .

MySQL

Anda akan menggunakan mysql-connector-python Modul Python SQL untuk membuat tabel di MySQL. Sama seperti SQLite, Anda harus meneruskan kueri Anda ke cursor.execute() , yang dikembalikan dengan memanggil .cursor() pada connection obyek. Anda dapat membuat fungsi lain execute_query() yang menerima connection dan query string:

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

Di baris 4, Anda melewati query ke cursor.execute() .

Sekarang Anda dapat membuat users tabel menggunakan fungsi ini:

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)

Permintaan untuk mengimplementasikan hubungan kunci asing sedikit berbeda di MySQL dibandingkan dengan SQLite. Terlebih lagi, MySQL menggunakan AUTO_INCREMENT kata kunci (dibandingkan dengan SQLite AUTOINCREMENT kata kunci) untuk membuat kolom yang nilainya bertambah secara otomatis saat catatan baru dimasukkan.

Skrip berikut membuat posts tabel, yang berisi kunci asing user_id yang mereferensikan id kolom users tabel:

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)

Demikian pula, untuk membuat comments dan likes tabel, Anda dapat meneruskan CREATE . yang sesuai kueri ke execute_query() .

PostgreSQL

Seperti halnya database SQLite dan MySQL, connection objek yang dikembalikan oleh psycopg2.connect() berisi cursor obyek. Anda dapat menggunakan cursor.execute() untuk mengeksekusi kueri Python SQL pada database PostgreSQL Anda.

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

Anda dapat menggunakan fungsi ini untuk membuat tabel, menyisipkan catatan, mengubah catatan, dan menghapus catatan di database PostgreSQL Anda.

Sekarang buat users tabel di dalam sm_app basis data:

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)

Anda dapat melihat bahwa kueri untuk membuat users tabel di PostgreSQL sedikit berbeda dari SQLite dan MySQL. Di sini, kata kunci SERIAL digunakan untuk membuat kolom yang bertambah secara otomatis. Ingat bahwa MySQL menggunakan kata kunci AUTO_INCREMENT .

Selain itu, referensi kunci asing juga ditentukan secara berbeda, seperti yang ditunjukkan pada skrip berikut yang membuat posts tabel:

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)

Untuk membuat comments tabel, Anda harus menulis CREATE kueri untuk comments tabel dan berikan ke execute_query() . Proses pembuatan likes tabel adalah sama. Anda hanya perlu mengubah CREATE kueri untuk membuat likes tabel alih-alih comments tabel.

Memasukkan Catatan

Di bagian sebelumnya, Anda melihat cara membuat tabel di database SQLite, MySQL, dan PostgreSQL Anda dengan menggunakan modul Python SQL yang berbeda. Di bagian ini, Anda akan melihat cara menyisipkan data ke dalam tabel Anda.

SQLite

Untuk menyisipkan record ke database SQLite, Anda dapat menggunakan execute_query() yang sama fungsi yang Anda gunakan untuk membuat tabel. Pertama, Anda harus menyimpan INSERT INTO kueri dalam sebuah string. Kemudian, Anda dapat melewati connection objek dan query string ke execute_query() . Mari kita masukkan lima record ke dalam users tabel:

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)   

Karena Anda mengatur id kolom untuk kenaikan otomatis, Anda tidak perlu menentukan nilai id kolom untuk users ini . users tabel akan otomatis mengisi lima catatan ini dengan id nilai dari 1 ke 5 .

Sekarang masukkan enam record ke dalam posts tabel:

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)  

Penting untuk disebutkan bahwa user_id kolom posts tabel adalah kunci asing yang mereferensikan id kolom users meja. Artinya user_id kolom harus berisi nilai yang sudah ada di id kolom users meja. Jika tidak ada, maka Anda akan melihat kesalahan.

Demikian pula, skrip berikut menyisipkan catatan ke dalam comments dan likes tabel:

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)  

Dalam kedua kasus, Anda menyimpan INSERT INTO kueri sebagai string dan jalankan dengan execute_query() .

MySQL

Ada dua cara untuk memasukkan record ke dalam database MySQL dari aplikasi Python. Pendekatan pertama mirip dengan SQLite. Anda dapat menyimpan INSERT INTO kueri dalam string dan kemudian gunakan cursor.execute() untuk menyisipkan catatan.

Sebelumnya, Anda mendefinisikan fungsi pembungkus execute_query() yang Anda gunakan untuk menyisipkan catatan. Anda dapat menggunakan fungsi yang sama ini sekarang untuk memasukkan catatan ke dalam tabel MySQL Anda. Skrip berikut menyisipkan catatan ke dalam users tabel menggunakan 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)  

Pendekatan kedua menggunakan cursor.executemany() , yang menerima dua parameter:

1. Kueri string yang berisi placeholder untuk catatan yang akan disisipkan
2. Daftar catatan yang ingin Anda sisipkan

Lihat contoh berikut, yang menyisipkan dua record ke dalam likes tabel:

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

Terserah Anda pendekatan mana yang Anda pilih untuk memasukkan catatan ke tabel MySQL Anda. Jika Anda ahli dalam SQL, maka Anda dapat menggunakan .execute() . Jika Anda tidak terlalu familiar dengan SQL, mungkin lebih mudah bagi Anda untuk menggunakan .executemany() . Dengan salah satu dari dua pendekatan tersebut, Anda dapat berhasil memasukkan catatan ke dalam posts , comments , dan likes tabel.

PostgreSQL

Di bagian sebelumnya, Anda melihat dua pendekatan untuk memasukkan record ke dalam tabel database SQLite. Yang pertama menggunakan kueri string SQL, dan yang kedua menggunakan .executemany() . psycopg2 mengikuti pendekatan kedua ini, meskipun .execute() digunakan untuk mengeksekusi kueri berbasis placeholder.

Anda meneruskan kueri SQL dengan placeholder dan daftar rekaman ke .execute() . Setiap catatan dalam daftar akan menjadi tupel, di mana nilai tupel sesuai dengan nilai kolom dalam tabel database. Inilah cara Anda memasukkan catatan pengguna ke dalam users tabel dalam database 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)

Script di atas membuat daftar users yang berisi lima catatan pengguna dalam bentuk tupel. Selanjutnya, Anda membuat string placeholder dengan lima elemen placeholder (%s ) yang sesuai dengan lima catatan pengguna. String placeholder digabungkan dengan kueri yang menyisipkan catatan ke dalam users meja. Terakhir, string kueri dan catatan pengguna diteruskan ke .execute() . Script di atas berhasil memasukkan lima record ke dalam users tabel.

Lihat contoh lain untuk memasukkan record ke dalam tabel PostgreSQL. Script berikut menyisipkan record ke dalam posts tabel:

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)

Anda dapat memasukkan catatan ke dalam comments dan likes tabel dengan pendekatan yang sama.

Memilih Catatan

Di bagian ini, Anda akan melihat cara memilih record dari tabel database menggunakan modul Python SQL yang berbeda. Secara khusus, Anda akan melihat cara melakukan SELECT kueri pada database SQLite, MySQL, dan PostgreSQL Anda.

SQLite

Untuk memilih record menggunakan SQLite, Anda dapat kembali menggunakan cursor.execute() . Namun, setelah Anda selesai melakukannya, Anda harus memanggil .fetchall() . Metode ini mengembalikan daftar tupel di mana setiap tupel dipetakan ke baris yang sesuai dalam catatan yang diambil.

Untuk menyederhanakan proses, Anda dapat membuat fungsi 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")

Fungsi ini menerima connection objek dan SELECT query dan mengembalikan record yang dipilih.

SELECT

Sekarang mari kita pilih semua record dari users tabel:

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

for user in users:
    print(user)

Dalam skrip di atas, SELECT kueri memilih semua pengguna dari users meja. Ini diteruskan ke execute_read_query() , yang mengembalikan semua catatan dari users meja. Catatan tersebut kemudian dilintasi dan dicetak ke konsol.

Catatan: Tidak disarankan untuk menggunakan SELECT * pada tabel besar karena dapat menghasilkan sejumlah besar operasi I/O yang meningkatkan lalu lintas jaringan.

Output dari query di atas terlihat seperti ini:

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

Dengan cara yang sama, Anda dapat mengambil semua catatan dari posts tabel dengan script di bawah ini:

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

for post in posts:
    print(post)

Outputnya terlihat seperti ini:

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

Hasilnya menunjukkan semua record di posts tabel.

JOIN

Anda juga dapat menjalankan kueri kompleks yang melibatkan JOIN operasi untuk mengambil data dari dua tabel terkait. Misalnya, skrip berikut mengembalikan id dan nama pengguna, bersama dengan deskripsi pos yang diposkan pengguna ini:

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 object. 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 tabel:

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.