Доступ к данным Python - Краткое руководство

Стандарт Python для интерфейсов баз данных - Python DB-API. Большинство интерфейсов баз данных Python соответствуют этому стандарту.

Вы можете выбрать подходящую базу данных для своего приложения. Python Database API поддерживает широкий спектр серверов баз данных, таких как -

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

Вот список доступных интерфейсов базы данных Python : Интерфейсы и API базы данных Python . Вы должны загрузить отдельный модуль DB API для каждой базы данных, к которой вам нужен доступ. Например, если вам нужно получить доступ к базе данных Oracle, а также к базе данных MySQL, вы должны загрузить модули базы данных Oracle и MySQL.

Что такое mysql-connector-python?

MySQL Python / Connector - это интерфейс для подключения к серверу базы данных MySQL из Python. Он реализует API базы данных Python и построен на базе MySQL.

Как установить mysql-connector-python?

Прежде всего, вам нужно убедиться, что вы уже установили python на свой компьютер. Для этого откройте командную строку, введите в ней python и нажмите Enter. Если python уже установлен в вашей системе, эта команда отобразит его версию, как показано ниже -

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

Теперь нажмите ctrl + z, а затем Enter, чтобы выйти из оболочки python и создать папку (в которой вы собирались установить соединитель Python-MySQL) с именем Python_MySQL как -

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

Проверить PIP

PIP - это менеджер пакетов на Python, с помощью которого вы можете устанавливать различные модули / пакеты в Python. Следовательно, чтобы установить Mysql-python mysql-connector-python, вам необходимо убедиться, что на вашем компьютере установлен PIP и его местоположение добавлено в путь.

Вы можете сделать это, выполнив команду pip. Если в вашей системе не было PIP или вы не добавили его местоположение вPath переменная окружения, вы получите сообщение об ошибке:

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

Чтобы установить PIP, загрузите get-pip.py в созданную выше папку и с помощью команды перейдите по ней и установите pip следующим образом:

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

Установка mysql-connector-python

После установки Python и PIP откройте командную строку и обновите pip (необязательно), как показано ниже -

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

Затем откройте командную строку в режиме администратора и установите python MySQL connect как -

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

Проверка

Чтобы проверить установку, создайте образец сценария Python со следующей строкой в нем.

import mysql.connector

Если установка прошла успешно, при ее выполнении вы не должны получить никаких ошибок -

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

Установка python с нуля

Проще говоря, если вам нужно установить Python с нуля. Посетите домашнюю страницу Python .

Нажми на Downloads , вы будете перенаправлены на страницу загрузок, на которой есть ссылки на последнюю версию Python для различных платформ, выберите одну и загрузите ее.

Например, мы скачали python-3.7.4.exe (для Windows). Запустите процесс установки, дважды щелкнув загруженный файл .exe .

Установите флажок «Добавить Python 3.7 в путь» и продолжите установку. После завершения этого процесса в вашей системе будет установлен python.

Чтобы подключиться к MySQL, (один из способов) откройте командную строку MySQL в вашей системе, как показано ниже -

Здесь запрашивается пароль; вам необходимо ввести пароль, который вы установили для пользователя по умолчанию (root) во время установки.

Затем устанавливается соединение с MySQL, отображающее следующее сообщение -

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

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

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

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

Вы можете отключиться от базы данных MySQL в любое время, используя команду выхода в командной строке mysql>.

mysql> exit
Bye

Установление соединения с MySQL с помощью Python

Перед установкой соединения с базой данных MySQL с помощью python предположим:

Мы создали базу данных с именем mydb.
Мы создали таблицу EMPLOYEE со столбцами FIRST_NAME, LAST_NAME, AGE, SEX и INCOME.
Учетные данные, которые мы используем для подключения к MySQL, - это имя пользователя: root, пароль: password.

Вы можете установить соединение, используя connect()конструктор. Он принимает имя пользователя, пароль, хост и имя базы данных, к которой необходимо подключиться (необязательно), и возвращает объект класса MySQLConnection.

пример

Ниже приведен пример подключения к базе данных MySQL «mydb».

import mysql.connector

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

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

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

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

#Closing the connection
conn.close()

Вывод

При выполнении этот скрипт производит следующий вывод -

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

Вы также можете установить соединение с MySQL, передав учетные данные (имя пользователя, пароль, имя хоста и имя базы данных) в connection.MySQLConnection() как показано ниже -

from mysql.connector import (connection)

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

#Closing the connection
conn.close()

Вы можете создать базу данных в MYSQL, используя запрос CREATE DATABASE.

Синтаксис

Ниже приведен синтаксис запроса CREATE DATABASE:

CREATE DATABASE name_of_the_database

пример

Следующий оператор создает базу данных с именем mydb в MySQL -

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

Если вы наблюдаете за списком баз данных с помощью оператора SHOW DATABASES, вы можете наблюдать в нем вновь созданную базу данных, как показано ниже -

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

Создание базы данных в MySQL с использованием Python

После установления соединения с MySQL, чтобы управлять данными в нем, вам необходимо подключиться к базе данных. Вы можете подключиться к существующей базе данных или создать свою собственную.

Вам потребуются особые привилегии для создания или удаления базы данных MySQL. Поэтому, если у вас есть доступ к пользователю root, вы можете создать любую базу данных.

пример

В следующем примере устанавливается соединение с MYSQL и создается база данных в нем.

import mysql.connector

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

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

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

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

#Creating a database
cursor.execute(sql)

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

#Closing the connection
conn.close()

Вывод

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

Оператор CREATE TABLE используется для создания таблиц в базе данных MYSQL. Здесь вам нужно указать имя таблицы и определение (имя и тип данных) каждого столбца.

Синтаксис

Ниже приведен синтаксис для создания таблицы в MySQL:

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

пример

Следующий запрос создает таблицу с именем EMPLOYEE в MySQL с пятью столбцами, а именно FIRST_NAME, LAST_NAME, AGE, SEX и 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)

Оператор DESC дает вам описание указанной таблицы. Используя это, вы можете проверить, была ли создана таблица или нет, как показано ниже -

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

Создание таблицы в MySQL с использованием Python

Названный метод execute() (вызывается на объекте курсора) принимает две переменные -

Значение типа String, представляющее запрос, который нужно выполнить.
Необязательный параметр args, который может быть кортежем, списком или словарем, представляющим параметры запроса (значения заполнителей).

Он возвращает целочисленное значение, представляющее количество строк, обработанных запросом.

Как только соединение с базой данных установлено, вы можете создавать таблицы, передавая запрос CREATE TABLE в execute() метод.

Короче говоря, для создания таблицы с помощью python 7minus;

импорт mysql.connector пакет.
Создайте объект подключения, используя mysql.connector.connect() , передав ему имя пользователя, пароль, хост (необязательно по умолчанию: localhost) и базу данных (необязательно) в качестве параметров.
Создайте объект курсора, вызвав cursor() в созданном выше объекте подключения.
Затем выполните оператор CREATE TABLE , передав его в качестве параметра вexecute() метод.

пример

В следующем примере создается таблица с именем Employee в базе данных mydb.

import mysql.connector

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

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

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

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

#Closing the connection
conn.close()

Вы можете добавлять новые строки в существующую таблицу MySQL, используя INSERT INTOзаявление. В этом случае вам необходимо указать имя таблицы, имена столбцов и значения (в том же порядке, что и имена столбцов).

Синтаксис

Ниже приведен синтаксис оператора MySQL INSERT INTO.

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

пример

Следующий запрос вставляет запись в таблицу с именем EMPLOYEE.

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

Вы можете проверить записи таблицы после операции вставки, используя оператор SELECT как -

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

Необязательно указывать имена столбцов всегда, если вы передаете значения записи в том же порядке, что и столбцы таблицы, вы можете выполнить оператор SELECT без имен столбцов следующим образом:

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

Вставка данных в таблицу MySQL с использованием Python

В execute()Метод (вызываемый для объекта курсора) принимает запрос в качестве параметра и выполняет данный запрос. Чтобы вставить данные, вам необходимо передать инструкцию MySQL INSERT в качестве параметра.

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

Чтобы вставить данные в таблицу в MySQL с помощью python -

импорт mysql.connector пакет.
Создайте объект подключения, используя mysql.connector.connect() , передав ему имя пользователя, пароль, хост (необязательно по умолчанию: localhost) и базу данных (необязательно) в качестве параметров.
Создайте объект курсора, вызвав cursor() метод для объекта подключения, созданного выше
Затем выполните INSERT оператор, передав его как параметр в execute() метод.

пример

В следующем примере выполняется инструкция SQL INSERT для вставки записи в таблицу EMPLOYEE:

import mysql.connector

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

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

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

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

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

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

# Closing the connection
conn.close()

Вставка значений динамически

Вы также можете использовать «% s» вместо значений в INSERT запрос MySQL и передать им значения в виде списков, как показано ниже -

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

пример

В следующем примере запись динамически вставляется в таблицу сотрудников.

import mysql.connector

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

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

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

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

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

print("Data inserted")

# Closing the connection
conn.close()

Вывод

Data inserted

Вы можете извлекать / извлекать данные из таблицы в MySQL, используя запрос SELECT. Этот запрос / инструкция возвращает содержимое указанной таблицы в табличной форме и вызывается как набор результатов.

Синтаксис

Ниже приведен синтаксис запроса SELECT -

SELECT column1, column2, columnN FROM table_name;

пример

Предположим, мы создали таблицу в MySQL с именем cricketers_data как -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующий запрос извлекает значения FIRST_NAME и Country из таблицы.

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

Вы также можете получить все значения каждой записи, используя * instated имени столбца как -

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

Чтение данных из таблицы MYSQL с использованием Python

READ Операция с любой базой данных означает получение некоторой полезной информации из базы данных. Вы можете получить данные из MYSQL, используяfetch() метод, предоставляемый mysql-connector-python.

Класс cursor.MySQLCursor предоставляет три метода, а именно:fetchall(), fetchmany() и, fetchone() где,

В fetchall()Метод извлекает все строки в результирующем наборе запроса и возвращает их как список кортежей. (Если мы выполним это после получения нескольких строк, он вернет оставшиеся).
В fetchone() Метод выбирает следующую строку в результате запроса и возвращает ее как кортеж.
В fetchmany() похож на fetchone (), но он извлекает следующий набор строк в результирующем наборе запроса вместо одной строки.

Note - Набор результатов - это объект, который возвращается, когда объект курсора используется для запроса таблицы.

rowcount - Это атрибут только для чтения и возвращает количество строк, на которые повлиял метод execute ().

пример

В следующем примере извлекаются все строки таблицы EMPLOYEE с помощью запроса SELECT, и из полученного набора результатов сначала мы извлекаем первую строку с помощью метода fetchone (), а затем извлекаем оставшиеся строки с помощью метода fetchall ().

import mysql.connector

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

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

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

#Executing the query
cursor.execute(sql)

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

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

#Closing the connection
conn.close()

Вывод

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

В следующем примере извлекаются первые две строки таблицы EMPLOYEE с помощью метода fetchmany ().

пример

import mysql.connector

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

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Вывод

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

Если вы хотите получить, удалить или обновить определенные строки таблицы в MySQL, вам необходимо использовать предложение where, чтобы указать условие для фильтрации строк таблицы для операции.

Например, если у вас есть оператор SELECT с предложением where, будут извлечены только те строки, которые удовлетворяют указанному условию.

Синтаксис

Ниже приводится синтаксис предложения WHERE -

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

пример

Предположим, мы создали таблицу в MySQL с именем EMPLOYEES как -

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

И если мы вставили в него 4 записи, используя инструкции INSERT как -

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

Следующий оператор MySQL извлекает записи сотрудников, чей доход превышает 4000.

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

Предложение WHERE с использованием Python

Чтобы получить определенные записи из таблицы с помощью программы python -

импорт mysql.connector пакет.
Создайте объект подключения, используя mysql.connector.connect() , передав ему имя пользователя, пароль, хост (необязательно по умолчанию: localhost) и базу данных (необязательно) в качестве параметров.
Создайте объект курсора, вызвав cursor() в созданном выше объекте подключения.
Затем выполните оператор SELECT с предложением WHERE , передав его в качестве параметра вexecute() метод.

пример

В следующем примере создается таблица с именем Employee и заполняется ее. Затем, используя предложение where, он извлекает записи со значением возраста менее 23.

import mysql.connector

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

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

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

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

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

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

#Closing the connection
conn.close()

Вывод

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

При получении данных с помощью запроса SELECT вы можете отсортировать результаты в желаемом порядке (по возрастанию или по убыванию) с помощью предложения OrderBy. По умолчанию это предложение сортирует результаты в порядке возрастания, если вам нужно расположить их в порядке убывания, вам нужно явно использовать «DESC».

Синтаксис

Ниже приведен синтаксис SELECT column-list.

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

пример

Предположим, мы создали таблицу в MySQL с именем EMPLOYEES как -

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

И если мы вставили в него 4 записи, используя инструкции INSERT как -

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

Следующий оператор извлекает содержимое таблицы EMPLOYEE в порядке возрастания возраста.

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

Вы также можете получать данные в порядке убывания, используя DESC как -

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

Предложение ORDER BY с использованием Python

Чтобы получить содержимое таблицы в определенном порядке, вызовите execute() для объекта курсора и передайте оператор SELECT вместе с предложением ORDER BY в качестве параметра для него.

пример

В следующем примере мы создаем таблицу с именем и сотрудником, заполняем ее и получаем ее записи в порядке возрастания (возрастания), используя предложение ORDER BY.

import mysql.connector

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

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

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

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

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

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

#Closing the connection
conn.close()

Вывод

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

Таким же образом вы можете получить данные из таблицы в порядке убывания с помощью предложения ORDER BY.

пример

import mysql.connector

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

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

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

#Closing the connection
conn.close()

Вывод

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

UPDATE Операция в любой базе данных обновляет одну или несколько записей, которые уже доступны в базе данных. Вы можете обновить значения существующих записей в MySQL с помощью оператора UPDATE. Чтобы обновить определенные строки, вам необходимо использовать предложение WHERE вместе с ним.

Синтаксис

Ниже приведен синтаксис оператора UPDATE в MySQL:

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

Вы можете объединить N условий, используя операторы И или ИЛИ.

пример

Предположим, мы создали таблицу в MySQL с именем EMPLOYEES как -

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

И если мы вставили в него 4 записи, используя инструкции INSERT как -

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

Следующее утверждение MySQL увеличивает возраст всех сотрудников-мужчин на один год -

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

Если вы извлечете содержимое таблицы, вы можете увидеть обновленные значения как -

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

Обновление содержимого таблицы с помощью Python

Чтобы обновить записи в таблице в MySQL с помощью python -

импорт mysql.connector пакет.
Создайте объект подключения, используя mysql.connector.connect() , передав ему имя пользователя, пароль, хост (необязательно по умолчанию: localhost) и базу данных (необязательно) в качестве параметров.
Создайте объект курсора, вызвав cursor() в созданном выше объекте подключения.
Затем выполните оператор UPDATE, передав его в качестве параметра в execute() метод.

пример

В следующем примере возраст всех мужчин увеличивается на один год.

import mysql.connector

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

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

#Preparing the query to update the records
sql = '''UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M' '''
try:
   # Execute the SQL command
   cursor.execute(sql)
   
   # Commit your changes in the database
   conn.commit()
except:
   # Rollback in case there is any error
   conn.rollback()
   
#Retrieving data
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Вывод

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

Чтобы удалить записи из таблицы MySQL, вам необходимо использовать DELETE FROMзаявление. Чтобы удалить определенные записи, вам необходимо использовать предложение WHERE вместе с ним.

Синтаксис

Ниже приведен синтаксис запроса DELETE в MYSQL:

DELETE FROM table_name [WHERE Clause]

пример

Предположим, мы создали таблицу в MySQL с именем EMPLOYEES как -

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

И если мы вставили в него 4 записи, используя инструкции INSERT как -

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

Следующий оператор MySQL удаляет запись о сотруднике с FIRST_NAME «Mac».

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

Если вы получите содержимое таблицы, вы увидите только 3 записи, так как мы удалили одну.

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

Если вы выполните оператор DELETE без предложения WHERE, все записи из указанной таблицы будут удалены.

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

Если вы получите содержимое таблицы, вы получите пустой набор, как показано ниже -

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

Удаление записей таблицы с помощью Python

Операция DELETE требуется, если вы хотите удалить некоторые записи из своей базы данных.

Чтобы удалить записи в таблице -

импорт mysql.connector пакет.
Создайте объект подключения, используя mysql.connector.connect() , передав ему имя пользователя, пароль, хост (необязательно по умолчанию: localhost) и базу данных (необязательно) в качестве параметров.
Создайте объект курсора, вызвав cursor() в созданном выше объекте подключения.
Затем выполните DELETE оператор, передав его как параметр в execute() метод.

пример

Следующая программа удаляет все записи из СОТРУДНИКА, возраст которого превышает 20 -

import mysql.connector

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

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

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

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

try:
   # Execute the SQL command
   cursor.execute(sql)
   
   # Commit your changes in the database
   conn.commit()
except:
   # Roll back in case there is any error
   conn.rollback()

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

#Closing the connection
conn.close()

Вывод

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

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

Вы можете удалить всю таблицу, используя DROP TABLEзаявление. Вам просто нужно указать имя таблицы, которую нужно удалить.

Синтаксис

Ниже приведен синтаксис оператора DROP TABLE в MySQL:

DROP TABLE table_name;

пример

Перед удалением таблицы получите список таблиц с помощью оператора SHOW TABLES следующим образом:

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

Следующий оператор полностью удаляет таблицу с именем sample из базы данных:

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

Поскольку мы удалили таблицу с именем sample из MySQL, если вы снова получите список таблиц, вы не найдете в нем образец имени таблицы.

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

Удаление таблицы с помощью Python

Вы можете удалить таблицу, когда вам нужно, используя оператор DROP в MYSQL, но вам нужно быть очень осторожным при удалении любой существующей таблицы, потому что потерянные данные не будут восстановлены после удаления таблицы.

Чтобы удалить таблицу из базы данных MYSQL с помощью python, вызовите execute() для объекта курсора и передайте ему оператор drop в качестве параметра.

пример

Следующая таблица удаляет из базы данных таблицу с именем EMPLOYEE.

import mysql.connector

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

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

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

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

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

#Closing the connection conn.close()

Вывод

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

Удалить таблицу, только если она существует

Если вы попытаетесь удалить таблицу, которой нет в базе данных, возникает ошибка:

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

Вы можете предотвратить эту ошибку, проверив, существует ли таблица перед удалением, добавив IF EXISTS в оператор 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()

Вывод

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

При извлечении записей, если вы хотите ограничить их определенным числом, вы можете сделать это, используя предложение LIMIT в MYSQL.

пример

Предположим, мы создали таблицу в MySQL с именем EMPLOYEES как -

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

И если мы вставили в него 4 записи, используя инструкции INSERT как -

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

Следующий оператор SQL извлекает первые две записи таблицы Employee с помощью предложения 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)

Предложение Limit с использованием Python

Если вы вызовете execute() для объекта курсора, передав запрос SELECT вместе с предложением LIMIT, вы можете получить необходимое количество записей.

пример

В следующем примере Python создается и заполняется таблица с именем EMPLOYEE, и с помощью предложения 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'''

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Вывод

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

LIMIT со смещением

Если вам нужно ограничить записи, начиная с n-й записи (а не с 1- ^й ), вы можете сделать это, используя OFFSET вместе с 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()

Вывод

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

Когда вы разделили данные на две таблицы, вы можете получить объединенные записи из этих двух таблиц с помощью объединений.

пример

Предположим, мы создали таблицу с именем EMPLOYEE и заполнили ее данными, как показано ниже -

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

Затем, если мы создали другую таблицу и заполнили ее как -

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

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

Следующий оператор извлекает данные, объединяющие значения в этих двух таблицах -

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 с использованием Python

В следующем примере извлекаются данные из двух вышеупомянутых таблиц, объединенных по столбцу контактов таблицы EMPLOYEE и столбцу ID таблицы 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()

Вывод

[('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 (и подобных библиотек) используется для выполнения операторов для связи с базой данных MySQL.

Используя его методы, вы можете выполнять операторы SQL, извлекать данные из наборов результатов, вызывать процедуры.

Вы можете создать Cursor объект, используя метод cursor () объекта / класса Connection.

пример

import mysql.connector

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

Методы

Ниже приведены различные методы, предоставляемые классом / объектом Cursor.

Старший Нет	Метод и описание
1	callproc() Этот метод используется для вызова существующих процедур базы данных MySQL.
2	close() Этот метод используется для закрытия текущего объекта курсора.
3	Info() Этот метод дает информацию о последнем запросе.
4	executemany() Этот метод принимает серию списков параметров list. Подготавливает запрос MySQL и выполняет его со всеми параметрами.
5	execute() Этот метод принимает запрос MySQL в качестве параметра и выполняет данный запрос.
6	fetchall() Этот метод извлекает все строки в результирующем наборе запроса и возвращает их в виде списка кортежей. (Если мы выполним это после получения нескольких строк, он вернет оставшиеся)
7	fetchone() Этот метод выбирает следующую строку в результате запроса и возвращает ее как кортеж.
8	fetchmany() Этот метод похож на fetchone (), но он извлекает следующий набор строк в результирующем наборе запроса вместо одной строки.
9	etchwarnings() Этот метод возвращает предупреждения, сгенерированные последним выполненным запросом.

Свойства

Ниже приведены свойства класса Cursor -

Старший Нет	Описание недвижимости
1	column_names Это свойство только для чтения, которое возвращает список, содержащий имена столбцов набора результатов.
2	description Это свойство только для чтения, которое возвращает список, содержащий описание столбцов в наборе результатов.
3	lastrowid Это свойство доступно только для чтения. Если в таблице есть какие-либо автоматически увеличивающиеся столбцы, возвращается значение, сгенерированное для этого столбца в последней операции INSERT или UPDATE.
4	rowcount Это возвращает количество возвращенных / обновленных строк в случае операций SELECT и UPDATE.
5	statement Это свойство возвращает последний выполненный оператор.

Установка

PostgreSQL - это мощная объектно-реляционная база данных с открытым исходным кодом. У него более 15 лет активной фазы разработки и проверенная архитектура, которая заработала прочную репутацию за надежность, целостность и корректность данных.

Чтобы общаться с PostgreSQL с помощью Python, вам необходимо установить psycopg, адаптер для программирования на Python, текущая версия которого psycog2.

psycopg2 был написан с целью сделать его очень маленьким, быстрым и стабильным, как скала. Он доступен в PIP (диспетчер пакетов Python)

Установка Psycog2 с помощью PIP

Прежде всего, убедитесь, что в вашей системе правильно установлены python и PIP, а PIP обновлен.

Чтобы обновить PIP, откройте командную строку и выполните следующую команду -

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

Затем откройте командную строку в режиме администратора и выполните команду pip install psycopg2-binary команда, как показано ниже -

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

Проверка

Чтобы проверить установку, создайте образец скрипта python со следующей строкой в нем.

import mysql.connector

Если установка прошла успешно, при ее выполнении вы не должны получить никаких ошибок -

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

PostgreSQL предоставляет собственную оболочку для выполнения запросов. Чтобы установить соединение с базой данных PostgreSQL, убедитесь, что вы правильно установили его в своей системе. Откройте приглашение оболочки PostgreSQL и передайте такие сведения, как сервер, база данных, имя пользователя и пароль. Если все указанные вами данные подходят, устанавливается соединение с базой данных PostgreSQL.

При передаче сведений вы можете указать сервер, базу данных, порт и имя пользователя по умолчанию, предложенные оболочкой.

Установление соединения с использованием Python

Класс подключения psycopg2представляет / обрабатывает экземпляр соединения. Вы можете создавать новые подключения, используяconnect()функция. Он принимает основные параметры подключения, такие как имя базы данных, пользователь, пароль, хост, порт, и возвращает объект подключения. Используя эту функцию, вы можете установить соединение с PostgreSQL.

пример

Следующий код Python показывает, как подключиться к существующей базе данных. Если база данных не существует, она будет создана и, наконец, будет возвращен объект базы данных. Имя базы данных PostgreSQL по умолчанию - postrgre . Поэтому мы указываем его как имя базы данных.

import psycopg2

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

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

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

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

Вывод

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

Вы можете создать базу данных в PostgreSQL с помощью оператора CREATE DATABASE. Вы можете выполнить этот оператор в приглашении оболочки PostgreSQL, указав имя создаваемой базы данных после команды.

Синтаксис

Ниже приводится синтаксис оператора CREATE DATABASE.

CREATE DATABASE dbname;

пример

Следующий оператор создает базу данных с именем testdb в PostgreSQL.

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

Вы можете просмотреть базу данных в PostgreSQL с помощью команды \ l. Если вы проверите список баз данных, вы можете найти вновь созданную базу данных следующим образом:

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)

Вы также можете создать базу данных в PostgreSQL из командной строки, используя команду createdb , оболочку для оператора SQL CREATE DATABASE.

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

Создание базы данных с использованием Python

Класс курсора psycopg2 предоставляет различные методы для выполнения различных команд PostgreSQL, выборки записей и копирования данных. Вы можете создать объект курсора, используя метод cursor () класса Connection.

Метод execute () этого класса принимает запрос PostgreSQL в качестве параметра и выполняет его.

Поэтому, чтобы создать базу данных в PostgreSQL, выполните запрос CREATE DATABASE, используя этот метод.

пример

В следующем примере Python создается база данных с именем mydb в базе данных 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()

Вывод

Database created successfully........

Вы можете создать новую таблицу в базе данных PostgreSQL с помощью оператора CREATE TABLE. При этом вам необходимо указать имя таблицы, имена столбцов и их типы данных.

Синтаксис

Ниже приводится синтаксис оператора CREATE TABLE в PostgreSQL.

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

пример

В следующем примере создается таблица с именем CRICKETERS в 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=#

Вы можете получить список таблиц в базе данных в PostgreSQL, используя команду \ dt. После создания таблицы, если вы можете проверить список таблиц, вы можете увидеть в нем вновь созданную таблицу следующим образом:

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

Таким же образом вы можете получить описание созданной таблицы, используя \ d, как показано ниже -

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

Создание таблицы с использованием Python

Чтобы создать таблицу с использованием python, вам необходимо выполнить оператор CREATE TABLE, используя метод execute () курсора pyscopg2 .

пример

В следующем примере Python создается таблица с именем employee.

import psycopg2

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

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

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

#Closing the connection
conn.close()

Вывод

Table created successfully........

Вы можете вставить запись в существующую таблицу в PostgreSQL, используя INSERT INTOзаявление. Выполняя это, вам необходимо указать имя таблицы и значения для столбцов в ней.

Синтаксис

Ниже приведен рекомендуемый синтаксис оператора INSERT:

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

Где, column1, column2, column3, .. - это имена столбцов таблицы, а value1, value2, value3, ... - значения, которые вам нужно вставить в таблицу.

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя оператор CREATE TABLE, как показано ниже -

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

Следующий оператор PostgreSQL вставляет строку в созданную выше таблицу -

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

При вставке записей с помощью оператора INSERT INTO , если вы пропустите имена столбцов, запись будет вставлена, оставляя пустые места в столбцах, которые вы пропустили.

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

Вы также можете вставлять записи в таблицу без указания имен столбцов, если порядок передаваемых значений совпадает с их соответствующими именами столбцов в таблице.

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

После вставки записей в таблицу вы можете проверить ее содержимое с помощью оператора SELECT, как показано ниже -

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

Вставка данных с использованием Python

Класс курсора psycopg2 предоставляет метод с именем execute () method. Этот метод принимает запрос в качестве параметра и выполняет его.

Поэтому для вставки данных в таблицу в PostgreSQL с помощью python -

импорт psycopg2 пакет.
Создайте объект подключения, используя connect() , передав ему имя пользователя, пароль, хост (необязательно по умолчанию: localhost) и базу данных (необязательно) в качестве параметров.
Отключите режим автоматической фиксации, установив false в качестве значения атрибута autocommit.
В cursor() метод ConnectionКласс библиотеки psycopg2 возвращает объект курсора. Создайте объект курсора, используя этот метод.
Затем выполните оператор INSERT, передав его / их в качестве параметра методу execute ().

пример

Следующая программа Python создает таблицу с именем EMPLOYEE в базе данных PostgreSQL и вставляет в нее записи с помощью метода execute () -

import psycopg2

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

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

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

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

# Closing the connection
conn.close()

Вывод

Records inserted........

Вы можете получить содержимое существующей таблицы в PostgreSQL с помощью оператора SELECT. В этом операторе вам необходимо указать имя таблицы, и она вернет ее содержимое в табличном формате, который известен как набор результатов.

Синтаксис

Ниже приводится синтаксис оператора SELECT в PostgreSQL:

SELECT column1, column2, columnN FROM table_name;

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующий запрос SELECT извлекает значения столбцов FIRST_NAME, LAST_NAME и COUNTRY из таблицы CRICKETERS.

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

Если вы хотите получить все столбцы каждой записи, вам необходимо заменить имена столбцов на «*», как показано ниже -

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

Получение данных с помощью Python

READ Операция с любой базой данных означает получение некоторой полезной информации из базы данных. Вы можете получить данные из PostgreSQL, используя метод fetch (), предоставляемый psycopg2.

Класс Cursor предоставляет три метода, а именно fetchall (), fetchmany () и fetchone (), где:

Метод fetchall () извлекает все строки в наборе результатов запроса и возвращает их как список кортежей. (Если мы выполним это после получения нескольких строк, он вернет оставшиеся).
Метод fetchone () выбирает следующую строку в результате запроса и возвращает ее как кортеж.
Метод fetchmany () похож на метод fetchone (), но он извлекает следующий набор строк в результирующем наборе запроса вместо одной строки.

пример

Следующая программа Python подключается к базе данных с именем mydb из PostgreSQL и извлекает все записи из таблицы с именем EMPLOYEE.

import psycopg2

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

#Setting auto commit false
conn.autocommit = True

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

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

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

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

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

#Closing the connection
conn.close()

Вывод

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

При выполнении операций SELECT, UPDATE или DELETE вы можете указать условие для фильтрации записей с помощью предложения WHERE. Операция будет выполнена с записями, удовлетворяющими заданному условию.

Синтаксис

Ниже приведен синтаксис предложения WHERE в PostgreSQL:

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

Вы можете указать условие поиска, используя сравнение или логические операторы. как>, <, =, LIKE, NOT и т. д. Следующие примеры поясняют эту концепцию.

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующий оператор SELECT извлекает записи, возраст которых превышает 35 -

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

Предложение where с использованием Python

Чтобы получить определенные записи из таблицы с помощью программы python, выполните оператор SELECT с предложением WHERE, передав его в качестве параметра в execute() метод.

пример

Следующий пример python демонстрирует использование команды WHERE с использованием 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()

Вывод

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

Обычно, если вы пытаетесь получить данные из таблицы, вы получаете записи в том же порядке, в котором вы их вставляли.

Используя ORDER BY предложения, при извлечении записей таблицы вы можете отсортировать результирующие записи в порядке возрастания или убывания в зависимости от нужного столбца.

Синтаксис

Ниже приводится синтаксис предложения ORDER BY в PostgreSQL.

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

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующий оператор SELECT извлекает строки таблицы CRICKETERS в порядке возрастания их возраста -

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

Вы можете использовать более одного столбца для сортировки записей таблицы. Следующие операторы SELECT сортируют записи таблицы CRICKETERS на основе возраста столбцов и 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)

По умолчанию ORDER BYПредложение сортирует записи таблицы в порядке возрастания. Вы можете расположить результаты в порядке убывания, используя DESC как -

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

Предложение ORDER BY с использованием Python

Чтобы получить содержимое таблицы в определенном порядке, вызовите метод execute () для объекта курсора и передайте оператор SELECT вместе с предложением ORDER BY в качестве параметра для него.

пример

В следующем примере мы создаем таблицу с именем и сотрудником, заполняем ее и получаем записи в порядке возрастания (возрастания) с помощью предложения ORDER BY.

import psycopg2

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

#Setting auto commit false
conn.autocommit = True

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

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

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

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

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

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

#Closing the connection
conn.close()

Вывод

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

Вы можете изменить содержимое существующих записей таблицы в PostgreSQL с помощью оператора UPDATE. Чтобы обновить определенные строки, вам необходимо использовать предложение WHERE вместе с ним.

Синтаксис

Ниже приводится синтаксис оператора UPDATE в PostgreSQL:

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

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующее утверждение изменяет возраст игрока в крикет, имя которого Shikhar -

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

Если вы извлечете запись, в которой ПЕРВОЕ ИМЯ - Шихар, вы заметите, что значение возраста было изменено на 45 -

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

Если вы не использовали предложение WHERE, значения всех записей будут обновлены. После оператора UPDATE возраст всех записей в таблице CRICKETERS увеличивается на 1 -

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

Если вы извлекаете содержимое таблицы с помощью команды SELECT, вы можете увидеть обновленные значения как -

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

Обновление записей с помощью Python

Поэтому для вставки данных в таблицу в PostgreSQL с помощью python -

импорт psycopg2 пакет.
Создайте объект подключения, используя connect() , передав ему имя пользователя, пароль, хост (необязательно по умолчанию: localhost) и базу данных (необязательно) в качестве параметров.
Отключите режим автоматической фиксации, установив false в качестве значения атрибута autocommit.
В cursor() метод ConnectionКласс библиотеки psycopg2 возвращает объект курсора. Создайте объект курсора, используя этот метод.
Затем выполните оператор UPDATE, передав его в качестве параметра методу execute ().

пример

Следующий код Python обновляет содержимое таблицы Employee и извлекает результаты -

import psycopg2

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

#Setting auto commit false
conn.autocommit = True

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

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

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

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

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

#Closing the connection
conn.close()

Вывод

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

Вы можете удалить записи в существующей таблице, используя DELETE FROMвыписка из базы данных PostgreSQL. Чтобы удалить определенные записи, вам необходимо использовать предложение WHERE вместе с ним.

Синтаксис

Ниже приведен синтаксис запроса DELETE в PostgreSQL:

DELETE FROM table_name [WHERE Clause]

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующее утверждение удаляет запись игрока в крикет по фамилии «Сангаккара». -

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

Если вы получите содержимое таблицы с помощью оператора SELECT, вы увидите только 4 записи, так как мы удалили одну.

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

Если вы выполните оператор DELETE FROM без предложения WHERE, все записи из указанной таблицы будут удалены.

postgres=# DELETE FROM CRICKETERS;
DELETE 4

Поскольку вы удалили все записи, если вы попытаетесь получить содержимое таблицы CRICKETERS, используя оператор SELECT, вы получите пустой набор результатов, как показано ниже -

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

Удаление данных с помощью Python

Поэтому для вставки данных в таблицу в PostgreSQL с помощью python -

импорт psycopg2 пакет.
Создайте объект подключения, используя connect() , передав ему имя пользователя, пароль, хост (необязательно по умолчанию: localhost) и базу данных (необязательно) в качестве параметров.
Отключите режим автоматической фиксации, установив false в качестве значения атрибута autocommit.
В cursor()Метод класса Connection библиотеки psycopg2 возвращает объект курсора. Создайте объект курсора, используя этот метод.
Затем выполните оператор UPDATE, передав его в качестве параметра методу execute ().

пример

Следующий код Python удаляет записи таблицы EMPLOYEE со значениями возраста более 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()

Вывод

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

Вы можете удалить таблицу из базы данных PostgreSQL с помощью оператора DROP TABLE.

Синтаксис

Ниже приводится синтаксис оператора DROP TABLE в PostgreSQL:

DROP TABLE table_name;

пример

Предположим, мы создали две таблицы с именами CRICKETERS и EMPLOYEES, используя следующие запросы:

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

Теперь, если вы проверите список таблиц с помощью команды «\ dt», вы можете увидеть созданные выше таблицы как -

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

Следующий оператор удаляет таблицу с именем Employee из базы данных -

postgres=# DROP table employee;
DROP TABLE

Поскольку вы удалили таблицу Employee, если вы снова получите список таблиц, вы увидите в нем только одну таблицу.

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

Если вы снова попытаетесь удалить таблицу сотрудников, поскольку вы уже удалили ее, вы получите сообщение об ошибке «таблица не существует», как показано ниже -

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

Чтобы решить эту проблему, вы можете использовать предложение IF EXISTS вместе с оператором DELTE. Это удаляет таблицу, если она существует, иначе пропускает операцию DLETE.

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

Удаление всей таблицы с помощью Python

Вы можете удалить таблицу в любое время, используя оператор DROP. Но вы должны быть очень осторожны при удалении любой существующей таблицы, потому что потерянные данные не будут восстановлены после удаления таблицы.

import psycopg2

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

#Setting auto commit false
conn.autocommit = True

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

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

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

#Closing the connection
conn.close()

Вывод

#Table dropped...

При выполнении оператора SELECT PostgreSQL вы можете ограничить количество записей в его результате с помощью предложения LIMIT.

Синтаксис

Ниже приведен синтаксис предложения LMIT в PostgreSQL:

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

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующий оператор извлекает первые 3 записи таблицы Cricketers с помощью предложения 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)

Если вы хотите получить записи, начиная с определенной записи (смещения), вы можете сделать это, используя предложение OFFSET вместе с 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=#

Предложение Limit с использованием Python

Следующий пример python извлекает содержимое таблицы с именем EMPLOYEE, ограничивая количество записей в результате до 2 -

пример

import psycopg2

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

#Setting auto commit false
conn.autocommit = True

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

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

#Executing the query
cursor.execute(sql)

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

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

#Closing the connection
conn.close()

Вывод

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

пример

Предположим, мы создали таблицу с именем CRICKETERS и вставили в нее 5 записей, как показано ниже -

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

И, если мы создали другую таблицу с именем OdiStats и вставили в нее 5 записей как -

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

Следующий оператор извлекает данные, объединяющие значения в этих двух таблицах -

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

Присоединяется с использованием Python

пример

Следующая программа на Python демонстрирует использование предложения JOIN -

import psycopg2

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

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

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

#Executing the query
cursor.execute(sql)

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

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

#Closing the connection
conn.close()

Вывод

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

Класс Cursor библиотеки psycopg предоставляет методы для выполнения команд PostgreSQL в базе данных с использованием кода Python.

Вы можете создать Cursor объект, используя метод cursor () объекта / класса Connection.

пример

import psycopg2

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

#Setting auto commit false
conn.autocommit = True

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

Методы

Ниже приведены различные методы, предоставляемые классом / объектом Cursor.

Старший Нет	Метод и описание
1	callproc() Этот метод используется для вызова существующих процедур базы данных PostgreSQL.
2	close() Этот метод используется для закрытия текущего объекта курсора.
3	executemany() Этот метод принимает серию списков параметров list. Подготавливает запрос MySQL и выполняет его со всеми параметрами.
4	execute() Этот метод принимает запрос MySQL в качестве параметра и выполняет данный запрос.
5	fetchall() Этот метод извлекает все строки в результирующем наборе запроса и возвращает их в виде списка кортежей. (Если мы выполним это после получения нескольких строк, он вернет оставшиеся)
6	fetchone() Этот метод выбирает следующую строку в результате запроса и возвращает ее как кортеж.
7	fetchmany() Этот метод похож на fetchone (), но он извлекает следующий набор строк в результирующем наборе запроса вместо одной строки.

Свойства

Ниже приведены свойства класса Cursor -

Старший Нет	Описание недвижимости
1	description Это свойство только для чтения, которое возвращает список, содержащий описание столбцов в наборе результатов.
2	astrowid Это свойство доступно только для чтения. Если в таблице есть какие-либо автоматически увеличивающиеся столбцы, возвращается значение, сгенерированное для этого столбца в последней операции INSERT или UPDATE.
3	rowcount Это возвращает количество возвращенных / обновленных строк в случае операций SELECT и UPDATE.
4	closed Это свойство указывает, закрыт ли курсор или нет, если да, то возвращает true, иначе false.
5	connection Это возвращает ссылку на объект соединения, с помощью которого был создан этот курсор.
6	name Это свойство возвращает имя курсора.
7	scrollable Это свойство указывает, можно ли прокручивать конкретный курсор.

Установка

SQLite3 может быть интегрирован с Python с помощью модуля sqlite3, написанного Герхардом Харингом. Он предоставляет интерфейс SQL, соответствующий спецификации DB-API 2.0, описанной в PEP 249. Вам не нужно устанавливать этот модуль отдельно, поскольку он поставляется по умолчанию вместе с Python версии 2.5.x и более поздних версий.

Чтобы использовать модуль sqlite3, вы должны сначала создать объект подключения, представляющий базу данных, а затем, при желании, вы можете создать объект курсора, который поможет вам в выполнении всех операторов SQL.

API модуля Python sqlite3

Ниже приведены важные процедуры модуля sqlite3, которые могут удовлетворить ваши требования для работы с базой данных SQLite из вашей программы Python. Если вы ищете более сложное приложение, вы можете заглянуть в официальную документацию модуля Python sqlite3.

Sr.No.	API и описание
1	sqlite3.connect(database [,timeout ,other optional arguments]) Этот API открывает соединение с файлом базы данных SQLite. Вы можете использовать ": memory:", чтобы открыть соединение с базой данных, которая находится в ОЗУ, а не на диске. Если база данных открыта успешно, возвращается объект подключения.
2	connection.cursor([cursorClass]) Эта процедура создает cursorкоторый будет использоваться во всем программировании вашей базы данных с помощью Python. Этот метод принимает единственный необязательный параметр cursorClass. Если указан, это должен быть пользовательский класс курсора, расширяющий sqlite3.Cursor.
3	cursor.execute(sql [, optional parameters]) Эта подпрограмма выполняет инструкцию SQL. Оператор SQL может быть параметризован (т. Е. Заполнители вместо литералов SQL). Модуль sqlite3 поддерживает два типа заполнителей: вопросительные знаки и именованные заполнители (именованный стиль). For example - cursor.execute ("вставить в людей значения (?,?)", (Кто, возраст))
4	connection.execute(sql [, optional parameters]) Эта процедура является сокращением вышеупомянутого метода execute, предоставляемого объектом курсора, и она создает промежуточный объект курсора, вызывая метод курсора, а затем вызывает метод выполнения курсора с заданными параметрами.
5	cursor.executemany(sql, seq_of_parameters) Эта процедура выполняет команду SQL для всех последовательностей параметров или сопоставлений, найденных в последовательности sql.
6	connection.executemany(sql[, parameters]) Эта процедура представляет собой ярлык, который создает промежуточный объект курсора путем вызова метода курсора, а затем вызывает метод cursor.s executemany с заданными параметрами.
7	cursor.executescript(sql_script) Эта процедура одновременно выполняет несколько операторов SQL, представленных в форме сценария. Сначала он выдает оператор COMMIT, а затем выполняет сценарий SQL, который он получает в качестве параметра. Все операторы SQL следует разделять точкой с запятой (;).
8	connection.executescript(sql_script) Эта процедура представляет собой ярлык, который создает промежуточный объект курсора путем вызова метода курсора, а затем вызывает метод курсора executescript с заданными параметрами.
9	connection.total_changes() Эта процедура возвращает общее количество строк базы данных, которые были изменены, вставлены или удалены с момента открытия соединения с базой данных.
10	connection.commit() Этот метод фиксирует текущую транзакцию. Если вы не вызовете этот метод, все, что вы сделали с момента последнего вызова commit (), не будет видно из других подключений к базе данных.
11	connection.rollback() Этот метод откатывает любые изменения в базе данных с момента последнего вызова commit ().
12	connection.close() Этот метод закрывает соединение с базой данных. Обратите внимание, что это не вызывает автоматического вызова commit (). Если вы просто закроете соединение с базой данных без предварительного вызова commit (), ваши изменения будут потеряны!
13	cursor.fetchone() Этот метод выбирает следующую строку набора результатов запроса, возвращая одну последовательность, или None, если больше нет доступных данных.
14	cursor.fetchmany([size = cursor.arraysize]) Эта процедура выбирает следующий набор строк результата запроса, возвращая список. Когда строк больше нет, возвращается пустой список. Метод пытается получить столько строк, сколько указано в параметре размера.
15	cursor.fetchall() Эта процедура извлекает все (оставшиеся) строки результата запроса, возвращая список. Если строк нет, возвращается пустой список.

Чтобы установить соединение с командной строкой SQLite Open, просмотрите место, где вы установили SQLite, и просто выполните команду sqlite3 как показано ниже -

Установление соединения с использованием Python

Вы можете общаться с базой данных SQLite2 с помощью модуля Python SQLite3. Для этого в первую очередь необходимо установить соединение (создать объект соединения).

Чтобы установить соединение с базой данных SQLite3 с помощью Python, вам необходимо:

Импортируйте модуль sqlite3 с помощью оператора импорта.
Метод connect () принимает имя базы данных, к которой необходимо подключиться, в качестве параметра и возвращает объект Connection.

пример

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

Вывод

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

Используя оператор SQLite CREATE TABLE, вы можете создать таблицу в базе данных.

Синтаксис

Ниже приведен синтаксис для создания таблицы в базе данных SQLite.

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

пример

После запроса / оператора SQLite создается таблица с именем CRICKETERS в базе данных SQLite -

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

Создадим еще одну таблицу OdiStats, описывающую однодневную статистику крикета каждого игрока в таблице CRICKETERS.

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

Вы можете получить список таблиц в базе данных в базе данных SQLite, используя .tablesкоманда. После создания таблицы, если вы можете проверить список таблиц, вы можете увидеть в нем вновь созданную таблицу как -

sqlite> . tables
CRICKETERS ODIStats
sqlite>

Создание таблицы с использованием Python

Объект Cursor содержит все методы для выполнения запросов и выборки данных и т. Д. Метод курсора класса соединения возвращает объект курсора.

Поэтому для создания таблицы в базе данных SQLite с помощью python -

Установите соединение с базой данных с помощью метода connect ().
Создайте объект курсора, вызвав метод cursor () для созданного выше объекта подключения.
Теперь выполните оператор CREATE TABLE, используя метод execute () класса Cursor.

пример

Следующая программа Python создает таблицу с именем Employee в 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()

Вывод

Table created successfully........

Вы можете добавлять новые строки в существующую таблицу SQLite с помощью оператора INSERT INTO. В этом случае вам необходимо указать имя таблицы, имена столбцов и значения (в том же порядке, что и имена столбцов).

Синтаксис

Ниже приведен рекомендуемый синтаксис оператора INSERT:

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

Где, column1, column2, column3, .. - это имена столбцов таблицы, а value1, value2, value3, ... - значения, которые необходимо вставить в таблицу.

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя оператор CREATE TABLE, как показано ниже -

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

Следующий оператор PostgreSQL вставляет строку в созданную выше таблицу.

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

Если при вставке записей с помощью оператора INSERT INTO вы пропустите имена столбцов, эта запись будет вставлена, оставив пустые места в столбцах, которые вы пропустили.

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

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

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

Вставка данных с использованием Python

Чтобы добавить записи в существующую таблицу в базе данных SQLite -

Импортируйте пакет sqlite3.
Создайте объект подключения с помощью метода connect (), передав ему имя базы данных в качестве параметра.
В cursor()Метод возвращает объект курсора, с помощью которого вы можете общаться с SQLite3. Создайте объект курсора, вызвав объект cursor () на (созданном выше) объекте Connection.
Затем вызовите метод execute () для объекта курсора, передав ему оператор INSERT в качестве параметра.

пример

Следующий пример Python вставляет записи в таблицу с именем EMPLOYEE -

import sqlite3

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

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

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

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

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

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

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

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

# Closing the connection
conn.close()

Вывод

Records inserted........

Вы можете получить данные из таблицы SQLite с помощью запроса SELCT. Этот запрос / инструкция возвращает содержимое указанного отношения (таблицы) в табличной форме и вызывается как набор результатов.

Синтаксис

Ниже приводится синтаксис оператора SELECT в SQLite:

SELECT column1, column2, columnN FROM table_name;

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующий запрос SELECT извлекает значения столбцов FIRST_NAME, LAST_NAME и COUNTRY из таблицы CRICKETERS.

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

Как вы заметили, оператор SELECT базы данных SQLite просто возвращает записи указанных таблиц. Чтобы получить форматированный вывод, вам необходимо установитьheader, и mode используя соответствующие команды перед оператором SELECT, как показано ниже -

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

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

В SQLite по умолчанию ширина столбцов составляет 10 значений, превышающих эту ширину (обратите внимание на столбец страны во 2- ^й строке в приведенной выше таблице). Вы можете установить ширину каждого столбца на необходимое значение, используя.width перед извлечением содержимого таблицы, как показано ниже -

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

Получение данных с помощью Python

READ Операция с любой базой данных означает получение некоторой полезной информации из базы данных. Вы можете получить данные из MYSQL, используя метод fetch (), предоставляемый модулем sqlite python.

Класс sqlite3.Cursor предоставляет три метода, а именно fetchall (), fetchmany () и fetchone (), где,

Метод fetchall () извлекает все строки в наборе результатов запроса и возвращает их как список кортежей. (Если мы выполним это после получения нескольких строк, он вернет оставшиеся).
Метод fetchone () выбирает следующую строку в результате запроса и возвращает ее как кортеж.
Метод fetchmany () похож на метод fetchone (), но он извлекает следующий набор строк в результирующем наборе запроса вместо одной строки.

пример

Следующая программа Python показывает, как получать и отображать записи из таблицы COMPANY, созданной в приведенном выше примере.

import sqlite3

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

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

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

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

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

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

#Closing the connection
conn.close()

Вывод

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

Если вы хотите получить, удалить или обновить определенные строки таблицы в SQLite, вам необходимо использовать предложение where, чтобы указать условие для фильтрации строк таблицы для операции.

Синтаксис

Ниже приведен синтаксис предложения WHERE в SQLite:

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

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующий оператор SELECT извлекает записи, возраст которых превышает 35 -

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

Предложение where с использованием Python

Объект / класс Cursor содержит все методы для выполнения запросов, выборки данных и т. Д. Метод курсора класса соединения возвращает объект курсора.

Поэтому для создания таблицы в базе данных SQLite с помощью python -

Установите соединение с базой данных с помощью метода connect ().
Создайте объект курсора, вызвав метод cursor () для созданного выше объекта подключения.
Теперь выполните оператор CREATE TABLE, используя метод execute () класса Cursor.

пример

import sqlite3

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

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

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

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

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

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

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

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

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

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

#Closing the connection
conn.close()

Вывод

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

При получении данных с помощью запроса SELECT вы получите записи в том же порядке, в котором вы их вставили.

Вы можете отсортировать результаты в желаемом порядке (по возрастанию или по убыванию), используя Order Byпункт. По умолчанию это предложение сортирует результаты в порядке возрастания, если вам нужно расположить их в порядке убывания, вам нужно явно использовать «DESC».

Синтаксис

Ниже приводится синтаксис предложения ORDER BY в SQLite.

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

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующий оператор SELECT извлекает строки таблицы CRICKETERS в порядке возрастания их возраста -

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

Вы можете использовать более одного столбца для сортировки записей таблицы. Следующие операторы SELECT сортируют записи таблицы CRICKETERS на основе столбцов AGE и 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>

По умолчанию ORDER BY Предложение сортирует записи таблицы в порядке возрастания, вы можете упорядочить результаты в порядке убывания, используя DESC как -

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

Предложение ORDER BY с использованием 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")

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

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

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

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

#Closing the connection
conn.close()

Вывод

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

UPDATE Операция с любой базой данных подразумевает изменение значений одной или нескольких записей таблицы, которые уже доступны в базе данных. Вы можете обновить значения существующих записей в SQLite с помощью оператора UPDATE.

Чтобы обновить определенные строки, вам необходимо использовать предложение WHERE вместе с ним.

Синтаксис

Ниже приводится синтаксис оператора UPDATE в SQLite:

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

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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

Следующее утверждение изменяет возраст игрока в крикет, имя которого Shikhar -

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

Если вы извлечете запись, в которой ПЕРВОЕ ИМЯ - Шихар, вы заметите, что значение возраста было изменено на 45 -

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

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

Если вы извлекаете содержимое таблицы с помощью команды SELECT, вы можете увидеть обновленные значения как -

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

Обновление существующих записей с помощью Python

Чтобы добавить записи в существующую таблицу в базе данных SQLite -

Импортируйте пакет sqlite3.
Создайте объект подключения с помощью метода connect () , передав ему имя базы данных в качестве параметра.
В cursor()Метод возвращает объект курсора, с помощью которого вы можете общаться с SQLite3. Создайте объект курсора, вызвав объект cursor () на (созданном выше) объекте Connection.
Затем вызовите метод execute () для объекта курсора, передав ему оператор UPDATE в качестве параметра.

пример

Следуя примеру Python, создает таблицу с именем EMPLOYEE, вставляет в нее 5 записей и увеличивает возраст всех сотрудников-мужчин на 1 -

import sqlite3

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

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

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

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

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

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

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

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

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

#Closing the connection
conn.close()

Вывод

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

Чтобы удалить записи из таблицы SQLite, вам необходимо использовать оператор DELETE FROM. Чтобы удалить определенные записи, вам необходимо использовать предложение WHERE вместе с ним.

Чтобы обновить определенные строки, вам необходимо использовать предложение WHERE вместе с ним.

Синтаксис

Ниже приведен синтаксис запроса DELETE в SQLite:

DELETE FROM table_name [WHERE Clause]

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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>

Следующее утверждение удаляет запись игрока в крикет по фамилии «Сангаккара».

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

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>

Если вы выполните оператор DELETE FROM без предложения WHERE, все записи из указанной таблицы будут удалены.

sqlite> DELETE FROM CRICKETERS;
sqlite>

sqlite> SELECT * FROM CRICKETERS;
sqlite>

Удаление данных с помощью Python

Чтобы добавить записи в существующую таблицу в базе данных SQLite -

Импортируйте пакет sqlite3.
Создайте объект подключения с помощью метода connect () , передав ему имя базы данных в качестве параметра.
В cursor()Метод возвращает объект курсора, с помощью которого вы можете общаться с SQLite3. Создайте объект курсора, вызвав объект cursor () на (созданном выше) объекте Connection.
Затем вызовите метод execute () для объекта курсора, передав ему оператор DELETE в качестве параметра.

пример

В следующем примере Python удаляются записи из таблицы EMPLOYEE со значением возраста больше 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()

Вывод

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

Вы можете удалить всю таблицу с помощью оператора DROP TABLE. Вам просто нужно указать имя таблицы, которую нужно удалить.

Синтаксис

Ниже приводится синтаксис оператора DROP TABLE в PostgreSQL:

DROP TABLE table_name;

пример

Предположим, мы создали две таблицы с именами CRICKETERS и EMPLOYEES, используя следующие запросы:

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

Теперь, если вы проверите список таблиц с помощью .tables вы можете увидеть созданные выше таблицы в ней (списке) как -

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

Следующий оператор удаляет таблицу с именем Employee из базы данных -

sqlite> DROP table employee;
sqlite>

sqlite> .tables
CRICKETERS
sqlite>

Если вы снова попытаетесь удалить таблицу сотрудников, поскольку вы уже удалили ее, вы получите сообщение об ошибке «нет такой таблицы», как показано ниже -

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

sqlite> DROP table IF EXISTS employee;
sqlite>

Удаление таблицы с помощью Python

пример

Чтобы удалить таблицу из базы данных SQLite3 с помощью python, вызовите execute() для объекта курсора и передайте ему оператор drop в качестве параметра.

import sqlite3

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

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

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

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

#Closing the connection
conn.close()

Вывод

Table dropped...

При извлечении записей, если вы хотите ограничить их определенным числом, вы можете сделать это с помощью предложения LIMIT SQLite.

Синтаксис

Ниже приведен синтаксис предложения LIMIT в SQLite:

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

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

И если мы вставили в него 5 записей, используя инструкции INSERT как -

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>

Следующий оператор извлекает первые 3 записи таблицы Cricketers с помощью предложения 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>

Если вам нужно ограничить записи, начиная с n-й записи (не с 1-й), вы можете сделать это, используя OFFSET вместе с LIMIT.

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

Предложение LIMIT с использованием Python

Если вы вызываете метод execute () для объекта курсора, передавая запрос SELECT вместе с предложением LIMIT, вы можете получить необходимое количество записей.

пример

Следующий пример python извлекает первые две записи таблицы EMPLOYEE с помощью предложения 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()

Вывод

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

пример

Предположим, мы создали таблицу с именем CRICKETERS, используя следующий запрос -

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

Создадим еще одну таблицу OdiStats, описывающую однодневную статистику крикета каждого игрока в таблице CRICKETERS.

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

Следующий оператор извлекает данные, объединяющие значения в этих двух таблицах -

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>

Предложение Join с использованием Python

Следуя примеру SQLite, демонстрирует предложение JOIN с использованием 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()

Вывод

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

Класс sqlite3.Cursor - это экземпляр, с помощью которого вы можете вызывать методы, выполняющие операторы SQLite, извлекать данные из наборов результатов запросов. Вы можете создатьCursor объект, используя метод cursor () объекта / класса Connection.

пример

import sqlite3

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

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

Методы

Ниже приведены различные методы, предоставляемые классом / объектом Cursor.

Старший Нет	Метод и описание
1	execute() Эта подпрограмма выполняет инструкцию SQL. Оператор SQL может быть параметризован (т. Е. Заполнителями вместо литералов SQL). Модуль psycopg2 поддерживает заполнитель с использованием знака% s Например: cursor.execute («вставить в людей значения (% s,% s)», (кто, возраст))
2	executemany() Эта процедура выполняет команду SQL для всех последовательностей параметров или сопоставлений, найденных в последовательности sql.
3	fetchone() Этот метод выбирает следующую строку набора результатов запроса, возвращая одну последовательность, или None, если больше нет доступных данных.
4	fetchmany() Эта процедура выбирает следующий набор строк результата запроса, возвращая список. Когда строк больше нет, возвращается пустой список. Метод пытается получить столько строк, сколько указано в параметре размера.
5	fetchall() Эта процедура извлекает все (оставшиеся) строки результата запроса, возвращая список. Если строк нет, возвращается пустой список.

Свойства

Ниже приведены свойства класса Cursor -

Старший Нет	Метод и описание
1	arraySize Это свойство чтения / записи, вы можете установить количество строк, возвращаемых методом fetchmany ().
2	description Это свойство только для чтения, которое возвращает список, содержащий описание столбцов в наборе результатов.
3	lastrowid Это свойство доступно только для чтения. Если в таблице есть какие-либо автоматически увеличивающиеся столбцы, возвращается значение, сгенерированное для этого столбца в последней операции INSERT или UPDATE.
4	rowcount Это возвращает количество возвращенных / обновленных строк в случае операций SELECT и UPDATE.
5	connection Этот доступный только для чтения атрибут обеспечивает соединение с базой данных SQLite, используемое объектом Cursor.

Pymongo - это дистрибутив python, который предоставляет инструменты для работы с MongoDB, это наиболее предпочтительный способ связи с базой данных MongoDB из python.

Установка

Чтобы установить pymongo, прежде всего убедитесь, что вы правильно установили python3 (вместе с PIP) и MongoDB. Затем выполните следующую команду.

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

Проверка

После того, как вы установили pymongo, откройте новый текстовый документ, вставьте в него следующую строку и сохраните как test.py.

import pymongo

Если вы правильно установили pymongo, если вы запустите test.py, как показано ниже, у вас не должно возникнуть никаких проблем.

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

В отличие от других баз данных, MongoDB не предоставляет отдельной команды для создания базы данных.

Как правило, команда use используется для выбора / переключения на конкретную базу данных. Эта команда сначала проверяет, существует ли указанная нами база данных, и если да, то подключается к ней. Если база данных, которую мы указываем с помощью команды use, не существует, будет создана новая база данных.

Следовательно, вы можете создать базу данных в MongoDB, используя Use команда.

Синтаксис

Базовый синтаксис use DATABASE заявление выглядит следующим образом -

use DATABASE_NAME

пример

Следующая команда создает базу данных с именем mydb.

>use mydb
switched to db mydb

Вы можете проверить свое создание с помощью команды db, она отображает текущую базу данных.

>db
mydb

Создание базы данных с использованием Python

Чтобы подключиться к MongoDB с помощью pymongo, вам необходимо импортировать и создать MongoClient, после чего вы можете напрямую получить доступ к базе данных, которую необходимо создать, в атрибуте passion.

пример

В следующем примере создается база данных в MangoDB.

from pymongo import MongoClient

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

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

#Verification
print("List of databases after creating new one")
print(client.list_database_names())

Вывод

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

Вы также можете указать имена порта и хоста при создании MongoClient и получить доступ к базам данных в стиле словаря.

пример

from pymongo import MongoClient

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

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

Вывод

Database created........

Коллекция в MongoDB содержит набор документов, она аналогична таблице в реляционных базах данных.

Вы можете создать коллекцию, используя createCollection()метод. Этот метод принимает значение String, представляющее имя создаваемой коллекции, и параметр options (необязательный).

Используя это, вы можете указать следующее -

Размер коллекции.
Максимальное количество документов, разрешенное в закрытой коллекции.
Должна ли создаваемая коллекция быть закрытой (коллекция фиксированного размера).
Должна ли создаваемая нами коллекция индексироваться автоматически.

Синтаксис

Ниже приведен синтаксис для создания коллекции в MongoDB.

db.createCollection("CollectionName")

пример

Следующий метод создает коллекцию с именем ExampleCollection.

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

Точно так же ниже представлен запрос, который создает коллекцию с использованием параметров метода createCollection ().

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

Создание коллекции с использованием Python

Следующий пример python подключается к базе данных в MongoDB (mydb) и создает в ней коллекцию.

пример

from pymongo import MongoClient

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

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

#Creating a collection
collection = db['example']
print("Collection created........")

Вывод

Collection created........

Вы можете хранить документы в MongoDB с помощью метода insert () . Этот метод принимает документ JSON в качестве параметра.

Синтаксис

Ниже приводится синтаксис метода вставки.

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

пример

> use mydb
switched to db mydb
> db.createCollection("sample")
{ "ok" : 1 }
> doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
{ "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
> db.sample.insert(doc1)
WriteResult({ "nInserted" : 1 })
>

Точно так же вы также можете вставить несколько документов, используя insert() метод.

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = 
[
   {
      "_id": "1001", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   }, 
   {
      "_id": "1002", 
      "name" : "Rahim", 
      "age" : 27, 
      "city" : "Bangalore" 
   }, 
   {
      "_id": "1003", 
      "name" : "Robert", 
      "age" : 28, 
      "city" : "Mumbai" 
   }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.sample.insert(data)
BulkWriteResult
({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 3,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})
>

Создание коллекции с использованием Python

Pymongo предоставляет метод с именем insert_one () для вставки документа в MangoDB. В этот метод нам нужно передать документ в формате словаря.

пример

В следующем примере документ вставляется в коллекцию с именем example.

from pymongo import MongoClient

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

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

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

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

Вывод

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

Чтобы вставить несколько документов в MongoDB с помощью pymongo, вам необходимо вызвать метод insert_many ().

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = 
[
   {
      "_id": "101", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   },
   {
      "_id": "102", 
      "name": "Rahim", 
      "age": "27", 
      "city": "Bangalore"
   },
   {
      "_id": "103", 
      "name": "Robert", 
      "age": "28", 
      "city": "Mumbai"
   }
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

Вывод

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

Вы можете читать / получать сохраненные документы из MongoDB, используя find()метод. Этот метод извлекает и отображает все документы в MongoDB неструктурированным способом.

Синтаксис

Ниже приводится синтаксис find() метод.

>db.CollectionName.find()

пример

Предположим, мы вставили 3 документа в базу данных с именем testDB в коллекции с именем sample, используя следующие запросы:

> use testDB
> db.createCollection("sample")
> data = [
   {"_id": "1001", "name" : "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
> db.sample.insert(data)

Вы можете получить вставленные документы, используя метод find () как -

> use testDB
switched to db testDB
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
>

Вы также можете получить первый документ в коллекции, используя метод findOne () как -

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

Получение данных (поиск) с помощью Python

В find_One() Метод pymongo используется для получения одного документа на основе вашего запроса, в случае отсутствия совпадений этот метод ничего не возвращает, а если вы не используете какой-либо запрос, он возвращает первый документ коллекции.

Этот метод удобен, когда вам нужно получить только один документ результата или, если вы уверены, что ваш запрос возвращает только один документ.

пример

Следующий пример python получает первый документ коллекции -

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

#Retrieving the first record using the find_one() method
print("First record of the collection: ")
print(coll.find_one())

#Retrieving a record with is 103 using the find_one() method
print("Record whose id is 103: ")
print(coll.find_one({"_id": "103"}))

Вывод

Data inserted ......
['101', '102', '103']
First record of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
Record whose id is 103:
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Чтобы получить несколько документов в одном запросе (один вызов метода find), вы можете использовать find()метод пимонго. Если запрос не передан, он возвращает все документы коллекции, а если вы передали запрос этому методу, он возвращает все согласованные документы.

пример

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

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

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Records of the collection: ")
for doc1 in coll.find():
print(doc1)

#Retrieving records with age greater than 26 using the find() method
print("Record whose age is more than 26: ")
for doc2 in coll.find({"age":{"$gt":"26"}}):
print(doc2)

Вывод

Data inserted ......
Records of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Record whose age is more than 26:
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

При получении с помощью find(), вы можете фильтровать документы с помощью объекта запроса. Вы можете передать запрос с указанием условия для необходимых документов в качестве параметра этому методу.

Операторы

Ниже приведен список операторов, используемых в запросах в MongoDB.

Операция	Синтаксис	пример
Равенство	{"ключ": "значение"}	db.mycol.find ({"автор": "точка обучения"})
Меньше, чем	{"ключ": {$ lt: "значение"}}	db.mycol.find ({"любит": {$ lt: 50}})
Меньше, чем равно	{"ключ": {$ lte: "значение"}}	db.mycol.find ({"любит": {$ lte: 50}})
Лучше чем	{"ключ": {$ gt: "значение"}}	db.mycol.find ({"любит": {$ gt: 50}})
Больше, чем равно	{"ключ" {$ gte: "значение"}}	db.mycol.find ({"любит": {$ gte: 50}})
Не равно	{"ключ": {$ ne: "значение"}}	db.mycol.find ({"любит": {$ ne: 50}})

Пример1

В следующем примере документ извлекается из коллекции с именем sarmista.

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc1 in coll.find({"name":"Sarmista"}):
   print(doc1)

Вывод

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

Пример2

В следующем примере извлекается документ из коллекции, возраст которой превышает 26.

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc in coll.find({"age":{"$gt":"26"}}):
   print(doc)

Вывод

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

При получении содержимого коллекции вы можете отсортировать и упорядочить их в возрастающем или убывающем порядке с помощью sort() метод.

В этот метод вы можете передать поле (поля) и порядок сортировки, равный 1 или -1. Где 1 - возрастающий порядок, а -1 - убывающий.

Синтаксис

Ниже приводится синтаксис метода sort () .

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

пример

Предположим, мы создали коллекцию и вставили в нее 5 документов, как показано ниже -

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Следующая строка извлекает все документы коллекции, которые отсортированы в порядке возрастания в зависимости от возраста.

> db.sample.find().sort({age:1})
{ "_id" : "1005", "name" : "Sarmista", "age" : 23, "city" : "Delhi" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

Сортировка документов с помощью Python

Для сортировки результатов запроса в возрастающем или убывающем порядке pymongo предоставляет sort()метод. В этот метод передайте числовое значение, представляющее количество документов, которые вам нужны в результате.

По умолчанию этот метод сортирует документы в порядке возрастания в соответствии с указанным полем. Если вам нужно отсортировать в порядке убывания, передайте -1 вместе с именем поля -

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

пример

В следующем примере извлекаются все документы коллекции, упорядоченные в соответствии со значениями возраста в порядке возрастания.

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("List of documents (sorted in ascending order based on age): ")

for doc1 in coll.find().sort("age"):
   print(doc1)

Вывод

Data inserted ......
List of documents (sorted in ascending order based on age):
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1006', 'name': 'Rasajna', 'age': 26, 'city': 'Chennai'}
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Вы можете удалить документы в коллекции, используя remove()метод MongoDB. Этот метод принимает два необязательных параметра -

критерии удаления, определяющие условие удаления документов.
только один, если вы передадите true или 1 в качестве второго параметра, то будет удален только один документ.

Синтаксис

Ниже приведен синтаксис метода remove ():

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

пример

Предположим, мы создали коллекцию и вставили в нее 5 документов, как показано ниже -

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Следующий запрос удаляет документ (ы) коллекции, имеющий значение имени как Sarmista.

> db.sample.remove({"name": "Sarmista"})
WriteResult({ "nRemoved" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }

Если вы вызовете remove() без прохождения критериев удаления, все документы в коллекции будут удалены.

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

Удаление документов с помощью Python

Чтобы удалить документы из коллекции MangoDB, вы можете удалить документы из коллекций, используя методы delete_one() и delete_many() методы.

Эти методы принимают объект запроса, определяющий условие удаления документов.

Метод Detele_one () удаляет один документ в случае совпадения. Если запрос не указан, этот метод удаляет первый документ в коллекции.

пример

Следующий пример python удаляет документ в коллекции, значение идентификатора которого равно 1006.

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting one document
coll.delete_one({"_id" : "1006"})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Вывод

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}

Точно так же delete_many() Метод pymongo удаляет все документы, удовлетворяющие указанному условию.

пример

В следующем примере удаляются все документы в коллекции, возраст которых превышает 26:

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting multiple documents
coll.delete_many({"age":{"$gt":"26"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Вывод

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1004', 'name': 'Romeo', 'age': '25', 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
{'_id': '1006', 'name': 'Rasajna', 'age': '26', 'city': 'Chennai'}

Если вы вызываете метод delete_many () без передачи запроса, этот метод удаляет все документы в коллекции.

coll.delete_many({})

Вы можете удалять коллекции, используя drop() метод MongoDB.

Синтаксис

Ниже приводится синтаксис метода drop () -

db.COLLECTION_NAME.drop()

пример

В следующем примере отбрасывается коллекция с образцом имени -

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

Удаление коллекции с использованием Python

Вы можете удалить / удалить коллекцию из текущей базы данных, вызвав метод drop ().

пример

from pymongo import MongoClient

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

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

#Creating a collection
col1 = db['collection']
col1.insert_one({"name": "Ram", "age": "26", "city": "Hyderabad"})
col2 = db['coll']
col2.insert_one({"name": "Rahim", "age": "27", "city": "Bangalore"})
col3 = db['myColl']
col3.insert_one({"name": "Robert", "age": "28", "city": "Mumbai"})
col4 = db['data']
col4.insert_one({"name": "Romeo", "age": "25", "city": "Pune"})

#List of collections
print("List of collections:")
collections = db.list_collection_names()
for coll in collections:
print(coll)

#Dropping a collection
col1.drop()
col4.drop()
print("List of collections after dropping two of them: ")

#List of collections
collections = db.list_collection_names()

for coll in collections:
   print(coll)

Вывод

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

Вы можете обновить содержимое существующих документов, используя update() метод или save() метод.

Метод обновления изменяет существующий документ, тогда как метод сохранения заменяет существующий документ новым.

Синтаксис

Ниже приведен синтаксис методов update () и save () MangoDB:

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

пример

Предположим, мы создали коллекцию в базе данных и вставили в нее 3 записи, как показано ниже -

> use testdatabase
switched to db testdatabase
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   ... {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.createCollection("sample")
{ "ok" : 1 }
> db.sample.insert(data)

Следующий метод обновляет значение города документа с идентификатором 1002.

> db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Точно так же вы можете заменить документ новыми данными, сохранив его с тем же идентификатором, используя метод save ().

> db.sample.save(
   { "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Обновление документов с помощью Python

Подобно методу find_one (), который извлекает отдельный документ, метод update_one () в pymongo обновляет отдельный документ.

Этот метод принимает запрос, указывающий, какой документ обновлять, и операцию обновления.

пример

Следующий пример python обновляет значение местоположения документа в коллекции.

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_one({"_id":"102"},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Вывод

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Точно так же update_many() Метод pymongo обновляет все документы, удовлетворяющие указанному условию.

пример

В следующем примере обновляется значение местоположения во всех документах в коллекции (пустое состояние) -

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_many({},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Вывод

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Visakhapatnam'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Visakhapatnam'}

При получении содержимого коллекции вы можете ограничить количество документов в результате с помощью метода limit (). Этот метод принимает числовое значение, представляющее количество документов, которые вы хотите получить в результате.

Синтаксис

Ниже приведен синтаксис метода limit () -

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

пример

Предположим, мы создали коллекцию и вставили в нее 5 документов, как показано ниже -

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Следующая строка извлекает первые 3 документа коллекции.

> db.sample.find().limit(3)
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Ограничение документов с помощью Python

Чтобы ограничить результаты запроса определенным количеством документов, pymongo предоставляет limit()метод. В этот метод передайте числовое значение, представляющее количество документов, которые вам нужны в результате.

пример

В следующем примере извлекаются первые три документа в коллекции.

from pymongo import MongoClient

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

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

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

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("First 3 documents in the collection: ")

for doc1 in coll.find().limit(3):
   print(doc1)

Вывод

Data inserted ......
First 3 documents in the collection:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}