Dostęp do danych w Pythonie - szybki przewodnik

Standardem Pythona dla interfejsów baz danych jest Python DB-API. Większość interfejsów baz danych Pythona jest zgodnych z tym standardem.

Możesz wybrać odpowiednią bazę danych dla swojej aplikacji. Python Database API obsługuje szeroką gamę serwerów baz danych, takich jak -

GadFly
mSQL
MySQL
PostgreSQL
Microsoft SQL Server 2000
Informix
Interbase
Oracle
Sybase

Oto lista dostępnych interfejsów baz danych Pythona : Python Database Interfaces and APIs . Musisz pobrać oddzielny moduł DB API dla każdej bazy danych, do której chcesz uzyskać dostęp. Na przykład, jeśli potrzebujesz dostępu do bazy danych Oracle, a także do bazy danych MySQL, musisz pobrać zarówno moduły bazy danych Oracle, jak i MySQL.

Co to jest mysql-connector-python?

MySQL Python / Connector to interfejs do łączenia się z serwerem bazy danych MySQL z Pythona. Implementuje interfejs API bazy danych Python i jest zbudowany na bazie MySQL.

Jak zainstalować mysql-connector-python?

Przede wszystkim musisz upewnić się, że masz już zainstalowany Python na swoim komputerze. Aby to zrobić, otwórz wiersz polecenia i wpisz w nim python i naciśnij Enter. Jeśli Python jest już zainstalowany w twoim systemie, to polecenie wyświetli jego wersję, jak pokazano poniżej -

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

Teraz naciśnij ctrl + z, a następnie Enter, aby wyjść z powłoki Pythona i utworzyć folder (w którym zamierzałeś zainstalować łącznik Python-MySQL) o nazwie Python_MySQL jako -

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

Sprawdź PIP

PIP to menedżer pakietów w Pythonie, za pomocą którego można instalować różne moduły / pakiety w Pythonie. Dlatego, aby zainstalować Mysql-python mysql-connector-python, musisz upewnić się, że masz zainstalowany PIP na swoim komputerze i jego lokalizację dodaną do ścieżki.

Możesz to zrobić, wykonując polecenie pip. Jeśli nie masz PIP w swoim systemie lub jeśli nie dodałeś jego lokalizacji wPath zmienna środowiskowa, otrzymasz komunikat o błędzie jako -

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

Aby zainstalować PIP, pobierz get-pip.py do powyższego utworzonego folderu i przejdź do niego z polecenia i zainstaluj pip w następujący sposób -

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

Instalowanie mysql-connector-python

Po zainstalowaniu Pythona i PIP otwórz wiersz polecenia i zaktualizuj pip (opcjonalnie), jak pokazano poniżej -

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

Następnie otwórz wiersz poleceń w trybie administratora i zainstaluj Python MySQL connect jako -

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

Weryfikacja

Aby zweryfikować instalację programu, utwórz przykładowy skrypt w języku Python z następującym wierszem.

import mysql.connector

Jeśli instalacja się powiedzie, po jej uruchomieniu nie powinny pojawić się żadne błędy -

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

Instalowanie Pythona od podstaw

Po prostu, jeśli chcesz zainstalować Pythona od zera. Odwiedź stronę główną języka Python .

Kliknij na Downloads zostaniesz przekierowany do strony pobierania, która zawiera linki do najnowszej wersji Pythona na różne platformy, wybierz jedną i pobierz ją.

Na przykład pobraliśmy python-3.7.4.exe (dla systemu Windows). Rozpocznij proces instalacji, klikając dwukrotnie pobrany plik .exe .

Zaznacz opcję Dodaj Python 3.7 do ścieżki i kontynuuj instalację. Po zakończeniu tego procesu w twoim systemie zostanie zainstalowany Python.

Aby połączyć się z MySQL, (jednym ze sposobów jest) otwórz wiersz poleceń MySQL w systemie, jak pokazano poniżej -

Tutaj prosi o hasło; musisz wpisać hasło ustawione dla domyślnego użytkownika (root) podczas instalacji.

Następnie nawiązywane jest połączenie z MySQL, wyświetlając następujący komunikat -

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.

Możesz odłączyć się od bazy danych MySQL w dowolnym momencie, używając polecenia exit w znaku zachęty mysql>.

mysql> exit
Bye

Nawiązywanie połączenia z MySQL za pomocą Pythona

Przed nawiązaniem połączenia z bazą danych MySQL za pomocą Pythona, załóżmy -

Że stworzyliśmy bazę danych o nazwie mydb.
Stworzyliśmy tabelę EMPLOYEE z kolumnami FIRST_NAME, LAST_NAME, AGE, SEX i INCOME.
Poświadczenia, których używamy do łączenia się z MySQL, to nazwa użytkownika: roothasło: password.

Możesz nawiązać połączenie za pomocą connect()konstruktor. Akceptuje nazwę użytkownika, hasło, hosta i nazwę bazy danych, z którą chcesz się połączyć (opcjonalnie) i zwraca obiekt klasy MySQLConnection.

Przykład

Poniżej znajduje się przykład połączenia z bazą danych 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()

Wynik

Podczas wykonywania ten skrypt generuje następujące dane wyjściowe -

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

Możesz również nawiązać połączenie z MySQL, przekazując poświadczenia (nazwa użytkownika, hasło, nazwa hosta i nazwa bazy danych) do connection.MySQLConnection() jak pokazano poniżej -

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

Możesz utworzyć bazę danych w MYSQL za pomocą zapytania CREATE DATABASE.

Składnia

Poniżej znajduje się składnia zapytania CREATE DATABASE -

CREATE DATABASE name_of_the_database

Przykład

Poniższa instrukcja tworzy bazę danych o nazwie mydb w MySQL -

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

Jeśli obserwujesz listę baz danych za pomocą instrukcji SHOW DATABASES, możesz obserwować nowo utworzoną w niej bazę danych, jak pokazano poniżej -

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

Tworzenie bazy danych w MySQL przy użyciu Pythona

Po nawiązaniu połączenia z MySQL, aby manipulować zawartymi w nim danymi należy połączyć się z bazą danych. Możesz połączyć się z istniejącą bazą danych lub stworzyć własną.

Do tworzenia lub usuwania bazy danych MySQL potrzebne byłyby specjalne uprawnienia. Więc jeśli masz dostęp do użytkownika root, możesz utworzyć dowolną bazę danych.

Przykład

Poniższy przykład nawiązuje połączenie z MYSQL i tworzy w nim bazę danych.

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

Wynik

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

Instrukcja CREATE TABLE służy do tworzenia tabel w bazie danych MYSQL. Tutaj musisz określić nazwę tabeli i definicję (nazwę i typ danych) każdej kolumny.

Składnia

Poniżej znajduje się składnia tworzenia tabeli w MySQL -

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

Przykład

Poniższe zapytanie tworzy tabelę o nazwie PRACOWNIK w MySQL z pięcioma kolumnami, a mianowicie FIRST_NAME, LAST_NAME, AGE, SEX i 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)

Instrukcja DESC zawiera opis określonej tabeli. Za pomocą tego możesz sprawdzić, czy tabela została utworzona, czy nie, jak pokazano poniżej -

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)

Tworzenie tabeli w MySQL przy użyciu Pythona

Metoda o nazwie execute() (wywołane na obiekcie kursora) akceptuje dwie zmienne -

Wartość typu String reprezentująca zapytanie do wykonania.
Opcjonalny parametr args, który może być krotką, listą lub słownikiem, reprezentujący parametry zapytania (wartości posiadaczy miejsc).

Zwraca wartość całkowitą reprezentującą liczbę wierszy, na które wpłynęło zapytanie.

Po nawiązaniu połączenia z bazą danych można tworzyć tabele, przekazując zapytanie CREATE TABLE do execute() metoda.

Krótko mówiąc, aby utworzyć tabelę za pomocą Pythona 7minus;

Import mysql.connector pakiet.
Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.
Utwórz obiekt kursora, wywołując plik cursor() na obiekt połączenia utworzony powyżej.
Następnie wykonaj instrukcję CREATE TABLE , przekazując ją jako parametr doexecute() metoda.

Przykład

Poniższy przykład tworzy tabelę o nazwie Employee w bazie danych 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()

Możesz dodać nowe wiersze do istniejącej tabeli MySQL za pomocą rozszerzenia INSERT INTOkomunikat. W tym celu musisz określić nazwę tabeli, nazwy kolumn i wartości (w tej samej kolejności, co nazwy kolumn).

Składnia

Poniżej przedstawiono składnię instrukcji INSERT INTO MySQL.

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

Przykład

Poniższe zapytanie wstawia rekord do tabeli o nazwie EMPLOYEE.

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

Możesz zweryfikować rekordy tabeli po operacji wstawiania za pomocą instrukcji SELECT jako -

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

Nie jest obowiązkowe podawanie nazw kolumn zawsze, jeśli przekazujesz wartości rekordu w tej samej kolejności co kolumny tabeli, możesz wykonać instrukcję SELECT bez nazw kolumn w następujący sposób -

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

Wstawianie danych do tabeli MySQL za pomocą Pythona

Plik execute()metoda (wywoływana na obiekcie kursora) przyjmuje zapytanie jako parametr i wykonuje zadane zapytanie. Aby wstawić dane, musisz przekazać do niego instrukcję MySQL INSERT jako parametr.

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

Aby wstawić dane do tabeli w MySQL za pomocą Pythona -

import mysql.connector pakiet.
Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.
Utwórz obiekt kursora, wywołując plik cursor() na obiekt połączenia utworzony powyżej
Następnie wykonaj INSERT instrukcja, przekazując ją jako parametr do execute() metoda.

Przykład

Poniższy przykład wykonuje instrukcję SQL INSERT, aby wstawić rekord do tabeli 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()

Dynamiczne wstawianie wartości

Możesz także użyć „% s” zamiast wartości w INSERT zapytanie MySQL i przekazanie do nich wartości w postaci list, jak pokazano poniżej -

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

Przykład

Poniższy przykład dynamicznie wstawia rekord do tabeli Employee.

import mysql.connector

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

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

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

try:
   # Executing the SQL command
   cursor.execute(insert_stmt, data)
   
   # Commit your changes in the database
   conn.commit()

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

print("Data inserted")

# Closing the connection
conn.close()

Wynik

Data inserted

Możesz pobierać / pobierać dane z tabeli w MySQL za pomocą zapytania SELECT. To zapytanie / instrukcja zwraca zawartość określonej tabeli w formie tabelarycznej i jest nazywane zestawem wyników.

Składnia

Poniżej znajduje się składnia zapytania SELECT -

SELECT column1, column2, columnN FROM table_name;

Przykład

Załóżmy, że utworzyliśmy tabelę w MySQL o nazwie cricketers_data as -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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

Następujące zapytanie pobiera wartości FIRST_NAME i Country z tabeli.

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)

Możesz również pobrać wszystkie wartości każdego rekordu, używając * instancji nazwy kolumn jako -

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)

Odczytywanie danych z tabeli MYSQL przy użyciu Pythona

READ Operacja na dowolnej bazie danych oznacza pobranie przydatnych informacji z bazy danych. Możesz pobrać dane z MYSQL za pomocą rozszerzeniafetch() metoda dostarczona przez mysql-connector-python.

Cursor.MySQLCursor klasa udostępnia trzy metody mianowiciefetchall(), fetchmany() i, fetchone() gdzie,

Plik fetchall()metoda pobiera wszystkie wiersze w zestawie wyników zapytania i zwraca je jako listę krotek. (Jeśli wykonamy to po pobraniu kilku wierszy, zwróci pozostałe).
Plik fetchone() metoda pobiera następny wiersz w wyniku zapytania i zwraca go jako krotkę.
Plik fetchmany() jest podobna do metody fetchone (), ale pobiera następny zestaw wierszy w zestawie wyników zapytania zamiast pojedynczego wiersza.

Note - Zestaw wyników to obiekt, który jest zwracany, gdy obiekt kursora jest używany do zapytania tabeli.

rowcount - To jest atrybut tylko do odczytu i zwraca liczbę wierszy, na które wpłynęła metoda execute ().

Przykład

Poniższy przykład pobiera wszystkie wiersze tabeli EMPLOYEE za pomocą zapytania SELECT iz uzyskanego zestawu wyników początkowo pobieramy pierwszy wiersz za pomocą metody fetchone (), a następnie pobieramy pozostałe wiersze za pomocą metody 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()

Wynik

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

Poniższy przykład pobiera pierwsze dwa wiersze tabeli EMPLOYEE przy użyciu metody fetchmany ().

Przykład

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

Wynik

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

Jeśli chcesz pobrać, usunąć lub zaktualizować określone wiersze tabeli w MySQL, musisz użyć klauzuli where, aby określić warunek filtrowania wierszy tabeli dla operacji.

Na przykład, jeśli masz instrukcję SELECT z klauzulą where, zostaną pobrane tylko wiersze spełniające określony warunek.

Składnia

Poniżej znajduje się składnia klauzuli WHERE -

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

Przykład

Załóżmy, że utworzyliśmy tabelę w MySQL o nazwie PRACOWNICY jako -

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)

A jeśli wstawiliśmy do niego 4 rekordy używając instrukcji INSERT jako -

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

Po zestawieniu MySQL pobiera rekordy pracowników, których dochody są większe niż 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)

WHERE za pomocą Pythona

Aby pobrać określone rekordy z tabeli za pomocą programu w języku Python -

import mysql.connector pakiet.
Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.
Utwórz obiekt kursora, wywołując plik cursor() na obiekt połączenia utworzony powyżej.
Następnie wykonaj instrukcję SELECT z klauzulą WHERE , przekazując ją jako parametr doexecute() metoda.

Przykład

Poniższy przykład tworzy tabelę o nazwie Employee i zapełnia ją. Następnie za pomocą klauzuli where pobiera rekordy z wartością wieku mniejszą niż 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()

Wynik

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

Podczas pobierania danych za pomocą zapytania SELECT można sortować wyniki w żądanej kolejności (rosnąco lub malejąco) za pomocą klauzuli OrderBy. Domyślnie ta klauzula sortuje wyniki w porządku rosnącym, jeśli chcesz ułożyć je w porządku malejącym, musisz jawnie użyć „DESC”.

Składnia

Poniżej znajduje się składnia SELECT lista-kolumn

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

Przykład

Załóżmy, że utworzyliśmy tabelę w MySQL o nazwie PRACOWNICY jako -

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)

A jeśli wstawiliśmy do niego 4 rekordy używając instrukcji INSERT jako -

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

Poniższa instrukcja pobiera zawartość tabeli PRACOWNIK w kolejności rosnącej według wieku.

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)

Możesz również pobierać dane w porządku malejącym, używając DESC jako -

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)

Klauzula ORDER BY używająca języka Python

Aby pobrać zawartość tabeli w określonej kolejności, wywołaj execute() na obiekcie kursora i przekaż instrukcję SELECT wraz z klauzulą ORDER BY jako parametr.

Przykład

W poniższym przykładzie tworzymy tabelę z imieniem i nazwiskiem oraz Pracownikiem, zapełniamy ją i pobieramy jej rekordy z powrotem w (rosnącej) kolejności ich wieku, używając klauzuli 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()

Wynik

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

W ten sam sposób możesz pobrać dane z tabeli w porządku malejącym, używając klauzuli ORDER BY.

Przykład

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

Wynik

[('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 Operacja na dowolnej bazie danych aktualizuje jeden lub więcej rekordów, które są już dostępne w bazie danych. Możesz zaktualizować wartości istniejących rekordów w MySQL za pomocą instrukcji UPDATE. Aby zaktualizować określone wiersze, musisz użyć wraz z nią klauzuli WHERE.

Składnia

Poniżej znajduje się składnia instrukcji UPDATE w MySQL -

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

Możesz łączyć liczbę N warunków za pomocą operatorów AND lub OR.

Przykład

Załóżmy, że utworzyliśmy tabelę w MySQL o nazwie PRACOWNICY jako -

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)

A jeśli wstawiliśmy do niego 4 rekordy używając instrukcji INSERT jako -

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

Postępowanie zgodnie z oświadczeniem MySQL zwiększa wiek wszystkich pracowników płci męskiej o jeden rok -

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

Jeśli pobierasz zawartość tabeli, możesz zobaczyć zaktualizowane wartości jako -

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)

Aktualizacja zawartości tabeli za pomocą Pythona

Aby zaktualizować rekordy w tabeli w MySQL za pomocą Pythona -

import mysql.connector pakiet.
Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.
Utwórz obiekt kursora, wywołując plik cursor() na obiekt połączenia utworzony powyżej.
Następnie wykonaj instrukcję UPDATE, przekazując ją jako parametr do pliku execute() metoda.

Przykład

Poniższy przykład zwiększa wiek wszystkich mężczyzn o jeden rok.

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

Wynik

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

Aby usunąć rekordy z tabeli MySQL, musisz użyć rozszerzenia DELETE FROMkomunikat. Aby usunąć określone rekordy, musisz użyć wraz z nią klauzuli WHERE.

Składnia

Poniżej znajduje się składnia zapytania DELETE w MYSQL -

DELETE FROM table_name [WHERE Clause]

Przykład

Załóżmy, że utworzyliśmy tabelę w MySQL o nazwie PRACOWNICY jako -

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)

A jeśli wstawiliśmy do niego 4 rekordy używając instrukcji INSERT jako -

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

Podążanie za instrukcją MySQL usuwa rekord pracownika z FIRST_NAME „Mac”.

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

Jeśli odzyskasz zawartość tabeli, zobaczysz tylko 3 rekordy, ponieważ jeden został usunięty.

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)

Jeśli wykonasz instrukcję DELETE bez klauzuli WHERE, wszystkie rekordy z określonej tabeli zostaną usunięte.

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

Jeśli odzyskasz zawartość tabeli, otrzymasz pusty zestaw, jak pokazano poniżej -

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

Usuwanie rekordów tabeli za pomocą języka Python

Operacja DELETE jest wymagana, gdy chcesz usunąć niektóre rekordy z bazy danych.

Aby usunąć rekordy w tabeli -

import mysql.connector pakiet.
Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.
Utwórz obiekt kursora, wywołując plik cursor() na obiekt połączenia utworzony powyżej.
Następnie wykonaj DELETE instrukcja, przekazując ją jako parametr do execute() metoda.

Przykład

Poniższy program usuwa wszystkie rekordy od PRACOWNIKA, którego WIEK przekracza 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()

Wynik

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

Możesz usunąć całą tabelę za pomocą DROP TABLEkomunikat. Wystarczy podać nazwę tabeli, którą chcesz usunąć.

Składnia

Poniżej znajduje się składnia instrukcji DROP TABLE w MySQL -

DROP TABLE table_name;

Przykład

Przed usunięciem tabeli pobierz listę tabel za pomocą instrukcji SHOW TABLES w następujący sposób -

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

Poniższa instrukcja całkowicie usuwa tabelę o nazwie sample z bazy danych -

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

Ponieważ usunęliśmy tabelę o nazwie sample z MySQL, jeśli ponownie otrzymasz listę tabel, nie znajdziesz w niej nazwy tabeli sample.

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

Usuwanie tabeli za pomocą języka Python

Możesz usunąć tabelę w dowolnym momencie, używając instrukcji DROP MYSQL, ale musisz być bardzo ostrożny podczas usuwania istniejącej tabeli, ponieważ utracone dane nie zostaną odzyskane po usunięciu tabeli.

Aby usunąć tabelę z bazy danych MYSQL za pomocą języka Python, wywołaj plik execute() na obiekcie kursora i przekaż do niego instrukcję drop jako parametr.

Przykład

Poniższa tabela usuwa tabelę o nazwie EMPLOYEE z bazy danych.

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

Wynik

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

Usuń tabelę tylko wtedy, gdy istnieje

Jeśli spróbujesz usunąć tabelę, której nie ma w bazie danych, pojawi się błąd, ponieważ -

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

Możesz zapobiec temu błędowi, sprawdzając, czy tabela istnieje przed usunięciem, dodając IF EXISTS do instrukcji DELETE.

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

Wynik

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

Podczas pobierania rekordów, jeśli chcesz ograniczyć je o określoną liczbę, możesz to zrobić, używając klauzuli LIMIT w MYSQL.

Przykład

Załóżmy, że utworzyliśmy tabelę w MySQL o nazwie PRACOWNICY jako -

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)

A jeśli wstawiliśmy do niego 4 rekordy używając instrukcji INSERT jako -

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

Następująca instrukcja SQL pobiera pierwsze dwa rekordy tabeli Employee przy użyciu klauzuli 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)

Klauzula limitu za pomocą języka Python

Jeśli wywołasz execute() na obiekcie kursora przekazując zapytanie SELECT wraz z klauzulą LIMIT, można pobrać wymaganą liczbę rekordów.

Aby usunąć tabelę z bazy danych MYSQL za pomocą języka Python, wywołaj plik execute() na obiekcie kursora i przekaż do niego instrukcję drop jako parametr.

Przykład

Poniższy przykład w Pythonie tworzy i zapełnia tabelę o nazwie EMPLOYEE i, używając klauzuli LIMIT, pobiera pierwsze dwa jej rekordy.

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

Wynik

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

LIMIT z PRZESUNIĘCIEM

Jeśli trzeba ograniczyć rekordy począwszy od n-tego rekordu (nie 1 ^st ), można to zrobić, offsetowego wraz z 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()

Wynik

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

Po podzieleniu danych na dwie tabele możesz pobrać połączone rekordy z tych dwóch tabel za pomocą funkcji Łączenia.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie PRACOWNIK i wprowadziliśmy do niej dane, jak pokazano poniżej -

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

Następnie, jeśli utworzyliśmy inną tabelę i zapełniliśmy ją jako -

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

INSERT INTO CONTACT (ID, EMAIL, CITY) VALUES 
   (101, '[email protected]', 'Hyderabad'), 
   (102, '[email protected]', 'Vishakhapatnam'), 
   (103, '[email protected]', 'Pune'), 
   (104, '[email protected]', 'Mumbai');
Query OK, 4 rows affected (0.10 sec)
Records: 4 Duplicates: 0 Warnings: 0

Następująca instrukcja pobiera dane łączące wartości z tych dwóch tabel -

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 JOIN przy użyciu języka Python

Poniższy przykład pobiera dane z dwóch powyższych tabel połączonych przez kolumnę kontaktów tabeli EMPLOYEE i kolumnę ID tabeli CONTACT.

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

Wynik

[('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 (i podobne biblioteki) jest używany do wykonywania instrukcji w celu komunikacji z bazą danych MySQL.

Używając jej metod można wykonywać instrukcje SQL, pobierać dane z zestawów wyników, wywoływać procedury.

Możesz tworzyć Cursor obiektu przy użyciu metody kursora () obiektu / klasy Connection.

Przykład

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

Metody

Poniżej przedstawiono różne metody udostępniane przez klasę / obiekt Cursor.

Sr.No	Metoda i opis
1	callproc() Ta metoda służy do wywoływania istniejących procedur bazy danych MySQL.
2	close() Ta metoda służy do zamykania bieżącego obiektu kursora.
3	Info() Ta metoda dostarcza informacji o ostatnim zapytaniu.
4	executemany() Ta metoda akceptuje listę serii list parametrów. Przygotowuje zapytanie MySQL i wykonuje je ze wszystkimi parametrami.
5	execute() Ta metoda przyjmuje zapytanie MySQL jako parametr i wykonuje dane zapytanie.
6	fetchall() Ta metoda pobiera wszystkie wiersze w zestawie wyników zapytania i zwraca je jako listę krotek. (Jeśli wykonamy to po pobraniu kilku wierszy, zwróci pozostałe)
7	fetchone() Ta metoda pobiera następny wiersz w wyniku zapytania i zwraca go jako krotkę.
8	fetchmany() Ta metoda jest podobna do metody fetchone (), ale pobiera następny zestaw wierszy w zestawie wyników zapytania zamiast pojedynczego wiersza.
9	etchwarnings() Ta metoda zwraca ostrzeżenia wygenerowane przez ostatnie wykonane zapytanie.

Nieruchomości

Poniżej przedstawiono właściwości klasy Cursor -

Sr.No	Właściwość i opis
1	column_names Jest to właściwość tylko do odczytu, która zwraca listę zawierającą nazwy kolumn zestawu wyników.
2	description Jest to właściwość tylko do odczytu, która zwraca listę zawierającą opis kolumn w zestawie wyników.
3	lastrowid Jest to właściwość tylko do odczytu, jeśli w tabeli znajdują się jakiekolwiek automatycznie zwiększane kolumny, zwraca wartość wygenerowaną dla tej kolumny w ostatniej operacji INSERT lub UPDATE.
4	rowcount Zwraca liczbę wierszy zwróconych / zaktualizowanych w przypadku operacji SELECT i UPDATE.
5	statement Ta właściwość zwraca ostatnią wykonaną instrukcję.

Instalacja

PostgreSQL to potężny, obiektowo-relacyjny system baz danych typu open source. Ma ponad 15 lat aktywnej fazy rozwoju i sprawdzoną architekturę, dzięki której zyskała dobrą reputację w zakresie niezawodności, integralności danych i poprawności.

Aby komunikować się z PostgreSQL za pomocą Pythona, musisz zainstalować psycopg, adapter dostarczony do programowania w Pythonie, aktualna wersja to psycog2.

psycopg2 został napisany z zamiarem bycia bardzo małym, szybkim i stabilnym jak skała. Jest dostępny pod PIP (menedżer pakietów w Pythonie)

Instalowanie Psycog2 przy użyciu PIP

Przede wszystkim upewnij się, że Python i PIP są poprawnie zainstalowane w twoim systemie i że PIP jest aktualny.

Aby zaktualizować PIP, otwórz wiersz polecenia i wykonaj następujące polecenie -

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

Następnie otwórz wiersz polecenia w trybie administratora i wykonaj plik pip install psycopg2-binary polecenie, jak pokazano poniżej -

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

Weryfikacja

Aby zweryfikować instalację, utwórz przykładowy skrypt w języku Python zawierający następujący wiersz.

import mysql.connector

Jeśli instalacja się powiedzie, po jej uruchomieniu nie powinny pojawić się żadne błędy -

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

PostgreSQL zapewnia własną powłokę do wykonywania zapytań. Aby nawiązać połączenie z bazą danych PostgreSQL, upewnij się, że zainstalowałeś ją poprawnie w swoim systemie. Otwórz monit powłoki PostgreSQL i podaj szczegóły, takie jak serwer, baza danych, nazwa użytkownika i hasło. Jeśli wszystkie podane przez Ciebie dane są prawidłowe, nawiązywane jest połączenie z bazą danych PostgreSQL.

Podczas przekazywania danych możesz przejść z domyślnym serwerem, bazą danych, portem i nazwą użytkownika sugerowaną przez powłokę.

Nawiązywanie połączenia za pomocą Pythona

Klasa połączenia psycopg2reprezentuje / obsługuje wystąpienie połączenia. Możesz tworzyć nowe połączenia za pomocąconnect()funkcjonować. Akceptuje podstawowe parametry połączenia, takie jak nazwa bazy danych, użytkownik, hasło, host, port i zwraca obiekt połączenia. Za pomocą tej funkcji możesz nawiązać połączenie z PostgreSQL.

Przykład

Poniższy kod w języku Python pokazuje, jak połączyć się z istniejącą bazą danych. Jeśli baza danych nie istnieje, zostanie utworzona i na koniec zostanie zwrócony obiekt bazy danych. Nazwa domyślnej bazy danych PostgreSQL to postrgre . Dlatego podajemy go jako nazwę bazy danych.

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

Wynik

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

Bazę danych można utworzyć w PostgreSQL za pomocą instrukcji CREATE DATABASE. Możesz wykonać tę instrukcję w zachęcie powłoki PostgreSQL, określając nazwę bazy danych, która ma zostać utworzona po poleceniu.

Składnia

Poniżej przedstawiono składnię instrukcji CREATE DATABASE.

CREATE DATABASE dbname;

Przykład

Poniższa instrukcja tworzy bazę danych o nazwie testdb w PostgreSQL.

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

Możesz wyświetlić listę bazy danych w PostgreSQL za pomocą polecenia \ l. Jeśli zweryfikujesz listę baz danych, możesz znaleźć nowo utworzoną bazę danych w następujący sposób -

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)

Możesz również utworzyć bazę danych w PostgreSQL z wiersza poleceń, używając polecenia createdb , opakowania wokół instrukcji SQL CREATE DATABASE.

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

Tworzenie bazy danych za pomocą języka Python

Klasa kursora psycopg2 zapewnia różne metody wykonywania różnych poleceń PostgreSQL, pobierania rekordów i kopiowania danych. Obiekt kursora można utworzyć za pomocą metody kursora () klasy Connection.

Metoda execute () tej klasy przyjmuje zapytanie PostgreSQL jako parametr i wykonuje je.

Dlatego, aby utworzyć bazę danych w PostgreSQL, wykonaj zapytanie CREATE DATABASE za pomocą tej metody.

Przykład

Poniższy przykład w Pythonie tworzy bazę danych o nazwie mydb w bazie danych 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()

Wynik

Database created successfully........

Możesz utworzyć nową tabelę w bazie danych w PostgreSQL za pomocą instrukcji CREATE TABLE. Wykonując to musisz podać nazwę tabeli, nazwy kolumn i ich typy danych.

Składnia

Poniżej znajduje się składnia instrukcji CREATE TABLE w PostgreSQL.

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

Przykład

Poniższy przykład tworzy tabelę o nazwie CRICKETERS w 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=#

Możesz pobrać listę tabel w bazie danych w PostgreSQL za pomocą polecenia \ dt. Po utworzeniu tabeli, jeśli możesz zweryfikować listę tabel, możesz obserwować nowo utworzoną tabelę w następujący sposób -

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

W ten sam sposób możesz uzyskać opis utworzonej tabeli za pomocą \ d, jak pokazano poniżej -

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=#

Tworzenie tabeli za pomocą języka Python

Aby utworzyć tabelę za pomocą języka Python, należy wykonać instrukcję CREATE TABLE przy użyciu metody execute () obiektu Cursor z pyscopg2 .

Przykład

Poniższy przykład w języku Python tworzy tabelę z nazwiskiem pracownik.

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

Wynik

Table created successfully........

Możesz wstawić rekord do istniejącej tabeli w PostgreSQL za pomocą rozszerzenia INSERT INTOkomunikat. Wykonując to, musisz określić nazwę tabeli i wartości dla znajdujących się w niej kolumn.

Składnia

Poniżej znajduje się zalecana składnia instrukcji INSERT -

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

Gdzie kolumna1, kolumna2, kolumna3, .. to nazwy kolumn tabeli, a wartość1, wartość2, wartość3, ... to wartości, które należy wstawić do tabeli.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS przy użyciu instrukcji CREATE TABLE, jak pokazano poniżej -

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=#

Następująca instrukcja PostgreSQL wstawia wiersz w powyższej tabeli -

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

Podczas wstawiania rekordów za pomocą instrukcji INSERT INTO , jeśli pominiesz nazwy kolumn Rekord zostanie wstawiony z pozostawieniem pustych spacji w kolumnach, które zostały pominięte.

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

Możesz także wstawiać rekordy do tabeli bez określania nazw kolumn, jeśli kolejność przekazywanych wartości jest taka sama, jak ich nazwy kolumn w tabeli.

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=#

Po wstawieniu rekordów do tabeli możesz zweryfikować jej zawartość za pomocą instrukcji SELECT, jak pokazano poniżej -

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)

Wstawianie danych za pomocą Pythona

Klasa kursora psycopg2 dostarcza metodę o nazwie metoda execute (). Ta metoda akceptuje zapytanie jako parametr i wykonuje je.

Dlatego, aby wstawić dane do tabeli w PostgreSQL za pomocą Pythona -

Import psycopg2 pakiet.
Utwórz obiekt połączenia przy użyciu connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.
Wyłącz tryb automatycznego zatwierdzania, ustawiając wartość false jako wartość atrybutu autocommit.
Plik cursor() metoda Connectionklasa biblioteki psycopg2 zwraca obiekt kursora. Utwórz obiekt kursora za pomocą tej metody.
Następnie wykonaj instrukcje INSERT, przekazując je / je jako parametr do metody execute ().

Przykład

Poniższy program w Pythonie tworzy tabelę o nazwie PRACOWNIK w bazie danych PostgreSQL i wstawia do niej rekordy za pomocą metody 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()

Wynik

Records inserted........

Możesz pobrać zawartość istniejącej tabeli w PostgreSQL za pomocą instrukcji SELECT. W tej instrukcji musisz podać nazwę tabeli i zwraca jej zawartość w formacie tabelarycznym, który jest znany jako zbiór wyników.

Składnia

Poniżej znajduje się składnia instrukcji SELECT w PostgreSQL -

SELECT column1, column2, columnN FROM table_name;

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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=#

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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

Następujące zapytanie SELECT pobiera wartości kolumn FIRST_NAME, LAST_NAME i COUNTRY z tabeli 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)

Jeśli chcesz pobrać wszystkie kolumny każdego rekordu, musisz zastąpić nazwy kolumn znakiem „*”, jak pokazano poniżej -

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=#

Pobieranie danych za pomocą języka Python

READ Operacja na dowolnej bazie danych oznacza pobranie przydatnych informacji z bazy danych. Możesz pobrać dane z PostgreSQL używając metody fetch () dostarczonej przez psycopg2.

Klasa Cursor udostępnia trzy metody: fetchall (), fetchmany () i, fetchone () gdzie,

Metoda fetchall () pobiera wszystkie wiersze ze zbioru wyników zapytania i zwraca je jako listę krotek. (Jeśli wykonamy to po pobraniu kilku wierszy, zwróci pozostałe).
Metoda fetchone () pobiera następny wiersz w wyniku zapytania i zwraca go jako krotkę.
Metoda fetchmany () jest podobna do metody fetchone (), ale pobiera następny zestaw wierszy w zestawie wyników zapytania zamiast pojedynczego wiersza.

Note - Zestaw wyników to obiekt, który jest zwracany, gdy obiekt kursora jest używany do zapytania tabeli.

Przykład

Poniższy program w języku Python łączy się z bazą danych o nazwie mydb PostgreSQL i pobiera wszystkie rekordy z tabeli o nazwie 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()

Wynik

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

Podczas wykonywania operacji SELECT, UPDATE lub DELETE można określić warunek filtrowania rekordów za pomocą klauzuli WHERE. Operacja zostanie wykonana na rekordach spełniających podany warunek.

Składnia

Poniżej znajduje się składnia klauzuli WHERE w PostgreSQL -

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

Warunek_wyszukiwania można określić za pomocą porównania lub operatorów logicznych. jak>, <, =, LUBIĘ, NIE, itd. Poniższe przykłady wyjaśniają tę koncepcję.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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=#

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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

Następująca instrukcja SELECT pobiera rekordy, których wiek jest większy niż 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=#

Where klauzula przy użyciu języka Python

Aby pobrać określone rekordy z tabeli za pomocą programu w języku Python, należy wykonać instrukcję SELECT z klauzulą WHERE, przekazując ją jako parametr do execute() metoda.

Przykład

Poniższy przykład w języku Python demonstruje użycie polecenia WHERE w języku 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()

Wynik

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

Zwykle, jeśli spróbujesz pobrać dane z tabeli, otrzymasz rekordy w tej samej kolejności, w jakiej je wstawiłeś.

Używając ORDER BY klauzuli, podczas pobierania rekordów tabeli można sortować wynikowe rekordy w porządku rosnącym lub malejącym na podstawie żądanej kolumny.

Składnia

Poniżej znajduje się składnia klauzuli ORDER BY w PostgreSQL.

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

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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=#

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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

Następująca instrukcja SELECT pobiera wiersze tabeli CRICKETERS w rosnącej kolejności ich wieku -

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:

Do sortowania rekordów tabeli można użyć więcej niż jednej kolumny. Następujące instrukcje SELECT sortują rekordy tabeli CRICKETERS na podstawie wieku kolumn i 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)

Domyślnie ORDER BYklauzula sortuje rekordy tabeli w porządku rosnącym. Możesz uporządkować wyniki w porządku malejącym, używając DESC jako -

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)

Klauzula ORDER BY używająca języka Python

Aby pobrać zawartość tabeli w określonej kolejności, wywołaj metodę execute () na obiekcie kursora i przekaż instrukcję SELECT wraz z klauzulą ORDER BY jako parametr do niej.

Przykład

W poniższym przykładzie tworzymy tabelę z imieniem i nazwiskiem i Pracownikiem, zapełniamy ją i pobieramy jej rekordy z powrotem w (rosnącej) kolejności ich wieku, używając klauzuli 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()

Wynik

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

Możesz modyfikować zawartość istniejących rekordów tabeli w PostgreSQL za pomocą instrukcji UPDATE. Aby zaktualizować określone wiersze, musisz użyć wraz z nią klauzuli WHERE.

Składnia

Poniżej znajduje się składnia instrukcji UPDATE w PostgreSQL -

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

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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=#

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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

Poniższe stwierdzenie modyfikuje wiek krykiecisty, którego imię brzmi Shikhar -

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

Jeśli odzyskasz rekord, którego FIRST_NAME to Shikhar, zauważysz, że wartość wieku została zmieniona na 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=#

Jeśli nie użyłeś klauzuli WHERE, wartości wszystkich rekordów zostaną zaktualizowane. Kolejne polecenie UPDATE zwiększa wiek wszystkich rekordów w tabeli CRICKETERS o 1 -

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

Jeśli pobierzesz zawartość tabeli za pomocą polecenia SELECT, możesz zobaczyć zaktualizowane wartości jako -

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)

Aktualizowanie rekordów za pomocą Pythona

Klasa kursora psycopg2 dostarcza metodę o nazwie metoda execute (). Ta metoda akceptuje zapytanie jako parametr i wykonuje je.

Dlatego, aby wstawić dane do tabeli w PostgreSQL za pomocą Pythona -

Import psycopg2 pakiet.
Utwórz obiekt połączenia przy użyciu connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.
Wyłącz tryb automatycznego zatwierdzania, ustawiając wartość false jako wartość atrybutu autocommit.
Plik cursor() metoda Connectionklasa biblioteki psycopg2 zwraca obiekt kursora. Utwórz obiekt kursora za pomocą tej metody.
Następnie wykonaj instrukcję UPDATE, przekazując ją jako parametr do metody execute ().

Przykład

Poniższy kod w Pythonie aktualizuje zawartość tabeli Employee i pobiera wyniki -

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

Wynik

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

Możesz usunąć rekordy w istniejącej tabeli za pomocą DELETE FROMzestawienie bazy danych PostgreSQL. Aby usunąć określone rekordy, musisz użyć wraz z nią klauzuli WHERE.

Składnia

Poniżej znajduje się składnia zapytania DELETE w PostgreSQL -

DELETE FROM table_name [WHERE Clause]

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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=#

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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

Poniższe stwierdzenie usuwa rekord krykieciarza, który nazywa się „Sangakkara”. -

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

Jeśli pobierzesz zawartość tabeli za pomocą instrukcji SELECT, zobaczysz tylko 4 rekordy, ponieważ jeden został usunięty.

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)

Jeśli wykonasz instrukcję DELETE FROM bez klauzuli WHERE, wszystkie rekordy z określonej tabeli zostaną usunięte.

postgres=# DELETE FROM CRICKETERS;
DELETE 4

Ponieważ usunąłeś wszystkie rekordy, jeśli spróbujesz odzyskać zawartość tabeli CRICKETERS, używając instrukcji SELECT, otrzymasz pusty zestaw wyników, jak pokazano poniżej -

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

Usuwanie danych za pomocą Pythona

Klasa kursora psycopg2 dostarcza metodę o nazwie metoda execute (). Ta metoda akceptuje zapytanie jako parametr i wykonuje je.

Dlatego, aby wstawić dane do tabeli w PostgreSQL za pomocą Pythona -

Import psycopg2 pakiet.
Utwórz obiekt połączenia przy użyciu connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.
Wyłącz tryb automatycznego zatwierdzania, ustawiając wartość false jako wartość atrybutu autocommit.
Plik cursor()metoda klasy Connection biblioteki psycopg2 zwraca obiekt kursora. Utwórz obiekt kursora za pomocą tej metody.
Następnie wykonaj instrukcję UPDATE, przekazując ją jako parametr do metody execute ().

Przykład

Podążanie za kodem Pythona usuwa rekordy tabeli EMPLOYEE z wartościami wiekowymi większymi niż 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()

Wynik

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

Możesz usunąć tabelę z bazy danych PostgreSQL za pomocą instrukcji DROP TABLE.

Składnia

Poniżej znajduje się składnia instrukcji DROP TABLE w PostgreSQL -

DROP TABLE table_name;

Przykład

Załóżmy, że stworzyliśmy dwie tabele o nazwach KRYKIETY i PRACOWNICY, używając następujących zapytań -

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=#

Teraz, jeśli zweryfikujesz listę tabel za pomocą polecenia „\ dt”, możesz zobaczyć powyższe utworzone tabele jako -

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

Poniższa instrukcja usuwa tabelę o nazwie Employee z bazy danych -

postgres=# DROP table employee;
DROP TABLE

Ponieważ usunąłeś tabelę Employee, jeśli ponownie odzyskasz listę tabel, możesz obserwować tylko jedną tabelę w niej.

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

Jeśli spróbujesz ponownie usunąć tabelę pracowników, ponieważ już ją usunąłeś, pojawi się błąd z informacją „tabela nie istnieje”, jak pokazano poniżej -

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

Aby rozwiązać ten problem, można użyć klauzuli IF EXISTS wraz z instrukcją DELTE. Spowoduje to usunięcie tabeli, jeśli istnieje, w przeciwnym razie pominie operację DLETE.

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

Usuwanie całej tabeli za pomocą języka Python

Możesz usunąć tabelę w dowolnym momencie, używając instrukcji DROP. Ale musisz być bardzo ostrożny podczas usuwania jakiejkolwiek istniejącej tabeli, ponieważ utracone dane nie zostaną odzyskane po usunięciu tabeli.

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

Wynik

#Table dropped...

Podczas wykonywania instrukcji SELECT PostgreSQL można ograniczyć liczbę rekordów w jej wyniku za pomocą klauzuli LIMIT.

Składnia

Poniżej znajduje się składnia klauzuli LMIT w PostgreSQL -

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

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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=#

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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

Następująca instrukcja pobiera pierwsze 3 rekordy tabeli Cricketers przy użyciu klauzuli 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)

Jeśli chcesz uzyskać rekordy zaczynające się od określonego rekordu (przesunięcia), możesz to zrobić, używając klauzuli OFFSET wraz z 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=#

Klauzula limitu za pomocą języka Python

Poniższy przykład w Pythonie pobiera zawartość tabeli o nazwie PRACOWNIK, ograniczając liczbę rekordów w wyniku do 2 -

Przykład

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

Wynik

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

Po podzieleniu danych na dwie tabele możesz pobrać połączone rekordy z tych dwóch tabel za pomocą funkcji Łączenia.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS i wstawiliśmy do niej 5 rekordów, jak pokazano poniżej -

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

A jeśli utworzyliśmy kolejną tabelę o nazwie OdiStats i wstawiliśmy do niej 5 rekordów jako -

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

Następująca instrukcja pobiera dane łączące wartości z tych dwóch tabel -

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=#

Łączy się za pomocą Pythona

Po podzieleniu danych na dwie tabele możesz pobrać połączone rekordy z tych dwóch tabel za pomocą funkcji Łączenia.

Przykład

Poniższy program w Pythonie demonstruje użycie klauzuli 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()

Wynik

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

Klasa Cursor biblioteki psycopg zapewnia metody wykonywania poleceń PostgreSQL w bazie danych przy użyciu kodu Pythona.

Używając jej metod można wykonywać instrukcje SQL, pobierać dane z zestawów wyników, wywoływać procedury.

Możesz tworzyć Cursor obiektu przy użyciu metody kursora () obiektu / klasy Connection.

Przykład

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

Metody

Poniżej przedstawiono różne metody udostępniane przez klasę / obiekt Cursor.

Sr.No	Metoda i opis
1	callproc() Ta metoda służy do wywoływania istniejących procedur bazy danych PostgreSQL.
2	close() Ta metoda służy do zamykania bieżącego obiektu kursora.
3	executemany() Ta metoda akceptuje listę serii list parametrów. Przygotowuje zapytanie MySQL i wykonuje je ze wszystkimi parametrami.
4	execute() Ta metoda przyjmuje zapytanie MySQL jako parametr i wykonuje dane zapytanie.
5	fetchall() Ta metoda pobiera wszystkie wiersze w zestawie wyników zapytania i zwraca je jako listę krotek. (Jeśli wykonamy to po pobraniu kilku wierszy, zwróci pozostałe)
6	fetchone() Ta metoda pobiera następny wiersz w wyniku zapytania i zwraca go jako krotkę.
7	fetchmany() Ta metoda jest podobna do metody fetchone (), ale pobiera następny zestaw wierszy w zestawie wyników zapytania zamiast pojedynczego wiersza.

Nieruchomości

Poniżej przedstawiono właściwości klasy Cursor -

Sr.No	Właściwość i opis
1	description Jest to właściwość tylko do odczytu, która zwraca listę zawierającą opis kolumn w zestawie wyników.
2	astrowid Jest to właściwość tylko do odczytu, jeśli w tabeli znajdują się jakiekolwiek automatycznie zwiększane kolumny, zwraca wartość wygenerowaną dla tej kolumny w ostatniej operacji INSERT lub UPDATE.
3	rowcount Zwraca liczbę wierszy zwróconych / zaktualizowanych w przypadku operacji SELECT i UPDATE.
4	closed Ta właściwość określa, czy kursor jest zamknięty, czy nie, jeśli tak, zwraca true, w przeciwnym razie false.
5	connection Zwraca to odniesienie do obiektu połączenia, za pomocą którego utworzono ten kursor.
6	name Ta właściwość zwraca nazwę kursora.
7	scrollable Ta właściwość określa, czy dany kursor jest przewijalny.

Instalacja

SQLite3 można zintegrować z Pythonem za pomocą modułu sqlite3, którego autorem jest Gerhard Haring. Zapewnia interfejs SQL zgodny ze specyfikacją DB-API 2.0 opisaną w PEP 249. Nie musisz instalować tego modułu oddzielnie, ponieważ jest on dostarczany domyślnie wraz z wersją Python 2.5.x.

Aby użyć modułu sqlite3, musisz najpierw utworzyć obiekt połączenia, który reprezentuje bazę danych, a następnie opcjonalnie możesz utworzyć obiekt kursora, który pomoże ci w wykonywaniu wszystkich instrukcji SQL.

Interfejsy API modułu Python sqlite3

Poniżej znajdują się ważne procedury modułu sqlite3, które mogą wystarczyć do pracy z bazą danych SQLite z poziomu programu w Pythonie. Jeśli szukasz bardziej wyrafinowanej aplikacji, możesz zajrzeć do oficjalnej dokumentacji modułu Python sqlite3.

Sr.No.	API i opis
1	sqlite3.connect(database [,timeout ,other optional arguments]) Ten interfejs API otwiera połączenie z plikiem bazy danych SQLite. Możesz użyć ": memory:" do otwarcia połączenia z bazą danych, która znajduje się w pamięci RAM zamiast na dysku. Jeśli baza danych zostanie otwarta pomyślnie, zwraca obiekt połączenia.
2	connection.cursor([cursorClass]) Ta procedura tworzy plik cursorktóry będzie używany podczas programowania bazy danych w języku Python. Ta metoda akceptuje pojedynczy opcjonalny parametr cursorClass. Jeśli jest podana, musi to być niestandardowa klasa kursora, która rozszerza sqlite3.Cursor.
3	cursor.execute(sql [, optional parameters]) Ta procedura wykonuje instrukcję SQL. Instrukcja SQL może być sparametryzowana (tj. Symbole zastępcze zamiast literałów SQL). Moduł sqlite3 obsługuje dwa rodzaje symboli zastępczych: znaki zapytania i nazwane symbole zastępcze (nazwany styl). For example - kursor.execute ("wstaw do wartości osób (?,?)", (Kto, wiek))
4	connection.execute(sql [, optional parameters]) Ta procedura jest skrótem do powyższej metody execute udostępnianej przez obiekt kursora i tworzy obiekt pośredniego kursora przez wywołanie metody kursora, a następnie wywołuje metodę wykonywania kursora z podanymi parametrami.
5	cursor.executemany(sql, seq_of_parameters) Ta procedura wykonuje polecenie SQL na wszystkich sekwencjach parametrów lub odwzorowaniach znalezionych w sekwencji sql.
6	connection.executemany(sql[, parameters]) Ta procedura jest skrótem, który tworzy obiekt kursora pośredniego przez wywołanie metody kursora, a następnie wywołuje metodę kursor.s executemany z podanymi parametrami.
7	cursor.executescript(sql_script) Ta procedura wykonuje jednocześnie wiele instrukcji SQL podanych w postaci skryptu. Najpierw wydaje instrukcję COMMIT, a następnie wykonuje skrypt SQL, który otrzymuje jako parametr. Wszystkie instrukcje SQL należy oddzielać średnikiem (;).
8	connection.executescript(sql_script) Ta procedura jest skrótem, który tworzy pośredni obiekt kursora przez wywołanie metody kursora, a następnie wywołuje metodę executescript kursora z podanymi parametrami.
9	connection.total_changes() Ta procedura zwraca całkowitą liczbę wierszy bazy danych, które zostały zmodyfikowane, wstawione lub usunięte od czasu otwarcia połączenia z bazą danych.
10	connection.commit() Ta metoda zatwierdza bieżącą transakcję. Jeśli nie wywołasz tej metody, wszystko, co zrobiłeś od ostatniego wywołania funkcji commit (), nie jest widoczne z innych połączeń z bazą danych.
11	connection.rollback() Ta metoda cofa wszelkie zmiany w bazie danych od ostatniego wywołania funkcji commit ().
12	connection.close() Ta metoda zamyka połączenie z bazą danych. Zwróć uwagę, że nie wywołuje to automatycznie funkcji commit (). Jeśli po prostu zamkniesz połączenie z bazą danych bez uprzedniego wywołania funkcji commit (), zmiany zostaną utracone!
13	cursor.fetchone() Ta metoda pobiera następny wiersz zestawu wyników zapytania, zwracając pojedynczą sekwencję lub None, gdy nie ma więcej danych.
14	cursor.fetchmany([size = cursor.arraysize]) Ta procedura pobiera następny zestaw wierszy wyniku zapytania, zwracając listę. Pusta lista jest zwracana, gdy nie ma więcej dostępnych wierszy. Metoda próbuje pobrać tyle wierszy, ile wskazuje parametr size.
15	cursor.fetchall() Ta procedura pobiera wszystkie (pozostałe) wiersze wyniku zapytania, zwracając listę. W przypadku braku dostępnych wierszy zwracana jest pusta lista.

Aby nawiązać połączenie z wierszem poleceń SQLite Open, przejrzyj lokalizację, w której zainstalowałeś SQLite i po prostu wykonaj polecenie sqlite3 jak pokazano poniżej -

Nawiązywanie połączenia za pomocą Pythona

Możesz komunikować się z bazą danych SQLite2 za pomocą modułu SQLite3 python. Aby to zrobić, musisz najpierw nawiązać połączenie (utworzyć obiekt połączenia).

Aby nawiązać połączenie z bazą danych SQLite3 za pomocą Pythona, musisz:

Zaimportuj moduł sqlite3 za pomocą instrukcji import.
Metoda connect () przyjmuje jako parametr nazwę bazy danych, z którą chcesz się połączyć, i zwraca obiekt Connection.

Przykład

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

Wynik

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

Używając instrukcji SQLite CREATE TABLE można utworzyć tabelę w bazie danych.

Składnia

Poniżej znajduje się składnia tworzenia tabeli w bazie danych SQLite -

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

Przykład

Wykonanie zapytania / instrukcji SQLite tworzy tabelę z nazwą CRICKETERS w bazie danych SQLite -

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

Stwórzmy jeszcze jedną tabelę OdiStats opisującą jednodniowe statystyki krykieta każdego gracza w tabeli CRICKETERS.

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

Możesz pobrać listę tabel w bazie danych w bazie danych SQLite za pomocą .tablesKomenda. Po utworzeniu tabeli, jeśli możesz zweryfikować listę tabel, możesz obserwować nowo utworzoną tabelę jako -

sqlite> . tables
CRICKETERS ODIStats
sqlite>

Tworzenie tabeli za pomocą języka Python

Obiekt Cursor zawiera wszystkie metody do wykonywania zapytań i pobierania danych itp. Metoda kursora klasy połączenia zwraca obiekt kursora.

Dlatego, aby utworzyć tabelę w bazie danych SQLite za pomocą Pythona -

Nawiąż połączenie z bazą danych za pomocą metody connect ().
Utwórz obiekt kursora, wywołując metodę cursor () na powyższym utworzonym obiekcie połączenia.
Teraz wykonaj instrukcję CREATE TABLE, używając metody execute () klasy Cursor.

Przykład

Poniższy program w Pythonie tworzy tabelę o nazwie Employee w 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()

Wynik

Table created successfully........

Możesz dodać nowe wiersze do istniejącej tabeli SQLite za pomocą instrukcji INSERT INTO. W tym celu musisz określić nazwę tabeli, nazwy kolumn i wartości (w tej samej kolejności, co nazwy kolumn).

Składnia

Poniżej znajduje się zalecana składnia instrukcji INSERT -

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

Gdzie kolumna1, kolumna2, kolumna3, .. to nazwy kolumn tabeli, a wartość1, wartość2, wartość3, ... to wartości, które należy wstawić do tabeli.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS przy użyciu instrukcji CREATE TABLE, jak pokazano poniżej -

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

Następująca instrukcja PostgreSQL wstawia wiersz do powyższej tabeli.

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

Podczas wstawiania rekordów za pomocą instrukcji INSERT INTO, jeśli pominiesz nazwy kolumn, ten rekord zostanie wstawiony z pozostawieniem pustych spacji w kolumnach, które zostały pominięte.

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

Możesz także wstawiać rekordy do tabeli bez określania nazw kolumn, jeśli kolejność przekazywanych wartości jest taka sama, jak ich nazwy kolumn w tabeli.

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>

Po wstawieniu rekordów do tabeli możesz zweryfikować jej zawartość za pomocą instrukcji SELECT, jak pokazano poniżej -

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>

Wstawianie danych za pomocą Pythona

Aby dodać rekordy do istniejącej tabeli w bazie danych SQLite -

Importuj pakiet sqlite3.
Utwórz obiekt połączenia za pomocą metody connect (), przekazując nazwę bazy danych jako parametr.
Plik cursor()metoda zwraca obiekt kursora, za pomocą którego można komunikować się z SQLite3. Utwórz obiekt kursora, wywołując obiekt kursora () na (utworzonym powyżej) obiekcie Connection.
Następnie wywołaj metodę execute () na obiekcie kursora, przekazując do niego instrukcję INSERT jako parametr.

Przykład

Poniższy przykład w Pythonie wstawia rekordy do tabeli o nazwie PRACOWNIK -

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

Wynik

Records inserted........

Możesz pobrać dane z tabeli SQLite za pomocą zapytania SELCT. To zapytanie / instrukcja zwraca zawartość określonej relacji (tabeli) w formie tabelarycznej i jest nazywana zbiorem wyników.

Składnia

Poniżej znajduje się składnia instrukcji SELECT w SQLite -

SELECT column1, column2, columnN FROM table_name;

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następujące zapytanie SELECT pobiera wartości kolumn FIRST_NAME, LAST_NAME i COUNTRY z tabeli 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>

Jak widać, instrukcja SELECT bazy danych SQLite po prostu zwraca rekordy z określonych tabel. Aby uzyskać sformatowane dane wyjściowe, musisz ustawićheader, i mode używając odpowiednich poleceń przed instrukcją SELECT, jak pokazano poniżej -

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>

Jeśli chcesz pobrać wszystkie kolumny każdego rekordu, musisz zastąpić nazwy kolumn znakiem „*”, jak pokazano poniżej -

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>

W SQLite domyślnie szerokość kolumn jest 10 wartości poza tym szerokość są posiekane (obserwować kolumnę kraj z 2 ^-go rzędu w powyższej tabeli). Możesz ustawić szerokość każdej kolumny na wymaganą wartość za pomocą.width polecenie, przed pobraniem zawartości tabeli, jak pokazano poniżej -

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>

Pobieranie danych za pomocą języka Python

READ Operacja na dowolnej bazie danych oznacza pobranie przydatnych informacji z bazy danych. Możesz pobrać dane z MYSQL za pomocą metody fetch () dostarczonej przez moduł sqlite python.

Klasa sqlite3.Cursor udostępnia trzy metody, mianowicie fetchall (), fetchmany () i fetchone (), gdzie,

Metoda fetchall () pobiera wszystkie wiersze ze zbioru wyników zapytania i zwraca je jako listę krotek. (Jeśli wykonamy to po pobraniu kilku wierszy, zwróci pozostałe).
Metoda fetchone () pobiera następny wiersz w wyniku zapytania i zwraca go jako krotkę.
Metoda fetchmany () jest podobna do metody fetchone (), ale pobiera następny zestaw wierszy w zestawie wyników zapytania zamiast pojedynczego wiersza.

Note - Zestaw wyników to obiekt, który jest zwracany, gdy obiekt kursora jest używany do zapytania tabeli.

Przykład

Poniższy program w Pythonie pokazuje, jak pobrać i wyświetlić rekordy z tabeli COMPANY utworzonej w powyższym przykładzie.

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

Wynik

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

Jeśli chcesz pobrać, usunąć lub zaktualizować określone wiersze tabeli w SQLite, musisz użyć klauzuli where, aby określić warunek filtrowania wierszy tabeli dla operacji.

Na przykład, jeśli masz instrukcję SELECT z klauzulą where, zostaną pobrane tylko wiersze spełniające określony warunek.

Składnia

Poniżej znajduje się składnia klauzuli WHERE w SQLite -

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

Warunek_wyszukiwania można określić za pomocą porównania lub operatorów logicznych. jak>, <, =, LUBIĘ, NIE, itd. Poniższe przykłady wyjaśniają tę koncepcję.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następująca instrukcja SELECT pobiera rekordy, których wiek jest większy niż 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>

Where klauzula przy użyciu języka Python

Obiekt / klasa Cursor zawiera wszystkie metody do wykonywania zapytań i pobierania danych itp. Metoda kursora klasy połączenia zwraca obiekt kursora.

Dlatego, aby utworzyć tabelę w bazie danych SQLite za pomocą Pythona -

Nawiąż połączenie z bazą danych za pomocą metody connect ().
Utwórz obiekt kursora, wywołując metodę cursor () na powyższym utworzonym obiekcie połączenia.
Teraz wykonaj instrukcję CREATE TABLE, używając metody execute () klasy Cursor.

Przykład

Poniższy przykład tworzy tabelę o nazwie Employee i zapełnia ją. Następnie za pomocą klauzuli where pobiera rekordy z wartością wieku mniejszą niż 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()

Wynik

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

Podczas pobierania danych za pomocą zapytania SELECT otrzymasz rekordy w takiej samej kolejności, w jakiej je wstawiłeś.

Wyniki można sortować w żądanej kolejności (rosnąco lub malejąco) za pomocą Order Byklauzula. Domyślnie ta klauzula sortuje wyniki w porządku rosnącym, jeśli chcesz ułożyć je w porządku malejącym, musisz jawnie użyć „DESC”.

Składnia

Poniżej znajduje się składnia klauzuli ORDER BY w SQLite.

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

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następująca instrukcja SELECT pobiera wiersze tabeli CRICKETERS w rosnącej kolejności ich wieku -

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>

Do sortowania rekordów tabeli można użyć więcej niż jednej kolumny. Następujące instrukcje SELECT sortują rekordy tabeli CRICKETERS na podstawie kolumn AGE i 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>

Domyślnie ORDER BY klauzula sortuje rekordy tabeli w porządku rosnącym, możesz uporządkować wyniki w porządku malejącym, używając DESC jako -

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>

Klauzula ORDER BY używająca języka Python

Aby pobrać zawartość tabeli w określonej kolejności, wywołaj metodę execute () na obiekcie kursora i przekaż instrukcję SELECT wraz z klauzulą ORDER BY jako parametr do niej.

Przykład

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

Wynik

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

UPDATE Operacja na dowolnej bazie danych oznacza modyfikację wartości jednego lub więcej rekordów tabeli, które są już dostępne w bazie danych. Możesz zaktualizować wartości istniejących rekordów w SQLite za pomocą instrukcji UPDATE.

Aby zaktualizować określone wiersze, musisz użyć wraz z nią klauzuli WHERE.

Składnia

Poniżej znajduje się składnia instrukcji UPDATE w SQLite -

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

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następujące zdanie modyfikuje wiek krykiecisty, którego imię brzmi Shikhar -

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

Jeśli odzyskasz rekord, którego FIRST_NAME to Shikhar, zauważysz, że wartość wieku została zmieniona na 45 -

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

Jeśli nie użyłeś klauzuli WHERE, wartości wszystkich rekordów zostaną zaktualizowane. Kolejne polecenie UPDATE zwiększa wiek wszystkich rekordów w tabeli CRICKETERS o 1 -

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

Jeśli pobierzesz zawartość tabeli za pomocą polecenia SELECT, możesz zobaczyć zaktualizowane wartości jako -

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>

Aktualizowanie istniejących rekordów za pomocą języka Python

Aby dodać rekordy do istniejącej tabeli w bazie danych SQLite -

Importuj pakiet sqlite3.
Utwórz obiekt połączenia za pomocą metody connect () , przekazując nazwę bazy danych jako parametr.
Plik cursor()metoda zwraca obiekt kursora, za pomocą którego można komunikować się z SQLite3. Utwórz obiekt kursora, wywołując obiekt kursora () na (utworzonym powyżej) obiekcie Connection.
Następnie wywołaj metodę execute () na obiekcie kursora, przekazując do niego instrukcję UPDATE jako parametr.

Przykład

Idąc za przykładem Pythona, tworzy tabelę o nazwie PRACOWNIK, wstawia do niej 5 rekordów i zwiększa wiek wszystkich pracowników płci męskiej o 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()

Wynik

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

Aby usunąć rekordy z tabeli SQLite, musisz użyć instrukcji DELETE FROM. Aby usunąć określone rekordy, musisz użyć wraz z nią klauzuli WHERE.

Aby zaktualizować określone wiersze, musisz użyć wraz z nią klauzuli WHERE.

Składnia

Poniżej znajduje się składnia zapytania DELETE w SQLite -

DELETE FROM table_name [WHERE Clause]

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Poniższe stwierdzenie usuwa rekord krykieciarza, który nazywa się „Sangakkara”.

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

Jeśli pobierzesz zawartość tabeli za pomocą instrukcji SELECT, zobaczysz tylko 4 rekordy, ponieważ jeden został usunięty.

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>

Jeśli wykonasz instrukcję DELETE FROM bez klauzuli WHERE, wszystkie rekordy z określonej tabeli zostaną usunięte.

sqlite> DELETE FROM CRICKETERS;
sqlite>

Ponieważ usunąłeś wszystkie rekordy, jeśli spróbujesz odzyskać zawartość tabeli CRICKETERS, używając instrukcji SELECT, otrzymasz pusty zestaw wyników, jak pokazano poniżej -

sqlite> SELECT * FROM CRICKETERS;
sqlite>

Usuwanie danych za pomocą Pythona

Aby dodać rekordy do istniejącej tabeli w bazie danych SQLite -

Importuj pakiet sqlite3.
Utwórz obiekt połączenia za pomocą metody connect () , przekazując nazwę bazy danych jako parametr.
Plik cursor()metoda zwraca obiekt kursora, za pomocą którego można komunikować się z SQLite3. Utwórz obiekt kursora, wywołując obiekt kursora () na (utworzonym powyżej) obiekcie Connection.
Następnie wywołaj metodę execute () na obiekcie kursora, przekazując do niego instrukcję DELETE jako parametr.

Przykład

Poniższy przykład w Pythonie usuwa rekordy z tabeli EMPLOYEE z wartością wieku większą niż 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()

Wynik

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

Możesz usunąć całą tabelę za pomocą instrukcji DROP TABLE. Wystarczy podać nazwę tabeli, którą chcesz usunąć.

Składnia

Poniżej znajduje się składnia instrukcji DROP TABLE w PostgreSQL -

DROP TABLE table_name;

Przykład

Załóżmy, że stworzyliśmy dwie tabele o nazwach KRYKIETY i PRACOWNICY, używając następujących zapytań -

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>

Teraz, jeśli zweryfikujesz listę tabel przy użyciu .tables polecenie, możesz zobaczyć powyższe utworzone tabele w nim (lista) jako -

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

Poniższa instrukcja usuwa tabelę o nazwie Employee z bazy danych -

sqlite> DROP table employee;
sqlite>

Ponieważ usunąłeś tabelę Employee, jeśli ponownie odzyskasz listę tabel, możesz obserwować tylko jedną tabelę w niej.

sqlite> .tables
CRICKETERS
sqlite>

Jeśli spróbujesz ponownie usunąć tabelę pracowników, ponieważ już ją usunąłeś, pojawi się komunikat o błędzie „nie ma takiej tabeli”, jak pokazano poniżej -

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

Aby rozwiązać ten problem, można użyć klauzuli IF EXISTS wraz z instrukcją DELTE. Spowoduje to usunięcie tabeli, jeśli istnieje, w przeciwnym razie pominie operację DLETE.

sqlite> DROP table IF EXISTS employee;
sqlite>

Usuwanie tabeli za pomocą Pythona

Przykład

Aby usunąć tabelę z bazy danych SQLite3 za pomocą języka Python, wywołaj plik execute() na obiekcie kursora i przekaż do niego instrukcję drop jako parametr.

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

Wynik

Table dropped...

Podczas pobierania rekordów, jeśli chcesz ograniczyć je o określoną liczbę, możesz to zrobić, korzystając z klauzuli LIMIT programu SQLite.

Składnia

Poniżej znajduje się składnia klauzuli LIMIT w SQLite -

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

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następująca instrukcja pobiera pierwsze 3 rekordy tabeli Cricketers przy użyciu klauzuli 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>

Jeśli chcesz ograniczyć rekordy zaczynające się od n-tego rekordu (nie pierwszego), możesz to zrobić, używając opcji OFFSET wraz z 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>

Klauzula LIMIT w Pythonie

Jeśli wywołasz metodę execute () na obiekcie kursora, przekazując zapytanie SELECT wraz z klauzulą LIMIT, możesz pobrać wymaganą liczbę rekordów.

Przykład

Poniższy przykład w języku Python pobiera pierwsze dwa rekordy tabeli EMPLOYEE przy użyciu klauzuli 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()

Wynik

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

Po podzieleniu danych na dwie tabele możesz pobrać połączone rekordy z tych dwóch tabel za pomocą funkcji Łączenia.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

Stwórzmy jeszcze jedną tabelę OdiStats opisującą jednodniowe statystyki krykieta każdego gracza w tabeli CRICKETERS.

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

Następująca instrukcja pobiera dane łączące wartości z tych dwóch tabel -

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>

Klauzula Join za pomocą Pythona

Zgodnie z przykładem SQLite demonstruje klauzulę JOIN przy użyciu języka 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()

Wynik

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

Klasa sqlite3.Cursor to instancja, za pomocą której można wywoływać metody wykonujące instrukcje SQLite, pobierać dane z wyników zapytań. Możesz tworzyćCursor obiektu przy użyciu metody kursora () obiektu / klasy Connection.

Przykład

import sqlite3

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

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

Metody

Poniżej przedstawiono różne metody udostępniane przez klasę / obiekt Cursor.

Sr.No	Metoda i opis
1	execute() Ta procedura wykonuje instrukcję SQL. Instrukcja SQL może być sparametryzowana (tj. Symbole zastępcze zamiast literałów SQL). Moduł psycopg2 obsługuje symbole zastępcze przy użyciu znaku% s Na przykład: kursor.execute ("wstaw do osób wartości (% s,% s)", (kto, wiek))
2	executemany() Ta procedura wykonuje polecenie SQL na wszystkich sekwencjach parametrów lub odwzorowaniach znalezionych w sekwencji sql.
3	fetchone() Ta metoda pobiera następny wiersz zestawu wyników zapytania, zwracając pojedynczą sekwencję lub None, gdy nie ma więcej danych.
4	fetchmany() Ta procedura pobiera następny zestaw wierszy wyniku zapytania, zwracając listę. Pusta lista jest zwracana, gdy nie ma więcej dostępnych wierszy. Metoda próbuje pobrać tyle wierszy, ile wskazuje parametr size.
5	fetchall() Ta procedura pobiera wszystkie (pozostałe) wiersze wyniku zapytania, zwracając listę. W przypadku braku dostępnych wierszy zwracana jest pusta lista.

Nieruchomości

Poniżej przedstawiono właściwości klasy Cursor -

Sr.No	Metoda i opis
1	arraySize Jest to właściwość do odczytu / zapisu, w której można ustawić liczbę wierszy zwracanych przez metodę fetchmany ().
2	description Jest to właściwość tylko do odczytu, która zwraca listę zawierającą opis kolumn w zestawie wyników.
3	lastrowid Jest to właściwość tylko do odczytu, jeśli w tabeli znajdują się jakiekolwiek automatycznie zwiększane kolumny, zwraca wartość wygenerowaną dla tej kolumny w ostatniej operacji INSERT lub UPDATE.
4	rowcount Zwraca liczbę wierszy zwróconych / zaktualizowanych w przypadku operacji SELECT i UPDATE.
5	connection Ten atrybut tylko do odczytu zapewnia połączenie z bazą danych SQLite używane przez obiekt Cursor.

Pymongo to dystrybucja Pythona dostarczająca narzędzi do pracy z MongoDB, jest to najbardziej preferowany sposób komunikacji z bazą danych MongoDB z poziomu pythona.

Instalacja

Aby zainstalować pymongo, najpierw upewnij się, że poprawnie zainstalowałeś python3 (wraz z PIP) i MongoDB. Następnie wykonaj następujące polecenie.

C:\WINDOWS\system32>pip install pymongo
Collecting pymongo
Using cached https://files.pythonhosted.org/packages/cb/a6/b0ae3781b0ad75825e00e29dc5489b53512625e02328d73556e1ecdf12f8/pymongo-3.9.0-cp37-cp37m-win32.whl
Installing collected packages: pymongo
Successfully installed pymongo-3.9.0

Weryfikacja

Po zainstalowaniu pymongo otwórz nowy dokument tekstowy, wklej w nim następującą linię i zapisz jako test.py.

import pymongo

Jeśli poprawnie zainstalowałeś pymongo, jeśli uruchomisz plik test.py, jak pokazano poniżej, nie powinieneś mieć żadnych problemów.

D:\Python_MongoDB>test.py
D:\Python_MongoDB>

W przeciwieństwie do innych baz danych, MongoDB nie zapewnia oddzielnego polecenia do tworzenia bazy danych.

Ogólnie polecenie use służy do wybierania / przełączania się do określonej bazy danych. To polecenie wstępnie sprawdza, czy wskazana przez nas baza danych istnieje, jeśli tak, łączy się z nią. Jeśli baza danych, którą określimy poleceniem use, nie istnieje, zostanie utworzona nowa baza danych.

Dlatego możesz utworzyć bazę danych w MongoDB przy użyciu Use Komenda.

Składnia

Podstawowa składnia use DATABASE oświadczenie jest następujące -

use DATABASE_NAME

Przykład

Następujące polecenie tworzy bazę danych o nazwie w mydb.

>use mydb
switched to db mydb

Możesz zweryfikować swoją kreację za pomocą komendy db, która wyświetli aktualną bazę danych.

>db
mydb

Tworzenie bazy danych za pomocą Pythona

Aby połączyć się z MongoDB za pomocą pymongo, musisz zaimportować i utworzyć MongoClient, a następnie możesz uzyskać bezpośredni dostęp do bazy danych, którą musisz utworzyć w pasji atrybutów.

Przykład

Poniższy przykład tworzy bazę danych w 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())

Wynik

Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']

Możesz również określić port i nazwy hostów podczas tworzenia MongoClient i uzyskać dostęp do baz danych w stylu słownikowym.

Przykład

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

Wynik

Database created........

Kolekcja w MongoDB zawiera zestaw dokumentów, jest analogiczna do tabeli w relacyjnych bazach danych.

Możesz utworzyć kolekcję za pomocą createCollection()metoda. Ta metoda akceptuje wartość String reprezentującą nazwę kolekcji, która ma zostać utworzona, i parametr options (opcjonalny).

Za pomocą tego możesz określić następujące elementy -

Wielkość kolekcji.
Maksymalna liczba dokumentów dozwolonych w limitowanej kolekcji.
Czy tworzona przez nas kolekcja powinna być kolekcją zamkniętą (zbiór o stałym rozmiarze).
Czy tworzona przez nas kolekcja powinna być automatycznie indeksowana.

Składnia

Poniżej znajduje się składnia tworzenia kolekcji w MongoDB.

db.createCollection("CollectionName")

Przykład

Poniższa metoda tworzy kolekcję o nazwie ExampleCollection.

> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>

Podobnie, następujące zapytanie tworzy kolekcję przy użyciu opcji metody createCollection ().

>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>

Tworzenie kolekcji za pomocą języka Python

Poniższy przykład w Pythonie łączy się z bazą danych w MongoDB (mydb) i tworzy w niej kolekcję.

Przykład

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

Wynik

Collection created........

Możesz przechowywać dokumenty w MongoDB za pomocą metody insert () . Ta metoda akceptuje dokument JSON jako parametr.

Składnia

Poniżej przedstawiono składnię metody insert.

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

Przykład

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

Podobnie możesz również wstawić wiele dokumentów za pomocą rozszerzenia insert() metoda.

> 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" : [ ]
})
>

Tworzenie kolekcji za pomocą języka Python

Pymongo udostępnia metodę o nazwie insert_one () do wstawiania dokumentu do MangoDB. Do tej metody musimy przekazać dokument w formacie słownikowym.

Przykład

Poniższy przykład wstawia dokument do kolekcji o nazwie example.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
coll.insert_one(doc1)
print(coll.find_one())

Wynik

{
   '_id': ObjectId('5d63ad6ce043e2a93885858b'), 
   'name': 'Ram', 
   'age': '26', 
   'city': 'Hyderabad'
}

Aby wstawić wiele dokumentów do MongoDB za pomocą pymongo, musisz wywołać metodę 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)

Wynik

Data inserted ......
['101', '102', '103']

Możesz czytać / pobierać zapisane dokumenty z MongoDB przy użyciu rozszerzenia find()metoda. Ta metoda pobiera i wyświetla wszystkie dokumenty w MongoDB w sposób nieuporządkowany.

Składnia

Poniżej znajduje się składnia find() metoda.

>db.CollectionName.find()

Przykład

Załóżmy, że wstawiliśmy 3 dokumenty do bazy danych o nazwie testDB w kolekcji o nazwie sample, używając następujących zapytań -

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

Możesz pobrać wstawione dokumenty za pomocą metody find () jako -

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

Możesz również pobrać pierwszy dokument w kolekcji za pomocą metody findOne () jako -

> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

Pobieranie danych (znajdowanie) za pomocą języka Python

Plik find_One() metoda pymongo służy do pobrania pojedynczego dokumentu na podstawie zapytania, w przypadku braku dopasowania ta metoda nic nie zwraca, a jeśli nie używasz żadnego zapytania, zwraca pierwszy dokument z kolekcji.

Ta metoda jest przydatna, gdy chcesz pobrać tylko jeden dokument wyniku lub, jeśli masz pewność, że zapytanie zwraca tylko jeden dokument.

Przykład

Poniższy przykład w języku Python umożliwia pobranie pierwszego dokumentu z kolekcji -

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

Wynik

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'}

Aby uzyskać wiele dokumentów w jednym zapytaniu (pojedyncze wywołanie metody find), możesz użyć rozszerzenia find()metoda pymongo. Jeśli żadne zapytanie nie przeszło, zwraca wszystkie dokumenty kolekcji, a jeśli przekazałeś zapytanie do tej metody, zwraca wszystkie dopasowane dokumenty.

Przykład

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

Wynik

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'}

Podczas pobierania za pomocą find()możesz filtrować dokumenty za pomocą obiektu zapytania. Możesz przekazać zapytanie określające warunek wymaganych dokumentów jako parametr do tej metody.

Operatorzy

Poniżej znajduje się lista operatorów używanych w zapytaniach w MongoDB.

Operacja	Składnia	Przykład
Równość	{"kluczowa wartość"}	db.mycol.find ({"by": "punkt samouczka"})
Mniej niż	{"klucz": {$ lt: "wartość"}}	db.mycol.find ({"lubi": {$ lt: 50}})
Mniej niż równa się	{"klucz": {$ lte: "wartość"}}	db.mycol.find ({"lubi": {$ lte: 50}})
Lepszy niż	{"klucz": {$ gt: "wartość"}}	db.mycol.find ({"lubi": {$ gt: 50}})
Większe niż równe	{"klucz" {$ gte: "wartość"}}	db.mycol.find ({"lubi": {$ gte: 50}})
Nie równa się	{"klucz": {$ ne: "wartość"}}	db.mycol.find ({"lubi": {$ ne: 50}})

Przykład 1

Poniższy przykład pobiera dokument w kolekcji o nazwie 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)

Wynik

Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}

Przykład 2

Poniższy przykład pobiera dokument w kolekcji, której wartość wieku jest większa niż 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)

Wynik

Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Podczas pobierania zawartości kolekcji można sortować i porządkować je w kolejności rosnącej lub malejącej przy użyciu rozszerzenia sort() metoda.

Do tej metody możesz przekazać pole (a) i kolejność sortowania, która wynosi 1 lub -1. Gdzie 1 oznacza kolejność rosnącą, a -1 malejącą.

Składnia

Poniżej znajduje się składnia metody sort () .

>db.COLLECTION_NAME.find().sort({KEY:1})

Przykład

Załóżmy, że utworzyliśmy kolekcję i wstawiliśmy do niej 5 dokumentów, jak pokazano poniżej -

> 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" : [ ]
})

Następna linia pobiera wszystkie dokumenty kolekcji, które są posortowane rosnąco na podstawie wieku.

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

Sortowanie dokumentów za pomocą Pythona

Aby posortować wyniki zapytania w porządku rosnącym lub malejącym, pymongo udostępnia rozszerzenie sort()metoda. Do tej metody należy przekazać wartość liczbową reprezentującą liczbę dokumentów potrzebnych w wyniku.

Domyślnie ta metoda sortuje dokumenty w kolejności rosnącej na podstawie określonego pola. Jeśli chcesz posortować w porządku malejącym pass -1 wraz z nazwą pola -

coll.find().sort("age",-1)

Przykład

Poniższy przykład pobiera wszystkie dokumenty kolekcji uporządkowane według wartości wieku w porządku rosnącym -

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)

Wynik

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'}

Możesz usuwać dokumenty w kolekcji za pomocą remove()metoda MongoDB. Ta metoda akceptuje dwa opcjonalne parametry -

kryteria usuwania określające warunek usunięcia dokumentów.
tylko jeden, jeśli jako drugi parametr podasz wartość true lub 1, tylko jeden dokument zostanie usunięty.

Składnia

Poniżej znajduje się składnia metody remove () -

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

Przykład

Załóżmy, że utworzyliśmy kolekcję i wstawiliśmy do niej 5 dokumentów, jak pokazano poniżej -

> 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" : [ ]
})

Poniższe zapytanie usuwa dokument (y) kolekcji, które mają wartość nazwy 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" }

Jeśli wywołasz remove() bez przejścia kryteriów usuwania, wszystkie dokumenty w kolekcji zostaną usunięte.

> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()

Usuwanie dokumentów za pomocą Pythona

Aby usunąć dokumenty z kolekcji MangoDB, możesz usunąć dokumenty z kolekcji przy użyciu tych metod delete_one() i delete_many() metody.

Te metody akceptują obiekt zapytania określający warunek usunięcia dokumentów.

Metoda detele_one () usuwa pojedynczy dokument w przypadku dopasowania. Jeśli nie określono zapytania, ta metoda usuwa pierwszy dokument w kolekcji.

Przykład

Poniższy przykład w Pythonie usuwa dokument w kolekcji, który ma wartość identyfikatora 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)

Wynik

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'}

Podobnie delete_many() metoda pymongo usuwa wszystkie dokumenty spełniające określony warunek.

Przykład

Poniższy przykład usuwa wszystkie dokumenty w kolekcji, których wiek jest większy niż 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)

Wynik

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'}

Jeśli wywołasz metodę delete_many () bez przekazywania żadnego zapytania, ta metoda usunie wszystkie dokumenty w kolekcji.

coll.delete_many({})

Możesz usuwać kolekcje za pomocą drop() metoda MongoDB.

Składnia

Poniżej znajduje się składnia metody drop () -

db.COLLECTION_NAME.drop()

Przykład

Poniższy przykład porzuca kolekcję z próbką nazwy -

> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myColl

Usuwanie kolekcji za pomocą Pythona

Możesz upuścić / usunąć kolekcję z bieżącej bazy danych, wywołując metodę drop ().

Przykład

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)

Wynik

List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myColl

Możesz zaktualizować zawartość istniejących dokumentów za pomocą update() metoda lub save() metoda.

Metoda aktualizacji modyfikuje istniejący dokument, natomiast metoda zapisu zastępuje istniejący dokument nowym.

Składnia

Poniżej przedstawiono składnię metod update () i save () MangoDB -

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

Przykład

Załóżmy, że utworzyliśmy kolekcję w bazie danych i wstawiliśmy do niej 3 rekordy, jak pokazano poniżej -

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

Poniższa metoda aktualizuje wartość miasta dokumentu o identyfikatorze 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" }

Podobnie możesz zastąpić dokument nowymi danymi, zapisując go z tym samym identyfikatorem za pomocą metody 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" }

Aktualizowanie dokumentów za pomocą Pythona

Podobnie jak metoda find_one (), która pobiera pojedynczy dokument, metoda update_one () pymongo aktualizuje pojedynczy dokument.

Ta metoda akceptuje kwerendę określającą dokument do zaktualizowania i operację aktualizacji.

Przykład

Poniższy przykład w języku Python aktualizuje wartość położenia dokumentu w kolekcji.

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)

Wynik

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'}

Podobnie update_many() metoda pymongo aktualizuje wszystkie dokumenty spełniające określony warunek.

Przykład

Poniższy przykład aktualizuje wartość lokalizacji we wszystkich dokumentach w kolekcji (warunek pusty) -

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)

Wynik

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'}

Podczas pobierania zawartości kolekcji można ograniczyć liczbę dokumentów w wyniku za pomocą metody limit (). Ta metoda akceptuje wartość liczbową reprezentującą liczbę dokumentów, które mają znaleźć się w wyniku.

Składnia

Poniżej znajduje się składnia metody limit () -

>db.COLLECTION_NAME.find().limit(NUMBER)

Przykład

Załóżmy, że utworzyliśmy kolekcję i wstawiliśmy do niej 5 dokumentów, jak pokazano poniżej -

> 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" : [ ]
})

Następująca linia pobiera pierwsze 3 dokumenty z kolekcji.

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

Ograniczanie dokumentów za pomocą Pythona

Aby ograniczyć wyniki zapytania do określonej liczby dokumentów, pymongo udostępnia rozszerzenie limit()metoda. Do tej metody należy przekazać wartość liczbową reprezentującą liczbę dokumentów potrzebnych w wyniku.

Przykład

Poniższy przykład pobiera pierwsze trzy dokumenty w kolekcji.

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)

Wynik

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'}