PythonSQLライブラリの概要

最後に、 execute_query（）を呼び出します テーブルを作成します。 connectionを渡します 前のセクションで作成したオブジェクトとcreate_users_table テーブル作成クエリを含む文字列：

execute_query(connection, create_users_table)  

次のクエリは、投稿を作成するために使用されます テーブル：

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

ユーザーの間には1対多の関係があるため およびposts 、外部キー user_idが表示されます 投稿で idを参照するテーブル usersの列 テーブル。次のスクリプトを実行して、 postsを作成します テーブル：

execute_query(connection, create_posts_table)

最後に、コメントを作成できます および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を使用します MySQLでテーブルを作成するPythonSQLモジュール。 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（）へ 。

これで、ユーザーを作成できます この関数を使用するテーブル：

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)

外部キー関係を実装するためのクエリは、SQLiteと比較してMySQLではわずかに異なります。さらに、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)

同様に、コメントを作成するには およびlikes テーブルでは、対応する CREATEを渡すことができます execute_query（）へのクエリ 。

PostgreSQL

SQLiteおよびMySQLデータベースと同様に、 connection psycopg2.connect（）によって返されるオブジェクト カーソルが含まれています 物体。 cursor.execute（）を使用できます PostgreSQLデータベースでPythonSQLクエリを実行します。

関数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を使用していることを思い出してください 。

さらに、 post を作成する次のスクリプトに示すように、外部キー参照も異なる方法で指定されます。 テーブル：

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)

コメントを作成するには テーブルには、 CREATEを作成する必要があります コメントのクエリ テーブルを作成し、 execute_query（）に渡します。 。 likesを作成するプロセス テーブルは同じです。 CREATEを変更するだけです likesを作成するためのクエリ コメントの代わりにテーブル テーブル。

レコードの挿入

前のセクションでは、さまざまなPython SQLモジュールを使用して、SQLite、MySQL、およびPostgreSQLデータベースにテーブルを作成する方法を説明しました。このセクションでは、レコードを挿入する方法を説明します あなたのテーブルに。

SQLite

SQLiteデータベースにレコードを挿入するには、同じ execute_query（）を使用できます。 テーブルの作成に使用した関数。まず、 INSERT INTOを保存する必要があります 文字列でクエリします。次に、 connectionを渡すことができます オブジェクトとquery execute_query（）への文字列 。 usersに5つのレコードを挿入しましょう テーブル：

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の値を指定する必要はありません これらのユーザーの列 。 ユーザー tableは、これら5つのレコードに idを自動入力します 1の値 5へ 。

次に、6つのレコードを postに挿入します テーブル：

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 投稿の列 テーブルは外部キーです idを参照します usersの列 テーブル。これは、 user_idが 列には、すでに存在する値が含まれている必要があります id内 usersの列 テーブル。存在しない場合は、エラーが表示されます。

同様に、次のスクリプトはレコードをコメントに挿入します および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

PythonアプリケーションからMySQLデータベースにレコードを挿入する方法は2つあります。最初のアプローチは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)  

2番目のアプローチでは、 cursor.executemany（）を使用します 、2つのパラメータを受け入れます：

1. クエリ 挿入するレコードのプレースホルダーを含む文字列
2. リスト 挿入するレコードの数

次の例を見てください。この例では、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（）を使用する方が簡単な場合があります。 。 2つのアプローチのいずれかを使用すると、レコードを postに正常に挿入できます。 、コメント 、および likes テーブル。

PostgreSQL

前のセクションでは、SQLiteデータベーステーブルにレコードを挿入するための2つのアプローチを見ました。 1つ目はSQL文字列クエリを使用し、2つ目は .executemany（）を使用します 。 psycopg2 .execute（）は、この2番目のアプローチに従います。 プレースホルダーベースのクエリを実行するために使用されます。

プレースホルダーとレコードのリストを含む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を作成します タプルの形式で5つのユーザーレコードが含まれています。次に、5つのプレースホルダー要素（％s ）を含むプレースホルダー文字列を作成します ）5つのユーザーレコードに対応します。プレースホルダー文字列は、レコードを usersに挿入するクエリと連結されます。 テーブル。最後に、クエリ文字列とユーザーレコードが .execute（）に渡されます 。上記のスクリプトは、5つのレコードを usersに正常に挿入します テーブル。

PostgreSQLテーブルにレコードを挿入する別の例を見てください。次のスクリプトは、レコードを postに挿入します テーブル：

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)

コメントにレコードを挿入できます およびlikes 同じアプローチのテーブル。

レコードの選択

このセクションでは、さまざまなPythonSQLモジュールを使用してデータベーステーブルからレコードを選択する方法を説明します。特に、 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

次に、ユーザーからすべてのレコードを選択しましょう テーブル：

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を含む複雑なクエリを実行することもできます 操作 2つの関連するテーブルからデータを取得します。たとえば、次のスクリプトは、ユーザーIDと名前、およびこれらのユーザーが投稿した投稿の説明を返します。

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