Akses Data Python - Panduan Cepat
Standar Python untuk antarmuka database adalah Python DB-API. Kebanyakan antarmuka database Python mematuhi standar ini.
Anda dapat memilih database yang tepat untuk aplikasi Anda. Python Database API mendukung berbagai server database seperti -
- GadFly
- mSQL
- MySQL
- PostgreSQL
- Microsoft SQL Server 2000
- Informix
- Interbase
- Oracle
- Sybase
Berikut adalah daftar antarmuka database Python yang tersedia: Python Database Interfaces dan API . Anda harus mengunduh modul DB API terpisah untuk setiap database yang perlu Anda akses. Misalnya, jika Anda perlu mengakses database Oracle serta database MySQL, Anda harus mendownload modul database Oracle dan MySQL.
Apa itu mysql-connector-python?
MySQL Python / Connector adalah antarmuka untuk menghubungkan ke server database MySQL dari Python. Ini mengimplementasikan Python Database API dan dibangun di atas MySQL.
Bagaimana cara menginstal mysql-connector-python?
Pertama-tama, Anda perlu memastikan bahwa Anda telah menginstal python di mesin Anda. Untuk melakukannya, buka command prompt dan ketik python di dalamnya dan tekan Enter. Jika python sudah terinstal di sistem Anda, perintah ini akan menampilkan versinya seperti yang ditunjukkan di bawah ini -
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.
>>>Sekarang tekan ctrl + z dan kemudian Enter untuk keluar dari shell python dan buat folder (tempat Anda ingin menginstal konektor Python-MySQL) bernama Python_MySQL sebagai -
>>> ^Z
C:\Users\Tutorialspoint>d:
D:\>mkdir Python_MySQLVerifikasi PIP
PIP adalah manajer paket dalam python yang dengannya Anda dapat menginstal berbagai modul / paket dengan Python. Oleh karena itu, untuk menginstal Mysql-python mysql-connector-python Anda perlu memastikan bahwa Anda telah menginstal PIP di komputer Anda dan lokasinya ditambahkan ke jalur.
Anda dapat melakukannya, dengan menjalankan perintah pip. Jika Anda tidak memiliki PIP di sistem Anda atau, jika Anda belum menambahkan lokasinya di filePath variabel lingkungan, Anda akan mendapatkan pesan kesalahan sebagai -
D:\Python_MySQL>pip
'pip' is not recognized as an internal or external command,
operable program or batch file.Untuk menginstal PIP, unduh get-pip.py ke folder yang dibuat di atas dan, dari perintah navigasikan dan instal pip sebagai berikut -
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.6Menginstal mysql-connector-python
Setelah Anda menginstal Python dan PIP, buka command prompt dan tingkatkan pip (opsional) seperti yang ditunjukkan di bawah ini -
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.2Kemudian buka command prompt dalam mode admin dan instal python MySQL connect sebagai -
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.0Verifikasi
Untuk memverifikasi penginstalan, buat contoh skrip python dengan baris berikut di dalamnya.
import mysql.connectorJika penginstalan berhasil, saat Anda menjalankannya, Anda tidak akan mendapatkan error -
D:\Python_MySQL>python test.py
D:\Python_MySQL>Menginstal python dari awal
Sederhananya, jika Anda perlu menginstal Python dari awal. Kunjungi Halaman Beranda Python .
Klik pada Downloads tombol, Anda akan diarahkan ke halaman unduhan yang menyediakan tautan untuk versi terbaru python untuk berbagai platform, pilih satu dan unduh.
Misalnya, kami telah mengunduh python-3.7.4.exe (untuk windows). Mulailah proses instalasi dengan mengklik dua kali file .exe yang diunduh .
Centang opsi Add Python 3.7 to Path dan lanjutkan dengan instalasi. Setelah menyelesaikan proses ini, python akan diinstal di sistem Anda.
Untuk terhubung dengan MySQL, (salah satu caranya adalah) buka command prompt MySQL di sistem Anda seperti yang ditunjukkan di bawah ini -
Ini meminta kata sandi di sini; Anda perlu mengetikkan kata sandi yang telah Anda setel ke pengguna default (root) pada saat instalasi.
Kemudian koneksi dibuat dengan MySQL yang menampilkan pesan berikut -
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.Anda dapat memutuskan koneksi dari database MySQL kapan saja menggunakan perintah keluar pada prompt mysql>.
mysql> exit
ByeMembuat koneksi dengan MySQL menggunakan python
Sebelum membuat koneksi ke database MySQL menggunakan python, asumsikan -
Database yang telah kita buat dengan nama mydb.
Kami telah membuat tabel EMPLOYEE dengan kolom FIRST_NAME, LAST_NAME, AGE, SEX dan INCOME.
Kredensial yang kami gunakan untuk terhubung dengan MySQL adalah nama pengguna: root, kata sandi: password.
Anda dapat membuat koneksi menggunakan connect()konstruktor. Ini menerima nama pengguna, kata sandi, host dan, nama database yang perlu Anda sambungkan (opsional) dan, mengembalikan objek dari kelas MySQLConnection.
Contoh
Berikut adalah contoh koneksi dengan database 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()Keluaran
Saat menjalankan, skrip ini menghasilkan keluaran berikut -
D:\Python_MySQL>python EstablishCon.py
Connection established to: ('mydb',)Anda juga dapat membuat koneksi ke MySQL dengan meneruskan kredensial (nama pengguna, kata sandi, nama host, dan nama database) ke connection.MySQLConnection() seperti yang ditunjukkan di bawah ini -
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()Anda dapat membuat database di MYSQL menggunakan kueri CREATE DATABASE.
Sintaksis
Berikut ini adalah sintaks dari kueri CREATE DATABASE -
CREATE DATABASE name_of_the_databaseContoh
Pernyataan berikut membuat database dengan nama mydb di MySQL -
mysql> CREATE DATABASE mydb;
Query OK, 1 row affected (0.04 sec)Jika Anda mengamati daftar database menggunakan pernyataan SHOW DATABASES, Anda dapat mengamati database yang baru dibuat di dalamnya seperti yang ditunjukkan di bawah ini -
mysql> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| information_schema |
| logging |
| mydatabase |
| mydb |
| performance_schema |
| students |
| sys |
+--------------------+
26 rows in set (0.15 sec)Membuat database di MySQL menggunakan python
Setelah membuat koneksi dengan MySQL, untuk memanipulasi data di dalamnya Anda perlu terhubung ke database. Anda bisa menyambungkan ke database yang sudah ada atau, buat sendiri.
Anda memerlukan hak khusus untuk membuat atau menghapus database MySQL. Jadi jika Anda memiliki akses ke pengguna root, Anda dapat membuat database apa pun.
Contoh
Contoh berikut membuat koneksi dengan MYSQL dan membuat database di dalamnya.
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()Keluaran
List of databases:
[('information_schema',), ('dbbug61332',), ('details',), ('exampledatabase',), ('mydatabase',), ('mydb',), ('mysql',), ('performance_schema',)]Pernyataan CREATE TABLE digunakan untuk membuat tabel di database MYSQL. Di sini, Anda perlu menentukan nama tabel dan, definisi (nama dan tipe data) dari setiap kolom.
Sintaksis
Berikut sintaks untuk membuat tabel di MySQL -
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
);Contoh
Kueri berikut membuat tabel bernama EMPLOYEE di MySQL dengan lima kolom yaitu, FIRST_NAME, LAST_NAME, AGE, SEX dan, INCOME.
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)Pernyataan DESC memberi Anda deskripsi dari tabel yang ditentukan. Dengan menggunakan ini, Anda dapat memverifikasi apakah tabel telah dibuat atau tidak seperti yang ditunjukkan di bawah ini -
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)Membuat tabel di MySQL menggunakan python
Metode bernama execute() (dipanggil pada objek kursor) menerima dua variabel -
Nilai String yang mewakili kueri yang akan dieksekusi.
Parameter args opsional yang dapat berupa tuple atau, daftar atau, kamus, mewakili parameter kueri (nilai placeholder).
Ini mengembalikan nilai integer yang mewakili jumlah baris yang dipengaruhi oleh kueri.
Setelah koneksi database dibuat, Anda bisa membuat tabel dengan meneruskan kueri CREATE TABLE ke execute() metode.
Singkatnya, membuat tabel menggunakan python 7minus;
Impor mysql.connector paket.
Buat objek koneksi menggunakan mysql.connector.connect() metode, dengan meneruskan nama pengguna, kata sandi, host (opsional default: localhost) dan, database (opsional) sebagai parameter untuk itu.
Buat objek kursor dengan memanggil cursor() metode pada objek koneksi yang dibuat di atas.
Kemudian, jalankan pernyataan CREATE TABLE dengan meneruskannya sebagai parameter keexecute() metode.
Contoh
Contoh berikut membuat tabel bernama Employee di database 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()Anda dapat menambahkan baris baru ke tabel MySQL yang sudah ada menggunakan INSERT INTOpernyataan. Dalam hal ini, Anda perlu menentukan nama tabel, nama kolom, dan nilai (dalam urutan yang sama seperti nama kolom).
Sintaksis
Berikut ini adalah sintaks dari pernyataan INSERT INTO MySQL.
INSERT INTO TABLE_NAME (column1, column2,column3,...columnN)
VALUES (value1, value2, value3,...valueN);Contoh
Kueri berikut menyisipkan rekaman ke dalam tabel bernama EMPLOYEE.
INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES ('
Mac', 'Mohan', 20, 'M', 2000
);Anda dapat memverifikasi catatan tabel setelah operasi penyisipan menggunakan pernyataan SELECT sebagai -
mysql> select * from Employee;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE | SEX | INCOME |
+------------+-----------+------+------+--------+
| Mac | Mohan | 20 | M | 2000 |
+------------+-----------+------+------+--------+
1 row in set (0.00 sec)Tidak wajib untuk selalu menentukan nama kolom, jika Anda meneruskan nilai record dalam urutan yang sama dari kolom tabel Anda dapat mengeksekusi pernyataan SELECT tanpa nama kolom sebagai berikut -
INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000);Memasukkan data pada tabel MySQL menggunakan python
Itu execute()metode (dipanggil pada objek kursor) menerima kueri sebagai parameter dan menjalankan kueri yang diberikan. Untuk memasukkan data, Anda harus meneruskan pernyataan MySQL INSERT sebagai parameternya.
cursor.execute("""INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000)""")Untuk memasukkan data ke dalam tabel di MySQL menggunakan python -
impor mysql.connector paket.
Buat objek koneksi menggunakan mysql.connector.connect() metode, dengan meneruskan nama pengguna, kata sandi, host (opsional default: localhost) dan, database (opsional) sebagai parameter untuk itu.
Buat objek kursor dengan memanggil cursor() metode pada objek koneksi yang dibuat di atas
Kemudian, jalankan INSERT pernyataan dengan meneruskannya sebagai parameter ke execute() metode.
Contoh
Contoh berikut mengeksekusi pernyataan SQL INSERT untuk memasukkan record ke dalam tabel 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()Memasukkan nilai secara dinamis
Anda juga dapat menggunakan "% s" sebagai ganti nilai di INSERT query MySQL dan berikan nilai kepada mereka sebagai daftar seperti yang ditunjukkan di bawah ini -
cursor.execute("""INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000)""",
('Ramya', 'Ramapriya', 25, 'F', 5000))Contoh
Contoh berikut menyisipkan rekaman ke dalam tabel Karyawan secara dinamis.
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()Keluaran
Data insertedAnda dapat mengambil / mengambil data dari tabel di MySQL menggunakan kueri SELECT. Kueri / pernyataan ini mengembalikan konten dari tabel yang ditentukan dalam bentuk tabel dan disebut sebagai kumpulan hasil.
Sintaksis
Berikut ini adalah sintaks dari query SELECT -
SELECT column1, column2, columnN FROM table_name;Contoh
Asumsikan kita telah membuat tabel di MySQL dengan nama cricketers_data sebagai -
CREATE TABLE cricketers_data(
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Date_Of_Birth date,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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');Kueri berikut mengambil nilai FIRST_NAME dan Negara dari tabel.
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)Anda juga dapat mengambil semua nilai dari setiap record menggunakan * nama kolom yang dimasukkan sebagai -
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)Membaca data dari tabel MYSQL menggunakan Python
Operasi BACA pada database apa pun berarti mengambil beberapa informasi berguna dari database. Anda dapat mengambil data dari MYSQL menggunakanfetch() metode yang disediakan oleh mysql-connector-python.
Kelas cursor.MySQLCursor menyediakan tiga metode yaitufetchall(), fetchmany() dan, fetchone() dimana,
Itu fetchall()metode mengambil semua baris dalam kumpulan hasil kueri dan mengembalikannya sebagai daftar tupel. (Jika kita menjalankan ini setelah mengambil beberapa baris, ia mengembalikan yang tersisa).
Itu fetchone() metode mengambil baris berikutnya dalam hasil kueri dan mengembalikannya sebagai tupel.
Itu fetchmany() metode ini mirip dengan fetchone () tetapi, ia mengambil set baris berikutnya dalam set hasil kueri, bukan satu baris.
Note - Kumpulan hasil adalah objek yang dikembalikan saat objek kursor digunakan untuk membuat kueri tabel.
rowcount - Ini adalah atribut hanya-baca dan mengembalikan jumlah baris yang dipengaruhi oleh metode execute ().
Contoh
Contoh berikut mengambil semua baris dari tabel EMPLOYEE menggunakan query SELECT dan dari hasil yang diperoleh set awalnya, kita mengambil baris pertama menggunakan metode fetchone () dan kemudian mengambil baris yang tersisa menggunakan metode 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()Keluaran
('Krishna', 'Sharma', 19, 'M', 2000.0)
[('Raj', 'Kandukuri', 20, 'M', 7000.0), ('Ramya', 'Ramapriya', 25, 'M', 5000.0)]Contoh berikut mengambil dua baris pertama dari tabel EMPLOYEE menggunakan metode fetchmany ().
Contoh
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()Keluaran
[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]Jika Anda ingin mengambil, menghapus, atau memperbarui baris tertentu dari tabel di MySQL, Anda perlu menggunakan klausa where untuk menentukan kondisi guna memfilter baris tabel untuk operasi.
Misalnya, jika Anda memiliki pernyataan SELECT dengan klausa where, hanya baris yang memenuhi kondisi yang ditentukan yang akan diambil.
Sintaksis
Berikut ini adalah sintaks klausa WHERE -
SELECT column1, column2, columnN
FROM table_name
WHERE [condition]Contoh
Asumsikan kita telah membuat tabel di MySQL dengan nama EMPLOYEES sebagai -
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)Dan jika kita telah memasukkan 4 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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);Mengikuti pernyataan MySQL mengambil catatan karyawan yang penghasilannya lebih dari 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)Klausa WHERE menggunakan python
Untuk mengambil catatan tertentu dari tabel menggunakan program python -
impor mysql.connector paket.
Buat objek koneksi menggunakan mysql.connector.connect() metode, dengan meneruskan nama pengguna, kata sandi, host (opsional default: localhost) dan, database (opsional) sebagai parameter untuk itu.
Buat objek kursor dengan memanggil cursor() metode pada objek koneksi yang dibuat di atas.
Kemudian, jalankan pernyataan SELECT dengan klausa WHERE , dengan meneruskannya sebagai parameter keexecute() metode.
Contoh
Contoh berikut membuat tabel bernama Karyawan dan mengisinya. Kemudian menggunakan klausa where, ia mengambil rekaman dengan nilai usia kurang dari 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()Keluaran
[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]Saat mengambil data menggunakan kueri SELECT, Anda dapat mengurutkan hasil dalam urutan yang diinginkan (naik atau turun) menggunakan klausa OrderBy. Secara default, klausa ini mengurutkan hasil dalam urutan menaik, jika Anda perlu mengaturnya dalam urutan menurun Anda perlu menggunakan "DESC" secara eksplisit.
Sintaksis
Berikut ini adalah sintaks SELECT kolom-daftar
FROM table_name
[WHERE condition]
[ORDER BY column1, column2,.. columnN] [ASC | DESC]; of the ORDER BY clause:Contoh
Asumsikan kita telah membuat tabel di MySQL dengan nama EMPLOYEES sebagai -
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)Dan jika kita telah memasukkan 4 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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);Pernyataan berikut mengambil isi tabel EMPLOYEE dalam urutan usia.
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)Anda juga dapat mengambil data dalam urutan menurun menggunakan DESC sebagai -
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)Klausa ORDER BY menggunakan python
Untuk mengambil konten tabel dalam urutan tertentu, panggil execute() metode pada objek kursor dan, berikan pernyataan SELECT bersama dengan klausa ORDER BY, sebagai parameter untuknya.
Contoh
Dalam contoh berikut, kami membuat tabel dengan nama dan Karyawan, mengisinya, dan mengambil kembali rekamannya dalam urutan (menaik) sesuai usianya, menggunakan klausa 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()Keluaran
[('Raj', 'Kandukuri', 20, 'M', 7000.0),
('Krishna', 'Sharma', 26, 'M', 2000.0),
('Mac', 'Mohan', 26, 'M', 2000.0),
('Ramya', 'Ramapriya', 29, 'F', 5000.0)
]Dengan cara yang sama Anda bisa mengambil data dari tabel dalam urutan menurun menggunakan klausa ORDER BY.
Contoh
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()Keluaran
[('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 Operasi pada setiap pembaruan database satu atau lebih catatan, yang sudah tersedia dalam database. Anda dapat memperbarui nilai catatan yang ada di MySQL menggunakan pernyataan UPDATE. Untuk memperbarui baris tertentu, Anda perlu menggunakan klausa WHERE bersamanya.
Sintaksis
Berikut ini adalah sintaks dari pernyataan UPDATE di MySQL -
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];Anda dapat menggabungkan jumlah N kondisi menggunakan operator DAN atau ATAU.
Contoh
Asumsikan kita telah membuat tabel di MySQL dengan nama EMPLOYEES sebagai -
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)Dan jika kita telah memasukkan 4 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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);Mengikuti pernyataan MySQL meningkatkan usia semua karyawan pria satu tahun -
mysql> UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M';
Query OK, 3 rows affected (0.06 sec)
Rows matched: 3 Changed: 3 Warnings: 0Jika Anda mengambil konten tabel, Anda dapat melihat nilai yang diperbarui sebagai -
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)Memperbarui konten tabel menggunakan Python
Untuk memperbarui catatan dalam tabel di MySQL menggunakan python -
impor mysql.connector paket.
Buat objek koneksi menggunakan mysql.connector.connect() metode, dengan meneruskan nama pengguna, kata sandi, host (opsional default: localhost) dan, database (opsional) sebagai parameter untuk itu.
Buat objek kursor dengan memanggil cursor() metode pada objek koneksi yang dibuat di atas.
Kemudian, jalankan pernyataan UPDATE dengan meneruskannya sebagai parameter ke execute() metode.
Contoh
Contoh berikut meningkatkan usia semua laki-laki satu tahun.
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()Keluaran
[('Krishna', 'Sharma', 22, 'M', 2000.0),
('Raj', 'Kandukuri', 23, 'M', 7000.0),
('Ramya', 'Ramapriya', 26, 'F', 5000.0)
]Untuk menghapus record dari tabel MySQL, Anda perlu menggunakan DELETE FROMpernyataan. Untuk menghapus catatan tertentu, Anda perlu menggunakan klausa WHERE bersamanya.
Sintaksis
Following is the syntax of the DELETE query in MYSQL −
DELETE FROM table_name [WHERE Clause]Example
Assume we have created a table in MySQL with name EMPLOYEES as −
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)And if we have inserted 4 records in to it using INSERT statements as −
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);Following MySQL statement deletes the record of the employee with FIRST_NAME ”Mac”.
mysql> DELETE FROM EMPLOYEE WHERE FIRST_NAME = 'Mac';
Query OK, 1 row affected (0.12 sec)If you retrieve the contents of the table, you can see only 3 records since we have deleted one.
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)If you execute the DELETE statement without the WHERE clause all the records from the specified table will be deleted.
mysql> DELETE FROM EMPLOYEE;
Query OK, 3 rows affected (0.09 sec)If you retrieve the contents of the table, you will get an empty set as shown below −
mysql> select * from EMPLOYEE;
Empty set (0.00 sec)Removing records of a table using python
DELETE operation is required when you want to delete some records from your database.
To delete the records in a table −
import mysql.connector package.
Create a connection object using the mysql.connector.connect() method, by passing the user name, password, host (optional default: localhost) and, database (optional) as parameters to it.
Create a cursor object by invoking the cursor() method on the connection object created above.
Then, execute the DELETE statement by passing it as a parameter to the execute() method.
Example
Following program deletes all the records from EMPLOYEE whose AGE is more than 20 −
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()Output
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)]You can remove an entire table using the DROP TABLE statement. You just need to specify the name of the table you need to delete.
Syntax
Following is the syntax of the DROP TABLE statement in MySQL −
DROP TABLE table_name;Example
Before deleting a table get the list of tables using the SHOW TABLES statement as follows −
mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb |
+-----------------+
| contact |
| cricketers_data |
| employee |
| sample |
| tutorials |
+-----------------+
5 rows in set (0.00 sec)Following statement removes the table named sample from the database completely −
mysql> DROP TABLE sample;
Query OK, 0 rows affected (0.29 sec)Since we have deleted the table named sample from MySQL, if you get the list of tables again you will not find the table name sample in it.
mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb |
+-----------------+
| contact |
| cricketers_data |
| employee |
| tutorials |
+-----------------+
4 rows in set (0.00 sec)Removing a table using python
You can drop a table whenever you need to, using the DROP statement of MYSQL, but you need to be very careful while deleting any existing table because the data lost will not be recovered after deleting a table.
To drop a table from a MYSQL database using python invoke the execute() method on the cursor object and pass the drop statement as a parameter to it.
Example
Following table drops a table named EMPLOYEE from the database.
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()Output
List of tables in the database:
[('employee',), ('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',), ('tutorials',)]Drop table only if exists
If you try to drop a table which does not exist in the database, an error occurs as −
mysql.connector.errors.ProgrammingError: 1051 (42S02):
Unknown table 'mydb.employee'You can prevent this error by verifying whether the table exists before deleting, by adding the IF EXISTS to the DELETE statement.
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()Keluaran
List of tables in the database:
[('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',),
('tutorials',)]Saat mengambil catatan jika Anda ingin membatasinya dengan nomor tertentu, Anda dapat melakukannya, menggunakan klausa LIMIT MYSQL.
Contoh
Asumsikan kita telah membuat tabel di MySQL dengan nama EMPLOYEES sebagai -
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)Dan jika kita telah memasukkan 4 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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);Pernyataan SQL berikut mengambil dua catatan pertama dari tabel Karyawan menggunakan klausa LIMIT.
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)Batasi klausa menggunakan python
Jika Anda memanggil execute() metode pada objek kursor dengan meneruskan kueri SELECT bersama dengan klausa LIMIT, Anda dapat mengambil jumlah record yang diperlukan.
Untuk menjatuhkan tabel dari database MYSQL menggunakan python, panggil execute() metode pada objek kursor dan meneruskan pernyataan drop sebagai parameter untuk itu.
Contoh
Contoh python berikut membuat dan mengisi tabel dengan nama EMPLOYEE dan, dengan menggunakan klausa LIMIT, ia mengambil dua record pertama darinya.
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()Keluaran
[('Krishna', 'Sharma', 26, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]LIMIT dengan OFFSET
Jika Anda perlu membatasi record mulai dari record ke-n (bukan 1 st ), Anda dapat melakukannya, menggunakan OFFSET bersama dengan LIMIT.
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()Keluaran
[('Ramya', 'Ramapriya', 29, 'F', 5000.0), ('Mac', 'Mohan', 26, 'M', 2000.0)]Saat Anda telah membagi data dalam dua tabel, Anda dapat mengambil rekaman gabungan dari dua tabel ini menggunakan Gabungan.
Contoh
Misalkan kita telah membuat tabel dengan nama EMPLOYEE dan memasukkan data ke dalamnya seperti yang ditunjukkan di bawah ini -
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: 0Kemudian, jika kita telah membuat tabel lain dan mengisinya sebagai -
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: 0Pernyataan berikut mengambil data yang menggabungkan nilai-nilai dalam dua tabel ini -
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)MYSQL BERGABUNG menggunakan python
Contoh berikut mengambil data dari dua tabel di atas yang digabungkan dengan kolom kontak dari tabel KARYAWAN dan kolom ID dari tabel KONTAK.
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()Keluaran
[('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')]MySQLCursor mysql-connector-python (dan pustaka serupa) digunakan untuk menjalankan pernyataan untuk berkomunikasi dengan database MySQL.
Dengan menggunakan metodenya, Anda dapat menjalankan pernyataan SQL, mengambil data dari kumpulan hasil, memanggil prosedur.
Anda bisa membuat Cursor objek menggunakan metode cursor () dari objek / kelas Connection.
Contoh
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()Metode
Berikut adalah berbagai metode yang disediakan oleh kelas / objek Cursor.
| Sr Tidak | Metode & Deskripsi |
|---|---|
| 1 | callproc() Metode ini digunakan untuk memanggil prosedur yang ada database MySQL. |
| 2 | close() Metode ini digunakan untuk menutup objek kursor saat ini. |
| 3 | Info() Metode ini memberikan informasi tentang kueri terakhir. |
| 4 | executemany() Metode ini menerima serangkaian daftar daftar parameter. Menyiapkan kueri MySQL dan menjalankannya dengan semua parameter. |
| 5 | execute() Metode ini menerima kueri MySQL sebagai parameter dan menjalankan kueri yang diberikan. |
| 6 | fetchall() Metode ini mengambil semua baris dalam kumpulan hasil kueri dan mengembalikannya sebagai daftar tupel. (Jika kita menjalankan ini setelah mengambil beberapa baris, ia mengembalikan yang tersisa) |
| 7 | fetchone() Metode ini mengambil baris berikutnya dalam hasil kueri dan mengembalikannya sebagai tupel. |
| 8 | fetchmany() Metode ini mirip dengan fetchone () tetapi, metode ini mengambil kumpulan baris berikutnya dalam kumpulan hasil kueri, bukan satu baris. |
| 9 | etchwarnings() Metode ini mengembalikan peringatan yang dihasilkan oleh kueri yang terakhir dieksekusi. |
Properti
Berikut ini adalah properti dari kelas Cursor -
| Sr Tidak | Deskripsi properti |
|---|---|
| 1 | column_names Ini adalah properti hanya baca yang mengembalikan daftar yang berisi nama kolom dari kumpulan hasil. |
| 2 | description Ini adalah properti hanya baca yang mengembalikan daftar yang berisi deskripsi kolom dalam kumpulan hasil. |
| 3 | lastrowid Ini adalah properti hanya baca, jika ada kolom yang bertambah secara otomatis dalam tabel, ini mengembalikan nilai yang dihasilkan untuk kolom tersebut di operasi INSERT atau, UPDATE terakhir. |
| 4 | rowcount Ini mengembalikan jumlah baris yang dikembalikan / diperbarui dalam kasus operasi SELECT dan UPDATE. |
| 5 | statement Properti ini mengembalikan pernyataan yang terakhir dieksekusi. |
Instalasi
PostgreSQL adalah sistem database relasional objek open source yang kuat. Ini memiliki lebih dari 15 tahun fase pengembangan aktif dan arsitektur yang telah terbukti membuatnya mendapatkan reputasi yang kuat untuk keandalan, integritas data, dan kebenaran.
Untuk berkomunikasi dengan PostgreSQL menggunakan Python Anda perlu menginstal psycopg, adaptor yang disediakan untuk pemrograman python, versi saat ini adalah psycog2.
psycopg2 ditulis dengan tujuan menjadi sangat kecil dan cepat, serta stabil seperti batu. Ini tersedia di bawah PIP (manajer paket python)
Menginstal Psycog2 menggunakan PIP
Pertama-tama, pastikan python dan PIP terinstal di sistem Anda dengan benar dan, PIP up-to-date.
Untuk memutakhirkan PIP, buka command prompt dan jalankan perintah berikut -
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.2Kemudian, buka command prompt dalam mode admin dan jalankan file pip install psycopg2-binary perintah seperti yang ditunjukkan di bawah ini -
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.3Verifikasi
Untuk memverifikasi instalasi, buat contoh skrip python dengan baris berikut di dalamnya.
import mysql.connectorJika penginstalan berhasil, saat Anda menjalankannya, Anda tidak akan mendapatkan error -
D:\Python_PostgreSQL>import psycopg2
D:\Python_PostgreSQL>PostgreSQL menyediakan cangkangnya sendiri untuk mengeksekusi kueri. Untuk membuat koneksi dengan database PostgreSQL, pastikan Anda telah menginstalnya dengan benar di sistem Anda. Buka prompt shell PostgreSQL dan berikan detail seperti Server, Database, nama pengguna, dan kata sandi. Jika semua detail yang Anda berikan sudah sesuai, koneksi dibuat dengan database PostgreSQL.
Saat meneruskan detail, Anda dapat menggunakan server default, database, port, dan nama pengguna yang disarankan oleh shell.
Membuat koneksi menggunakan python
Kelas koneksi file psycopg2mewakili / menangani instance koneksi. Anda dapat membuat koneksi baru menggunakanconnect()fungsi. Ini menerima parameter koneksi dasar seperti dbname, pengguna, kata sandi, host, port dan mengembalikan objek koneksi. Dengan menggunakan fungsi ini, Anda dapat membuat koneksi dengan PostgreSQL.
Contoh
Kode Python berikut menunjukkan bagaimana menghubungkan ke database yang sudah ada. Jika database tidak ada, maka akan dibuatkan dan akhirnya objek database akan dikembalikan. Nama database default PostgreSQL adalah postrgre . Oleh karena itu, kami menyediakannya sebagai nama database.
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',
)Keluaran
Connection established to: (
'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)Anda dapat membuat database di PostgreSQL menggunakan pernyataan CREATE DATABASE. Anda dapat menjalankan pernyataan ini di prompt shell PostgreSQL dengan menentukan nama database yang akan dibuat setelah perintah.
Sintaksis
Berikut ini adalah sintaks dari pernyataan CREATE DATABASE.
CREATE DATABASE dbname;Contoh
Pernyataan berikut membuat database bernama testdb di PostgreSQL.
postgres=# CREATE DATABASE testdb;
CREATE DATABASEAnda dapat membuat daftar database di PostgreSQL menggunakan perintah \ l. Jika Anda memverifikasi daftar database, Anda dapat menemukan database yang baru dibuat sebagai berikut -
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)Anda juga dapat membuat database di PostgreSQL dari command prompt menggunakan perintah createb , pembungkus di sekitar pernyataan SQL CREATE DATABASE.
C:\Program Files\PostgreSQL\11\bin> createdb -h localhost -p 5432 -U postgres sampledb
Password:Membuat database menggunakan python
Kelas kursor psycopg2 menyediakan berbagai metode untuk menjalankan berbagai perintah PostgreSQL, mengambil catatan, dan menyalin data. Anda bisa membuat objek kursor menggunakan metode cursor () dari kelas Connection.
Metode execute () kelas ini menerima query PostgreSQL sebagai parameter dan menjalankannya.
Oleh karena itu, untuk membuat database di PostgreSQL, jalankan kueri CREATE DATABASE menggunakan metode ini.
Contoh
Contoh python berikut membuat database bernama mydb di database PostgreSQL.
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()Keluaran
Database created successfully........Anda dapat membuat tabel baru dalam database di PostgreSQL menggunakan pernyataan CREATE TABLE. Saat menjalankan ini, Anda perlu menentukan nama tabel, nama kolom dan tipe datanya.
Sintaksis
Berikut ini adalah sintaks dari pernyataan CREATE TABLE di PostgreSQL.
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
);Contoh
Contoh berikut membuat tabel dengan nama CRICKETERS di PostgreSQL.
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=#Anda bisa mendapatkan daftar tabel dalam database di PostgreSQL menggunakan perintah \ dt. Setelah membuat tabel, jika Anda dapat memverifikasi daftar tabel, Anda dapat mengamati tabel yang baru dibuat di dalamnya sebagai berikut -
postgres=# \dt
List of relations
Schema | Name | Type | Owner
--------+------------+-------+----------
public | cricketers | table | postgres
(1 row)
postgres=#Dengan cara yang sama, Anda bisa mendapatkan deskripsi tabel yang dibuat menggunakan \ d seperti yang ditunjukkan di bawah ini -
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=#Membuat tabel menggunakan python
Untuk membuat tabel menggunakan python, Anda perlu menjalankan pernyataan CREATE TABLE menggunakan metode execute () dari Cursor pyscopg2 .
Contoh
Contoh Python berikut membuat tabel dengan nama karyawan.
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()Keluaran
Table created successfully........Anda dapat memasukkan record ke dalam tabel yang ada di PostgreSQL menggunakan INSERT INTOpernyataan. Saat menjalankan ini, Anda perlu menentukan nama tabel, dan nilai untuk kolom di dalamnya.
Sintaksis
Berikut ini adalah sintaks yang direkomendasikan dari pernyataan INSERT -
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);Di mana, kolom1, kolom2, kolom3, .. adalah nama-nama kolom tabel, dan nilai1, nilai2, nilai3, ... adalah nilai-nilai yang perlu Anda masukkan ke dalam tabel.
Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan pernyataan CREATE TABLE seperti yang ditunjukkan di bawah ini -
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=#Mengikuti pernyataan PostgreSQL menyisipkan baris di tabel yang dibuat di atas -
postgres=# insert into CRICKETERS (
First_Name, Last_Name, Age, Place_Of_Birth, Country)
values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=#Saat memasukkan record menggunakan pernyataan INSERT INTO , jika Anda melewatkan nama kolom Record akan disisipkan meninggalkan ruang kosong di kolom yang telah Anda lewati.
postgres=# insert into CRICKETERS (First_Name, Last_Name, Country)
values('Jonathan', 'Trott', 'SouthAfrica');
INSERT 0 1Anda juga dapat menyisipkan rekaman ke dalam tabel tanpa menentukan nama kolom, jika urutan nilai yang Anda teruskan sama dengan masing-masing nama kolom dalam tabel.
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=#Setelah memasukkan record ke dalam tabel, Anda dapat memverifikasi isinya menggunakan pernyataan SELECT seperti yang ditunjukkan di bawah ini -
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)Memasukkan data menggunakan python
Kelas kursor psycopg2 menyediakan metode dengan metode nama execute (). Metode ini menerima kueri sebagai parameter dan menjalankannya.
Oleh karena itu, untuk memasukkan data ke dalam tabel di PostgreSQL menggunakan python -
Impor psycopg2 paket.
Buat objek koneksi menggunakan connect() metode, dengan meneruskan nama pengguna, kata sandi, host (opsional default: localhost) dan, database (opsional) sebagai parameter untuk itu.
Matikan mode komit otomatis dengan menyetel false sebagai nilai ke atribut autocommit.
Itu cursor() metode dari Connectionkelas pustaka psycopg2 mengembalikan objek kursor. Buat objek kursor menggunakan metode ini.
Kemudian, jalankan pernyataan INSERT dengan meneruskannya sebagai parameter ke metode execute ().
Contoh
Mengikuti program Python membuat tabel dengan nama EMPLOYEE di database PostgreSQL dan memasukkan catatan ke dalamnya menggunakan metode 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()Keluaran
Records inserted........Anda dapat mengambil konten dari tabel yang ada di PostgreSQL menggunakan pernyataan SELECT. Pada pernyataan ini, Anda perlu menentukan nama tabel dan mengembalikan isinya dalam format tabel yang dikenal sebagai kumpulan hasil.
Sintaksis
Berikut ini adalah sintaks dari pernyataan SELECT di PostgreSQL -
SELECT column1, column2, columnN FROM table_name;Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
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=#Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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 1Setelah kueri SELECT mengambil nilai kolom FIRST_NAME, LAST_NAME dan, COUNTRY dari tabel 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)Jika Anda ingin mengambil semua kolom dari setiap record, Anda perlu mengganti nama kolom dengan "*" seperti yang ditunjukkan di bawah ini -
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=#Mengambil data menggunakan python
Operasi BACA pada database apa pun berarti mengambil beberapa informasi berguna dari database. Anda dapat mengambil data dari PostgreSQL menggunakan metode fetch () yang disediakan oleh psycopg2.
Kelas Cursor menyediakan tiga metode yaitu fetchall (), fetchmany () dan, fetchone () di mana,
Metode fetchall () mengambil semua baris dalam kumpulan hasil kueri dan mengembalikannya sebagai daftar tupel. (Jika kita menjalankan ini setelah mengambil beberapa baris, ini mengembalikan yang tersisa).
Metode fetchone () mengambil baris berikutnya dalam hasil kueri dan mengembalikannya sebagai tupel.
Metode fetchmany () mirip dengan fetchone () tetapi, metode ini mengambil kumpulan baris berikutnya dalam kumpulan hasil kueri, bukan satu baris.
Note - Kumpulan hasil adalah objek yang dikembalikan saat objek kursor digunakan untuk membuat kueri tabel.
Contoh
Program Python berikut terhubung ke database bernama mydb dari PostgreSQL dan mengambil semua catatan dari tabel bernama 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()Keluaran
('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)]Saat melakukan operasi SELECT, UPDATE atau, DELETE, Anda dapat menentukan kondisi untuk memfilter record menggunakan klausa WHERE. Operasi akan dilakukan pada catatan yang memenuhi kondisi yang diberikan.
Sintaksis
Berikut ini adalah sintaks klausa WHERE di PostgreSQL -
SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]Anda dapat menentukan kondisi_penelusuran menggunakan perbandingan atau operator logika. like>, <, =, LIKE, NOT, dll. Contoh berikut akan membuat konsep ini menjadi jelas.
Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
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=#Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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 1Mengikuti pernyataan SELECT mengambil catatan yang usianya lebih dari 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=#Dimana klausa menggunakan python
Untuk mengambil record tertentu dari tabel menggunakan program python, jalankan pernyataan SELECT dengan klausa WHERE, dengan meneruskannya sebagai parameter ke execute() metode.
Contoh
Contoh python berikut menunjukkan penggunaan perintah WHERE menggunakan python.
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()Keluaran
[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]Biasanya jika Anda mencoba mengambil data dari tabel, Anda akan mendapatkan catatan dalam urutan yang sama dengan yang Anda masukkan.
Menggunakan ORDER BY klausa, saat mengambil rekaman tabel Anda bisa mengurutkan rekaman yang dihasilkan dalam urutan naik atau turun berdasarkan kolom yang diinginkan.
Sintaksis
Berikut adalah sintaks dari klausa ORDER BY di PostgreSQL.
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
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=#Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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 1Mengikuti pernyataan SELECT mengambil baris dari tabel CRICKETERS dalam urutan menaik dari usianya -
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:Anda bisa menggunakan lebih dari satu kolom untuk mengurutkan rekaman tabel. Pernyataan SELECT berikut mengurutkan catatan dari tabel CRICKETERS berdasarkan usia kolom dan FIRST_NAME.
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)Secara default, file ORDER BYklausa mengurutkan catatan tabel dalam urutan menaik. Anda dapat mengatur hasil dalam urutan menurun menggunakan DESC sebagai -
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)Klausa ORDER BY menggunakan python
Untuk mengambil konten tabel dalam urutan tertentu, panggil metode execute () pada objek kursor dan, teruskan pernyataan SELECT bersama dengan klausa ORDER BY, sebagai parameter untuknya.
Contoh
Dalam contoh berikut, kami membuat tabel dengan nama dan Karyawan, mengisinya, dan mengambil kembali rekamannya dalam urutan (menaik) sesuai usianya, menggunakan klausa 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()Keluaran
[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]Anda dapat mengubah konten catatan tabel yang ada di PostgreSQL menggunakan pernyataan UPDATE. Untuk memperbarui baris tertentu, Anda perlu menggunakan klausa WHERE bersamanya.
Sintaksis
Berikut ini adalah sintaks dari pernyataan UPDATE di PostgreSQL -
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
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=#Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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 1Pernyataan berikut mengubah usia pemain kriket, yang nama depannya adalah Shikhar -
postgres=# UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
UPDATE 1
postgres=#Jika Anda mengambil rekaman yang FIRST_NAME-nya adalah Shikhar, Anda mengamati bahwa nilai usia telah diubah menjadi 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=#Jika Anda belum pernah menggunakan klausa WHERE, nilai dari semua record akan diperbarui. Mengikuti pernyataan UPDATE meningkatkan usia semua catatan di tabel CRICKETERS sebesar 1 -
postgres=# UPDATE CRICKETERS SET AGE = AGE+1;
UPDATE 5Jika Anda mengambil konten tabel menggunakan perintah SELECT, Anda dapat melihat nilai yang diperbarui sebagai -
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)Memperbarui catatan menggunakan python
Kelas kursor psycopg2 menyediakan metode dengan metode nama execute (). Metode ini menerima kueri sebagai parameter dan menjalankannya.
Oleh karena itu, untuk memasukkan data ke dalam tabel di PostgreSQL menggunakan python -
Impor psycopg2 paket.
Buat objek koneksi menggunakan connect() metode, dengan meneruskan nama pengguna, kata sandi, host (opsional default: localhost) dan, database (opsional) sebagai parameter untuk itu.
Matikan mode komit otomatis dengan menyetel false sebagai nilai ke atribut autocommit.
Itu cursor() metode dari Connectionkelas pustaka psycopg2 mengembalikan objek kursor. Buat objek kursor menggunakan metode ini.
Kemudian, jalankan pernyataan UPDATE dengan meneruskannya sebagai parameter ke metode execute ().
Contoh
Mengikuti kode Python memperbarui konten tabel Karyawan dan mengambil hasilnya -
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()Keluaran
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)]Anda dapat menghapus rekaman dalam tabel yang sudah ada menggunakan DELETE FROMpernyataan database PostgreSQL. Untuk menghapus catatan tertentu, Anda perlu menggunakan klausa WHERE bersamanya.
Sintaksis
Berikut ini adalah sintaks dari query DELETE di PostgreSQL -
DELETE FROM table_name [WHERE Clause]Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
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=#Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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 1Pernyataan berikut menghapus rekor pemain kriket yang memiliki nama belakang 'Sangakkara'. -
postgres=# DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
DELETE 1Jika Anda mengambil isi tabel menggunakan pernyataan SELECT, Anda hanya dapat melihat 4 record karena kami telah menghapus satu record.
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)Jika Anda menjalankan pernyataan DELETE FROM tanpa klausa WHERE, semua rekaman dari tabel yang ditentukan akan dihapus.
postgres=# DELETE FROM CRICKETERS;
DELETE 4Karena Anda telah menghapus semua record, jika Anda mencoba untuk mengambil isi dari tabel CRICKETERS, dengan menggunakan pernyataan SELECT Anda akan mendapatkan hasil yang kosong seperti yang ditunjukkan di bawah ini -
postgres=# SELECT * FROM CRICKETERS;
first_name | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
(0 rows)Menghapus data menggunakan python
Kelas kursor psycopg2 menyediakan metode dengan metode nama execute (). Metode ini menerima kueri sebagai parameter dan menjalankannya.
Oleh karena itu, untuk memasukkan data ke dalam tabel di PostgreSQL menggunakan python -
Impor psycopg2 paket.
Buat objek koneksi menggunakan connect() metode, dengan meneruskan nama pengguna, kata sandi, host (opsional default: localhost) dan, database (opsional) sebagai parameter untuk itu.
Matikan mode komit otomatis dengan menyetel false sebagai nilai ke atribut autocommit.
Itu cursor()metode kelas Connection dari pustaka psycopg2 mengembalikan objek kursor. Buat objek kursor menggunakan metode ini.
Kemudian, jalankan pernyataan UPDATE dengan meneruskannya sebagai parameter ke metode execute ().
Contoh
Mengikuti kode Python menghapus catatan tabel EMPLOYEE dengan nilai usia lebih dari 25 -
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()Keluaran
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)]Anda dapat meletakkan tabel dari database PostgreSQL menggunakan pernyataan DROP TABLE.
Sintaksis
Berikut ini adalah sintaks dari pernyataan DROP TABLE di PostgreSQL -
DROP TABLE table_name;Contoh
Asumsikan kita telah membuat dua tabel dengan nama CRICKETERS dan EMPLOYEES menggunakan query berikut -
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=#Sekarang jika Anda memverifikasi daftar tabel menggunakan perintah “\ dt”, Anda dapat melihat tabel yang dibuat di atas sebagai -
postgres=# \dt;
List of relations
Schema | Name | Type | Owner
--------+------------+-------+----------
public | cricketers | table | postgres
public | employee | table | postgres
(2 rows)
postgres=#Pernyataan berikut menghapus tabel bernama Karyawan dari database -
postgres=# DROP table employee;
DROP TABLEKarena Anda telah menghapus tabel Karyawan, jika Anda mengambil kembali daftar tabel, Anda hanya dapat mengamati satu tabel di dalamnya.
postgres=# \dt;
List of relations
Schema | Name | Type | Owner
--------+------------+-------+----------
public | cricketers | table | postgres
(1 row)
postgres=#Jika Anda mencoba untuk menghapus tabel Karyawan lagi, karena Anda telah menghapusnya, Anda akan mendapatkan pesan kesalahan yang mengatakan "tabel tidak ada" seperti yang ditunjukkan di bawah ini -
postgres=# DROP table employee;
ERROR: table "employee" does not exist
postgres=#Untuk mengatasi ini, Anda dapat menggunakan klausa IF EXISTS bersama dengan pernyataan DELTE. Ini menghapus tabel jika ada, lewati operasi DLETE.
postgres=# DROP table IF EXISTS employee;
NOTICE: table "employee" does not exist, skipping
DROP TABLE
postgres=#Menghapus seluruh tabel menggunakan Python
Anda dapat menjatuhkan tabel kapan pun Anda mau, menggunakan pernyataan DROP. Tetapi Anda harus sangat berhati-hati saat menghapus tabel yang ada karena data yang hilang tidak akan dipulihkan setelah menghapus tabel.
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()Keluaran
#Table dropped...Saat menjalankan pernyataan PostgreSQL SELECT Anda dapat membatasi jumlah rekaman dalam hasilnya menggunakan klausa LIMIT.
Sintaksis
Berikut ini adalah sintaks klausa LMIT di PostgreSQL -
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
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=#Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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 1Pernyataan berikut mengambil 3 record pertama dari tabel Cricketers menggunakan klausa LIMIT -
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)Jika Anda ingin mendapatkan record mulai dari record tertentu (offset), Anda dapat melakukannya, menggunakan klausa OFFSET bersama dengan LIMIT.
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=#Batasi klausa menggunakan python
Contoh python berikut mengambil isi dari tabel bernama EMPLOYEE, membatasi jumlah catatan dalam hasil menjadi 2 -
Contoh
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()Keluaran
[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]Saat Anda telah membagi data dalam dua tabel, Anda dapat mengambil rekaman gabungan dari dua tabel ini menggunakan Gabungan.
Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS dan memasukkan 5 record ke dalamnya seperti yang ditunjukkan di bawah ini -
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'
);Dan, jika kita telah membuat tabel lain dengan nama OdiStats dan memasukkan 5 catatan ke dalamnya sebagai -
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);Pernyataan berikut mengambil data yang menggabungkan nilai-nilai dalam dua tabel ini -
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=#Bergabung menggunakan python
Saat Anda telah membagi data dalam dua tabel, Anda dapat mengambil rekaman gabungan dari dua tabel ini menggunakan Gabungan.
Contoh
Mengikuti program python mendemonstrasikan penggunaan klausa 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()Keluaran
[('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')]Kelas Cursor dari pustaka psycopg menyediakan metode untuk menjalankan perintah PostgreSQL dalam database menggunakan kode python.
Dengan menggunakan metodenya, Anda dapat menjalankan pernyataan SQL, mengambil data dari kumpulan hasil, memanggil prosedur.
Anda bisa membuat Cursor objek menggunakan metode cursor () dari objek / kelas Connection.
Contoh
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()Metode
Berikut adalah berbagai metode yang disediakan oleh kelas / objek Cursor.
| Sr Tidak | Metode & Deskripsi |
|---|---|
| 1 | callproc() Metode ini digunakan untuk memanggil prosedur yang ada database PostgreSQL. |
| 2 | close() Metode ini digunakan untuk menutup objek kursor saat ini. |
| 3 | executemany() Metode ini menerima serangkaian daftar daftar parameter. Menyiapkan kueri MySQL dan menjalankannya dengan semua parameter. |
| 4 | execute() Metode ini menerima kueri MySQL sebagai parameter dan menjalankan kueri yang diberikan. |
| 5 | fetchall() Metode ini mengambil semua baris dalam kumpulan hasil kueri dan mengembalikannya sebagai daftar tupel. (Jika kita menjalankan ini setelah mengambil beberapa baris, ia mengembalikan yang tersisa) |
| 6 | fetchone() Metode ini mengambil baris berikutnya dalam hasil kueri dan mengembalikannya sebagai tupel. |
| 7 | fetchmany() Metode ini mirip dengan fetchone () tetapi, metode ini mengambil kumpulan baris berikutnya dalam kumpulan hasil kueri, bukan satu baris. |
Properti
Berikut ini adalah properti dari kelas Cursor -
| Sr Tidak | Deskripsi properti |
|---|---|
| 1 | description Ini adalah properti hanya baca yang mengembalikan daftar yang berisi deskripsi kolom dalam kumpulan hasil. |
| 2 | astrowid Ini adalah properti hanya baca, jika ada kolom yang bertambah secara otomatis dalam tabel, ini mengembalikan nilai yang dihasilkan untuk kolom tersebut di operasi INSERT atau, UPDATE terakhir. |
| 3 | rowcount Ini mengembalikan jumlah baris yang dikembalikan / diperbarui dalam kasus operasi SELECT dan UPDATE. |
| 4 | closed Properti ini menentukan apakah kursor ditutup atau tidak, jika demikian ia mengembalikan benar, jika tidak salah. |
| 5 | connection Ini mengembalikan referensi ke objek koneksi yang menggunakan kursor ini dibuat. |
| 6 | name Properti ini mengembalikan nama kursor. |
| 7 | scrollable Properti ini menentukan apakah kursor tertentu dapat digulir. |
Instalasi
SQLite3 dapat diintegrasikan dengan Python menggunakan modul sqlite3 yang ditulis oleh Gerhard Haring. Ini menyediakan antarmuka SQL yang sesuai dengan spesifikasi DB-API 2.0 yang dijelaskan oleh PEP 249. Anda tidak perlu menginstal modul ini secara terpisah karena modul ini dikirimkan secara default bersama dengan Python versi 2.5.x dan seterusnya.
Untuk menggunakan modul sqlite3, Anda harus terlebih dahulu membuat objek koneksi yang mewakili database dan kemudian secara opsional Anda dapat membuat objek kursor, yang akan membantu Anda dalam menjalankan semua pernyataan SQL.
API modul Python sqlite3
Berikut adalah rutinitas modul sqlite3 yang penting, yang dapat mencukupi kebutuhan Anda untuk bekerja dengan database SQLite dari program Python Anda. Jika Anda mencari aplikasi yang lebih canggih, Anda dapat melihat dokumentasi resmi modul Python sqlite3.
| Sr.No. | API & Deskripsi |
|---|---|
| 1 | sqlite3.connect(database [,timeout ,other optional arguments]) API ini membuka koneksi ke file database SQLite. Anda dapat menggunakan ": memory:" untuk membuka koneksi database ke database yang berada di RAM, bukan di disk. Jika database berhasil dibuka, itu mengembalikan objek koneksi. |
| 2 | connection.cursor([cursorClass]) Rutinitas ini menciptakan file cursoryang akan digunakan di seluruh pemrograman database Anda dengan Python. Metode ini menerima satu parameter cursorClass opsional. Jika disediakan, ini harus berupa kelas kursor kustom yang memperluas sqlite3.Cursor. |
| 3 | cursor.execute(sql [, optional parameters]) Rutinitas ini menjalankan pernyataan SQL. Pernyataan SQL dapat diparameterisasi (yaitu placeholder, bukan literal SQL). Modul sqlite3 mendukung dua jenis placeholder: tanda tanya dan placeholder bernama (gaya bernama). For example - cursor.execute ("masukkan ke dalam nilai orang (?,?)", (Siapa, umur)) |
| 4 | connection.execute(sql [, optional parameters]) Rutin ini adalah jalan pintas dari metode eksekusi di atas yang disediakan oleh objek kursor dan itu membuat objek kursor perantara dengan memanggil metode kursor, kemudian memanggil metode eksekusi kursor dengan parameter yang diberikan. |
| 5 | cursor.executemany(sql, seq_of_parameters) Rutin ini mengeksekusi perintah SQL terhadap semua urutan parameter atau pemetaan yang ditemukan di urutan sql. |
| 6 | connection.executemany(sql[, parameters]) Rutin ini adalah jalan pintas yang membuat objek kursor perantara dengan memanggil metode kursor, kemudian memanggil metode eksekusi cursor.s dengan parameter yang diberikan. |
| 7 | cursor.executescript(sql_script) Rutinitas ini mengeksekusi beberapa pernyataan SQL sekaligus yang disediakan dalam bentuk script. Ini mengeluarkan pernyataan COMMIT terlebih dahulu, kemudian mengeksekusi skrip SQL yang didapatnya sebagai parameter. Semua pernyataan SQL harus dipisahkan dengan titik koma (;). |
| 8 | connection.executescript(sql_script) Rutin ini adalah pintasan yang membuat objek kursor perantara dengan memanggil metode kursor, lalu memanggil metode skrip eksekusi kursor dengan parameter yang diberikan. |
| 9 | connection.total_changes() Rutinitas ini mengembalikan jumlah baris database yang telah dimodifikasi, disisipkan, atau dihapus sejak koneksi database dibuka. |
| 10 | connection.commit() Metode ini melakukan transaksi saat ini. Jika Anda tidak memanggil metode ini, apa pun yang Anda lakukan sejak panggilan terakhir ke commit () tidak akan terlihat dari koneksi database lain. |
| 11 | connection.rollback() Metode ini mengembalikan setiap perubahan ke database sejak panggilan terakhir ke commit (). |
| 12 | connection.close() Metode ini menutup koneksi database. Perhatikan bahwa ini tidak secara otomatis memanggil commit (). Jika Anda baru saja menutup koneksi database tanpa memanggil commit () terlebih dahulu, perubahan Anda akan hilang! |
| 13 | cursor.fetchone() Metode ini mengambil baris berikutnya dari kumpulan hasil kueri, mengembalikan satu urutan, atau Tidak ada saat tidak ada lagi data yang tersedia. |
| 14 | cursor.fetchmany([size = cursor.arraysize]) Rutinitas ini mengambil rangkaian baris berikutnya dari hasil kueri, mengembalikan daftar. Daftar kosong dikembalikan ketika tidak ada lagi baris yang tersedia. Metode ini mencoba mengambil baris sebanyak yang ditunjukkan oleh parameter ukuran. |
| 15 | cursor.fetchall() Rutinitas ini mengambil semua baris (tersisa) dari hasil kueri, mengembalikan daftar. Daftar kosong dikembalikan jika tidak ada baris yang tersedia. |
Untuk membuat koneksi dengan SQLite Open command prompt, telusuri lokasi tempat Anda menginstal SQLite dan cukup jalankan perintah sqlite3 seperti yang ditunjukkan di bawah ini -
Membuat koneksi menggunakan python
Anda dapat berkomunikasi dengan database SQLite2 menggunakan modul python SQLite3. Untuk melakukannya, pertama-tama Anda perlu membuat koneksi (membuat objek koneksi).
Untuk membuat koneksi dengan database SQLite3 menggunakan python, Anda perlu -
Impor modul sqlite3 menggunakan pernyataan import.
Metode connect () menerima nama database yang Anda perlukan untuk terhubung sebagai parameter dan, mengembalikan objek Connection.
Contoh
import sqlite3
conn = sqlite3.connect('example.db')Keluaran
print("Connection established ..........")Menggunakan pernyataan SQLite CREATE TABLE Anda dapat membuat tabel dalam database.
Sintaksis
Berikut sintaks untuk membuat tabel di database SQLite -
CREATE TABLE database_name.table_name(
column1 datatype PRIMARY KEY(one or more columns),
column2 datatype,
column3 datatype,
.....
columnN datatype
);Contoh
Mengikuti kueri / pernyataan SQLite membuat tabel dengan nama CRICKETERS dalam database SQLite -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Mari kita buat satu lagi tabel OdiStats yang menjelaskan statistik kriket Satu hari dari setiap pemain di tabel CRICKETERS.
sqlite> CREATE TABLE ODIStats (
First_Name VARCHAR(255),
Matches INT,
Runs INT,
AVG FLOAT,
Centuries INT,
HalfCenturies INT
);
sqliteAnda bisa mendapatkan daftar tabel dalam database di database SQLite menggunakan .tablesperintah. Setelah membuat tabel, jika Anda dapat memverifikasi daftar tabel, Anda dapat mengamati tabel yang baru dibuat di dalamnya sebagai -
sqlite> . tables
CRICKETERS ODIStats
sqlite>Membuat tabel menggunakan python
Objek Cursor berisi semua metode untuk mengeksekusi quires dan mengambil data, dll. Metode kursor dari kelas koneksi mengembalikan objek kursor.
Oleh karena itu, untuk membuat tabel di database SQLite menggunakan python -
Buat koneksi dengan database menggunakan metode connect ().
Buat objek kursor dengan menjalankan metode cursor () pada objek koneksi yang dibuat di atas.
Sekarang jalankan pernyataan CREATE TABLE menggunakan metode execute () dari kelas Cursor.
Contoh
Mengikuti program Python membuat tabel bernama Employee di SQLite3 -
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()Keluaran
Table created successfully........Anda dapat menambahkan baris baru ke tabel SQLite yang ada menggunakan pernyataan INSERT INTO. Dalam hal ini, Anda perlu menentukan nama tabel, nama kolom, dan nilai (dalam urutan yang sama seperti nama kolom).
Sintaksis
Berikut ini adalah sintaks yang direkomendasikan dari pernyataan INSERT -
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);Di mana, kolom1, kolom2, kolom3, .. adalah nama-nama kolom dari tabel dan nilai1, nilai2, nilai3, ... adalah nilai yang perlu Anda masukkan ke dalam tabel.
Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan pernyataan CREATE TABLE seperti yang ditunjukkan di bawah ini -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Pernyataan PostgreSQL berikut menyisipkan baris di tabel yang dibuat di atas.
sqlite> insert into CRICKETERS
(First_Name, Last_Name, Age, Place_Of_Birth, Country) values
('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite>Saat memasukkan record menggunakan pernyataan INSERT INTO, jika Anda melewatkan nama kolom, record ini akan disisipkan meninggalkan ruang kosong di kolom yang telah Anda lewati.
sqlite> insert into CRICKETERS
(First_Name, Last_Name, Country) values
('Jonathan', 'Trott', 'SouthAfrica');
sqlite>Anda juga dapat menyisipkan rekaman ke dalam tabel tanpa menentukan nama kolom, jika urutan nilai yang Anda teruskan sama dengan masing-masing nama kolom dalam tabel.
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>Setelah memasukkan record ke dalam tabel, Anda dapat memverifikasi isinya menggunakan pernyataan SELECT seperti yang ditunjukkan di bawah ini -
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>Memasukkan data menggunakan python
Untuk menambahkan catatan ke tabel yang ada di database SQLite -
Impor paket sqlite3.
Buat objek koneksi menggunakan metode connect () dengan meneruskan nama database sebagai parameter untuknya.
Itu cursor()metode mengembalikan objek kursor yang dapat digunakan untuk berkomunikasi dengan SQLite3. Buat objek kursor dengan memanggil objek cursor () pada objek Connection (di atas dibuat).
Kemudian, aktifkan metode execute () pada objek kursor, dengan meneruskan pernyataan INSERT sebagai parameter padanya.
Contoh
Contoh python berikut menyisipkan record ke dalam tabel bernama 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()Keluaran
Records inserted........Anda dapat mengambil data dari tabel SQLite menggunakan kueri SELCT. Query / statement ini mengembalikan konten dari relasi yang ditentukan (tabel) dalam bentuk tabel dan disebut sebagai result-set.
Sintaksis
Berikut ini adalah sintaks dari pernyataan SELECT di SQLite -
SELECT column1, column2, columnN FROM table_name;Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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>Setelah kueri SELECT mengambil nilai kolom FIRST_NAME, LAST_NAME dan, COUNTRY dari tabel 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>Seperti yang Anda amati, pernyataan SELECT dari database SQLite hanya mengembalikan record dari tabel yang ditentukan. Untuk mendapatkan keluaran yang diformat, Anda perlu menyetelheader, dan mode menggunakan perintah masing-masing sebelum pernyataan SELECT seperti yang ditunjukkan di bawah ini -
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>Jika Anda ingin mengambil semua kolom dari setiap record, Anda perlu mengganti nama kolom dengan "*" seperti yang ditunjukkan di bawah ini -
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>Dalam SQLite secara default lebar kolom adalah 10 nilai-nilai luar ini lebar yang cincang (mengamati kolom negara 2 nd baris dalam tabel di atas). Anda dapat mengatur lebar setiap kolom ke nilai yang dibutuhkan menggunakan.width perintah, sebelum mengambil isi tabel seperti yang ditunjukkan di bawah ini -
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>Mengambil data menggunakan python
Operasi BACA pada database apa pun berarti mengambil beberapa informasi berguna dari database. Anda dapat mengambil data dari MYSQL menggunakan metode fetch () yang disediakan oleh modul python sqlite.
Kelas sqlite3.Cursor menyediakan tiga metode yaitu fetchall (), fetchmany () dan, fetchone () di mana,
Metode fetchall () mengambil semua baris dalam kumpulan hasil kueri dan mengembalikannya sebagai daftar tupel. (Jika kita menjalankan ini setelah mengambil beberapa baris, ia mengembalikan yang tersisa).
Metode fetchone () mengambil baris berikutnya dalam hasil kueri dan mengembalikannya sebagai tupel.
Metode fetchmany () mirip dengan fetchone () tetapi, metode ini mengambil kumpulan baris berikutnya dalam kumpulan hasil kueri, bukan satu baris.
Note - Kumpulan hasil adalah objek yang dikembalikan saat objek kursor digunakan untuk membuat kueri tabel.
Contoh
Contoh berikut mengambil semua baris dari tabel EMPLOYEE menggunakan query SELECT dan dari hasil yang diperoleh set awalnya, kita mengambil baris pertama menggunakan metode fetchone () dan kemudian mengambil baris yang tersisa menggunakan metode fetchall ().
Program Python berikut menunjukkan bagaimana mengambil dan menampilkan record dari tabel COMPANY yang dibuat pada contoh di atas.
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()Keluaran
('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)
]Jika Anda ingin mengambil, menghapus atau, memperbarui baris tertentu dari tabel di SQLite, Anda perlu menggunakan klausa where untuk menentukan kondisi guna memfilter baris tabel untuk operasi tersebut.
Misalnya, jika Anda memiliki pernyataan SELECT dengan klausa where, hanya baris yang memenuhi kondisi yang ditentukan yang akan diambil.
Sintaksis
Berikut ini adalah sintaks klausa WHERE di SQLite -
SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]Anda dapat menentukan kondisi_penelusuran menggunakan perbandingan atau operator logika. like>, <, =, LIKE, NOT, dll. Contoh berikut akan membuat konsep ini menjadi jelas.
Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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>Mengikuti pernyataan SELECT mengambil catatan yang usianya lebih dari 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>Dimana klausa menggunakan python
Objek / kelas Cursor berisi semua metode untuk mengeksekusi kueri dan mengambil data, dll. Metode kursor dari kelas koneksi mengembalikan objek kursor.
Oleh karena itu, untuk membuat tabel di database SQLite menggunakan python -
Buat koneksi dengan database menggunakan metode connect ().
Buat objek kursor dengan menjalankan metode cursor () pada objek koneksi yang dibuat di atas.
Sekarang jalankan pernyataan CREATE TABLE menggunakan metode execute () dari kelas Cursor.
Contoh
Contoh berikut membuat tabel bernama Karyawan dan mengisinya. Kemudian menggunakan klausa where, ia mengambil rekaman dengan nilai usia kurang dari 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()Keluaran
[('Vinay', 'Battacharya', 20, 'M', 6000.0)]Saat mengambil data menggunakan kueri SELECT, Anda akan mendapatkan record dalam urutan yang sama dengan yang Anda masukkan.
Anda dapat mengurutkan hasil dalam urutan yang diinginkan (naik atau turun) menggunakan Order Byayat. Secara default, klausa ini mengurutkan hasil dalam urutan menaik, jika Anda perlu mengaturnya dalam urutan menurun Anda perlu menggunakan "DESC" secara eksplisit.
Sintaksis
Berikut ini adalah sintaks klausa ORDER BY di SQLite.
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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>Mengikuti pernyataan SELECT mengambil baris dari tabel CRICKETERS dalam urutan menaik dari usianya -
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>Anda bisa menggunakan lebih dari satu kolom untuk mengurutkan rekaman tabel. Pernyataan SELECT berikut akan mengurutkan data dari tabel CRICKETERS berdasarkan kolom AGE dan FIRST_NAME .
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>Secara default, file ORDER BY klausa mengurutkan rekaman tabel dalam urutan menaik Anda dapat mengatur hasil dalam urutan menurun menggunakan DESC sebagai -
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>Klausa ORDER BY menggunakan python
Untuk mengambil konten tabel dalam urutan tertentu, panggil metode execute () pada objek kursor dan, teruskan pernyataan SELECT bersama dengan klausa ORDER BY, sebagai parameter untuknya.
Contoh
Dalam contoh berikut, kami membuat tabel dengan nama dan Karyawan, mengisinya, dan mengambil kembali rekamannya dalam urutan (menaik) sesuai usianya, menggunakan klausa 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()Keluaran
[('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)]Operasi UPDATE pada database apa pun menyiratkan modifikasi nilai dari satu atau lebih rekaman tabel, yang sudah tersedia dalam database. Anda dapat memperbarui nilai catatan yang ada di SQLite menggunakan pernyataan UPDATE.
Untuk memperbarui baris tertentu, Anda perlu menggunakan klausa WHERE bersamanya.
Sintaksis
Berikut ini adalah sintaks dari pernyataan UPDATE di SQLite -
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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>Pernyataan Mengikuti mengubah usia pemain kriket, yang nama depannya adalah Shikhar -
sqlite> UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
sqlite>Jika Anda mengambil rekaman yang FIRST_NAME-nya adalah Shikhar, Anda mengamati bahwa nilai usia telah diubah menjadi 45 -
sqlite> SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar Dhawan 45 Delhi India
sqlite>Jika Anda belum pernah menggunakan nilai klausa WHERE dari semua catatan akan diperbarui. Mengikuti pernyataan UPDATE meningkatkan usia semua catatan di tabel CRICKETERS sebesar 1 -
sqlite> UPDATE CRICKETERS SET AGE = AGE+1;
sqlite>Jika Anda mengambil konten tabel menggunakan perintah SELECT, Anda dapat melihat nilai yang diperbarui sebagai -
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>Memperbarui catatan yang ada menggunakan python
Untuk menambahkan catatan ke tabel yang ada di database SQLite -
Impor paket sqlite3.
Buat objek koneksi menggunakan metode connect () dengan meneruskan nama database sebagai parameter untuknya.
Itu cursor()metode mengembalikan objek kursor yang dapat digunakan untuk berkomunikasi dengan SQLite3. Buat objek kursor dengan memanggil objek cursor () pada objek Connection (di atas dibuat).
Kemudian, aktifkan metode execute () pada objek kursor, dengan meneruskan pernyataan UPDATE sebagai parameter untuknya.
Contoh
Mengikuti contoh Python, membuat tabel dengan nama EMPLOYEE, memasukkan 5 catatan ke dalamnya dan, menambah usia semua karyawan laki-laki sebanyak 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()Keluaran
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)]Untuk menghapus rekaman dari tabel SQLite, Anda perlu menggunakan pernyataan DELETE FROM. Untuk menghapus catatan tertentu, Anda perlu menggunakan klausa WHERE bersamanya.
Untuk memperbarui baris tertentu, Anda perlu menggunakan klausa WHERE bersamanya.
Sintaksis
Berikut ini adalah sintaks dari kueri DELETE di SQLite -
DELETE FROM table_name [WHERE Clause]Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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>Pernyataan berikut menghapus rekor pemain kriket yang memiliki nama belakang 'Sangakkara'.
sqlite> DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
sqlite>Jika Anda mengambil isi tabel menggunakan pernyataan SELECT, Anda hanya dapat melihat 4 record karena kami telah menghapus satu record.
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>Jika Anda menjalankan pernyataan DELETE FROM tanpa klausa WHERE, semua record dari tabel yang ditentukan akan dihapus.
sqlite> DELETE FROM CRICKETERS;
sqlite>Karena Anda telah menghapus semua record, jika Anda mencoba untuk mengambil isi dari tabel CRICKETERS, dengan menggunakan pernyataan SELECT Anda akan mendapatkan hasil yang kosong seperti yang ditunjukkan di bawah ini -
sqlite> SELECT * FROM CRICKETERS;
sqlite>Menghapus data menggunakan python
Untuk menambahkan catatan ke tabel yang ada di database SQLite -
Impor paket sqlite3.
Buat objek koneksi menggunakan metode connect () dengan meneruskan nama database sebagai parameter untuknya.
Itu cursor()metode mengembalikan objek kursor yang dapat digunakan untuk berkomunikasi dengan SQLite3. Buat objek kursor dengan memanggil objek cursor () pada objek Connection (di atas dibuat).
Kemudian, aktifkan metode execute () pada objek kursor, dengan meneruskan pernyataan DELETE sebagai parameter padanya.
Contoh
Contoh python berikut menghapus record dari tabel EMPLOYEE dengan nilai usia lebih dari 25.
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()Keluaran
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)]Anda dapat menghapus seluruh tabel menggunakan pernyataan DROP TABLE. Anda hanya perlu menentukan nama tabel yang perlu Anda hapus.
Sintaksis
Berikut ini adalah sintaks dari pernyataan DROP TABLE di PostgreSQL -
DROP TABLE table_name;Contoh
Asumsikan kita telah membuat dua tabel dengan nama CRICKETERS dan EMPLOYEES menggunakan query berikut -
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>Sekarang jika Anda memverifikasi daftar tabel menggunakan .tables perintah, Anda dapat melihat tabel yang dibuat di atas di dalamnya (daftar) sebagai -
sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>Pernyataan berikut menghapus tabel bernama Karyawan dari database -
sqlite> DROP table employee;
sqlite>Karena Anda telah menghapus tabel Karyawan, jika Anda mengambil kembali daftar tabel, Anda hanya dapat mengamati satu tabel di dalamnya.
sqlite> .tables
CRICKETERS
sqlite>Jika Anda mencoba untuk menghapus tabel Karyawan lagi, karena Anda telah menghapusnya, Anda akan mendapatkan pesan kesalahan yang mengatakan "tidak ada tabel seperti itu" seperti yang ditunjukkan di bawah ini -
sqlite> DROP table employee;
Error: no such table: employee
sqlite>Untuk mengatasi ini, Anda dapat menggunakan klausa IF EXISTS bersama dengan pernyataan DELTE. Ini menghapus tabel jika ada, lewati operasi DLETE.
sqlite> DROP table IF EXISTS employee;
sqlite>Menjatuhkan tabel menggunakan Python
Anda dapat meletakkan tabel kapan pun Anda mau, menggunakan pernyataan DROP dari MYSQL, tetapi Anda harus sangat berhati-hati saat menghapus tabel yang ada karena data yang hilang tidak akan dipulihkan setelah menghapus tabel.
Contoh
Untuk menjatuhkan tabel dari database SQLite3 menggunakan python, panggil execute() metode pada objek kursor dan meneruskan pernyataan drop sebagai parameter untuk itu.
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()Keluaran
Table dropped...Saat mengambil record jika Anda ingin membatasinya dengan nomor tertentu, Anda dapat melakukannya, menggunakan klausa LIMIT dari SQLite.
Sintaksis
Berikut ini adalah sintaks klausa LIMIT di SQLite -
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Dan jika kita telah memasukkan 5 record ke dalamnya menggunakan pernyataan INSERT sebagai -
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>Pernyataan berikut mengambil 3 record pertama dari tabel Cricketers menggunakan klausa LIMIT -
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>Jika Anda perlu membatasi record mulai dari record ke-n (bukan record pertama), Anda dapat melakukannya, menggunakan OFFSET bersama dengan 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>Klausa LIMIT menggunakan Python
Jika Anda Memanggil metode execute () pada objek kursor dengan meneruskan kueri SELECT bersama dengan klausa LIMIT, Anda bisa mengambil jumlah record yang diperlukan.
Contoh
Contoh python berikut mengambil dua record pertama dari tabel EMPLOYEE menggunakan klausa LIMIT.
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()Keluaran
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0)]Saat Anda telah membagi data dalam dua tabel, Anda dapat mengambil rekaman gabungan dari dua tabel ini menggunakan Gabungan.
Contoh
Asumsikan kita telah membuat tabel dengan nama CRICKETERS menggunakan query berikut -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Mari kita buat satu lagi tabel OdiStats yang menjelaskan statistik kriket Satu hari dari setiap pemain di tabel CRICKETERS.
sqlite> CREATE TABLE ODIStats (
First_Name VARCHAR(255),
Matches INT,
Runs INT,
AVG FLOAT,
Centuries INT,
HalfCenturies INT
);
sqlite>Pernyataan berikut mengambil data yang menggabungkan nilai-nilai dalam dua tabel ini -
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>Gabung klausul menggunakan python
Mengikuti contoh SQLite, mendemonstrasikan klausa JOIN menggunakan python -
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()Keluaran
[('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')]Kelas sqlite3.Cursor adalah instance yang digunakan untuk memanggil metode yang menjalankan pernyataan SQLite, mengambil data dari set hasil kueri. Anda bisa membuatCursor objek menggunakan metode cursor () dari objek / kelas Connection.
Contoh
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()Metode
Berikut adalah berbagai metode yang disediakan oleh kelas / objek Cursor.
| Sr Tidak | Metode & Deskripsi |
|---|---|
| 1 | execute() Rutinitas ini menjalankan pernyataan SQL. Pernyataan SQL dapat diparameterisasi (yaitu, placeholder, bukan literal SQL). Modul psycopg2 mendukung placeholder menggunakan tanda% s Misalnya: cursor.execute ("masukkan ke dalam nilai orang (% s,% s)", (siapa, umur)) |
| 2 | executemany() Rutin ini mengeksekusi perintah SQL terhadap semua urutan parameter atau pemetaan yang ditemukan di urutan sql. |
| 3 | fetchone() Metode ini mengambil baris berikutnya dari kumpulan hasil kueri, mengembalikan satu urutan, atau Tidak ada saat tidak ada lagi data yang tersedia. |
| 4 | fetchmany() Rutinitas ini mengambil rangkaian baris berikutnya dari hasil kueri, mengembalikan daftar. Daftar kosong dikembalikan ketika tidak ada lagi baris yang tersedia. Metode ini mencoba mengambil baris sebanyak yang ditunjukkan oleh parameter ukuran. |
| 5 | fetchall() Rutinitas ini mengambil semua baris (tersisa) dari hasil kueri, mengembalikan daftar. Daftar kosong dikembalikan jika tidak ada baris yang tersedia. |
Properti
Berikut ini adalah properti dari kelas Cursor -
| Sr Tidak | Metode & Deskripsi |
|---|---|
| 1 | arraySize Ini adalah properti baca / tulis Anda bisa menyetel jumlah baris yang dikembalikan oleh metode fetchmany (). |
| 2 | description Ini adalah properti hanya baca yang mengembalikan daftar yang berisi deskripsi kolom dalam kumpulan hasil. |
| 3 | lastrowid Ini adalah properti hanya baca, jika ada kolom yang bertambah secara otomatis dalam tabel, ini mengembalikan nilai yang dihasilkan untuk kolom tersebut di operasi INSERT atau, UPDATE terakhir. |
| 4 | rowcount Ini mengembalikan jumlah baris yang dikembalikan / diperbarui dalam kasus operasi SELECT dan UPDATE. |
| 5 | connection Atribut hanya baca ini menyediakan koneksi database SQLite yang digunakan oleh objek Cursor. |
Pymongo adalah distribusi python yang menyediakan alat untuk bekerja dengan MongoDB, ini adalah cara yang paling disukai untuk berkomunikasi dengan database MongoDB dari python.
Instalasi
Untuk menginstal pymongo pertama-tama pastikan Anda telah menginstal python3 (bersama dengan PIP) dan MongoDB dengan benar. Kemudian jalankan perintah berikut.
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.0Verifikasi
Setelah Anda menginstal pymongo, buka dokumen teks baru, tempel baris berikut di dalamnya dan, simpan sebagai test.py.
import pymongoJika Anda telah menginstal pymongo dengan benar, jika Anda menjalankan test.py seperti yang ditunjukkan di bawah ini, Anda tidak akan mendapatkan masalah apa pun.
D:\Python_MongoDB>test.py
D:\Python_MongoDB>Tidak seperti database lain, MongoDB tidak menyediakan perintah terpisah untuk membuat database.
Secara umum, perintah use digunakan untuk memilih / beralih ke database tertentu. Perintah ini pada awalnya memverifikasi apakah database yang kita tentukan ada, jika demikian, terhubung dengannya. Jika database kita tentukan dengan perintah use tidak ada database baru akan dibuat.
Oleh karena itu, Anda dapat membuat database di MongoDB menggunakan file Use perintah.
Sintaksis
Sintaks dasar use DATABASE pernyataannya adalah sebagai berikut -
use DATABASE_NAMEContoh
Perintah berikut membuat database bernama di mydb.
>use mydb
switched to db mydbAnda dapat memverifikasi kreasi Anda dengan menggunakan perintah db, ini menampilkan database saat ini.
>db
mydbMembuat database menggunakan python
Untuk terhubung ke MongoDB menggunakan pymongo, Anda perlu mengimpor dan membuat MongoClient, lalu Anda dapat langsung mengakses database yang perlu Anda buat di atribut passion.
Contoh
Contoh berikut membuat database di 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())Keluaran
Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']Anda juga dapat menentukan nama port dan host saat membuat MongoClient dan dapat mengakses database dengan gaya kamus.
Contoh
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
print("Database created........")Keluaran
Database created........Koleksi di MongoDB menyimpan sekumpulan dokumen, ini analog dengan tabel di database relasional.
Anda dapat membuat koleksi menggunakan createCollection()metode. Metode ini menerima nilai String yang mewakili nama koleksi yang akan dibuat dan parameter opsi (opsional).
Dengan menggunakan ini, Anda dapat menentukan yang berikut -
- Ukuran koleksinya.
- Jumlah maksimal dokumen yang diperbolehkan dalam koleksi capped.
- Apakah koleksi yang kita buat harus berupa koleksi terbatas (koleksi ukuran tetap).
- Apakah koleksi yang kita buat harus diindeks otomatis.
Sintaksis
Berikut sintaks untuk membuat koleksi di MongoDB.
db.createCollection("CollectionName")Contoh
Metode berikut membuat koleksi bernama ExampleCollection.
> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>Demikian pula, berikut adalah kueri yang membuat koleksi menggunakan opsi metode createCollection ().
>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>Membuat koleksi menggunakan python
Contoh python berikut terhubung ke database di MongoDB (mydb) dan, membuat koleksi di dalamnya.
Contoh
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........")Keluaran
Collection created........Anda dapat menyimpan dokumen ke dalam MongoDB menggunakan metode insert () . Metode ini menerima dokumen JSON sebagai parameter.
Sintaksis
Berikut ini adalah sintaks dari metode penyisipan.
>db.COLLECTION_NAME.insert(DOCUMENT_NAME)Contoh
> 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 })
>Demikian pula, Anda juga dapat memasukkan banyak dokumen menggunakan insert() metode.
> 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" : [ ]
})
>Membuat koleksi menggunakan python
Pymongo menyediakan metode bernama insert_one () untuk memasukkan dokumen ke MangoDB. Untuk metode ini, kita perlu mengirimkan dokumen dalam format kamus.
Contoh
Contoh berikut menyisipkan dokumen dalam contoh koleksi bernama.
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())Keluaran
{
'_id': ObjectId('5d63ad6ce043e2a93885858b'),
'name': 'Ram',
'age': '26',
'city': 'Hyderabad'
}Untuk memasukkan beberapa dokumen ke dalam MongoDB menggunakan pymongo, Anda perlu menjalankan metode 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)Keluaran
Data inserted ......
['101', '102', '103']Anda dapat membaca / mengambil dokumen yang disimpan dari MongoDB menggunakan find()metode. Metode ini mengambil dan menampilkan semua dokumen di MongoDB dengan cara yang tidak terstruktur.
Sintaksis
Berikut ini adalah sintaks find() metode.
>db.CollectionName.find()Contoh
Asumsikan kami telah memasukkan 3 dokumen ke dalam database bernama testDB dalam koleksi bernama sampel menggunakan kueri berikut -
> 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)Anda dapat mengambil dokumen yang dimasukkan menggunakan metode find () sebagai -
> 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" }
>Anda juga bisa mengambil dokumen pertama dalam koleksi menggunakan metode findOne () sebagai -
> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }Mengambil data (find) menggunakan python
Itu find_One() metode pymongo digunakan untuk mengambil satu dokumen berdasarkan kueri Anda, jika tidak ada yang cocok, metode ini tidak mengembalikan apa pun dan jika Anda tidak menggunakan kueri apa pun, metode ini mengembalikan dokumen pertama dari koleksi.
Metode ini berguna setiap kali Anda perlu mengambil hanya satu dokumen dari hasil atau, jika Anda yakin bahwa kueri Anda hanya mengembalikan satu dokumen.
Contoh
Mengikuti contoh python mengambil dokumen pertama dari sebuah koleksi -
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"}))Keluaran
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'}Untuk mendapatkan beberapa dokumen dalam satu kueri (metode pencarian od panggilan tunggal), Anda dapat menggunakan find()metode pymongo. Jika belum melewati kueri apa pun, ini mengembalikan semua dokumen dari sebuah koleksi dan, jika Anda telah menyampaikan kueri ke metode ini, ini mengembalikan semua dokumen yang cocok.
Contoh
#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)Keluaran
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'}Saat mengambil menggunakan find()metode, Anda dapat memfilter dokumen menggunakan objek kueri. Anda dapat meneruskan kueri yang menentukan kondisi untuk dokumen yang diperlukan sebagai parameter untuk metode ini.
Operator
Berikut adalah daftar operator yang digunakan dalam kueri di MongoDB.
| Operasi | Sintaksis | Contoh |
|---|---|---|
| Persamaan | {"key": "value"} | db.mycol.find ({"by": "tutorials point"}) |
| Kurang dari | {"key": {$ lt: "value"}} | db.mycol.find ({"suka": {$ lt: 50}}) |
| Kurang Dari Sama | {"key": {$ lte: "value"}} | db.mycol.find ({"suka": {$ lte: 50}}) |
| Lebih besar dari | {"key": {$ gt: "value"}} | db.mycol.find ({"suka": {$ gt: 50}}) |
| Lebih Dari Sama | {"kunci" {$ gte: "value"}} | db.mycol.find ({"suka": {$ gte: 50}}) |
| Tidak Sama | {"key": {$ ne: "value"}} | db.mycol.find ({"suka": {$ ne: 50}}) |
Contoh 1
Contoh berikut mengambil dokumen dalam koleksi yang namanya 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)Keluaran
Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}Contoh2
Contoh berikut mengambil dokumen dalam koleksi yang nilai usianya lebih dari 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)Keluaran
Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}Saat mengambil konten koleksi, Anda dapat mengurutkan dan mengaturnya dalam urutan naik atau turun menggunakan sort() metode.
Untuk metode ini, Anda dapat meneruskan kolom dan urutan pengurutan yaitu 1 atau -1. Di mana, 1 untuk urutan naik dan -1 untuk urutan turun.
Sintaksis
Berikut ini adalah sintaks dari metode sort () .
>db.COLLECTION_NAME.find().sort({KEY:1})Contoh
Asumsikan kita telah membuat koleksi dan memasukkan 5 dokumen ke dalamnya seperti yang ditunjukkan di bawah ini -
> 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" : [ ]
})Baris berikut mengambil semua dokumen koleksi yang diurutkan dalam urutan menaik berdasarkan usia.
> 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" }Menyortir dokumen menggunakan python
Untuk mengurutkan hasil kueri dalam ascending atau, descending order pymongo menyediakan sort()metode. Untuk metode ini, berikan nilai angka yang mewakili jumlah dokumen yang Anda perlukan dalam hasil.
Secara default, metode ini mengurutkan dokumen dalam urutan menaik berdasarkan bidang yang ditentukan. Jika Anda perlu mengurutkan dalam urutan turun -1 bersama dengan nama bidang -
coll.find().sort("age",-1)Contoh
Contoh berikut mengambil semua dokumen dari koleksi yang diatur sesuai dengan nilai usia dalam urutan menaik -
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)Keluaran
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'}Anda dapat menghapus dokumen dalam koleksi menggunakan remove()metode MongoDB. Metode ini menerima dua parameter opsional -
kriteria penghapusan yang menentukan kondisi untuk menghapus dokumen.
hanya satu, jika Anda mengirimkan true atau 1 sebagai parameter kedua, maka hanya satu dokumen yang akan dihapus.
Sintaksis
Berikut ini adalah sintaks dari metode remove () -
>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)Contoh
Asumsikan kita telah membuat koleksi dan memasukkan 5 dokumen ke dalamnya seperti yang ditunjukkan di bawah ini -
> 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" : [ ]
})Kueri berikut menghapus dokumen dari koleksi yang memiliki nilai nama sebagai 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" }Jika Anda memohon remove() metode tanpa melewati kriteria penghapusan, semua dokumen dalam koleksi akan dihapus.
> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()Menghapus dokumen menggunakan python
Untuk menghapus dokumen dari koleksi MangoDB, Anda dapat menghapus dokumen dari koleksi menggunakan metode delete_one() dan delete_many() metode.
Metode ini menerima objek kueri yang menentukan kondisi untuk menghapus dokumen.
Metode detele_one () menghapus satu dokumen, jika ada kecocokan. Jika tidak ada kueri yang ditentukan, metode ini menghapus dokumen pertama dalam koleksi.
Contoh
Contoh python berikut menghapus dokumen dalam koleksi yang memiliki nilai 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)Keluaran
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'}Demikian pula dengan delete_many() metode pymongo menghapus semua dokumen yang memenuhi kondisi yang ditentukan.
Contoh
Contoh berikut menghapus semua dokumen dalam koleksi yang nilai usianya lebih dari 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)Keluaran
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'}Jika Anda memanggil metode delete_many () tanpa meneruskan kueri apa pun, metode ini akan menghapus semua dokumen dalam koleksi.
coll.delete_many({})Anda dapat menghapus koleksi menggunakan drop() metode MongoDB.
Sintaksis
Berikut ini adalah sintaks metode drop () -
db.COLLECTION_NAME.drop()Contoh
Contoh berikut menjatuhkan koleksi dengan contoh nama -
> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myCollMenghapus koleksi menggunakan python
Anda bisa melepaskan / menghapus koleksi dari database saat ini dengan memanggil metode drop ().
Contoh
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)Keluaran
List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myCollAnda dapat memperbarui konten dokumen yang sudah ada menggunakan update() metode atau save() metode.
Metode pembaruan mengubah dokumen yang sudah ada sedangkan metode simpan menggantikan dokumen yang ada dengan yang baru.
Sintaksis
Berikut ini adalah sintaks metode update () dan save () dari MangoDB -
>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})Contoh
Asumsikan kita telah membuat koleksi dalam database dan memasukkan 3 record ke dalamnya seperti yang ditunjukkan di bawah ini -
> 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)Metode berikut memperbarui nilai kota dokumen dengan id 1002.
> db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }Demikian pula Anda dapat mengganti dokumen dengan data baru dengan menyimpannya dengan id yang sama menggunakan metode save ().
> 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" }Memperbarui dokumen menggunakan python
Mirip dengan metode find_one () yang mengambil dokumen tunggal, metode update_one () dari pymongo memperbarui satu dokumen.
Metode ini menerima kueri yang menentukan dokumen mana yang akan diperbarui dan operasi pembaruan.
Contoh
Contoh python berikut memperbarui nilai lokasi dokumen dalam koleksi.
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)Keluaran
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'}Demikian pula dengan update_many() metode pymongo memperbarui semua dokumen yang memenuhi kondisi yang ditentukan.
Contoh
Contoh berikut memperbarui nilai lokasi di semua dokumen dalam koleksi (kondisi kosong) -
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)Keluaran
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'}Saat mengambil konten koleksi, Anda dapat membatasi jumlah dokumen dalam hasil menggunakan metode limit (). Metode ini menerima nilai angka yang mewakili jumlah dokumen yang Anda inginkan dalam hasil.
Sintaksis
Berikut ini adalah sintaks dari metode limit () -
>db.COLLECTION_NAME.find().limit(NUMBER)Contoh
Asumsikan kita telah membuat koleksi dan memasukkan 5 dokumen ke dalamnya seperti yang ditunjukkan di bawah ini -
> 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" : [ ]
})Baris berikut mengambil 3 dokumen pertama dari koleksi.
> 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" }Membatasi dokumen menggunakan python
Untuk membatasi hasil query ke sejumlah dokumen tertentu, pymongo menyediakan limit()metode. Untuk metode ini, berikan nilai angka yang mewakili jumlah dokumen yang Anda perlukan dalam hasil.
Contoh
Contoh berikut mengambil tiga dokumen pertama dalam sebuah koleksi.
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)Keluaran
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'}