Python MySQL-はじめに

データベースインターフェイスのPython標準は、Python DB-APIです。ほとんどのPythonデータベースインターフェイスは、この標準に準拠しています。

アプリケーションに適したデータベースを選択できます。 Python Database APIは、次のような幅広いデータベースサーバーをサポートしています-

ガドフライ
mSQL
MySQL
PostgreSQL
Microsoft SQL Server 2000
Informix
Interbase
オラクル
Sybase

利用可能なPythonデータベースインターフェイスのリストは次のとおりです。https://wiki.python.org/moin/DatabaseInterfaces [PythonデータベースインターフェイスとAPI]。アクセスする必要のあるデータベースごとに個別のDB APIモジュールをダウンロードする必要があります。たとえば、MySQLデータベースだけでなくOracleデータベースにもアクセスする必要がある場合、OracleとMySQLデータベースモジュールの両方をダウンロードする必要があります。

mysql-connector-pythonとは何ですか？

MySQL Python/Connectorは、PythonからMySQLデータベースサーバーに接続するためのインターフェイスです。 Python Database APIを実装し、MySQLの上に構築されています。

mysql-connector-pythonをインストールするにはどうすればよいですか？

まず最初に、あなたのマシンに既にpythonがインストールされていることを確認する必要があります。これを行うには、コマンドプロンプトを開き、そこにpythonと入力してEnterキーを押します。 pythonが既にシステムにインストールされている場合、このコマンドは以下に示すようにバージョンを表示します-

C:\Users\finddevguides>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

_ctrl + z_を押してからEnterを押して、Pythonシェルから抜け出し、Python_MySQLという名前のフォルダー（Python-MySQLコネクターをインストールする予定）を作成します-

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

PIPを検証する

PIPは、Pythonのさまざまなモジュール/パッケージをインストールできるPythonのパッケージマネージャーです。したがって、Mysql-python mysql-connector-pythonをインストールするには、コンピューターにPIPがインストールされており、その場所がパスに追加されていることを確認する必要があります。

そのためには、pipコマンドを実行します。システムにPIPがない場合、または Path 環境変数にその場所を追加していない場合、次のようなエラーメッセージが表示されます-

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

PIPをインストールするには、上記で作成したフォルダにhttps://bootstrap.pypa.io/get-pip.py[get-pip.py]をダウンロードし、コマンドから次のようにナビゲートしてpipをインストールします-

D:\>cd Python_MySQL
D:\Python_MySQL>python get-pip.py
Collecting pip
Downloading https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl (1.4MB)
|████████████████████████████████| 1.4MB 1.3MB/s
Collecting wheel
Downloading https://files.pythonhosted.org/packages/00/83/b4a77d044e78ad1a45610eb88f745be2fd2c6d658f9798a15e384b7d57c9/wheel-0.33.6-py2.py3-none-any.whl
Installing collected packages: pip, wheel
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
Successfully installed pip-19.2.2 wheel-0.33.6

mysql-connector-pythonのインストール

PythonとPIPをインストールしたら、以下に示すようにコマンドプロンプトを開き、pip（オプション）をアップグレードします-

C:\Users\finddevguides>python -m pip install --upgrade pip
Collecting pip
Using cached https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Python Data Access
4
Installing collected packages: pip
Found existing installation: pip 19.0.3
Uninstalling pip-19.0.3:
Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

次に、管理者モードでコマンドプロンプトを開き、python MySQLをインストールします。

C:\WINDOWS\system32>pip install mysql-connector-python
Collecting mysql-connector-python
Using cached https://files.pythonhosted.org/packages/99/74/f41182e6b7aadc62b038b6939dce784b7f9ec4f89e2ae14f9ba8190dc9ab/mysql_connector_python-8.0.17-py2.py3-none-any.whl
Collecting protobuf>=3.0.0 (from mysql-connector-python)
Using cached https://files.pythonhosted.org/packages/09/0e/614766ea191e649216b87d331a4179338c623e08c0cca291bcf8638730ce/protobuf-3.9.1-cp37-cp37m-win32.whl
Collecting six>=1.9 (from protobuf>=3.0.0->mysql-connector-python)
Using cached https://files.pythonhosted.org/packages/73/fb/00a976f728d0d1fecfe898238ce23f502a721c0ac0ecfedb80e0d88c64e9/six-1.12.0-py2.py3-none-any.whl
Requirement already satisfied: setuptools in c:\program files (x86)\python37-32\lib\site-packages (from protobuf>=3.0.0->mysql-connector-python) (40.8.0)
Installing collected packages: six, protobuf, mysql-connector-python
Successfully installed mysql-connector-python-8.0.17 protobuf-3.9.1 six-1.12.0

検証

のインストールを確認するには、次の行を含むサンプルPythonスクリプトを作成します。

import mysql.connector

インストールが成功した場合、それを実行すると、エラーが発生しないはずです-

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

Pythonをゼロからインストールする

単に、Pythonをゼロからインストールする必要がある場合。 https://www.python.org [Python Home Page]にアクセスしてください。

Pythonのインストール

*_Downloads_* ボタンをクリックすると、ダウンロードページにリダイレクトされ、さまざまなプラットフォームのPythonの最新バージョンへのリンクが表示され、いずれかを選択してダウンロードします。

Pythonダウンロード

たとえば、python-3.7.4.exe（Windows用）をダウンロードしました。ダウンロードした_.exe_ファイルをダブルクリックして、インストールプロセスを開始します。

インストールの開始

[パスにPython 3.7を追加]オプションをオンにして、インストールを続行します。このプロセスの完了後、pythonがシステムにインストールされます。

インストール後

Python MySQL-データベース接続

MySQLに接続するには、（1つの方法は）以下に示すようにシステムでMySQLコマンドプロンプトを開きます-

MySQLコマンドプロンプト

ここでパスワードを要求します。インストール時にデフォルトユーザー（root）に設定したパスワードを入力する必要があります。

次に、MySQLとの接続が確立され、次のメッセージが表示されます-

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4
Server version: 5.7.12-log MySQL Community Server (GPL)

Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>プロンプトでexitコマンドを使用すると、いつでもMySQLデータベースから切断できます。

mysql> exit
Bye

Pythonを使用してMySQLとの接続を確立する

Pythonを使用してMySQLデータベースへの接続を確立する前に、次のことを想定します-

mydbという名前のデータベースを作成したこと。
FIRST_NAME、LAST_NAME、AGE、SEX、およびINCOME列を含むテーブルEMPLOYEEを作成しました。

MySQLとの接続に使用している資格情報は、ユーザー名： root 、パスワード： password です。

*_connect（）_* コンストラクターを使用して接続を確立できます。 これは、ユーザー名、パスワード、ホスト、および接続する必要があるデータベースの名前を受け入れ（オプション）、MySQLConnectionクラスのオブジェクトを返します。

例

以下は、MySQLデータベース「mydb」と接続する例です。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1', database='mydb')

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

#Executing an MYSQL function using the execute() method
cursor.execute("SELECT DATABASE()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Connection established to: ",data)

#Closing the connection
conn.close()

出力

実行すると、このスクリプトは次の出力を生成します-

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

以下に示すように、資格情報（ユーザー名、パスワード、ホスト名、データベース名）を connection.MySQLConnection（） に渡すことで、MySQLへの接続を確立することもできます-

from mysql.connector import (connection)

#establishing the connection
conn = connection.MySQLConnection(user='root', password='password', host='127.0.0.1', database='mydb')

#Closing the connection
conn.close()

Python MySQL-データベースの作成

CREATE DATABASEクエリを使用して、MYSQLでデータベースを作成できます。

構文

以下は、CREATE DATABASEクエリの構文です-

CREATE DATABASE name_of_the_database

例

次のステートメントは、MySQLにmydbという名前のデータベースを作成します-

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

SHOW DATABASESステートメントを使用してデータベースのリストを見ると、以下に示すように、その中に新しく作成されたデータベースを見ることができます-

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

Pythonを使用してMySQLでデータベースを作成する

MySQLとの接続を確立した後、その中のデータを操作するには、データベースに接続する必要があります。既存のデータベースに接続するか、独自のデータベースを作成できます。

MySQLデータベースを作成または削除するには、特別な権限が必要です。したがって、rootユーザーにアクセスできる場合は、任意のデータベースを作成できます。

例

次の例では、MYSQLとの接続を確立し、その中にデータベースを作成します。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1')

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

#Doping database MYDATABASE if already exists.
cursor.execute("DROP database IF EXISTS MyDatabase")

#Preparing query to create a database
sql = "CREATE database MYDATABASE";

#Creating a database
cursor.execute(sql)

#Retrieving the list of databases
print("List of databases: ")
cursor.execute("SHOW DATABASES")
print(cursor.fetchall())

#Closing the connection
conn.close()

出力

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

Python MySQL-テーブルの作成

CREATE TABLEステートメントは、MYSQLデータベースにテーブルを作成するために使用されます。ここでは、テーブルの名前と、各列の定義（名前とデータ型）を指定する必要があります。

構文

以下は、MySQLでテーブルを作成するための構文です-

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

例

次のクエリは、FIRST_NAME、LAST_NAME、AGE、SEX、およびINCOMEという5つの列を持つMySQLのEMPLOYEEという名前のテーブルを作成します。

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.42 sec)

DESCステートメントは、指定されたテーブルの説明を提供します。これを使用すると、以下に示すように、テーブルが作成されているかどうかを確認できます-

mysql> Desc Employee;
+------------+----------+------+-----+---------+-------+
| Field      | Type     | Null | Key | Default | Extra |
+------------+----------+------+-----+---------+-------+
| FIRST_NAME | char(20) | NO   |     | NULL    |       |
| LAST_NAME  | char(20) | YES  |     | NULL    |       |
| AGE        | int(11)  | YES  |     | NULL    |       |
| SEX        | char(1)  | YES  |     | NULL    |       |
| INCOME     | float    | YES  |     | NULL    |       |
+------------+----------+------+-----+---------+-------+
5 rows in set (0.07 sec)

Pythonを使用してMySQLでテーブルを作成する

*_execute（）_* （カーソルオブジェクトで呼び出される）という名前のメソッドは、2つの変数を受け入れます-

実行されるクエリを表す文字列値。
クエリのパラメーター（プレースホルダーの値）を表す、タプル、リスト、または辞書であるオプションのargsパラメーター。

クエリの影響を受ける行の数を表す整数値を返します。

データベース接続が確立されると、CREATE TABLEクエリを* execute（）*メソッドに渡すことでテーブルを作成できます。

つまり、python 7minusを使用してテーブルを作成します。

mysql.connector パッケージをインポートします。
mysql.connector.connect（） メソッドを使用して、ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡すことにより、接続オブジェクトを作成します。
上記で作成した接続オブジェクトで cursor（） メソッドを呼び出して、カーソルオブジェクトを作成します。
次に、_CREATE TABLE_ステートメントをパラメーターとして* execute（）*メソッドに渡すことで実行します。

例

次の例では、データベースmydbに Employee という名前のテーブルを作成します。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

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

#Dropping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Closing the connection
conn.close()

Python MySQL-データの挿入

*INSERT INTO* ステートメントを使用して、MySQLの既存のテーブルに新しい行を追加できます。 この場合、テーブルの名前、列名、および値を（列名と同じ順序で）指定する必要があります。

構文

以下は、MySQLのINSERT INTOステートメントの構文です。

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

例

次のクエリは、EMPLOYEEという名前のテーブルにレコードを挿入します。

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

SELECTステートメントを使用して、挿入操作後にテーブルのレコードを確認できます-

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

列の名前を常に指定することは必須ではありません。テーブルの列と同じ順序でレコードの値を渡す場合、次のように列名なしでSELECTステートメントを実行できます-

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

Pythonを使用してMySQLテーブルにデータを挿入する

（カーソルオブジェクトで呼び出される）* execute（）*メソッドは、パラメーターとしてクエリを受け取り、指定されたクエリを実行します。データを挿入するには、MySQL INSERTステートメントをパラメーターとして渡す必要があります。

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

Pythonを使用してMySQLのテーブルにデータを挿入するには-

mysql.connector パッケージをインポートします。
mysql.connector.connect（） メソッドを使用して、ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡すことにより、接続オブジェクトを作成します。
上記で作成した接続オブジェクトで cursor（） メソッドを呼び出して、カーソルオブジェクトを作成します。
次に、パラメータとして* execute（）メソッドを渡して、 *_ INSERT_ ステートメントを実行します。

例

次の例では、SQL INSERTステートメントを実行して、レコードをEMPLOYEEテーブルに挿入します-

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

# Preparing SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""

try:
   # Executing the SQL command
   cursor.execute(sql)

   # Commit your changes in the database
   conn.commit()

except:
   # Rolling back in case of error
   conn.rollback()

# Closing the connection
conn.close()

値を動的に挿入する

また、MySQLの INSERT クエリで値の代わりに「％s」を使用して、以下に示すように値をリストとして渡すこともできます-

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

例

次の例では、レコードをEmployeeテーブルに動的に挿入します。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

# Preparing SQL query to INSERT a record into the database.
insert_stmt = (
   "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)"
   "VALUES (%s, %s, %s, %s, %s)"
)
data = ('Ramya', 'Ramapriya', 25, 'F', 5000)

try:
   # Executing the SQL command
   cursor.execute(insert_stmt, data)

   # Commit your changes in the database
   conn.commit()

except:
   # Rolling back in case of error
   conn.rollback()

print("Data inserted")

# Closing the connection
conn.close()

出力

Data inserted

Python MySQL-データの選択

SELECTクエリを使用して、MySQLのテーブルからデータを取得または取得できます。このクエリ/ステートメントは、指定されたテーブルの内容を表形式で返し、結果セットとして呼び出されます。

構文

SELECTクエリの構文は次のとおりです-

SELECT column1, column2, columnN FROM table_name;

例

MySQLにcricketers_dataという名前のテーブルを作成したとします-

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

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

insert into cricketers_data values(
   'Shikhar', 'Dhawan', DATE('1981-12-05'), 'Delhi', 'India');
insert into cricketers_data values(
   'Jonathan', 'Trott', DATE('1981-04-22'), 'CapeTown', 'SouthAfrica');
insert into cricketers_data values(
   'Kumara', 'Sangakkara', DATE('1977-10-27'), 'Matale', 'Srilanka');
insert into cricketers_data values(
   'Virat', 'Kohli', DATE('1988-11-05'), 'Delhi', 'India');
insert into cricketers_data values(
   'Rohit', 'Sharma', DATE('1987-04-30'), 'Nagpur', 'India');

次のクエリは、テーブルからFIRST_NAMEとCountryの値を取得します。

mysql> select FIRST_NAME, Country from cricketers_data;
+------------+-------------+
| FIRST_NAME | Country     |
+------------+-------------+
| Shikhar    | India       |
| Jonathan   | SouthAfrica |
| Kumara     | Srilanka    |
| Virat      | India       |
| Rohit      | India       |
+------------+-------------+
5 rows in set (0.00 sec)

また、列名のinstatedを使用して各レコードのすべての値を取得することもできます-

mysql> SELECT * from cricketers_data;
+------------+------------+---------------+----------------+-------------+
| First_Name | Last_Name  | Date_Of_Birth | Place_Of_Birth | Country     |
+------------+------------+---------------+----------------+-------------+
| Shikhar    | Dhawan     | 1981-12-05    | Delhi          | India       |
| Jonathan   | Trott      | 1981-04-22    | CapeTown       | SouthAfrica |
| Kumara     | Sangakkara | 1977-10-27    | Matale         | Srilanka    |
| Virat      | Kohli      | 1988-11-05    | Delhi          | India       |
| Rohit      | Sharma     | 1987-04-30    | Nagpur         | India       |
+------------+------------+---------------+----------------+-------------+
5 rows in set (0.00 sec)

Pythonを使用してMYSQLテーブルからデータを読み取る

任意のデータベースに対するREAD操作は、データベースからいくつかの有用な情報を取得することを意味します。 mysql-connector-pythonが提供する* fetch（）*メソッドを使用して、MYSQLからデータを取得できます。

_cursor.MySQLCursor_クラスは、* fetchall（）、fetchmany（）、および fetchone（）*という3つのメソッドを提供します。ここで、

* fetchall（）*メソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます）。
* fetchone（）*メソッドは、クエリの結果の次の行をフェッチし、タプルとして返します。
* fetchmany（）*メソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行セットを取得します。

注意-結果セットは、カーソルオブジェクトを使用してテーブルを照会するときに返されるオブジェクトです。

*rowcount* -これは読み取り専用の属性であり、execute（）メソッドの影響を受けた行の数を返します。

例

次の例では、SELECTクエリを使用してEMPLOYEEテーブルのすべての行をフェッチし、最初に取得した結果セットから、fetchone（）メソッドを使用して最初の行を取得してから、fetchall（）メソッドを使用して残りの行をフェッチしています。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

#Retrieving single row
sql = '''SELECT *from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

出力

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

次の例では、fetchmany（）メソッドを使用して、EMPLOYEEテーブルの最初の2行を取得します。

例

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

#Retrieving single row
sql = '''SELECT* from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchmany(size =2);
print(result)

#Closing the connection
conn.close()

出力

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

Python MySQL-Where句

MySQLのテーブルの特定の行を取得、削除、または更新する場合は、where句を使用して条件を指定し、操作のためにテーブルの行をフィルタリングする必要があります。

たとえば、where句を含むSELECTステートメントがある場合、指定された条件を満たす行のみが取得されます。

構文

以下はWHERE句の構文です-

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

例

MySQLにEMPLOYEESという名前のテーブルを作成したとします-

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

そして、INSERTステートメントを使用して4つのレコードを挿入した場合-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

次のMySQLステートメントは、収入が4000を超える従業員のレコードを取得します。

mysql> SELECT * FROM EMPLOYEE WHERE INCOME > 4000;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Raj        | Kandukuri | 20   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

Pythonを使用したWHERE句

Pythonプログラムを使用してテーブルから特定のレコードを取得するには-

mysql.connector パッケージをインポートします。
mysql.connector.connect（） メソッドを使用して、ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡すことにより、接続オブジェクトを作成します。
上記で作成した接続オブジェクトで cursor（） メソッドを呼び出して、カーソルオブジェクトを作成します。
次に、_WHERE_句を使用して_SELECT_ステートメントをパラメーターとして実行し、* execute（）*メソッドに渡します。

例

次の例では、Employeeという名前のテーブルを作成し、それを設定します。次に、where句を使用して、年齢値が23未満のレコードを取得します。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES (%s, %s, %s, %s, %s)"

data = [('Krishna', 'Sharma', 19, 'M', 2000), ('Raj', 'Kandukuri', 20, 'M', 7000),
('Ramya', 'Ramapriya', 25, 'F', 5000),('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Closing the connection
conn.close()

出力

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

Python MySQL-注文者

SELECTクエリを使用してデータをフェッチしている間、OrderBy句を使用して、結果を目的の順序（昇順または降順）にソートできます。デフォルトでは、この句は結果を昇順でソートします。降順に並べる必要がある場合は、明示的に「DESC」を使用する必要があります。

構文

構文SELECT column-listは次のとおりです。

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

例

MySQLにEMPLOYEESという名前のテーブルを作成したとします-

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

そして、INSERTステートメントを使用して4つのレコードを挿入した場合-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

次の文は、年齢の昇順でEMPLOYEE表の内容を取得します。

mysql> SELECT *FROM EMPLOYEE ORDER BY AGE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |   19 |    M |   2000 |
| Raj        | Kandukuri |   20 |    M |   7000 |
| Ramya      | Ramapriya |   25 |    F |   5000 |
| Mac        | Mohan     |   26 |    M |   2000 |
+------------+-----------+------+------+--------+
4 rows in set (0.04 sec)

また、DESCを使用して降順でデータを取得できます-

mysql> SELECT* FROM EMPLOYEE ORDER BY FIRST_NAME, INCOME DESC;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |   19 |    M |   2000 |
| Mac        | Mohan     |   26 |    M |   2000 |
| Raj        | Kandukuri |   20 |    M |   7000 |
| Ramya      | Ramapriya |   25 |    F |   5000 |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

Pythonを使用したORDER BY句

テーブルの内容を特定の順序で取得するには、カーソルオブジェクトで* execute（）*メソッドを呼び出し、パラメータとしてORDER BY句とともにSELECTステートメントを渡します。

例

次の例では、ORDER BY句を使用して、名前とEmployeeを使用してテーブルを作成し、それを設定し、年齢の（昇順）のレコードを取得します。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES (%s, %s, %s, %s, %s)"

data = [('Krishna', 'Sharma', 26, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 29, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)
conn.commit()

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

#Closing the connection
conn.close()

出力

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

同様に、ORDER BY句を使用して、降順でテーブルからデータを取得できます。

例

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

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

#Closing the connection
conn.close()

出力

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

Python MySQL-テーブルの更新

データベースでのUPDATE操作は、データベースですでに使用可能な1つ以上のレコードを更新します。 UPDATEステートメントを使用して、MySQLの既存のレコードの値を更新できます。特定の行を更新するには、それと共にWHERE句を使用する必要があります。

構文

以下は、MySQLのUPDATEステートメントの構文です-

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

ANDまたはOR演算子を使用して、N個の条件を組み合わせることができます。

例

MySQLにEMPLOYEESという名前のテーブルを作成したとします-

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

そして、INSERTステートメントを使用して4つのレコードを挿入した場合-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

MySQLの声明に従うと、すべての男性従業員の年齢が1年増加します-

mysql> UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M';
Query OK, 3 rows affected (0.06 sec)
Rows matched: 3 Changed: 3 Warnings: 0

テーブルの内容を取得すると、更新された値を次のように表示できます-

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 20   | M    | 2000   |
| Raj        | Kandukuri | 21   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
| Mac        | Mohan     | 27   | M    | 2000   |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

Pythonを使用してテーブルの内容を更新する

Pythonを使用してMySQLのテーブルのレコードを更新するには-

mysql.connector パッケージをインポートします。
mysql.connector.connect（） メソッドを使用して、ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡すことにより、接続オブジェクトを作成します。
上記で作成した接続オブジェクトで cursor（） メソッドを呼び出して、カーソルオブジェクトを作成します。
次に、UPDATEステートメントをパラメーターとして* execute（）*メソッドに渡して実行します。

例

次の例は、すべての男性の年齢を1年増やします。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

#Preparing the query to update the records
sql = '''UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M' '''
try:
   # Execute the SQL command
   cursor.execute(sql)

   # Commit your changes in the database
   conn.commit()
except:
   # Rollback in case there is any error
   conn.rollback()

#Retrieving data
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Displaying the result
print(cursor.fetchall())

#Closing the connection
conn.close()

出力

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

Python MySQL-データの削除

MySQLテーブルからレコードを削除するには、 DELETE FROM ステートメントを使用する必要があります。特定のレコードを削除するには、それと共にWHERE句を使用する必要があります。

構文

MYSQLのDELETEクエリの構文は次のとおりです-

DELETE FROM table_name [WHERE Clause]

例

MySQLにEMPLOYEESという名前のテーブルを作成したとします-

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

そして、INSERTステートメントを使用して4つのレコードを挿入した場合-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

次のMySQLステートメントは、FIRST_NAME「Mac」を持つ従業員のレコードを削除します。

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

テーブルの内容を取得すると、1つのレコードが削除されているため、3つのレコードしか表示できません。

mysql> select *from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 20   | M    | 2000   |
| Raj        | Kandukuri | 21   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
+------------+-----------+------+------+--------+
3 rows in set (0.00 sec)

WHERE句なしでDELETEステートメントを実行すると、指定されたテーブルのすべてのレコードが削除されます。

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

あなたがテーブルの内容を取得する場合、以下に示すように空のセットを取得します-

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

Pythonを使用してテーブルのレコードを削除する

データベースから一部のレコードを削除する場合は、DELETE操作が必要です。

テーブル内のレコードを削除するには-

mysql.connector パッケージをインポートします。
mysql.connector.connect（） メソッドを使用して、ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡すことにより、接続オブジェクトを作成します。
上記で作成した接続オブジェクトで cursor（） メソッドを呼び出して、カーソルオブジェクトを作成します。
次に、 _ DELETE_ ステートメントをパラメーターとして* execute（）*メソッドに渡して実行します。

例

次のプログラムは、年齢が20を超えるEMPLOYEEからすべてのレコードを削除します-

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

#Retrieving single row
print("Contents of the table: ")
cursor.execute("SELECT *from EMPLOYEE")
print(cursor.fetchall())

#Preparing the query to delete records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (25)

try:
   # Execute the SQL command
   cursor.execute(sql)

   # Commit your changes in the database
   conn.commit()
except:
   # Roll back in case there is any error
   conn.rollback()

#Retrieving data
print("Contents of the table after delete operation ")
cursor.execute("SELECT* from EMPLOYEE")
print(cursor.fetchall())

#Closing the connection
conn.close()

出力

Contents of the table:
[('Krishna', 'Sharma', 22, 'M', 2000.0),
   ('Raj', 'Kandukuri', 23, 'M', 7000.0),
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0),
   ('Mac', 'Mohan', 20, 'M', 2000.0),
   ('Ramya', 'Rama priya', 27, 'F', 9000.0)]

Contents of the table after delete operation:
[('Krishna', 'Sharma', 22, 'M', 2000.0),
   ('Raj', 'Kandukuri', 23, 'M', 7000.0),
   ('Mac', 'Mohan', 20, 'M', 2000.0)]

Python MySQL-ドロップテーブル

*DROP TABLE* ステートメントを使用して、テーブル全体を削除できます。 削除する必要があるテーブルの名前を指定するだけです。

構文

以下は、MySQLのDROP TABLEステートメントの構文です-

DROP TABLE table_name;

例

テーブルを削除する前に、次のようにSHOW TABLESステートメントを使用してテーブルのリストを取得します-

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

次のステートメントは、sampleという名前のテーブルをデータベースから完全に削除します-

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

MySQLからsampleという名前のテーブルを削除したため、テーブルのリストを再度取得しても、テーブル名のサンプルは見つかりません。

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

Pythonを使用してテーブルを削除する

MYSQLのDROPステートメントを使用して、必要なときにいつでもテーブルを削除できますが、既存のテーブルを削除するときは、テーブルの削除後に失われたデータが復元されないため、非常に注意する必要があります。

Pythonを使用してMYSQLデータベースからテーブルを削除するには、カーソルオブジェクトで* execute（）*メソッドを呼び出し、dropステートメントをパラメーターとして渡します。

例

次のテーブルは、データベースからEMPLOYEEという名前のテーブルを削除します。

import mysql.connector

#establishing the connection conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

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

#Retrieving the list of tables print("List of tables in the database: ")
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Doping EMPLOYEE table if already exists cursor.execute
   ("DROP TABLE EMPLOYEE") print("Table dropped... ")

#Retrieving the list of tables print(
   "List of tables after dropping the EMPLOYEE table: ")
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Closing the connection conn.close()

出力

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

存在する場合にのみテーブルを削除する

データベースに存在しないテーブルを削除しようとすると、エラーが発生します-

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

削除ステートメントにIF EXISTSを追加して、削除する前にテーブルが存在するかどうかを確認することにより、このエラーを防ぐことができます。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

#Retrieving the list of tables
print("List of tables in the database: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
print("Table dropped... ")

#Retrieving the list of tables
print("List of tables after dropping the EMPLOYEE table: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Closing the connection
conn.close()

出力

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

Python MySQL-制限

特定の数でレコードを制限する場合は、MYSQLのLIMIT句を使用してレコードをフェッチできます。

例

MySQLにEMPLOYEESという名前のテーブルを作成したとします-

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

そして、INSERTステートメントを使用して4つのレコードを挿入した場合-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

次のSQLステートメントは、LIMIT句を使用してEmployeeテーブルの最初の2つのレコードを取得します。

SELECT * FROM EMPLOYEE LIMIT 2;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 19   | M    | 2000   |
| Raj        | Kandukuri | 20   | M    | 7000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

Pythonを使用した制限句

SELECTクエリとLIMIT句を渡すことにより、カーソルオブジェクトで* execute（）*メソッドを呼び出すと、必要な数のレコードを取得できます。

Pythonを使用してMYSQLデータベースからテーブルを削除するには、カーソルオブジェクトで* execute（）*メソッドを呼び出し、dropステートメントをパラメーターとして渡します。

例

次のpythonの例では、EMPLOYEEという名前のテーブルを作成してデータを設定し、LIMIT句を使用して最初の2つのレコードをフェッチします。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

#Retrieving single row
sql = '''SELECT *from EMPLOYEE LIMIT 2'''

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

出力

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

オフセット付きの制限

n番目のレコード（1 ^ st ^ではない）から始まるレコードを制限する必要がある場合は、LIMITとともにOFFSETを使用して制限できます。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

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

#Retrieving single row
sql = '''SELECT* from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

出力

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

Python MySQL-参加

データを2つのテーブルに分割したら、結合を使用してこれらの2つのテーブルから結合レコードをフェッチできます。

例

以下に示すように、EMPLOYEEという名前のテーブルを作成し、そこにデータを入力したとします-

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT,
   CONTACT INT
);
Query OK, 0 rows affected (0.36 sec)
INSERT INTO Employee VALUES ('Ramya', 'Rama Priya', 27, 'F', 9000, 101),
   ('Vinay', 'Bhattacharya', 20, 'M', 6000, 102),
   ('Sharukh', 'Sheik', 25, 'M', 8300, 103),
   ('Sarmista', 'Sharma', 26, 'F', 10000, 104),
   ('Trupthi', 'Mishra', 24, 'F', 6000, 105);
Query OK, 5 rows affected (0.08 sec)
Records: 5 Duplicates: 0 Warnings: 0

次に、別のテーブルを作成し、次のように入力した場合-

CREATE TABLE CONTACT(
   ID INT NOT NULL,
   EMAIL CHAR(20) NOT NULL,
   PHONE LONG,
   CITY CHAR(20)
);
Query OK, 0 rows affected (0.49 sec)

INSERT INTO CONTACT (ID, EMAIL, CITY) VALUES
   (101, 'Krishna@mymail.com', 'Hyderabad'),
   (102, 'Raja@mymail.com', 'Vishakhapatnam'),
   (103, 'Krishna@mymail.com', 'Pune'),
   (104, 'Raja@mymail.com', 'Mumbai');
Query OK, 4 rows affected (0.10 sec)
Records: 4 Duplicates: 0 Warnings: 0

次のステートメントは、これら2つのテーブルの値を組み合わせたデータを取得します-

mysql> SELECT *from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID;
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| FIRST_NAME | LAST_NAME    | AGE  | SEX  | INCOME | CONTACT | ID  | EMAIL              | PHONE | CITY           |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| Ramya      | Rama Priya   | 27   | F    | 9000   | 101     | 101 | Krishna@mymail.com | NULL  | Hyderabad      |
| Vinay      | Bhattacharya | 20   | M    | 6000   | 102     | 102 | Raja@mymail.com    | NULL  | Vishakhapatnam |
| Sharukh    | Sheik        | 25   | M    | 8300   | 103     | 103 | Krishna@mymail.com | NULL  | Pune           |
| Sarmista   | Sharma       | 26   | F    | 10000  | 104     | 104 | Raja@mymail.com    | NULL  | Mumbai         |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
4 rows in set (0.00 sec)

Pythonを使用したMYSQL JOIN

次の例では、EMPLOYEEテーブルのcontact列とCONTACTテーブルのID列で結合された上記の2つのテーブルからデータを取得します。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

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

#Retrieving single row
sql = '''SELECT* from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

出力

[('Krishna', 'Sharma', 26, 'M', 2000, 101, 101, 'Krishna@mymail.com', 9848022338, 'Hyderabad'),
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102, 102, 'Raja@mymail.com', 9848022339, 'Vishakhapatnam'),
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103, 103, 'Krishna@mymail.com', 9848022337, 'Pune'),
   ('Mac', 'Mohan', 26, 'M', 2000, 104, 104, 'Raja@mymail.com', 9848022330, 'Mumbai')]

Python MySQL-カーソルオブジェクト

mysql-connector-python（および同様のライブラリ）のMySQLCursorは、MySQLデータベースと通信するステートメントを実行するために使用されます。

そのメソッドを使用して、SQLステートメントを実行し、結果セットからデータをフェッチし、プロシージャを呼び出すことができます。

Connectionオブジェクト/クラスのcursor（）メソッドを使用して Cursor オブジェクトを作成できます。

例

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

方法

以下は、Cursorクラス/オブジェクトによって提供されるさまざまなメソッドです。

Sr.No	Method & Description
1	callproc() このメソッドは、既存のプロシージャMySQLデータベースを呼び出すために使用されます。
2	close() このメソッドは、現在のカーソルオブジェクトを閉じるために使用されます。
3	Info() このメソッドは、最後のクエリに関する情報を提供します。
4	executemany() このメソッドは、一連のパラメーターリストを受け入れます。 MySQLクエリを準備し、すべてのパラメーターを使用して実行します。
5	execute() このメソッドは、MySQLクエリをパラメーターとして受け取り、指定されたクエリを実行します。
6	fetchall() このメソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます）
7	fetchone() このメソッドは、クエリの結果の次の行をフェッチし、タプルとして返します。
8	fetchmany() このメソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行セットを取得します。
9	etchwarnings() このメソッドは、最後に実行されたクエリによって生成された警告を返します。

プロパティ

以下は、カーソルクラスのプロパティです-

Sr.No	Property & Description
1	column_names これは、結果セットの列名を含むリストを返す読み取り専用プロパティです。
2	description これは、結果セットの列の説明を含むリストを返す読み取り専用プロパティです。
3	lastrowid これは読み取り専用のプロパティです。テーブルに自動インクリメントされた列がある場合、最後のINSERTまたはUPDATE操作でその列に対して生成された値を返します。
4	rowcount これは、SELECTおよびUPDATE操作の場合に返される/更新される行の数を返します。
5	statement このプロパティは、最後に実行されたステートメントを返します。

Python PostgreSQL-はじめに

インストール

PostgreSQLは、強力なオープンソースのオブジェクトリレーショナルデータベースシステムです。 15年以上の活発な開発フェーズと、信頼性、データの整合性、正確性で高い評価を得ている実績のあるアーキテクチャを備えています。

Pythonを使用してPostgreSQLと通信するには、pythonプログラミング用に提供されているアダプターであるpsycopgをインストールする必要があります。現在のバージョンは psycog2 です。

psycopg2は、非常に小さく高速で、岩のように安定することを目的に書かれています。 PIP（pythonのパッケージマネージャー）で利用可能

PIPを使用したPsycog2のインストール

まず、システムにpythonとPIPが適切にインストールされていること、およびPIPが最新であることを確認してください。

PIPをアップグレードするには、コマンドプロンプトを開き、次のコマンドを実行します-

C:\Users\finddevguides>python -m pip install --upgrade pip
Collecting pip
Using cached https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Installing collected packages: pip
Found existing installation: pip 19.0.3
Uninstalling pip-19.0.3:
Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

次に、管理モードでコマンドプロンプトを開き、以下に示すように pip install psycopg2-binary コマンドを実行します-

C:\WINDOWS\system32>pip install psycopg2-binary
Collecting psycopg2-binary
Using cached https://files.pythonhosted.org/packages/80/79/d0d13ce4c2f1addf4786f4a2ded802c2df66ddf3c1b1a982ed8d4cb9fc6d/psycopg2_binary-2.8.3-cp37-cp37m-win32.whl
Installing collected packages: psycopg2-binary
Successfully installed psycopg2-binary-2.8.3

検証

インストールを確認するには、次の行を含むサンプルPythonスクリプトを作成します。

import mysql.connector

インストールが成功した場合、それを実行すると、エラーが発生しないはずです-

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

Python PostgreSQL-データベース接続

PostgreSQLはクエリを実行する独自のシェルを提供します。 PostgreSQLデータベースとの接続を確立するには、システムに適切にインストールされていることを確認してください。 PostgreSQLシェルプロンプトを開き、サーバー、データベース、ユーザー名、パスワードなどの詳細を渡します。指定した詳細がすべて適切な場合、PostgreSQLデータベースとの接続が確立されます。

詳細を渡す際に、デフォルトのサーバー、データベース、ポート、およびシェルによって提案されたユーザー名を使用できます。

PostgreSQLシェルプロンプト

Pythonを使用して接続を確立する

*_psycopg2_* の接続クラスは、接続のインスタンスを表し/処理します。 * connect（）*関数を使用して、新しい接続を作成できます。 これは、dbname、user、password、host、portなどの基本的な接続パラメーターを受け入れ、接続オブジェクトを返します。 この関数を使用して、PostgreSQLとの接続を確立できます。

例

次のPythonコードは、既存のデータベースに接続する方法を示しています。データベースが存在しない場合は、データベースが作成され、最終的にデータベースオブジェクトが返されます。 PostgreSQLのデフォルトデータベースの名前は_postrgre_です。したがって、データベース名として提供しています。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Executing an MYSQL function using the execute() method
cursor.execute("select version()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Connection established to: ",data)

#Closing the connection
conn.close()
Connection established to: (
   'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)

出力

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

Python PostgreSQL-データベースの作成

CREATE DATABASEステートメントを使用して、PostgreSQLにデータベースを作成できます。コマンドの後に作成されるデータベースの名前を指定することにより、PostgreSQLシェルプロンプトでこのステートメントを実行できます。

構文

以下は、CREATE DATABASEステートメントの構文です。

CREATE DATABASE dbname;

例

次の文は、PostgreSQLにtestdbという名前のデータベースを作成します。

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

\ lコマンドを使用して、PostgreSQLのデータベースを一覧表示できます。データベースのリストを確認すると、次のように新しく作成されたデータベースを見つけることができます-

postgres=# \l
                                           List of databases
Name       | Owner    | Encoding | Collate                    | Ctype       |
-----------+----------+----------+----------------------------+-------------+
mydb       | postgres | UTF8     | English_United States.1252 | ........... |
postgres   | postgres | UTF8     | English_United States.1252 | ........... |
template0  | postgres | UTF8     | English_United States.1252 | ........... |
template1  | postgres | UTF8     | English_United States.1252 | ........... |
testdb     | postgres | UTF8     | English_United States.1252 | ........... |
(5 rows)

SQLステートメントCREATE DATABASEのラッパーである_createdb_コマンドを使用して、コマンドプロンプトからPostgreSQLにデータベースを作成することもできます。

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

Pythonを使用してデータベースを作成する

psycopg2のカーソルクラスは、さまざまなPostgreSQLコマンドを実行し、レコードを取得してデータをコピーするさまざまなメソッドを提供します。 Connectionクラスのcursor（）メソッドを使用して、カーソルオブジェクトを作成できます。

このクラスのexecute（）メソッドは、PostgreSQLクエリをパラメーターとして受け取り、実行します。

したがって、PostgreSQLでデータベースを作成するには、このメソッドを使用してCREATE DATABASEクエリを実行します。

例

次のpythonの例は、PostgreSQLデータベースにmydbという名前のデータベースを作成します。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
conn.autocommit = True

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

#Preparing query to create a database
sql = '''CREATE database mydb''';

#Creating a database
cursor.execute(sql)
print("Database created successfully........")

#Closing the connection
conn.close()

出力

Database created successfully........

Python PostgreSQL-テーブルの作成

CREATE TABLEステートメントを使用して、PostgreSQLのデータベースに新しいテーブルを作成できます。これを実行する際、テーブルの名前、列名、およびそれらのデータ型を指定する必要があります。

構文

以下は、PostgreSQLのCREATE TABLEステートメントの構文です。

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

例

次の例は、PostgreSQLでCRICKETERSという名前のテーブルを作成します。

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age INT,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
CREATE TABLE
postgres=#

\ dtコマンドを使用して、PostgreSQLのデータベース内のテーブルのリストを取得できます。テーブルを作成した後、テーブルのリストを確認できる場合、次のように新しく作成されたテーブルを観察できます-

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

同様に、以下に示すように\ dを使用して作成されたテーブルの説明を取得することができます-

postgres=# \d cricketers
               Table "public.cricketers"
Column          | Type                   | Collation | Nullable | Default
----------------+------------------------+-----------+----------+---------
first_name      | character varying(255) |           |          |
last_name       | character varying(255) |           |          |
age             | integer                |           |          |
place_of_birth  | character varying(255) |           |          |
country         | character varying(255) |           |          |
postgres=#

Pythonを使用してテーブルを作成する

pythonを使用してテーブルを作成するには、_pyscopg2_のCursorのexecute（）メソッドを使用してCREATE TABLEステートメントを実行する必要があります。

例

次のPythonの例は、employeeという名前のテーブルを作成します。

import psycopg2

#Establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
print("Table created successfully........")

#Closing the connection
conn.close()

出力

Table created successfully........

Python PostgreSQL-データの挿入

*INSERT INTO* ステートメントを使用して、PostgreSQLの既存のテーブルにレコードを挿入できます。 これを実行する際、テーブルの名前と、その中の列の値を指定する必要があります。

構文

INSERTステートメントの推奨構文は次のとおりです-

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

ここで、column1、column2、column3、.. テーブルの列の名前、およびvalue1、value2、value3、… テーブルに挿入する必要がある値です。

例

以下に示すように、CREATE TABLEステートメントを使用してCRICKETERSという名前のテーブルを作成したとします-

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age INT,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
CREATE TABLE
postgres=#

次のPostgreSQLステートメントは、上記で作成したテーブルに行を挿入します-

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

_INSERT INTO_ステートメントを使用してレコードを挿入するときに、列名をスキップすると、スキップした列に空のスペースを残してレコードが挿入されます。

postgres=# insert into CRICKETERS (First_Name, Last_Name, Country)
   values('Jonathan', 'Trott', 'SouthAfrica');
INSERT 0 1

渡す値の順序がテーブル内のそれぞれの列名と同じ場合、列名を指定せずにテーブルにレコードを挿入することもできます。

postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1
postgres=#

レコードをテーブルに挿入した後、以下に示すようにSELECTステートメントを使用してその内容を確認できます-

postgres=# SELECT * from CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      |     |                | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(5 rows)

Pythonを使用してデータを挿入する

psycopg2のカーソルクラスは、execute（）メソッドという名前のメソッドを提供します。このメソッドは、クエリをパラメーターとして受け取り、実行します。

したがって、Pythonを使用してPostgreSQLのテーブルにデータを挿入するには-

psycopg2 パッケージをインポートします。
ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡すことにより、 _ connect（）_ メソッドを使用して接続オブジェクトを作成します。
属性 autocommit の値としてfalseを設定して、自動コミットモードをオフにします。
psycopg2ライブラリの Connection クラスの* cursor（）*メソッドは、カーソルオブジェクトを返します。このメソッドを使用してカーソルオブジェクトを作成します。
次に、INSERT文をパラメータとしてexecute（）メソッドに渡すことにより、INSERT文を実行します。

例

次のPythonプログラムは、PostgreSQLデータベースにEMPLOYEEという名前のテーブルを作成し、execute（）メソッドを使用してレコードを挿入します-

import psycopg2

#Establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

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

# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Ramya', 'Rama priya', 27, 'F', 9000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Vinay', 'Battacharya', 20, 'M', 6000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Sharukh', 'Sheik', 25, 'M', 8300)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Sarmista', 'Sharma', 26, 'F', 10000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Tripthi', 'Mishra', 24, 'F', 6000)''')

# Commit your changes in the database
conn.commit()
print("Records inserted........")

# Closing the connection
conn.close()

出力

Records inserted........

Python PostgreSQL-データの選択

SELECTステートメントを使用して、PostgreSQLの既存のテーブルの内容を取得できます。このステートメントでは、テーブルの名前を指定する必要があり、結果セットとして知られる表形式でコンテンツを返します。

構文

以下は、PostgreSQLのSELECTステートメントの構文です-

SELECT column1, column2, columnN FROM table_name;

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255),
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

次のSELECTクエリは、列FIRST_NAME、LAST_NAME、およびCOUNTRYの値をCRICKETERSテーブルから取得します。

postgres=# SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
first_name  | last_name  | country
------------+------------+-------------
Shikhar     | Dhawan     | India
Jonathan    | Trott      | SouthAfrica
Kumara      | Sangakkara | Srilanka
Virat       | Kohli      | India
Rohit       | Sharma     | India
(5 rows)

あなたが各レコードのすべての列を取得したい場合は、以下に示すように、列の名前を「*」に置き換える必要があります-

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(5 rows)
postgres=#

Pythonを使用してデータを取得する

任意のデータベースに対するREAD操作は、データベースからいくつかの有用な情報を取得することを意味します。 psycopg2が提供するfetch（）メソッドを使用して、PostgreSQLからデータをフェッチできます。

Cursorクラスは、3つのメソッド、つまりfetchall（）、fetchmany（）、およびfetchone（）を提供します。ここで、

fetchall（）メソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます）。
fetchone（）メソッドは、クエリの結果の次の行を取得し、タプルとして返します。
fetchmany（）メソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行セットを取得します。

注意-結果セットは、カーソルオブジェクトを使用してテーブルを照会するときに返されるオブジェクトです。

例

次のPythonプログラムは、PostgreSQLのmydbという名前のデータベースに接続し、EMPLOYEEという名前のテーブルからすべてのレコードを取得します。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

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

#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Python PostgreSQL-Where句

SELECT、UPDATE、またはDELETE操作の実行中に、WHERE句を使用してレコードをフィルターする条件を指定できます。操作は、指定された条件を満たすレコードに対して実行されます。

構文

PostgreSQLのWHERE句の構文は次のとおりです-

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

比較演算子または論理演算子を使用してsearch_conditionを指定できます。 >、<、=、LIKE、NOTなど。次の例は、この概念を明確にします。

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255),
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

次のSELECTステートメントは、年齢が35歳以上のレコードを取得します-

postgres=# SELECT * FROM CRICKETERS WHERE AGE > 35;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(2 rows)
postgres=#

Pythonを使用したWhere節

pythonプログラムを使用してテーブルから特定のレコードを取得するには、WHERE句を指定したSELECTステートメントをパラメーターとして実行し、* execute（）*メソッドに渡します。

例

次のpythonの例は、pythonを使用したWHEREコマンドの使用方法を示しています。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

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

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES (%s, %s, %s, %s, %s)"
data = [('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'M', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

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

Python PostgreSQL-注文者

通常、テーブルからデータを取得しようとすると、挿入した順序と同じ順序でレコードが取得されます。

*ORDER BY* 句を使用すると、テーブルのレコードを取得しながら、目的の列に基づいて結果のレコードを昇順または降順に並べ替えることができます。

構文

以下は、PostgreSQLのORDER BY句の構文です。

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

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255),
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

次のSELECTステートメントは、年齢の昇順でCRICKETERSテーブルの行を取得します-

postgres=# SELECT *FROM CRICKETERS ORDER BY AGE;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(5 rows)es:

複数の列を使用して、テーブルのレコードをソートできます。次のSELECTステートメントは、列ageおよびFIRST_NAMEに基づいてCRICKETERSテーブルのレコードをソートします。

postgres=# SELECT* FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(5 rows)

デフォルトでは、 ORDER BY 句はテーブルのレコードを昇順でソートします。次のようにDESCを使用して、結果を降順に並べることができます-

postgres=# SELECT *FROM CRICKETERS ORDER BY AGE DESC;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Shikhar     | Dhawan     | 33  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Virat       | Kohli      | 30  | Delhi          | India
(5 rows)

Pythonを使用したORDER BY句

テーブルの内容を特定の順序で取得するには、カーソルオブジェクトでexecute（）メソッドを呼び出し、パラメータとしてORDER BY句とともにSELECTステートメントを渡します。

例

次の例では、ORDER BY句を使用して、名前とEmployeeを使用してテーブルを作成し、それを設定し、そのレコードを年齢の（昇順）順序で取得します。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

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

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT, SEX CHAR(1),
   INCOME INT,
   CONTACT INT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME, CONTACT) VALUES
   (%s, %s, %s, %s, %s, %s)"
data = [('Krishna', 'Sharma', 26, 'M', 2000, 101),
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102),
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103),
   ('Mac', 'Mohan', 26, 'M', 2000, 104)]
cursor.executemany(insert_stmt, data)
conn.commit()

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

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

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

Python PostgreSQL-更新テーブル

UPDATEステートメントを使用して、PostgreSQLのテーブルの既存のレコードの内容を変更できます。特定の行を更新するには、それと共にWHERE句を使用する必要があります。

構文

PostgreSQLのUPDATEステートメントの構文は次のとおりです-

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

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255),
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

次のステートメントは、クリケット選手の年齢を変更します。その名は Shikhar です-

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

FIRST_NAMEがShikharであるレコードを取得すると、年齢の値が45に変更されていることがわかります-

postgres=# SELECT *FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
Shikhar     | Dhawan    | 45  | Delhi          | India
(1 row)
postgres=#

WHERE句を使用していない場合、すべてのレコードの値が更新されます。 UPDATEステートメントを実行すると、CRICKETERSテーブル内のすべてのレコードの経過時間が1ずつ増加します-

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

SELECTコマンドを使用してテーブルの内容を取得する場合、更新された値を次のように表示できます-

postgres=# SELECT* FROM CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan    | Trott      | 39  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 42  | Matale         | Srilanka
Virat       | Kohli      | 31  | Delhi          | India
Rohit       | Sharma     | 33  | Nagpur         | India
Shikhar     | Dhawan     | 46  | Delhi          | India
(5 rows)

Pythonを使用してレコードを更新する

psycopg2のカーソルクラスは、execute（）メソッドという名前のメソッドを提供します。このメソッドは、クエリをパラメーターとして受け取り、実行します。

したがって、Pythonを使用してPostgreSQLのテーブルにデータを挿入するには-

psycopg2 パッケージをインポートします。
ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡すことにより、 _ connect（）_ メソッドを使用して接続オブジェクトを作成します。
属性 autocommit の値としてfalseを設定して、自動コミットモードをオフにします。
psycopg2ライブラリの Connection クラスの* cursor（）*メソッドは、カーソルオブジェクトを返します。このメソッドを使用してカーソルオブジェクトを作成します。 *次に、UPDATEステートメントをパラメーターとしてexecute（）メソッドに渡して実行します。

例

次のPythonコードは、Employeeテーブルの内容を更新し、結果を取得します-

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

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

#Fetching all the rows before the update
print("Contents of the Employee table: ")
sql = '''SELECT* from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())

#Updating the records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M'"
cursor.execute(sql)
print("Table updated...... ")

#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
sql = '''SELECT * from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
   ('Vinay', 'Battacharya', 20, 'M', 6000.0),
   ('Sharukh', 'Sheik', 25, 'M', 8300.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0),
   ('Vinay', 'Battacharya', 21, 'M', 6000.0),
   ('Sharukh', 'Sheik', 26, 'M', 8300.0)]

Python PostgreSQL-データの削除

PostgreSQLデータベースの DELETE FROM ステートメントを使用して、既存のテーブルのレコードを削除できます。特定のレコードを削除するには、それと共にWHERE句を使用する必要があります。

構文

PostgreSQLのDELETEクエリの構文は次のとおりです-

DELETE FROM table_name [WHERE Clause]

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255),
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

次の文は、姓が「Sangakkara」であるクリケット選手のレコードを削除します。 −

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

SELECTステートメントを使用してテーブルの内容を取得すると、1つのレコードが削除されているため、4つのレコードしか表示できません。

postgres=# SELECT *FROM CRICKETERS;
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+-------------
Jonathan    | Trott     | 39  | CapeTown       | SouthAfrica
Virat       | Kohli     | 31  | Delhi          | India
Rohit       | Sharma    | 33  | Nagpur         | India
Shikhar     | Dhawan    | 46  | Delhi          | India
(4 rows)

WHERE句なしでDELETE FROMステートメントを実行すると、指定されたテーブルのすべてのレコードが削除されます。

postgres=# DELETE FROM CRICKETERS;
DELETE 4

すべてのレコードを削除しているため、SELECTステートメントを使用してCRICKETERSテーブルの内容を取得しようとすると、以下に示すように空の結果セットが得られます-

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

Pythonを使用してデータを削除する

psycopg2のカーソルクラスは、execute（）メソッドという名前のメソッドを提供します。このメソッドは、クエリをパラメーターとして受け取り、実行します。

したがって、Pythonを使用してPostgreSQLのテーブルにデータを挿入するには-

psycopg2 パッケージをインポートします。
ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡すことにより、 _ connect（）_ メソッドを使用して接続オブジェクトを作成します。
属性 autocommit の値としてfalseを設定して、自動コミットモードをオフにします。
psycopg2ライブラリのConnectionクラスの* cursor（）*メソッドは、カーソルオブジェクトを返します。このメソッドを使用してカーソルオブジェクトを作成します。 *次に、UPDATEステートメントをパラメーターとしてexecute（）メソッドに渡して実行します。

例

次のPythonコードは、年齢値が25を超えるEMPLOYEEテーブルのレコードを削除します-

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

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

#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT* from EMPLOYEE''')
print(cursor.fetchall())

#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')

#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0),
   ('Vinay', 'Battacharya', 21, 'M', 6000.0),
   ('Sharukh', 'Sheik', 26, 'M', 8300.0)]
Contents of the table after delete operation:
[('Tripthi', 'Mishra', 24, 'F', 6000.0),
   ('Vinay', 'Battacharya', 21, 'M', 6000.0)]

Python PostgreSQL-ドロップテーブル

DROP TABLEステートメントを使用して、PostgreSQLデータベースからテーブルを削除できます。

構文

以下は、PostgreSQLのDROP TABLEステートメントの構文です-

DROP TABLE table_name;

例

次のクエリを使用して、名前がCRICKETERSとEMPLOYEESの2つのテーブルを作成したとします-

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int,
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#
postgres=# CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT,
   SEX CHAR(1), INCOME FLOAT
);
CREATE TABLE
postgres=#

「\ dt」コマンドを使用してテーブルのリストを確認すると、上記で作成したテーブルを次のように表示できます-

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

次の文は、データベースからEmployeeという名前のテーブルを削除します-

postgres=# DROP table employee;
DROP TABLE

Employeeテーブルを削除したため、テーブルのリストを再度取得すると、その中の1つのテーブルのみを観察できます。

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

既に削除しているため、再びEmployeeテーブルを削除しようとすると、次のように「テーブルが存在しません」というエラーが表示されます-

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

これを解決するには、DELTEステートメントと一緒にIF EXISTS句を使用できます。これにより、テーブルが存在する場合は削除され、存在しない場合はDLETE操作がスキップされます。

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

Pythonを使用してテーブル全体を削除する

DROPステートメントを使用して、必要なときにいつでもテーブルを削除できます。ただし、既存のテーブルを削除するときは、テーブルを削除した後に失われたデータが復元されないため、非常に注意する必要があります。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

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

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

#Table dropped...

Python PostgreSQL-制限

PostgreSQL SELECTステートメントの実行中に、LIMIT句を使用して、結果のレコード数を制限できます。

構文

以下はPostgreSQLのLMIT句の構文です-

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

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int,
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

次のステートメントは、LIMIT句を使用してCricketersテーブルの最初の3つのレコードを取得します-

postgres=# SELECT *FROM CRICKETERS LIMIT 3;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(3 rows)

特定のレコード（オフセット）から始まるレコードを取得したい場合は、LIMITとともにOFFSET句を使用して取得できます。

postgres=# SELECT* FROM CRICKETERS LIMIT 3 OFFSET 2;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+----------
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(3 rows)
postgres=#

Pythonを使用した制限句

次のPythonの例では、EMPLOYEEという名前のテーブルの内容を取得し、結果のレコード数を2に制限します-

例

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

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

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

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

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

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

Python PostgreSQL-参加

データを2つのテーブルに分割したら、結合を使用してこれらの2つのテーブルから結合レコードをフェッチできます。

例

CRICKETERSという名前のテーブルを作成し、以下に示すように5つのレコードを挿入したとします-

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int,
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
postgres=# insert into CRICKETERS values (
   'Shikhar', 'Dhawan', 33, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
   'Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica'
);
postgres=# insert into CRICKETERS values (
   'Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka'
);
postgres=# insert into CRICKETERS values (
   'Virat', 'Kohli', 30, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
   'Rohit', 'Sharma', 32, 'Nagpur', 'India'
);

そして、OdiStatsという名前で別のテーブルを作成し、5つのレコードを挿入した場合-

postgres=# CREATE TABLE ODIStats (
   First_Name VARCHAR(255), Matches INT, Runs INT, AVG FLOAT,
   Centuries INT, HalfCenturies INT
);
postgres=# insert into OdiStats values ('Shikhar', 133, 5518, 44.5, 17, 27);
postgres=# insert into OdiStats values ('Jonathan', 68, 2819, 51.25, 4, 22);
postgres=# insert into OdiStats values ('Kumara', 404, 14234, 41.99, 25, 93);
postgres=# insert into OdiStats values ('Virat', 239, 11520, 60.31, 43, 54);
postgres=# insert into OdiStats values ('Rohit', 218, 8686, 48.53, 24, 42);

次のステートメントは、これら2つのテーブルの値を組み合わせたデータを取得します-

postgres=# SELECT
Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
first_name  | last_name  | country     | matches | runs  | centuries | halfcenturies
------------+------------+-------------+---------+-------+-----------+---------------
Shikhar     | Dhawan     | India       | 133     | 5518  | 17        | 27
Jonathan    | Trott      | SouthAfrica | 68      | 2819  | 4         | 22
Kumara      | Sangakkara | Srilanka    | 404     | 14234 | 25        | 93
Virat       | Kohli      | India       | 239     | 11520 | 43        | 54
Rohit       | Sharma     | India       | 218     | 8686  | 24        | 42
(5 rows)
postgres=#

Pythonを使用して参加する

データを2つのテーブルに分割したら、結合を使用してこれらの2つのテーブルから結合レコードをフェッチできます。

例

次のPythonプログラムは、JOIN句の使用方法を示しています-

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

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

#Retrieving single row
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, 'Krishna@mymail.com', 'Hyderabad'),
   ('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102, 'Raja@mymail.com', 'Vishakhapatnam'),
   ('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, 'Krishna@mymail.com ', 'Pune'),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, 'Raja@mymail.com', 'Mumbai')]

Python PostgreSQL-カーソルオブジェクト

_psycopg_ライブラリのCursorクラスは、Pythonコードを使用してデータベースでPostgreSQLコマンドを実行するメソッドを提供します。

そのメソッドを使用して、SQLステートメントを実行し、結果セットからデータをフェッチし、プロシージャを呼び出すことができます。

Connectionオブジェクト/クラスのcursor（）メソッドを使用して Cursor オブジェクトを作成できます。

例

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

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

方法

以下は、Cursorクラス/オブジェクトによって提供されるさまざまなメソッドです。

Sr.No	Method & Description
1	callproc() このメソッドは、PostgreSQLデータベースの既存のプロシージャを呼び出すために使用されます。
2	close() このメソッドは、現在のカーソルオブジェクトを閉じるために使用されます。
3	executemany() このメソッドは、一連のパラメーターリストを受け入れます。 MySQLクエリを準備し、すべてのパラメーターを使用して実行します。
4	execute() このメソッドは、MySQLクエリをパラメーターとして受け取り、指定されたクエリを実行します。
5	fetchall() このメソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます）
6	fetchone() このメソッドは、クエリの結果の次の行をフェッチし、タプルとして返します。
7	fetchmany() このメソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行セットを取得します。

プロパティ

以下は、カーソルクラスのプロパティです-

Sr.No	Property & Description
1	description これは、結果セットの列の説明を含むリストを返す読み取り専用プロパティです。
2	astrowid これは読み取り専用のプロパティです。テーブルに自動インクリメントされた列がある場合、最後のINSERTまたはUPDATE操作でその列に対して生成された値を返します。
3	rowcount これは、SELECTおよびUPDATE操作の場合に返される/更新される行の数を返します。
4	closed このプロパティは、カーソルが閉じているかどうかを指定します。閉じている場合はtrue、そうでない場合はfalseを返します。
5	connection これは、このカーソルが作成された接続オブジェクトへの参照を返します。
6	name このプロパティは、カーソルの名前を返します。
7	scrollable このプロパティは、特定のカーソルがスクロール可能かどうかを指定します。

Python SQLite-はじめに

インストール

SQLite3は、Gerhard Haringによって作成されたsqlite3モジュールを使用してPythonと統合できます。 PEP 249で説明されているDB-API 2.0仕様に準拠したSQLインターフェイスを提供します。このモジュールはPythonバージョン2.5.x以降でデフォルトで出荷されるため、このモジュールを個別にインストールする必要はありません。

sqlite3モジュールを使用するには、最初にデータベースを表す接続オブジェクトを作成する必要があります。次に、オプションでカーソルオブジェクトを作成できます。これは、すべてのSQLステートメントの実行に役立ちます。

Python sqlite3モジュールAPI

以下は重要なsqlite3モジュールルーチンであり、PythonプログラムからSQLiteデータベースを操作するための要件を満たすことができます。より洗練されたアプリケーションをお探しの場合は、Python sqlite3モジュールの公式ドキュメントをご覧ください。

Sr.No.	API & Description
1	sqlite3.connect(database [,timeout ,other optional arguments]) このAPIは、SQLiteデータベースファイルへの接続を開きます。 "：memory："を使用して、ディスクではなくRAMにあるデータベースへのデータベース接続を開くことができます。データベースが正常に開くと、接続オブジェクトが返されます。
2	connection.cursor([cursorClass]) このルーチンは、Pythonを使用したデータベースプログラミング全体で使用されるカーソルを作成します。このメソッドは、単一のオプションパラメータcursorClassを受け入れます。指定する場合、これはsqlite3.Cursorを拡張するカスタムカーソルクラスである必要があります。
3	cursor.execute(sql [, optional parameters]) このルーチンは、SQLステートメントを実行します。 SQLステートメントはパラメーター化できます（i。 e. SQLリテラルの代わりのプレースホルダー）。 sqlite3モジュールは、疑問符と名前付きプレースホルダー（名前付きスタイル）の2種類のプレースホルダーをサポートしています。たとえば-cursor.execute（ "insert into people values（？、？）"、（who、age））
4	connection.execute(sql [, optional parameters]) このルーチンは、カーソルオブジェクトによって提供される上記のexecuteメソッドのショートカットであり、cursorメソッドを呼び出して中間カーソルオブジェクトを作成し、指定されたパラメーターでカーソルのexecuteメソッドを呼び出します。
5	cursor.executemany(sql, seq_of_parameters) このルーチンは、シーケンスsqlで見つかったすべてのパラメーターシーケンスまたはマッピングに対してSQLコマンドを実行します。
6	connection.executemany(sql[, parameters]) このルーチンは、cursorメソッドを呼び出して中間カーソルオブジェクトを作成し、指定されたパラメーターでcursor.s executemanyメソッドを呼び出すショートカットです。
7	cursor.executescript(sql_script) このルーチンは、スクリプトの形式で提供される複数のSQLステートメントを一度に実行します。最初にCOMMITステートメントを発行し、次にパラメーターとして取得したSQLスクリプトを実行します。すべてのSQLステートメントはセミコロン（;）で区切る必要があります。
8	connection.executescript(sql_script) このルーチンは、カーソルメソッドを呼び出して中間カーソルオブジェクトを作成し、指定されたパラメーターを使用してカーソルのexecutescriptメソッドを呼び出すショートカットです。
9	connection.total_changes() このルーチンは、データベース接続が開かれてから変更、挿入、または削除されたデータベース行の総数を返します。
10	connection.commit() このメソッドは、現在のトランザクションをコミットします。このメソッドを呼び出さないと、最後のcommit（）の呼び出し以降に行った操作は、他のデータベース接続からは見えません。
11	connection.rollback() このメソッドは、commit（）の最後の呼び出し以降のデータベースへの変更をロールバックします。
12	connection.close() このメソッドは、データベース接続を閉じます。これはcommit（）を自動的に呼び出さないことに注意してください。最初にcommit（）を呼び出さずにデータベース接続を閉じると、変更は失われます！
13	cursor.fetchone() このメソッドは、クエリ結果セットの次の行をフェッチして単一のシーケンスを返します。使用可能なデータがなくなったらNoneを返します。
14	cursor.fetchmany([size = cursor.arraysize]) このルーチンは、クエリ結果の次の行セットをフェッチし、リストを返します。使用可能な行がなくなると、空のリストが返されます。このメソッドは、sizeパラメーターで指定された数の行をフェッチしようとします。
15	cursor.fetchall() このルーチンは、クエリ結果のすべての（残りの）行をフェッチし、リストを返します。使用可能な行がない場合、空のリストが返されます。

Python SQLite-接続の確立

SQLite Openコマンドプロンプトとの接続を確立するには、SQLiteをインストールした場所を参照し、次のようにコマンド sqlite3 を実行します-

接続の確立

Pythonを使用して接続を確立する

SQLite3 pythonモジュールを使用して、SQLite2データベースと通信できます。そのためには、まず接続を確立する（接続オブジェクトを作成する）必要があります。

Pythonを使用してSQLite3データベースとの接続を確立するには、以下を行う必要があります-

importステートメントを使用してsqlite3モジュールをインポートします。
connect（）メソッドは、接続する必要があるデータベースの名前をパラメーターとして受け入れ、Connectionオブジェクトを返します。

例

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

出力

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

Python SQLite-テーブルの作成

SQLite CREATE TABLEステートメントを使用して、データベースにテーブルを作成できます。

構文

以下は、SQLiteデータベースにテーブルを作成するための構文です-

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

例

次のSQLiteクエリ/ステートメントは、SQLiteデータベースに CRICKETERS という名前のテーブルを作成します-

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

CRICKETERSテーブルの各プレーヤーの1日のクリケット統計を記述するOdiStatsテーブルをもう1つ作成します。

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

*_。tables_* コマンドを使用して、SQLiteデータベースのデータベース内のテーブルのリストを取得できます。 テーブルを作成した後、テーブルのリストを確認できれば、新しく作成されたテーブルを次のように観察できます-

sqlite> . tables
CRICKETERS ODIStats
sqlite>

Pythonを使用してテーブルを作成する

Cursorオブジェクトには、要求を実行し、データなどを取得するためのすべてのメソッドが含まれています。接続クラスのカーソルメソッドは、カーソルオブジェクトを返します。

したがって、Pythonを使用してSQLiteデータベースにテーブルを作成するには-

connect（）メソッドを使用して、データベースとの接続を確立します。
上記で作成した接続オブジェクトでcursor（）メソッドを呼び出して、カーソルオブジェクトを作成します。
次に、Cursorクラスのexecute（）メソッドを使用してCREATE TABLEステートメントを実行します。

例

次のPythonプログラムは、SQLite3でEmployeeという名前のテーブルを作成します-

import sqlite3

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

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

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
print("Table created successfully........")

# Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

Table created successfully........

Python SQLite-データの挿入

INSERT INTOステートメントを使用して、SQLiteの既存のテーブルに新しい行を追加できます。この場合、テーブルの名前、列名、および値を（列名と同じ順序で）指定する必要があります。

構文

INSERTステートメントの推奨構文は次のとおりです-

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

ここで、column1、column2、column3、.. テーブルの列の名前とvalue1、value2、value3、… テーブルに挿入する必要がある値です。

例

以下に示すように、CREATE TABLEステートメントを使用してCRICKETERSという名前のテーブルを作成したとします-

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

次のPostgreSQLステートメントは、上記で作成されたテーブルに行を挿入します。

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

INSERT INTOステートメントを使用してレコードを挿入するときに、列名をスキップすると、このレコードが挿入され、スキップした列に空のスペースが残ります。

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

渡す値の順序がテーブル内のそれぞれの列名と同じ場合、列名を指定せずにテーブルにレコードを挿入することもできます。

sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

レコードをテーブルに挿入した後、以下に示すようにSELECTステートメントを使用してその内容を確認できます-

sqlite> select * from cricketers;
Shikhar  | Dhawan     | 33 | Delhi  | India
Jonathan | Trott      |    |        | SouthAfrica
Kumara   | Sangakkara | 41 | Matale | Srilanka
Virat    | Kohli      | 30 | Delhi  | India
Rohit    | Sharma     | 32 | Nagpur | India
sqlite>

Pythonを使用してデータを挿入する

SQLiteデータベースの既存のテーブルにレコードを追加するには-

sqlite3パッケージをインポートします。
データベースの名前をパラメーターとして渡すことにより、connect（）メソッドを使用して接続オブジェクトを作成します。
cursor（） メソッドは、SQLite3と通信できるカーソルオブジェクトを返します。（作成済みの）Connectionオブジェクトでcursor（）オブジェクトを呼び出して、カーソルオブジェクトを作成します。
次に、INSERTステートメントをパラメーターとして渡すことにより、カーソルオブジェクトでexecute（）メソッドを呼び出します。

例

次のPythonの例では、EMPLOYEEという名前のテーブルにレコードを挿入します-

import sqlite3

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

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

# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Ramya', 'Rama Priya', 27, 'F', 9000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Vinay', 'Battacharya', 20, 'M', 6000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Sharukh', 'Sheik', 25, 'M', 8300)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Sarmista', 'Sharma', 26, 'F', 10000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')

# Commit your changes in the database
conn.commit()
print("Records inserted........")

# Closing the connection
conn.close()

出力

Records inserted........

Python SQLite-データの選択

SELCTクエリを使用して、SQLiteテーブルからデータを取得できます。このクエリ/ステートメントは、指定された関係（テーブル）の内容を表形式で返し、結果セットとして呼び出されます。

構文

以下は、SQLiteのSELECTステートメントの構文です-

SELECT column1, column2, columnN FROM table_name;

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

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

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

次のSELECTクエリは、列FIRST_NAME、LAST_NAME、およびCOUNTRYの値をCRICKETERSテーブルから取得します。

sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
Shikhar  |Dhawan     |India
Jonathan |Trott      |SouthAfrica
Kumara   |Sangakkara |Srilanka
Virat    |Kohli      |India
Rohit    |Sharma     |India
sqlite>

ご覧のとおり、SQLiteデータベースのSELECTステートメントは、指定されたテーブルのレコードを返すだけです。フォーマットされた出力を取得するには、以下に示すように、SELECT文の前にそれぞれのコマンドを使用して header および mode を設定する必要があります-

sqlite> .header on
sqlite> .mode column
sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
First_Name Last_Name            Country
---------- -------------------- ----------
Shikhar    Dhawan               India
Jonathan   Trott                SouthAfric
Kumara     Sangakkara           Srilanka
Virat      Kohli                India
Rohit      Sharma               India
sqlite>

あなたが各レコードのすべての列を取得したい場合は、以下に示すように、列の名前を「*」に置き換える必要があります-

sqlite> .header on
sqlite> .mode column
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age        Place_Of_Birth Country
---------- ---------- ---------- -------------- ----------
Shikhar    Dhawan     33         Delhi          India
Jonathan   Trott      38         CapeTown       SouthAfric
Kumara     Sangakkara 41         Matale         Srilanka
Virat      Kohli      30         Delhi          India
Rohit      Sharma     32         Nagpur         India
sqlite>

SQLite_では、列の幅はデフォルトで10で、この幅を超える値は切り取られます（上記の表の2 ^ nd ^行の国列に注目してください）。以下に示すように、テーブルの内容を取得する前に、 '。width_ コマンドを使用して、各列の幅を必要な値に設定できます-

sqlite> .width 10, 10, 4, 10, 13
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
sqlite>

Pythonを使用してデータを取得する

任意のデータベースに対するREAD操作は、データベースからいくつかの有用な情報を取得することを意味します。 sqlite pythonモジュールが提供するfetch（）メソッドを使用して、MYSQLからデータをフェッチできます。

sqlite3.Cursorクラスは、3つのメソッド、すなわちfetchall（）、fetchmany（）、およびfetchone（）を提供します。ここで、

fetchall（）メソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます）。
fetchone（）メソッドは、クエリの結果の次の行を取得し、タプルとして返します。
fetchmany（）メソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行セットを取得します。

注意-結果セットは、カーソルオブジェクトを使用してテーブルを照会するときに返されるオブジェクトです。

例

次の例では、SELECTクエリを使用してEMPLOYEEテーブルのすべての行をフェッチし、最初に取得した結果セットから、fetchone（）メソッドを使用して最初の行を取得してから、fetchall（）メソッドを使用して残りの行をフェッチしています。

次のPythonプログラムは、上記の例で作成されたCOMPANYテーブルからレコードを取得して表示する方法を示しています。

import sqlite3

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

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

#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
   ('Sharukh', 'Sheik', 25, 'M', 8300.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)
]

Python SQLite-Where句

SQLiteでテーブルの特定の行をフェッチ、削除、または更新する場合は、where句を使用して条件を指定し、操作のためにテーブルの行をフィルタリングする必要があります。

たとえば、where句を含むSELECTステートメントがある場合、指定された条件を満たす行のみが取得されます。

構文

以下は、SQLiteのWHERE句の構文です-

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

比較演算子または論理演算子を使用してsearch_conditionを指定できます。 >、<、=、LIKE、NOTなど。次の例は、この概念を明確にします。

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

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

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

次のSELECTステートメントは、年齢が35歳以上のレコードを取得します-

sqlite> SELECT * FROM CRICKETERS WHERE AGE > 35;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

Pythonを使用したWhere節

Cursorオブジェクト/クラスには、クエリを実行したりデータをフェッチしたりするためのすべてのメソッドが含まれています。接続クラスのカーソルメソッドは、カーソルオブジェクトを返します。

したがって、Pythonを使用してSQLiteデータベースにテーブルを作成するには-

connect（）メソッドを使用して、データベースとの接続を確立します。
上記で作成した接続オブジェクトでcursor（）メソッドを呼び出して、カーソルオブジェクトを作成します。 *次に、Cursorクラスのexecute（）メソッドを使用してCREATE TABLEステートメントを実行します。

例

次の例では、Employeeという名前のテーブルを作成し、それを設定します。次に、where句を使用して、年齢値が23未満のレコードを取得します。

import sqlite3

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

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

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Ramya', 'Rama priya', 27, 'F', 9000)''')

cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Vinay', 'Battacharya', 20, 'M', 6000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Sharukh', 'Sheik', 25, 'M', 8300)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Sarmista', 'Sharma', 26, 'F', 10000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')

#Retrieving specific records using the where clause
cursor.execute("SELECT* from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

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

Python SQLite-注文者

SELECTクエリを使用してデータをフェッチしている間、挿入したのと同じ順序でレコードを取得します。

*_Order By_* 句を使用して、結果を目的の順序（昇順または降順）に並べ替えることができます。 デフォルトでは、この句は結果を昇順でソートします。降順に並べる必要がある場合は、明示的に「DESC」を使用する必要があります。

構文

以下は、SQLiteのORDER BY句の構文です。

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

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

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

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

次のSELECTステートメントは、年齢の昇順でCRICKETERSテーブルの行を取得します-

sqlite> SELECT *FROM CRICKETERS ORDER BY AGE;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

複数の列を使用して、テーブルのレコードをソートできます。次のSELECTステートメントは、列_AGE_および_FIRST_NAME_に基づいてCRICKETERSテーブルのレコードをソートします。

sqlite> SELECT* FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

デフォルトでは、 ORDER BY 句はテーブルのレコードを昇順でソートします。DESCを使用して結果を降順で並べることができます-

sqlite> SELECT *FROM CRICKETERS ORDER BY AGE DESC;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara     Sangakkara 41   Matale     Srilanka
Jonathan   Trott      38   CapeTown   SouthAfrica
Shikhar    Dhawan     33   Delhi      India
Rohit      Sharma     32   Nagpur     India
Virat      Kohli      30   Delhi      India
sqlite>

Pythonを使用したORDER BY句

テーブルの内容を特定の順序で取得するには、カーソルオブジェクトでexecute（）メソッドを呼び出し、パラメータとしてORDER BY句とともにSELECTステートメントを渡します。

例

次の例では、ORDER BY句を使用して、名前とEmployeeを使用してテーブルを作成し、それを設定し、年齢の（昇順）のレコードを取得します。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

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

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT, SEX CHAR(1),
   INCOME INT,
   CONTACT INT
)'''
cursor.execute(sql)

#Populating the table
#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000),
   ('Sharukh', 'Sheik', 25, 'M', 8300),
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

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

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

[('Vinay', 'Battacharya', 20, 'M', 6000, None),
   ('Tripthi', 'Mishra', 24, 'F', 6000, None),
   ('Sharukh', 'Sheik', 25, 'M', 8300, None),
   ('Sarmista', 'Sharma', 26, 'F', 10000, None),
   ('Ramya', 'Rama priya', 27, 'F', 9000, None)]

Python SQLite-テーブルの更新

データベースでのUPDATE操作は、データベースですでに使用可能なテーブルの1つ以上のレコードの値を変更することを意味します。 UPDATEステートメントを使用して、SQLiteの既存のレコードの値を更新できます。

特定の行を更新するには、それと共にWHERE句を使用する必要があります。

構文

以下は、SQLiteのUPDATEステートメントの構文です-

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

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

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

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

次のステートメントは、クリケット選手の年齢を変更します。ファーストネームは Shikhar です-

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

FIRST_NAMEがShikharであるレコードを取得すると、年齢の値が45に変更されていることがわかります-

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

使用していない場合は、すべてのレコードのWHERE句の値が更新されます。 UPDATEステートメントを実行すると、CRICKETERSテーブル内のすべてのレコードの経過時間が1ずつ増加します-

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

SELECTコマンドを使用してテーブルの内容を取得する場合、更新された値を次のように表示できます-

sqlite> SELECT* FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     46   Delhi      India
Jonathan   Trott      39   CapeTown   SouthAfrica
Kumara     Sangakkara 42   Matale     Srilanka
Virat      Kohli      31   Delhi      India
Rohit      Sharma     33   Nagpur     India
sqlite>

Pythonを使用して既存のレコードを更新する

SQLiteデータベースの既存のテーブルにレコードを追加するには-

sqlite3パッケージをインポートします。
データベースの名前をパラメーターとして渡すことにより、_connect（）_メソッドを使用して接続オブジェクトを作成します。
cursor（） メソッドは、SQLite3と通信できるカーソルオブジェクトを返します。（作成済みの）Connectionオブジェクトでcursor（）オブジェクトを呼び出して、カーソルオブジェクトを作成します。 *次に、UPDATEステートメントをパラメーターとして渡すことにより、カーソルオブジェクトでexecute（）メソッドを呼び出します。

例

Pythonの例に従って、EMPLOYEEという名前のテーブルを作成し、5つのレコードを挿入して、すべての男性従業員の年齢を1ずつ増やします-

import sqlite3

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

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

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Inserting data
cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
   ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000),
   ('Sharukh', 'Sheik', 25, 'M', 8300),
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

#Fetching all the rows before the update
print("Contents of the Employee table: ")
cursor.execute('''SELECT* from EMPLOYEE''')
print(cursor.fetchall())

#Updating the records
sql = '''UPDATE EMPLOYEE SET AGE=AGE+1 WHERE SEX = 'M' '''
cursor.execute(sql)
print("Table updated...... ")

#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
   ('Vinay', 'Battacharya', 20, 'M', 6000.0),
   ('Sharukh', 'Sheik', 25, 'M', 8300.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
   ('Vinay', 'Battacharya', 21, 'M', 6000.0),
   ('Sharukh', 'Sheik', 26, 'M', 8300.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Python SQLite-データの削除

SQLiteテーブルからレコードを削除するには、DELETE FROMステートメントを使用する必要があります。特定のレコードを削除するには、それと共にWHERE句を使用する必要があります。

特定の行を更新するには、それと共にWHERE句を使用する必要があります。

構文

以下は、SQLiteのDELETEクエリの構文です-

DELETE FROM table_name [WHERE Clause]

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

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

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

次の文は、姓が「Sangakkara」であるクリケット選手のレコードを削除します。

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

SELECTステートメントを使用してテーブルの内容を取得すると、1つのレコードが削除されているため、4つのレコードしか表示できません。

sqlite> SELECT *FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     46   Delhi      India
Jonathan   Trott      39   CapeTown   SouthAfrica
Virat      Kohli      31   Delhi      India
Rohit      Sharma     33   Nagpur     India
sqlite>

WHERE句なしでDELETE FROMステートメントを実行すると、指定されたテーブルのすべてのレコードが削除されます。

sqlite> DELETE FROM CRICKETERS;
sqlite>

すべてのレコードを削除しているため、SELECTステートメントを使用してCRICKETERSテーブルの内容を取得しようとすると、以下に示すように空の結果セットが得られます-

sqlite> SELECT* FROM CRICKETERS;
sqlite>

Pythonを使用してデータを削除する

SQLiteデータベースの既存のテーブルにレコードを追加するには-

sqlite3パッケージをインポートします。
データベースの名前をパラメーターとして渡すことにより、_connect（）_メソッドを使用して接続オブジェクトを作成します。
cursor（） メソッドは、SQLite3と通信できるカーソルオブジェクトを返します。（作成済みの）Connectionオブジェクトでcursor（）オブジェクトを呼び出して、カーソルオブジェクトを作成します。 *次に、DELETEステートメントをパラメーターとして渡すことにより、カーソルオブジェクトでexecute（）メソッドを呼び出します。

例

次のpythonの例では、年齢値が25を超えるレコードをEMPLOYEEテーブルから削除します。

import sqlite3

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

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

#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT* from EMPLOYEE''')
print(cursor.fetchall())

#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')

#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
   ('Vinay', 'Battacharya', 21, 'M', 6000.0),
   ('Sharukh', 'Sheik', 26, 'M', 8300.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Contents of the table after delete operation
[('Vinay', 'Battacharya', 21, 'M', 6000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Python SQLite-テーブルの削除

DROP TABLEステートメントを使用して、テーブル全体を削除できます。削除する必要があるテーブルの名前を指定するだけです。

構文

以下は、PostgreSQLのDROP TABLEステートメントの構文です-

DROP TABLE table_name;

例

次のクエリを使用して、名前がCRICKETERSとEMPLOYEESの2つのテーブルを作成したとします-

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int,
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
sqlite> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT,
   SEX CHAR(1), INCOME FLOAT
);
sqlite>

*_。tables_* コマンドを使用してテーブルのリストを確認すると、上記の作成されたテーブル（リスト）が次のように表示されます-

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

次の文は、データベースからEmployeeという名前のテーブルを削除します-

sqlite> DROP table employee;
sqlite>

Employeeテーブルを削除したため、テーブルのリストを再度取得すると、その中の1つのテーブルのみを観察できます。

sqlite> .tables
CRICKETERS
sqlite>

Employeeテーブルを再度削除しようとすると、既に削除されているため、以下に示すように「そのようなテーブルはありません」というエラーが表示されます-

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

これを解決するには、DELTEステートメントと一緒にIF EXISTS句を使用できます。これにより、テーブルが存在する場合は削除され、存在しない場合はDLETE操作がスキップされます。

sqlite> DROP table IF EXISTS employee;
sqlite>

Pythonを使用してテーブルを削除する

MYSQLのDROPステートメントを使用して、必要なときにいつでもテーブルを削除できますが、既存のテーブルを削除するときは、テーブルの削除後に失われたデータが復元されないため、非常に注意する必要があります。

例

Pythonを使用してSQLite3データベースからテーブルを削除するには、カーソルオブジェクトで execute（） メソッドを呼び出し、dropステートメントをパラメーターとして渡します。

import sqlite3

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

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

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

Table dropped...

Python SQLite-制限

特定の数でレコードを制限する場合は、SQLiteのLIMIT句を使用してレコードを取得できます。

構文

以下は、SQLiteのLIMIT句の構文です-

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

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

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

そして、INSERTステートメントを使用して5つのレコードを挿入した場合-

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

次のステートメントは、LIMIT句を使用してCricketersテーブルの最初の3つのレコードを取得します-

sqlite> SELECT *FROM CRICKETERS LIMIT 3;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

レコードを1番目ではなくn番目のレコードから制限する必要がある場合は、LIMITとともにOFFSETを使用して制限できます。

sqlite> SELECT* FROM CRICKETERS LIMIT 3 OFFSET 2;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara     Sangakkara 41   Matale     Srilanka
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
sqlite>

Pythonを使用したLIMIT句

SELECTクエリとLIMIT句を渡すことにより、カーソルオブジェクトでexecute（）メソッドを呼び出すと、必要な数のレコードを取得できます。

例

次のpythonの例では、LIMIT句を使用してEMPLOYEEテーブルの最初の2つのレコードを取得します。

import sqlite3

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

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

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 3'''

#Executing the query
cursor.execute(sql)

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

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

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

Python SQLite-参加

データを2つのテーブルに分割したら、結合を使用してこれらの2つのテーブルから結合レコードをフェッチできます。

例

次のクエリを使用して、名前CRICKETERSのテーブルを作成したとします-

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

CRICKETERSテーブルの各プレーヤーの1日のクリケット統計を記述するOdiStatsテーブルをもう1つ作成します。

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

次のステートメントは、これら2つのテーブルの値を組み合わせたデータを取得します-

sqlite> SELECT
   Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
   OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
   from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
First_Name Last_Name    Country  Matches    Runs          Centuries  HalfCenturies
---------- ----------   -------  ---------- ------------- ---------- ----------
Shikhar    Dhawan       Indi     133        5518          17         27
Jonathan   Trott        Sout     68         2819          4          22
Kumara     Sangakkara   Sril     404        14234         25         93
Virat      Kohli        Indi     239        11520         43         54
Rohit      Sharma       Indi     218        8686          24         42
sqlite>

Pythonを使用した結合句

次のSQLiteの例では、Pythonを使用してJOIN句を示しています-

import sqlite3

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

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

#Retrieving data
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

出力

[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, 'Krishna@mymail.com', 'Hyderabad'),
   ('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102,'Raja@mymail.com', 'Vishakhapatnam'),
   ('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, 'Krishna@mymail.com', 'Pune'),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, 'Raja@mymail.com', 'Mumbai')]

Python SQLite-カーソルオブジェクト

sqlite3.Cursorクラスは、SQLiteステートメントを実行し、クエリの結果セットからデータを取得するメソッドを呼び出すことができるインスタンスです。 Connectionオブジェクト/クラスのcursor（）メソッドを使用して Cursor オブジェクトを作成できます。

例

import sqlite3

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

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

方法

以下は、Cursorクラス/オブジェクトによって提供されるさまざまなメソッドです。

Sr.No	Method & Description
1	execute() このルーチンは、SQLステートメントを実行します。 SQLステートメントはパラメーター化できます（つまり、SQLリテラルではなくプレースホルダー）。 psycopg2モジュールは、％s記号を使用したプレースホルダーをサポートしますたとえば、cursor.execute（ "insert into people values（％s、％s）"、（who、age））
2	executemany() このルーチンは、シーケンスsqlで見つかったすべてのパラメーターシーケンスまたはマッピングに対してSQLコマンドを実行します。
3	fetchone() このメソッドは、クエリ結果セットの次の行をフェッチして単一のシーケンスを返します。使用可能なデータがなくなったらNoneを返します。
4	fetchmany() このルーチンは、クエリ結果の次の行セットをフェッチし、リストを返します。使用可能な行がなくなると、空のリストが返されます。このメソッドは、sizeパラメーターで指定された数の行をフェッチしようとします。
5	fetchall() このルーチンは、クエリ結果のすべての（残りの）行をフェッチし、リストを返します。使用可能な行がない場合、空のリストが返されます。

プロパティ

以下は、カーソルクラスのプロパティです-

Sr.No	Method & Description
1	arraySize これは、fetchmany（）メソッドによって返される行数を設定できる読み取り/書き込みプロパティです。
2	description これは、結果セットの列の説明を含むリストを返す読み取り専用プロパティです。
3	lastrowid これは読み取り専用のプロパティです。テーブルに自動インクリメントされた列がある場合、最後のINSERTまたはUPDATE操作でその列に対して生成された値を返します。
4	rowcount これは、SELECTおよびUPDATE操作の場合に返される/更新される行の数を返します。
5	connection この読み取り専用属性は、Cursorオブジェクトが使用するSQLiteデータベース接続を提供します。

Python MongoDB-はじめに

Pymongoは、MongoDBで動作するツールを提供するPythonディストリビューションです。PythonからMongoDBデータベースと通信するための最も好ましい方法です。

インストール

pymongoを最初にインストールするには、python3（PIPとともに）およびMongoDBが適切にインストールされていることを確認してください。次に、次のコマンドを実行します。

C:\WINDOWS\system32>pip install pymongo
Collecting pymongo
Using cached https://files.pythonhosted.org/packages/cb/a6/b0ae3781b0ad75825e00e29dc5489b53512625e02328d73556e1ecdf12f8/pymongo-3.9.0-cp37-cp37m-win32.whl
Installing collected packages: pymongo
Successfully installed pymongo-3.9.0

検証

pymongoをインストールしたら、新しいテキストドキュメントを開き、次の行を貼り付けて、test.pyとして保存します。

import pymongo

pymongoを適切にインストールした場合、以下に示すようにtest.pyを実行すると、問題は発生しません。

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

Python MongoDB-データベースの作成

他のデータベースとは異なり、MongoDBはデータベースを作成するための個別のコマンドを提供しません。

一般に、useコマンドは、特定のデータベースを選択または切り替えるために使用されます。このコマンドは、最初に指定したデータベースが存在するかどうかを確認し、存在する場合は接続します。データベースがuseコマンドで指定されていない場合、新しいデータベースが作成されます。

したがって、 _ Use_ コマンドを使用して、MongoDBにデータベースを作成できます。

構文

*use DATABASE* ステートメントの基本構文は次のとおりです-

use DATABASE_NAME

例

次のコマンドは、mydbという名前のデータベースを作成します。

>use mydb
switched to db mydb

dbコマンドを使用して作成を確認できます。これにより、現在のデータベースが表示されます。

>db
mydb

Pythonを使用してデータベースを作成する

pymongoを使用してMongoDBに接続するには、MongoClientをインポートして作成する必要があります。その後、属性passionで作成する必要があるデータベースに直接アクセスできます。

例

次の例では、MangoDBにデータベースを作成します。

from pymongo import MongoClient

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

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

#Verification
print("List of databases after creating new one")
print(client.list_database_names())

出力

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

MongoClientの作成中にポート名とホスト名を指定することもでき、辞書形式でデータベースにアクセスできます。

例

from pymongo import MongoClient

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

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

出力

Database created........

Python MongoDB-コレクションの作成

MongoDBのコレクションは一連のドキュメントを保持します。これは、リレーショナルデータベースのテーブルに似ています。

*_createCollection（）_* メソッドを使用してコレクションを作成できます。 このメソッドは、作成するコレクションの名前を表す文字列値と、オプション（オプション）パラメーターを受け入れます。

これを使用して、次を指定できます-

コレクションのサイズ。
上限付きコレクションで許可されるドキュメントの最大数。
作成するコレクションをキャップ付きコレクション（固定サイズコレクション）にするかどうか。
作成するコレクションに自動インデックスを付けるかどうか。

構文

MongoDBでコレクションを作成する構文は次のとおりです。

db.createCollection("CollectionName")

例

次のメソッドは、ExampleCollectionという名前のコレクションを作成します。

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

同様に、以下はcreateCollection（）メソッドのオプションを使用してコレクションを作成するクエリです。

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

Pythonを使用してコレクションを作成する

次のpythonの例は、MongoDB（mydb）のデータベースに接続し、その中にコレクションを作成します。

例

from pymongo import MongoClient

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

#Getting the database instance
db = client['mydb']

#Creating a collection
collection = db['example']
print("Collection created........")

出力

Collection created........

Python MongoDB-文書の挿入

_insert（）_メソッドを使用して、MongoDBにドキュメントを保存できます。このメソッドは、パラメーターとしてJSONドキュメントを受け入れます。

構文

insertメソッドの構文は次のとおりです。

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

例

> use mydb
switched to db mydb
> db.createCollection("sample")
{ "ok" : 1 }
> doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
{ "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
> db.sample.insert(doc1)
WriteResult({ "nInserted" : 1 })
>

同様に、 _ insert（）_ メソッドを使用して複数のドキュメントを挿入することもできます。

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data =
[
   {
      "_id": "1001",
      "name": "Ram",
      "age": "26",
      "city": "Hyderabad"
   },
   {
      "_id": "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id": "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.sample.insert(data)
BulkWriteResult
({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 3,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})
>

Pythonを使用してコレクションを作成する

Pymongoは、MangoDBにドキュメントを挿入するinsert_one（）という名前のメソッドを提供します。このメソッドには、辞書形式でドキュメントを渡す必要があります。

例

次の例では、exampleという名前のコレクションにドキュメントを挿入します。

from pymongo import MongoClient

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

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
coll.insert_one(doc1)
print(coll.find_one())

出力

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

pymongoを使用して複数のドキュメントをMongoDBに挿入するには、insert_many（）メソッドを呼び出す必要があります。

from pymongo import MongoClient

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

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data =
[
   {
      "_id": "101",
      "name": "Ram",
      "age": "26",
      "city": "Hyderabad"
   },
   {
      "_id": "102",
      "name": "Rahim",
      "age": "27",
      "city": "Bangalore"
   },
   {
      "_id": "103",
      "name": "Robert",
      "age": "28",
      "city": "Mumbai"
   }
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

出力

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

Python MongoDB-検索

*_find（）_* メソッドを使用して、MongoDBから保存されたドキュメントを読み取り/取得できます。 このメソッドは、非構造化された方法でMongoDB内のすべてのドキュメントを取得して表示します。

構文

以下は、 _ find（）_ メソッドの構文です。

>db.CollectionName.find()

例

次のクエリを使用して、sampleという名前のコレクション内のtestDBという名前のデータベースに3つのドキュメントを挿入したとします-

> use testDB
> db.createCollection("sample")
> data = [
   {"_id": "1001", "name" : "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
> db.sample.insert(data)

次のようにfind（）メソッドを使用して、挿入されたドキュメントを取得できます-

> use testDB
switched to db testDB
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
>

また、findOne（）メソッドを使用してコレクションの最初のドキュメントを取得することもできます-

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

Pythonを使用したデータの取得（検索）

pymongoの find_One（） メソッドは、クエリに基づいて単一のドキュメントを取得するために使用されます。一致しない場合、このメソッドは何も返さず、クエリを使用しない場合、コレクションの最初のドキュメントを返します。

このメソッドは、結果のドキュメントを1つだけ取得する必要がある場合、またはクエリが1つのドキュメントのみを返すことが確実な場合に便利です。

例

次のPythonの例では、コレクションの最初のドキュメントを取得します-

from pymongo import MongoClient

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

#Getting the database instance
db = client['mydatabase']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

#Retrieving the first record using the find_one() method
print("First record of the collection: ")
print(coll.find_one())

#Retrieving a record with is 103 using the find_one() method
print("Record whose id is 103: ")
print(coll.find_one({"_id": "103"}))

出力

Data inserted ......
['101', '102', '103']
First record of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
Record whose id is 103:
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

1つのクエリで複数のドキュメントを取得するには（単一メソッドのod findメソッド）、pymongoの find（） メソッドを使用できます。クエリを渡していない場合、これはコレクションのすべてのドキュメントを返し、このメソッドにクエリを渡した場合、一致したすべてのドキュメントを返します。

例

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Records of the collection: ")
for doc1 in coll.find():
print(doc1)

#Retrieving records with age greater than 26 using the find() method
print("Record whose age is more than 26: ")
for doc2 in coll.find({"age":{"$gt":"26"}}):
print(doc2)

出力

Data inserted ......
Records of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Record whose age is more than 26:
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Python MongoDB-クエリ

find（）*メソッドを使用して取得している間、クエリオブジェクトを使用してドキュメントをフィルタリングできます。必要なドキュメントの条件を指定するクエリを、このメソッドのパラメーターとして渡すことができます。

オペレータ

以下は、MongoDBのクエリで使用される演算子のリストです。

Operation	Syntax	Example
Equality	\{"key" : "value"}	db.mycol.find(\{"by":"tutorials point"})
Less Than	\{"key" :\{$lt:"value"}}	db.mycol.find(\{"likes":\{$lt:50}})
Less Than Equals	\{"key" :\{$lte:"value"}}	db.mycol.find(\{"likes":\{$lte:50}})
Greater Than	\{"key" :\{$gt:"value"}}	db.mycol.find(\{"likes":\{$gt:50}})
Greater Than Equals	\{"key" \{$gte:"value"}}	db.mycol.find(\{"likes":\{$gte:50}})
Not Equals	\{"key":\{$ne: "value"}}	db.mycol.find(\{"likes":\{$ne:50}})

例1

次の例では、名前がsarmistaであるコレクション内のドキュメントを取得します。

from pymongo import MongoClient

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

#Getting the database instance
db = client['sdsegf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc1 in coll.find({"name":"Sarmista"}):
   print(doc1)

出力

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

例2

次の例では、年齢の値が26を超えるコレクション内のドキュメントを取得します。

from pymongo import MongoClient

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

#Getting the database instance
db = client['ghhj']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc in coll.find({"age":{"$gt":"26"}}):
   print(doc)

出力

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

Python MongoDB-並べ替え

コレクションのコンテンツを取得する際、 sort（） メソッドを使用して、昇順または降順でコレクションを並べ替えることができます。

このメソッドには、フィールドとソート順（1または-1）を渡すことができます。ここで、1は昇順、-1は降順です。

構文

_sort（）_メソッドの構文は次のとおりです。

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

例

以下に示すように、コレクションを作成し、それに5つのドキュメントを挿入したと仮定します-

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

次の行は、年齢に基づいて昇順でソートされたコレクションのすべてのドキュメントを取得します。

> db.sample.find().sort({age:1})
{ "_id" : "1005", "name" : "Sarmista", "age" : 23, "city" : "Delhi" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

Pythonを使用してドキュメントを並べ替える

クエリの結果を昇順または降順に並べ替えるために、pymongoは sort（） メソッドを提供します。このメソッドには、結果に必要なドキュメントの数を表す数値を渡します。

デフォルトでは、このメソッドは指定されたフィールドに基づいて文書を昇順でソートします。降順でソートする必要がある場合は、フィールド名とともに-1を渡します-

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

例

次の例では、年齢の値に従って昇順に並べられたコレクションのすべてのドキュメントを取得します-

from pymongo import MongoClient

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

#Getting the database instance
db = client['b_mydb']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("List of documents (sorted in ascending order based on age): ")

for doc1 in coll.find().sort("age"):
   print(doc1)

出力

Data inserted ......
List of documents (sorted in ascending order based on age):
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1006', 'name': 'Rasajna', 'age': 26, 'city': 'Chennai'}
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Python MongoDB-ドキュメントの削除

MongoDBの remove（） メソッドを使用して、コレクション内のドキュメントを削除できます。このメソッドは、2つのオプションのパラメータを受け入れます-

文書を削除する条件を指定する削除基準。
1つだけ。2番目のパラメーターとしてtrueまたは1を渡すと、1つのドキュメントのみが削除されます。

構文

以下は、remove（）メソッドの構文です-

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

例

以下に示すように、コレクションを作成し、それに5つのドキュメントを挿入したと仮定します-

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

次のクエリは、Sarmistaという名前の値を持つコレクションのドキュメントを削除します。

> db.sample.remove({"name": "Sarmista"})
WriteResult({ "nRemoved" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }

削除基準を渡さずに* remove（）*メソッドを呼び出すと、コレクション内のすべてのドキュメントが削除されます。

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

Pythonを使用してドキュメントを削除する

MangoDBのコレクションからドキュメントを削除するには、メソッド* delete_one（）および delete_many（）*メソッドを使用して、コレクションからドキュメントを削除できます。

これらのメソッドは、ドキュメントを削除する条件を指定するクエリオブジェクトを受け入れます。

detele_one（）メソッドは、一致した場合に単一のドキュメントを削除します。クエリが指定されていない場合、このメソッドはコレクション内の最初のドキュメントを削除します。

例

次のpythonの例では、1006のid値を持つコレクション内のドキュメントを削除します。

from pymongo import MongoClient

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

#Getting the database instance
db = client['lpaksgf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting one document
coll.delete_one({"_id" : "1006"})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

出力

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}

同様に、pymongoの delete_many（） メソッドは、指定された条件を満たすすべてのドキュメントを削除します。

例

次の例では、年齢の値が26より大きいコレクション内のすべてのドキュメントを削除します-

from pymongo import MongoClient

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

#Getting the database instance
db = client['sampleDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting multiple documents
coll.delete_many({"age":{"$gt":"26"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

出力

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1004', 'name': 'Romeo', 'age': '25', 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
{'_id': '1006', 'name': 'Rasajna', 'age': '26', 'city': 'Chennai'}

クエリを渡さずにdelete_many（）メソッドを呼び出すと、このメソッドはコレクション内のすべてのドキュメントを削除します。

coll.delete_many({})

Python MongoDB-ドロップコレクション

MongoDBの drop（） メソッドを使用してコレクションを削除できます。

構文

以下は、drop（）メソッドの構文です-

db.COLLECTION_NAME.drop()

例

次の例では、sampleという名前のコレクションを削除します-

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

Pythonを使用してコレクションを削除する

drop（）メソッドを呼び出すことにより、現在のデータベースからコレクションを削除/削除できます。

例

from pymongo import MongoClient

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

#Getting the database instance
db = client['example2']

#Creating a collection
col1 = db['collection']
col1.insert_one({"name": "Ram", "age": "26", "city": "Hyderabad"})
col2 = db['coll']
col2.insert_one({"name": "Rahim", "age": "27", "city": "Bangalore"})
col3 = db['myColl']
col3.insert_one({"name": "Robert", "age": "28", "city": "Mumbai"})
col4 = db['data']
col4.insert_one({"name": "Romeo", "age": "25", "city": "Pune"})

#List of collections
print("List of collections:")
collections = db.list_collection_names()
for coll in collections:
print(coll)

#Dropping a collection
col1.drop()
col4.drop()
print("List of collections after dropping two of them: ")

#List of collections
collections = db.list_collection_names()

for coll in collections:
   print(coll)

出力

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

Python MongoDB-アップデート

*_update（）_* メソッドまたは *_save（）_* メソッドを使用して、既存のドキュメントの内容を更新できます。

更新メソッドは既存のドキュメントを変更しますが、保存メソッドは既存のドキュメントを新しいドキュメントに置き換えます。

構文

以下は、MangoDBのupdate（）およびsave（）メソッドの構文です-

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

例

データベースにコレクションを作成し、以下に示すように3つのレコードを挿入したと仮定します-

> use testdatabase
switched to db testdatabase
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   ... {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.createCollection("sample")
{ "ok" : 1 }
> db.sample.insert(data)

次のメソッドは、ID 1002のドキュメントの都市値を更新します。

> db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

同様に、save（）メソッドを使用して同じIDで保存することにより、ドキュメントを新しいデータに置き換えることができます。

> db.sample.save(
   { "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Pythonを使用してドキュメントを更新する

単一のドキュメントを取得するfind_one（）メソッドと同様に、pymongoのupdate_one（）メソッドは単一のドキュメントを更新します。

このメソッドは、更新するドキュメントと更新操作を指定するクエリを受け入れます。

例

次のpythonの例は、コレクション内のドキュメントの場所の値を更新します。

from pymongo import MongoClient

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

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_one({"_id":"102"},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

出力

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

同様に、pymongoの update_many（） メソッドは、指定された条件を満たすすべてのドキュメントを更新します。

例

次の例では、コレクション内のすべてのドキュメントの場所の値を更新します（空の状態）-

from pymongo import MongoClient

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

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_many({},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

出力

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Visakhapatnam'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Visakhapatnam'}

Python MongoDB-制限

コレクションのコンテンツを取得する際、limit（）メソッドを使用して結果のドキュメントの数を制限できます。このメソッドは、結果に必要なドキュメントの数を表す数値を受け入れます。

構文

以下は、limit（）メソッドの構文です-

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

例

以下に示すように、コレクションを作成し、それに5つのドキュメントを挿入したと仮定します-

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

次の行は、コレクションの最初の3つのドキュメントを取得します。

> db.sample.find().limit(3)
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Pythonを使用してドキュメントを制限する

クエリの結果を特定の数のドキュメントに制限するために、pymongoは limit（） メソッドを提供します。このメソッドには、結果に必要なドキュメントの数を表す数値を渡します。

例

次の例では、コレクション内の最初の3つのドキュメントを取得します。

from pymongo import MongoClient

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

#Getting the database instance
db = client['l']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("First 3 documents in the collection: ")

for doc1 in coll.find().limit(3):
   print(doc1)

出力

Data inserted ......
First 3 documents in the collection:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Python-data-access-quick-guide

Python MySQL-はじめに

mysql-connector-pythonとは何ですか？

mysql-connector-pythonをインストールするにはどうすればよいですか？

PIPを検証する

mysql-connector-pythonのインストール

検証

Pythonをゼロからインストールする

Python MySQL-データベース接続

Pythonを使用してMySQLとの接続を確立する

例

出力

Python MySQL-データベースの作成

構文

例

Pythonを使用してMySQLでデータベースを作成する

例

出力

Python MySQL-テーブルの作成

構文

例

Pythonを使用してMySQLでテーブルを作成する

例

Python MySQL-データの挿入

構文

例

Pythonを使用してMySQLテーブルにデータを挿入する

例

値を動的に挿入する

例

出力

Python MySQL-データの選択

構文

例

Pythonを使用してMYSQLテーブルからデータを読み取る

例

出力

例

出力

Python MySQL-Where句

構文

例

Pythonを使用したWHERE句

例

出力

Python MySQL-注文者

構文

例

Pythonを使用したORDER BY句

例

出力

例

出力

Python MySQL-テーブルの更新

構文

例

Pythonを使用してテーブルの内容を更新する

例

出力

Python MySQL-データの削除

構文

例

Pythonを使用してテーブルのレコードを削除する

例

出力

Python MySQL-ドロップテーブル

構文

例

Pythonを使用してテーブルを削除する

例

出力

存在する場合にのみテーブルを削除する

出力

Python MySQL-制限

例

Pythonを使用した制限句

例

出力

オフセット付きの制限

出力