Python MySQL - szybki przewodnik

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

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

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

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

Co to jest mysql-connector-python?

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

Jak zainstalować mysql-connector-python?

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

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

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

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

Sprawdź PIP

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

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

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

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

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

Instalowanie mysql-connector-python

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

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

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

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

Weryfikacja

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

import mysql.connector

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

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

Instalowanie Pythona od zera

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

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

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

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

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

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

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

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

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

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

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

Możesz odłączyć się od bazy danych MySQL w dowolnym momencie przy użyciu rozszerzenia exitpolecenie w mysql> prompt.

mysql> exit
Bye

Nawiązywanie połączenia z MySQL przy użyciu Pythona

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

• Że stworzyliśmy bazę danych o nazwie mydb.

• Stworzyliśmy tabelę EMPLOYEE z kolumnami FIRST_NAME, LAST_NAME, AGE, SEX i INCOME.

• Poświadczenia, których używamy do łączenia się z MySQL, to nazwa użytkownika - roothasło - password.

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

Przykład

Poniżej znajduje się przykład połączenia z bazą danych MySQL „mydb”.

import mysql.connector

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

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

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

#Fetch a single row using fetchone() method.
data = cursor.fetchone()

print("Connection established to: ",data)

#Closing the connection
conn.close()

Wynik

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

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

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

from mysql.connector import (connection)

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

#Closing the connection
conn.close()

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

Składnia

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

CREATE DATABASE name_of_the_database

Przykład

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

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

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

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

Tworzenie bazy danych w MySQL przy użyciu Pythona

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

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

Przykład

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

import mysql.connector

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

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

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

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

#Creating a database
cursor.execute(sql)

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

#Closing the connection
conn.close()

Wynik

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

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

Składnia

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

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

Przykład

Poniższe zapytanie tworzy tabelę o nazwie PRACOWNIK w MySQL z pięcioma kolumnami, a mianowicie FIRST_NAME, LAST_NAME, AGE, SEX i INCOME.

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

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

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

Tworzenie tabeli w MySQL przy użyciu Pythona

Metoda o nazwie execute () (wywołana na obiekcie kursora) przyjmuje dwie zmienne -

• Wartość typu String reprezentująca zapytanie do wykonania.

• Opcjonalny parametr args, który może być krotką, listą lub słownikiem, reprezentujący parametry zapytania (wartości posiadaczy miejsc).

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

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

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

• Import mysql.connector pakiet.

• Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.

• Utwórz obiekt kursora, wywołując plik cursor() na obiekt połączenia utworzony powyżej.

• Następnie wykonaj instrukcję CREATE TABLE , przekazując ją jako parametr doexecute() metoda.

Przykład

Poniższy przykład tworzy tabelę o nazwie Employee w bazie danych mydb.

import mysql.connector

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

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

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

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

#Closing the connection
conn.close()

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

Składnia

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

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

Przykład

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

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

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

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

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

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

Wstawianie danych do tabeli MySQL za pomocą Pythona

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

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

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

• import mysql.connector pakiet.

• Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.

• Utwórz obiekt kursora, wywołując plik cursor() na obiekt połączenia utworzony powyżej.

• Następnie wykonaj INSERT instrukcja, przekazując ją jako parametr do execute() metoda.

Przykład

Poniższy przykład wykonuje instrukcję SQL INSERT , aby wstawić rekord do tabeli EMPLOYEE -

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
# Preparing SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Executing the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   conn.commit()
except:
   # Rolling back in case of error
   conn.rollback()
# Closing the connection
conn.close()

Dynamiczne wstawianie wartości

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

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

Przykład

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

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

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

# Preparing SQL query to INSERT a record into the database.
insert_stmt = (
   "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)"
   "VALUES (%s, %s, %s, %s, %s)"
)
data = ('Ramya', 'Ramapriya', 25, 'F', 5000)
try:
   # Executing the SQL command
   cursor.execute(insert_stmt, data)
   # Commit your changes in the database
   conn.commit()
except:
   # Rolling back in case of error
   conn.rollback()
print("Data inserted")
# Closing the connection
conn.close()

Wynik

Data inserted

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

Składnia

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

SELECT column1, column2, columnN FROM table_name;

Przykład

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

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

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

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

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

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

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

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

Odczytywanie danych z tabeli MYSQL za pomocą języka Python

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

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

• Plik fetchall()metoda pobiera wszystkie wiersze w zestawie wyników zapytania i zwraca je jako listę krotek. (Jeśli wykonamy to po pobraniu kilku wierszy, zwróci pozostałe).

• Plik fetchone() metoda pobiera następny wiersz w wyniku zapytania i zwraca go jako krotkę.

• Plik fetchmany() jest podobna do metody fetchone (), ale pobiera następny zestaw wierszy w zestawie wyników zapytania zamiast pojedynczego wiersza.

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

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

Przykład

Poniższy przykład pobiera wszystkie wiersze tabeli EMPLOYEE za pomocą zapytania SELECT iz uzyskanego zestawu wyników początkowo pobieramy pierwszy wiersz za pomocą metody fetchone (), a następnie pobieramy pozostałe wiersze za pomocą metody fetchall ().

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

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

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

#Executing the query
cursor.execute(sql)

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

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

#Closing the connection
conn.close()

Wynik

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

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

Przykład

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

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Wynik

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

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

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

Składnia

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

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

Przykład

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

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

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

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

Po zestawieniu MySQL pobiera rekordy pracowników, których dochody są większe niż 4000.

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

WHERE Klauzula w Pythonie

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

• import mysql.connector pakiet.

• Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.

• Utwórz obiekt kursora, wywołując plik cursor() na obiekt połączenia utworzony powyżej.

• Następnie wykonaj instrukcję SELECT z klauzulą WHERE , przekazując ją jako parametr doexecute() metoda.

Przykład

Poniższy przykład tworzy tabelę o nazwie Employee i zapełnia ją. Następnie za pomocą klauzuli where pobiera rekordy z wartością wieku mniejszą niż 23.

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

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

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES (%s, %s, %s, %s, %s
)"
data = [
   ('Krishna', 'Sharma', 19, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)
]
cursor.executemany(insert_stmt, data)
conn.commit()
#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Closing the connection
conn.close()

Wynik

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

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

Składnia

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

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

Przykład

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

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

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

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

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

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

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

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

Klauzula ORDER BY w języku Python

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

Przykład

W poniższym przykładzie tworzymy tabelę z imieniem i nazwiskiem oraz Pracownikiem, zapełniamy ją i pobieramy jej rekordy z powrotem w (rosnącej) kolejności ich wieku, używając klauzuli ORDER BY.

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

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

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

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

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

print(cursor.fetchall())

#Closing the connection
conn.close()

Wynik

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

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

Przykład

import mysql.connector

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

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

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

print(cursor.fetchall())

#Closing the connection
conn.close()

Wynik

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

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

Składnia

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

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

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

Przykład

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

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

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

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

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

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

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

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

Aktualizacja zawartości tabeli za pomocą języka Python

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

• import mysql.connector pakiet.

• Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.

• Utwórz obiekt kursora, wywołując plik cursor() na obiekt połączenia utworzony powyżej.

• Następnie wykonaj instrukcję UPDATE , przekazując ją jako parametr do plikuexecute() metoda.

Przykład

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

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

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

#Preparing the query to update the records
sql = '''UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M' '''

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Wynik

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

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

Składnia

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

DELETE FROM table_name [WHERE Clause]

Przykład

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

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

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

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

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

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

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

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

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

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

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

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

Usuwanie rekordów tabeli za pomocą Pythona

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

Aby usunąć rekordy w tabeli -

• import mysql.connector pakiet.

• Utwórz obiekt połączenia przy użyciu mysql.connector.connect() metody, przekazując nazwę użytkownika, hasło, host (opcjonalnie domyślnie: localhost) i bazę danych (opcjonalnie) jako parametry.

• Utwórz obiekt kursora, wywołując metodę cursor () na obiekcie połączenia utworzonym powyżej.

• Następnie wykonaj DELETE instrukcja, przekazując ją jako parametr do execute() metoda.

Przykład

Poniższy program usuwa wszystkie rekordy od PRACOWNIKA, którego WIEK przekracza 20 -

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

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

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

#Preparing the query to delete records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (25)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   conn.commit()
except:
   # Roll back in case there is any error
   conn.rollback()

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

#Closing the connection
conn.close()

Wynik

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

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

Składnia

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

DROP TABLE table_name;

Przykład

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

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

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

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

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

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

Usuwanie tabeli za pomocą Pythona

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

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

Przykład

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

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

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

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

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

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

#Closing the connection 
conn.close()

Wynik

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

Upuść tabelę tylko wtedy, gdy istnieje

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

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

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

Example

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

Output

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

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

Przykład

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

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

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

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

Następująca instrukcja SQL pobiera pierwsze dwa rekordy tabeli Employee przy użyciu klauzuli LIMIT.

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

Klauzula ograniczająca w języku Python

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

Przykład

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

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

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Wynik

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

LIMIT z PRZESUNIĘCIEM

Jeśli chcesz ograniczyć rekordy zaczynające się od n-tego rekordu (nie pierwszego), możesz to zrobić, używając opcji OFFSET wraz z LIMIT.

Example

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

Output

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

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

Przykład

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

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

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

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

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

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

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

MYSQL JOIN przy użyciu Pythona

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

Przykład

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

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

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

#Executing the query
cursor.execute(sql)

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

print(result)

#Closing the connection
conn.close()

Wynik

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

MySQLCursor mysql-connector-python (i podobne biblioteki) jest używany do wykonywania instrukcji w celu komunikacji z bazą danych MySQL.

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

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

Przykład

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

Metody

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

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

Nieruchomości

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

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