Pythonデータアクセス-クイックガイド
データベースインターフェイスのPython標準は、PythonDB-APIです。ほとんどのPythonデータベースインターフェイスはこの標準に準拠しています。
アプリケーションに適したデータベースを選択できます。Python Database APIは、次のような幅広いデータベースサーバーをサポートします。
- GadFly
- mSQL
- MySQL
- PostgreSQL
- Microsoft SQL Server 2000
- Informix
- Interbase
- Oracle
- Sybase
使用可能なPythonデータベースインターフェイスのリストは次のとおりです：PythonデータベースインターフェイスとAPI。アクセスする必要のあるデータベースごとに個別のDBAPIモジュールをダウンロードする必要があります。たとえば、MySQLデータベースだけでなくOracleデータベースにもアクセスする必要がある場合は、OracleデータベースモジュールとMySQLデータベースモジュールの両方をダウンロードする必要があります。
mysql-connector-pythonとは何ですか？
MySQL Python / Connectorは、PythonからMySQLデータベースサーバーに接続するためのインターフェイスです。PythonデータベースAPIを実装し、MySQLの上に構築されています。
mysql-connector-pythonをインストールするにはどうすればよいですか？
まず、マシンにPythonがすでにインストールされていることを確認する必要があります。これを行うには、コマンドプロンプトを開き、Pythonと入力して、Enterキーを押します。Pythonがすでにシステムにインストールされている場合、このコマンドは次のようにそのバージョンを表示します-
C:\Users\Tutorialspoint>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\Tutorialspoint>d:
D:\>mkdir Python_MySQLPIPを確認する
PIPは、Pythonのパッケージマネージャーであり、Pythonでさまざまなモジュール/パッケージをインストールできます。したがって、Mysql-python mysql-connector-pythonをインストールするには、コンピューターにPIPがインストールされており、その場所がパスに追加されていることを確認する必要があります。
これを行うには、pipコマンドを実行します。システムにPIPがない場合、またはPIPの場所をシステムに追加していない場合Path 環境変数の場合、次のようなエラーメッセージが表示されます。
D:\Python_MySQL>pip
'pip' is not recognized as an internal or external command,
operable program or batch file.PIPをインストールするには、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.6mysql-connector-pythonのインストール
PythonとPIPをインストールしたら、コマンドプロンプトを開き、以下に示すようにpip（オプション）をアップグレードします。
C:\Users\Tutorialspoint>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 MySQLConnectを-としてインストールします。
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を最初からインストールする必要がある場合です。Pythonホームページにアクセスします。
クリックしてください Downloads ボタンをクリックすると、さまざまなプラットフォーム用の最新バージョンのPythonへのリンクを提供するダウンロードページにリダイレクトされます。1つを選択してダウンロードします。
たとえば、python-3.7.4.exe（Windows用）をダウンロードしました。ダウンロードした.exeファイルをダブルクリックして、インストールプロセスを開始します。
[Python 3.7をパスに追加]オプションをオンにして、インストールを続行します。このプロセスが完了すると、Pythonがシステムにインストールされます。
MySQLに接続するには、（1つの方法は）以下に示すようにシステムで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
ByePythonを使用して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',)資格情報（ユーザー名、パスワード、ホスト名、データベース名）をに渡すことでMySQLへの接続を確立することもできます connection.MySQLConnection() 以下に示すように-
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()CREATE DATABASEクエリを使用して、MYSQLでデータベースを作成できます。
構文
以下は、CREATEDATABASEクエリの構文です。
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内のデータを操作するには、データベースに接続する必要があります。既存のデータベースに接続することも、独自のデータベースを作成することもできます。
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',)]CREATE TABLEステートメントは、MYSQLデータベースにテーブルを作成するために使用されます。ここでは、テーブルの名前と、各列の定義（名前とデータ型）を指定する必要があります。
構文
以下は、MySQLでテーブルを作成するための構文です。
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
);例
次のクエリは、5つの列（FIRST_NAME、LAST_NAME、AGE、SEX、およびINCOME）を持つ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パラメーター。
クエリの影響を受ける行数を表す整数値を返します。
データベース接続が確立されたら、CREATETABLEクエリをに渡すことでテーブルを作成できます。 execute() 方法。
つまり、python7minusを使用してテーブルを作成するには;
インポート mysql.connector パッケージ。
を使用して接続オブジェクトを作成します mysql.connector.connect() メソッド、ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡します。
を呼び出してカーソルオブジェクトを作成します cursor() 上で作成した接続オブジェクトのメソッド。
次に、CREATE TABLEステートメントをパラメーターとして、execute() 方法。
例
次の例では、という名前のテーブルを作成します Employee データベース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()
#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()MySQLの既存のテーブルに新しい行を追加するには、 INSERT INTOステートメント。この場合、テーブルの名前、列名、および値を（列名と同じ順序で）指定する必要があります。
構文
以下は、MySQLのINSERTINTOステートメントの構文です。
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()メソッド（カーソルオブジェクトで呼び出される）は、クエリをパラメータとして受け入れ、指定されたクエリを実行します。データを挿入するには、MySQLINSERTステートメントをパラメーターとしてデータに渡す必要があります。
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() 上で作成した接続オブジェクトのメソッド
次に、を実行します INSERT ステートメントをパラメーターとしてに渡すことにより、 execute() 方法。
例
次の例では、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()値を動的に挿入する
の値の代わりに「％s」を使用することもできます INSERT 以下に示すように、MySQLにクエリを実行し、値をリストとして渡します。
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 insertedSELECTクエリを使用して、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)列の名前を-として示す*を使用して、各レコードのすべての値を取得することもできます。
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からデータをフェッチできますfetch() mysql-connector-pythonによって提供されるメソッド。
cursor.MySQLCursorのクラス、すなわち3つのメソッドを提供しますfetchall(), fetchmany() そして、 fetchone() どこ、
ザ・ fetchall()メソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます）。
ザ・ fetchone() メソッドは、クエリの結果の次の行をフェッチし、それをタプルとして返します。
ザ・ fetchmany() メソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行のセットを取得します。
Note −結果セットは、カーソルオブジェクトを使用してテーブルをクエリしたときに返されるオブジェクトです。
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)]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)]SELECTクエリを使用してデータをフェッチしているときに、OrderBy句を使用して、結果を目的の順序（昇順または降順）で並べ替えることができます。デフォルトでは、この句は結果を昇順でソートします。降順で並べ替える必要がある場合は、「DESC」を明示的に使用する必要があります。
構文
以下は、構文SELECTcolumn-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を使用したORDERBY句
テーブルの内容を特定の順序で取得するには、 execute() カーソルオブジェクトのメソッドと、パラメータとしてSELECTステートメントをORDERBY句と一緒に渡します。
例
次の例では、名前とEmployeeを使用してテーブルを作成し、そのテーブルにデータを入力し、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()
#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)
]データベースに対する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)
]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() 方法。
例
次のプログラムは、AGEが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)]を使用してテーブル全体を削除できます DROP TABLEステートメント。削除する必要のあるテーブルの名前を指定するだけです。
構文
以下は、MySQLのDROPTABLEステートメントの構文です。
DROP TABLE table_name;例
テーブルを削除する前に、次のようにSHOWTABLESステートメントを使用してテーブルのリストを取得します。
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'DELETEステートメントにIFEXISTSを追加して、削除する前にテーブルが存在するかどうかを確認することで、このエラーを防ぐことができます。
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',)]レコードを特定の数で制限したい場合は、レコードをフェッチするときに、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を使用した制限句
を呼び出すと execute() SELECTクエリをLIMIT句と一緒に渡すことにより、カーソルオブジェクトのメソッドを使用して、必要な数のレコードを取得できます。
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)]オフセットによる制限
あなたは番目のレコード（ない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)]データを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, '[email protected]', 'Hyderabad'),
(102, '[email protected]', 'Vishakhapatnam'),
(103, '[email protected]', 'Pune'),
(104, '[email protected]', '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 | [email protected] | NULL | Hyderabad |
| Vinay | Bhattacharya | 20 | M | 6000 | 102 | 102 | [email protected] | NULL | Vishakhapatnam |
| Sharukh | Sheik | 25 | M | 8300 | 103 | 103 | [email protected] | NULL | Pune |
| Sarmista | Sharma | 26 | F | 10000 | 104 | 104 | [email protected] | NULL | Mumbai |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
4 rows in set (0.00 sec)Pythonを使用したMYSQLJOIN
次の例では、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, '[email protected]', 9848022338, 'Hyderabad'),
('Raj', 'Kandukuri', 20, 'M', 7000, 102, 102, '[email protected]', 9848022339, 'Vishakhapatnam'),
('Ramya', 'Ramapriya', 29, 'F', 5000, 103, 103, '[email protected]', 9848022337, 'Pune'),
('Mac', 'Mohan', 26, 'M', 2000, 104, 104, '[email protected]', 9848022330, 'Mumbai')]mysql-connector-python（および同様のライブラリ）のMySQLCursorは、MySQLデータベースと通信するステートメントを実行するために使用されます。
そのメソッドを使用して、SQLステートメントの実行、結果セットからのデータのフェッチ、プロシージャの呼び出しを行うことができます。
あなたが作成することができます Cursor Connectionオブジェクト/クラスの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クラス/オブジェクトによって提供されるさまざまなメソッドです。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | callproc() このメソッドは、既存のプロシージャMySQLデータベースを呼び出すために使用されます。 |
| 2 | close() このメソッドは、現在のカーソルオブジェクトを閉じるために使用されます。 |
| 3 | Info() このメソッドは、最後のクエリに関する情報を提供します。 |
| 4 | executemany() このメソッドは、一連のパラメーターリストのリストを受け入れます。MySQLクエリを準備し、すべてのパラメータを使用して実行します。 |
| 5 | execute() このメソッドは、MySQLクエリをパラメータとして受け入れ、指定されたクエリを実行します。 |
| 6 | fetchall() このメソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます） |
| 7 | fetchone() このメソッドは、クエリの結果の次の行をフェッチし、それをタプルとして返します。 |
| 8 | fetchmany() このメソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行のセットを取得します。 |
| 9 | etchwarnings() このメソッドは、最後に実行されたクエリによって生成された警告を返します。 |
プロパティ
Cursorクラスのプロパティは次のとおりです-
| シニア番号 | プロパティと説明 |
|---|---|
| 1 | column_names これは、結果セットの列名を含むリストを返す読み取り専用プロパティです。 |
| 2 | description これは、結果セットの列の説明を含むリストを返す読み取り専用プロパティです。 |
| 3 | lastrowid これは読み取り専用プロパティです。テーブルに自動インクリメントされた列がある場合、これは最後のINSERTまたはUPDATE操作でその列に対して生成された値を返します。 |
| 4 | rowcount これは、SELECTおよびUPDATE操作の場合に返される/更新された行の数を返します。 |
| 5 | statement このプロパティは、最後に実行されたステートメントを返します。 |
インストール
PostgreSQLは、強力なオープンソースのオブジェクトリレーショナルデータベースシステムです。15年以上の活発な開発フェーズと、信頼性、データの整合性、および正確性で高い評価を得ている実証済みのアーキテクチャを備えています。
Pythonを使用してPostgreSQLと通信するには、Pythonプログラミング用に提供されているアダプターであるpsycopgをインストールする必要があります。現在のバージョンは次のとおりです。 psycog2。
psycopg2は、非常に小さくて速く、岩のように安定することを目的として作成されました。PIP（Pythonのパッケージマネージャー）で利用できます
PIPを使用したPsycog2のインストール
まず、PythonとPIPがシステムに正しくインストールされていること、およびPIPが最新であることを確認します。
PIPをアップグレードするには、コマンドプロンプトを開き、次のコマンドを実行します-
C:\Users\Tutorialspoint>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>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',
)CREATE DATABASEステートメントを使用して、PostgreSQLでデータベースを作成できます。コマンドの後に作成するデータベースの名前を指定することにより、PostgreSQLシェルプロンプトでこのステートメントを実行できます。
構文
以下は、CREATEDATABASEステートメントの構文です。
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ステートメントCREATEDATABASEのラッパーであるコマンド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でデータベースを作成するには、このメソッドを使用してCREATEDATABASEクエリを実行します。
例
次の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........CREATE TABLEステートメントを使用して、PostgreSQLのデータベースに新しいテーブルを作成できます。これを実行するときに、テーブルの名前、列名、およびそれらのデータ型を指定する必要があります。
構文
以下は、PostgreSQLのCREATETABLEステートメントの構文です。
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のカーソルのexecute（）メソッドを使用してCREATETABLEステートメントを実行する必要があります。
例
次の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........を使用して、PostgreSQLの既存のテーブルにレコードを挿入できます。 INSERT INTOステートメント。これを実行するときに、テーブルの名前とその中の列の値を指定する必要があります。
構文
以下は、INSERTステートメントの推奨構文です-
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);ここで、column1、column2、column3、..はテーブルの列の名前であり、value1、value2、value3、...はテーブルに挿入する必要のある値です。
例
以下に示すように、CREATETABLEステートメントを使用して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 パッケージ。
を使用して接続オブジェクトを作成します connect() メソッド、ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡します。
属性の値としてfalseを設定して、自動コミットモードをオフにします autocommit。
ザ・ cursor() の方法 Connectionpsycopg2ライブラリのクラスはカーソルオブジェクトを返します。このメソッドを使用してカーソルオブジェクトを作成します。
次に、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........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クラスは、fetchall（）、fetchmany（）、およびfetchone（）の3つのメソッドを提供します。ここで、
fetchall（）メソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます）。
fetchone（）メソッドは、クエリの結果の次の行をフェッチし、それをタプルとして返します。
fetchmany（）メソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行のセットを取得します。
Note −結果セットは、カーソルオブジェクトを使用してテーブルをクエリしたときに返されるオブジェクトです。
例
次の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)]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)]通常、テーブルからデータを取得しようとすると、挿入したのと同じ順序でレコードを取得します。
を使用して ORDER BY 句を使用すると、テーブルのレコードを取得するときに、結果のレコードを目的の列に基づいて昇順または降順で並べ替えることができます。
構文
以下は、PostgreSQLのORDERBY句の構文です。
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を使用したORDERBY句
テーブルの内容を特定の順序で取得するには、カーソルオブジェクトでexecute（）メソッドを呼び出し、SELECTステートメントとORDERBY句をパラメータとして渡します。
例
次の例では、名前とEmployeeを使用してテーブルを作成し、そのテーブルにデータを入力し、ORDER BY句を使用して、そのレコードを年齢の（昇順）順に取得しています。
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)]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 5SELECTコマンドを使用してテーブルの内容を取得すると、更新された値は次のように表示されます。
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 パッケージ。
を使用して接続オブジェクトを作成します connect() メソッド、ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡します。
属性の値としてfalseを設定して、自動コミットモードをオフにします autocommit。
ザ・ cursor() の方法 Connectionpsycopg2ライブラリのクラスはカーソルオブジェクトを返します。このメソッドを使用してカーソルオブジェクトを作成します。
次に、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)]を使用して、既存のテーブルのレコードを削除できます。 DELETE FROMPostgreSQLデータベースのステートメント。特定のレコードを削除するには、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 1SELECTステートメントを使用してテーブルの内容を取得すると、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句を指定せずにDELETEFROMステートメントを実行すると、指定したテーブルのすべてのレコードが削除されます。
postgres=# DELETE FROM CRICKETERS;
DELETE 4すべてのレコードを削除したので、CRICKETERSテーブルの内容を取得しようとすると、SELECTステートメントを使用して、以下に示すような空の結果セットが得られます。
postgres=# SELECT * FROM CRICKETERS;
first_name | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
(0 rows)Pythonを使用してデータを削除する
psycopg2のカーソルクラスは、execute（）メソッドという名前のメソッドを提供します。このメソッドは、クエリをパラメータとして受け取り、それを実行します。
したがって、pythonを使用してPostgreSQLのテーブルにデータを挿入するには-
インポート psycopg2 パッケージ。
を使用して接続オブジェクトを作成します connect() メソッド、ユーザー名、パスワード、ホスト（オプションのデフォルト：localhost）、およびデータベース（オプション）をパラメーターとして渡します。
属性の値としてfalseを設定して、自動コミットモードをオフにします autocommit。
ザ・ cursor()psycopg2ライブラリのConnectionクラスのメソッドは、カーソルオブジェクトを返します。このメソッドを使用してカーソルオブジェクトを作成します。
次に、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)]DROP TABLEステートメントを使用して、PostgreSQLデータベースからテーブルを削除できます。
構文
以下は、PostgreSQLのDROPTABLEステートメントの構文です。
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 TABLEEmployeeテーブルを削除したため、テーブルのリストを再度取得すると、その中のテーブルは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ステートメントとともにIFEXISTS句を使用できます。これにより、テーブルが存在する場合は削除され、存在しない場合は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...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)]データを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, '[email protected]', 'Hyderabad'),
('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102, '[email protected]', 'Vishakhapatnam'),
('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected] ', 'Pune'),
('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]psycopgライブラリのCursorクラスは、Pythonコードを使用してデータベース内のPostgreSQLコマンドを実行するためのメソッドを提供します。
そのメソッドを使用して、SQLステートメントの実行、結果セットからのデータのフェッチ、プロシージャの呼び出しを行うことができます。
あなたが作成することができます Cursor Connectionオブジェクト/クラスの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クラス/オブジェクトによって提供されるさまざまなメソッドです。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | callproc() このメソッドは、既存のプロシージャPostgreSQLデータベースを呼び出すために使用されます。 |
| 2 | close() このメソッドは、現在のカーソルオブジェクトを閉じるために使用されます。 |
| 3 | executemany() このメソッドは、一連のパラメーターリストのリストを受け入れます。MySQLクエリを準備し、すべてのパラメータを使用して実行します。 |
| 4 | execute() このメソッドは、MySQLクエリをパラメータとして受け入れ、指定されたクエリを実行します。 |
| 5 | fetchall() このメソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます） |
| 6 | fetchone() このメソッドは、クエリの結果の次の行をフェッチし、それをタプルとして返します。 |
| 7 | fetchmany() このメソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行のセットを取得します。 |
プロパティ
Cursorクラスのプロパティは次のとおりです-
| シニア番号 | プロパティと説明 |
|---|---|
| 1 | description これは、結果セットの列の説明を含むリストを返す読み取り専用プロパティです。 |
| 2 | astrowid これは読み取り専用プロパティです。テーブルに自動インクリメントされた列がある場合、これは最後のINSERTまたはUPDATE操作でその列に対して生成された値を返します。 |
| 3 | rowcount これは、SELECTおよびUPDATE操作の場合に返される/更新された行の数を返します。 |
| 4 | closed このプロパティは、カーソルが閉じているかどうかを指定します。閉じている場合はtrueを返し、閉じていない場合はfalseを返します。 |
| 5 | connection これは、このカーソルが作成された接続オブジェクトへの参照を返します。 |
| 6 | name このプロパティは、カーソルの名前を返します。 |
| 7 | scrollable このプロパティは、特定のカーソルがスクロール可能かどうかを指定します。 |
インストール
SQLite3は、GerhardHaringによって作成されたsqlite3モジュールを使用してPythonと統合できます。これは、PEP249で説明されているDB-API2.0仕様に準拠したSQLインターフェイスを提供します。このモジュールはデフォルトでPythonバージョン2.5.x以降に同梱されているため、個別にインストールする必要はありません。
sqlite3モジュールを使用するには、最初にデータベースを表す接続オブジェクトを作成する必要があります。次に、オプションでカーソルオブジェクトを作成できます。これは、すべてのSQLステートメントの実行に役立ちます。
Pythonsqlite3モジュールAPI
以下は重要なsqlite3モジュールルーチンです。これは、PythonプログラムからSQLiteデータベースを操作するための要件で十分です。より洗練されたアプリケーションを探している場合は、Pythonsqlite3モジュールの公式ドキュメントを調べることができます。
| シニア番号 | APIと説明 |
|---|---|
| 1 | sqlite3.connect(database [,timeout ,other optional arguments]) このAPIは、SQLiteデータベースファイルへの接続を開きます。「：memory：」を使用して、ディスクではなくRAMにあるデータベースへのデータベース接続を開くことができます。データベースが正常に開かれると、接続オブジェクトが返されます。 |
| 2 | connection.cursor([cursorClass]) このルーチンは、 cursorこれは、Pythonを使用したデータベースプログラミング全体で使用されます。このメソッドは、単一のオプションのパラメーターcursorClassを受け入れます。指定する場合、これはsqlite3.Cursorを拡張するカスタムカーソルクラスである必要があります。 |
| 3 | cursor.execute(sql [, optional parameters]) このルーチンはSQLステートメントを実行します。SQLステートメントはパラメーター化できます（つまり、SQLリテラルの代わりにプレースホルダー）。sqlite3モジュールは、疑問符と名前付きプレースホルダー（名前付きスタイル）の2種類のプレースホルダーをサポートします。 For example − cursor.execute（ "insert into people values（？、？）"、（who、age）） |
| 4 | connection.execute(sql [, optional parameters]) このルーチンは、cursorオブジェクトによって提供される上記のexecuteメソッドのショートカットであり、cursorメソッドを呼び出すことによって中間カーソルオブジェクトを作成し、指定されたパラメーターを使用してカーソルのexecuteメソッドを呼び出します。 |
| 5 | cursor.executemany(sql, seq_of_parameters) このルーチンは、シーケンスsqlで見つかったすべてのパラメーターシーケンスまたはマッピングに対してSQLコマンドを実行します。 |
| 6 | connection.executemany(sql[, parameters]) このルーチンは、cursorメソッドを呼び出して中間カーソルオブジェクトを作成し、指定されたパラメータを使用してcursor.sexecutemanyメソッドを呼び出すショートカットです。 |
| 7 | cursor.executescript(sql_script) このルーチンは、スクリプトの形式で提供される複数のSQLステートメントを一度に実行します。最初にCOMMITステートメントを発行し、次にパラメーターとして取得したSQLスクリプトを実行します。すべてのSQLステートメントはセミコロン（;）で区切る必要があります。 |
| 8 | connection.executescript(sql_script) このルーチンは、cursorメソッドを呼び出して中間カーソルオブジェクトを作成し、指定されたパラメータを使用してカーソルの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() このルーチンは、クエリ結果のすべての（残りの）行をフェッチして、リストを返します。使用可能な行がない場合は、空のリストが返されます。 |
SQLite Openコマンドプロンプトとの接続を確立するには、SQLiteをインストールした場所を参照し、コマンドを実行するだけです。 sqlite3 以下に示すように-
Pythonを使用して接続を確立する
SQLite3pythonモジュールを使用してSQLite2データベースと通信できます。そのためには、まず接続を確立する（接続オブジェクトを作成する）必要があります。
Pythonを使用してSQLite3データベースとの接続を確立するには、次のことを行う必要があります。
importステートメントを使用してsqlite3モジュールをインポートします。
connect（）メソッドは、接続する必要のあるデータベースの名前をパラメーターとして受け入れ、Connectionオブジェクトを返します。
例
import sqlite3
conn = sqlite3.connect('example.db')出力
print("Connection established ..........")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クエリ/ステートメントは、名前の付いたテーブルを作成します CRICKETERS SQLiteデータベース内-
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
);
sqliteSQLiteデータベースのデータベース内のテーブルのリストは、 .tablesコマンド。テーブルを作成した後、テーブルのリストを確認できれば、その中に新しく作成されたテーブルを次のように確認できます。
sqlite> . tables
CRICKETERS ODIStats
sqlite>Pythonを使用してテーブルを作成する
Cursorオブジェクトには、クワイアを実行したりデータをフェッチしたりするためのすべてのメソッドが含まれています。接続クラスのcursorメソッドは、カーソルオブジェクトを返します。
したがって、Pythonを使用してSQLiteデータベースにテーブルを作成するには−
connect（）メソッドを使用してデータベースとの接続を確立します。
上記で作成した接続オブジェクトでcursor（）メソッドを呼び出して、カーソルオブジェクトを作成します。
次に、Cursorクラスのexecute（）メソッドを使用してCREATETABLEステートメントを実行します。
例
次の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........INSERT INTOステートメントを使用して、SQLiteの既存のテーブルに新しい行を追加できます。この場合、テーブルの名前、列名、および値を（列名と同じ順序で）指定する必要があります。
構文
以下は、INSERTステートメントの推奨構文です-
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);ここで、column1、column2、column3、..はテーブルの列の名前であり、value1、value2、value3、...はテーブルに挿入する必要のある値です。
例
以下に示すように、CREATETABLEステートメントを使用して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........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ステートメントは、指定されたテーブルのレコードを返すだけです。フォーマットされた出力を取得するには、を設定する必要がありますheader、および mode 以下に示すように、SELECTステートメントの前にそれぞれのコマンドを使用します-
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クラスは、fetchall（）、fetchmany（）、fetchone（）の3つのメソッドを提供します。ここで、
fetchall（）メソッドは、クエリの結果セット内のすべての行を取得し、それらをタプルのリストとして返します。（いくつかの行を取得した後にこれを実行すると、残りの行が返されます）。
fetchone（）メソッドは、クエリの結果の次の行をフェッチし、それをタプルとして返します。
fetchmany（）メソッドはfetchone（）に似ていますが、単一の行ではなく、クエリの結果セット内の次の行のセットを取得します。
Note −結果セットは、カーソルオブジェクトを使用してテーブルをクエリしたときに返されるオブジェクトです。
例
次の例では、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)
]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オブジェクト/クラスには、クエリの実行やデータのフェッチなどを行うためのすべてのメソッドが含まれています。接続クラスのcursorメソッドは、カーソルオブジェクトを返します。
したがって、Pythonを使用してSQLiteデータベースにテーブルを作成するには−
connect（）メソッドを使用してデータベースとの接続を確立します。
上記で作成した接続オブジェクトでcursor（）メソッドを呼び出して、カーソルオブジェクトを作成します。
次に、Cursorクラスのexecute（）メソッドを使用してCREATETABLEステートメントを実行します。
例
次の例では、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)]SELECTクエリを使用してデータをフェッチしている間、レコードを挿入したのと同じ順序で取得します。
を使用して、結果を希望の順序（昇順または降順）で並べ替えることができます。 Order By句。デフォルトでは、この句は結果を昇順でソートします。降順で並べ替える必要がある場合は、「DESC」を明示的に使用する必要があります。
構文
以下は、SQLiteのORDERBY句の構文です。
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を使用したORDERBY句
テーブルの内容を特定の順序で取得するには、カーソルオブジェクトでexecute（）メソッドを呼び出し、SELECTステートメントとORDERBY句をパラメータとして渡します。
例
次の例では、名前とEmployeeを使用してテーブルを作成し、そのテーブルにデータを入力し、ORDER BY句を使用して、そのレコードを年齢の（昇順）順に取得しています。
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)]データベースに対する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)]SQLiteテーブルからレコードを削除するには、DELETEFROMステートメントを使用する必要があります。特定のレコードを削除するには、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句を指定せずにDELETEFROMステートメントを実行すると、指定したテーブルのすべてのレコードが削除されます。
sqlite> DELETE FROM CRICKETERS;
sqlite>すべてのレコードを削除したので、CRICKETERSテーブルの内容を取得しようとすると、SELECTステートメントを使用して、以下に示すような空の結果セットが得られます。
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)]DROP TABLEステートメントを使用して、テーブル全体を削除できます。削除する必要のあるテーブルの名前を指定するだけです。
構文
以下は、PostgreSQLのDROPTABLEステートメントの構文です。
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ステートメントとともにIFEXISTS句を使用できます。これにより、テーブルが存在する場合は削除され、存在しない場合は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...レコードを特定の数で制限したい場合は、レコードをフェッチするときに、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番目のレコードから始まるレコードを制限する必要がある場合は、OFFSETとLIMITを使用して制限できます。
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)]データを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, '[email protected]', 'Hyderabad'),
('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102,'[email protected]', 'Vishakhapatnam'),
('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected]', 'Pune'),
('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]sqlite3.Cursorクラスは、SQLiteステートメントを実行するメソッドを呼び出したり、クエリの結果セットからデータをフェッチしたりできるインスタンスです。あなたが作成することができますCursor Connectionオブジェクト/クラスのcursor（）メソッドを使用するオブジェクト。
例
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()メソッド
以下は、Cursorクラス/オブジェクトによって提供されるさまざまなメソッドです。
| シニア番号 | 方法と説明 |
|---|---|
| 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() このルーチンは、クエリ結果のすべての（残りの）行をフェッチして、リストを返します。使用可能な行がない場合は、空のリストが返されます。 |
プロパティ
Cursorクラスのプロパティは次のとおりです-
| シニア番号 | 方法と説明 |
|---|---|
| 1 | arraySize これは、fetchmany（）メソッドによって返される行数を設定できる読み取り/書き込みプロパティです。 |
| 2 | description これは、結果セットの列の説明を含むリストを返す読み取り専用プロパティです。 |
| 3 | lastrowid これは読み取り専用プロパティです。テーブルに自動インクリメントされた列がある場合、これは最後のINSERTまたはUPDATE操作でその列に対して生成された値を返します。 |
| 4 | rowcount これは、SELECTおよびUPDATE操作の場合に返される/更新された行の数を返します。 |
| 5 | connection この読み取り専用属性は、Cursorオブジェクトによって使用されるSQLiteデータベース接続を提供します。 |
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 pymongopymongoを正しくインストールしている場合、以下に示すようにtest.pyを実行すると、問題は発生しません。
D:\Python_MongoDB>test.py
D:\Python_MongoDB>他のデータベースとは異なり、MongoDBはデータベースを作成するための個別のコマンドを提供していません。
一般に、useコマンドは、特定のデータベースを選択/切り替えるために使用されます。このコマンドは、最初に、指定したデータベースが存在するかどうかを確認し、存在する場合はそれに接続します。データベースが存在しない場合は、useコマンドで指定すると新しいデータベースが作成されます。
したがって、MongoDBでデータベースを作成するには、 Use コマンド。
構文
の基本構文 use DATABASE ステートメントは次のとおりです-
use DATABASE_NAME例
次のコマンドは、mydbという名前のデータベースを作成します。
>use mydb
switched to db mydbdbコマンドを使用して作成を確認できます。これにより、現在のデータベースが表示されます。
>db
mydbPythonを使用してデータベースを作成する
pymongoを使用してMongoDBに接続するには、MongoClientをインポートして作成する必要があります。その後、属性の情熱で作成する必要のあるデータベースに直接アクセスできます。
例
次の例では、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........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........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']保存されたドキュメントは、MongoDBを使用して読み取り/取得できます。 find()方法。このメソッドは、構造化されていない方法で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を使用したデータの取得（検索）
ザ・ find_One() pymongoのメソッドは、クエリに基づいて単一のドキュメントを取得するために使用されます。一致するものがない場合、このメソッドは何も返しません。クエリを使用しない場合は、コレクションの最初のドキュメントを返します。
このメソッドは、結果のドキュメントを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つのクエリ（1回の呼び出しod findメソッド）で複数のドキュメントを取得するには、 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'}を使用して取得中 find()メソッドでは、クエリオブジェクトを使用してドキュメントをフィルタリングできます。このメソッドのパラメーターとして、必要なドキュメントの条件を指定するクエリを渡すことができます。
演算子
以下は、MongoDBのクエリで使用される演算子のリストです。
| 操作 | 構文 | 例 |
|---|---|---|
| 平等 | {"キー"： "値"} | db.mycol.find（{"by"： "tutorials point"}） |
| 未満 | {"キー"：{$ lt： "値"}} | db.mycol.find（{"likes"：{$ lt：50}}） |
| 等しい未満 | {"key"：{$ lte： "value"}} | db.mycol.find（{"likes"：{$ lte：50}}） |
| 大なり記号 | {"キー"：{$ gt： "値"}} | db.mycol.find（{"likes"：{$ gt：50}}） |
| 大なり記号 | {"キー" {$ gte： "値"}} | db.mycol.find（{"likes"：{$ gte：50}}） |
| 等しくない | {"キー"：{$ ne： "値"}} | 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'}コレクションのコンテンツを取得する際に、を使用して昇順または降順で並べ替えたり並べ替えたりできます。 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'}コレクション内のドキュメントは、 remove()MongoDBのメソッド。このメソッドは、2つのオプションのパラメーターを受け入れます-
ドキュメントを削除する条件を指定する削除基準。
1つだけ、trueまたは1を2番目のパラメーターとして渡すと、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の例では、ID値が1006のコレクション内のドキュメントを削除します。
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'}同様に、 delete_many() pymongoのメソッドは、指定された条件を満たすすべてのドキュメントを削除します。
例
次の例では、年齢値が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({})を使用してコレクションを削除できます drop() MongoDBのメソッド。
構文
以下はdrop（）メソッドの構文です-
db.COLLECTION_NAME.drop()例
次の例では、サンプルという名前のコレクションを削除します-
> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myCollPythonを使用してコレクションを削除する
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を使用して、既存のドキュメントの内容を更新できます。 update() メソッドまたは save() 方法。
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)次のメソッドは、ID1002のドキュメントの都市値を更新します。
> 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'}同様に、 update_many() pymongoのメソッドは、指定された条件を満たすすべてのドキュメントを更新します。
例
次の例では、コレクション内のすべてのドキュメントの場所の値を更新します（空の状態）-
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'}コレクションのコンテンツを取得するときに、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'}