Python MySQL - Kurzanleitung

Der Python-Standard für Datenbankschnittstellen ist die Python-DB-API. Die meisten Python-Datenbankschnittstellen entsprechen diesem Standard.

Sie können die richtige Datenbank für Ihre Anwendung auswählen. Die Python-Datenbank-API unterstützt eine Vielzahl von Datenbankservern wie -

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

Hier ist die Liste der verfügbaren Python-Datenbankschnittstellen - Python-Datenbankschnittstellen und APIs . Sie müssen für jede Datenbank, auf die Sie zugreifen müssen, ein separates DB-API-Modul herunterladen. Wenn Sie beispielsweise sowohl auf eine Oracle-Datenbank als auch auf eine MySQL-Datenbank zugreifen müssen, müssen Sie sowohl das Oracle- als auch das MySQL-Datenbankmodul herunterladen.

Was ist MySQL-Connector-Python?

MySQL Python / Connector ist eine Schnittstelle zum Herstellen einer Verbindung zu einem MySQL-Datenbankserver von Python. Es implementiert die Python-Datenbank-API und basiert auf MySQL.

Wie installiere ich mysql-connector-python?

Zunächst müssen Sie sicherstellen, dass Sie Python bereits auf Ihrem Computer installiert haben. Öffnen Sie dazu die Eingabeaufforderung, geben Sie Python ein und drücken Sie die Eingabetaste . Wenn Python bereits auf Ihrem System installiert ist, zeigt dieser Befehl seine Version wie unten gezeigt an -

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

Drücken Sie nun Strg + Z und dann die Eingabetaste , um die Python-Shell zu verlassen und einen Ordner (in dem Sie den Python-MySQL-Connector installieren wollten) mit dem Namen Python_MySQL als - zu erstellen.

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

Überprüfen Sie PIP

PIP ist ein Paketmanager in Python, mit dem Sie verschiedene Module / Pakete in Python installieren können. Um MySQL-Python MySQL-Connector-Python zu installieren, müssen Sie daher sicherstellen, dass PIP auf Ihrem Computer installiert ist und dessen Speicherort dem Pfad hinzugefügt wurde.

Sie können dies tun, indem Sie den Befehl pip ausführen. Wenn Sie kein PIP in Ihrem System hatten oder wenn Sie seinen Speicherort nicht in der hinzugefügt habenPath Umgebungsvariable erhalten Sie eine Fehlermeldung als -

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

Um PIP zu installieren, laden Sie die Datei get-pip.py in den oben erstellten Ordner herunter und navigieren Sie über den Befehl darin und installieren Sie pip wie folgt:

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 installieren

Sobald Sie Python und PIP installiert haben, öffnen Sie die Eingabeaufforderung und aktualisieren Sie pip (optional) wie unten gezeigt -

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

Öffnen Sie dann die Eingabeaufforderung im Admin-Modus und installieren Sie Python MySQL Connect als -

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

Überprüfung

Um die Installation des zu überprüfen, erstellen Sie ein Beispiel-Python-Skript mit der folgenden Zeile.

import mysql.connector

Wenn die Installation erfolgreich ist, sollten Sie bei der Ausführung keine Fehler erhalten -

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

Python von Grund auf neu installieren

Einfach, wenn Sie Python von Grund auf neu installieren müssen. Besuchen Sie die Python-Homepage .

Klick auf das Downloads Klicken Sie auf die Schaltfläche, um zur Downloadseite zu gelangen, die Links für die neueste Version von Python für verschiedene Plattformen enthält. Wählen Sie eine aus und laden Sie sie herunter.

Zum Beispiel haben wir python-3.7.4.exe (für Windows) heruntergeladen. Starten Sie den Installationsvorgang, indem Sie auf die heruntergeladene EXE-Datei doppelklicken.

Aktivieren Sie die Option Python 3.7 zum Pfad hinzufügen und fahren Sie mit der Installation fort. Nach Abschluss dieses Vorgangs wird Python auf Ihrem System installiert.

Um eine Verbindung mit MySQL herzustellen, öffnen Sie die MySQL-Eingabeaufforderung in Ihrem System wie unten gezeigt.

Hier wird nach dem Passwort gefragt. Sie müssen das Kennwort eingeben, das Sie zum Zeitpunkt der Installation auf den Standardbenutzer (root) festgelegt haben.

Dann wird eine Verbindung mit MySQL hergestellt, die die folgende Meldung anzeigt:

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.

Sie können jederzeit mit der Verbindung zur MySQL-Datenbank trennen exitBefehl an der Eingabeaufforderung mysql> .

mysql> exit
Bye

Herstellen einer Verbindung mit MySQL mithilfe von Python

Nehmen Sie vor dem Herstellen einer Verbindung zur MySQL-Datenbank mit Python Folgendes an:

• Dass wir eine Datenbank mit dem Namen mydb erstellt haben.

• Wir haben eine Tabelle EMPLOYEE mit den Spalten FIRST_NAME, LAST_NAME, AGE, SEX und INCOME erstellt.

• Die Anmeldeinformationen, die wir für die Verbindung mit MySQL verwenden, sind Benutzername - root, Passwort - password.

Sie können eine Verbindung mit dem Konstruktor connect () herstellen . Dies akzeptiert Benutzername, Kennwort, Host und den Namen der Datenbank, mit der Sie eine Verbindung herstellen müssen (optional), und gibt ein Objekt der MySQLConnection-Klasse zurück.

Beispiel

Das folgende Beispiel zeigt die Verbindung mit der MySQL-Datenbank "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()

Ausgabe

Bei der Ausführung erzeugt dieses Skript die folgende Ausgabe:

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

Sie können auch eine Verbindung zu MySQL herstellen, indem Sie Anmeldeinformationen (Benutzername, Kennwort, Hostname und Datenbankname) an übergeben connection.MySQLConnection() wie unten gezeigt -

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

Sie können eine Datenbank in MYSQL mit der Abfrage CREATE DATABASE erstellen.

Syntax

Es folgt die Syntax der Abfrage CREATE DATABASE -

CREATE DATABASE name_of_the_database

Beispiel

Die folgende Anweisung erstellt eine Datenbank mit dem Namen mydb in MySQL -

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

Wenn Sie die Liste der Datenbanken mit der Anweisung SHOW DATABASES beobachten, können Sie die neu erstellte Datenbank darin wie unten gezeigt beobachten.

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

Erstellen einer Datenbank in MySQL mit Python

Nachdem Sie eine Verbindung mit MySQL hergestellt haben, müssen Sie eine Verbindung zu einer Datenbank herstellen, um die darin enthaltenen Daten zu bearbeiten. Sie können eine Verbindung zu einer vorhandenen Datenbank herstellen oder eine eigene erstellen.

Sie benötigen spezielle Berechtigungen, um eine MySQL-Datenbank zu erstellen oder zu löschen. Wenn Sie also Zugriff auf den Root-Benutzer haben, können Sie eine beliebige Datenbank erstellen.

Beispiel

Das folgende Beispiel stellt eine Verbindung mit MYSQL her und erstellt eine Datenbank darin.

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

Ausgabe

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

Mit der Anweisung CREATE TABLE werden Tabellen in der MYSQL-Datenbank erstellt. Hier müssen Sie den Namen der Tabelle und die Definition (Name und Datentyp) jeder Spalte angeben.

Syntax

Es folgt die Syntax zum Erstellen einer Tabelle in MySQL:

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

Beispiel

Die folgende Abfrage erstellt eine Tabelle mit dem Namen EMPLOYEE in MySQL mit fünf Spalten, nämlich FIRST_NAME, LAST_NAME, AGE, SEX und 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)

Die DESC-Anweisung enthält die Beschreibung der angegebenen Tabelle. Auf diese Weise können Sie überprüfen, ob die Tabelle wie unten gezeigt erstellt wurde oder nicht.

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)

Erstellen einer Tabelle in MySQL mit Python

Die Methode execute () (wird für das Cursorobjekt aufgerufen) akzeptiert zwei Variablen -

• Ein String-Wert, der die auszuführende Abfrage darstellt.

• Ein optionaler args-Parameter, der ein Tupel oder eine Liste oder ein Wörterbuch sein kann und die Parameter der Abfrage (Werte der Platzhalter) darstellt.

Es wird ein ganzzahliger Wert zurückgegeben, der die Anzahl der von der Abfrage betroffenen Zeilen darstellt.

Sobald eine Datenbankverbindung hergestellt ist, können Sie Tabellen erstellen, indem Sie die Abfrage CREATE TABLE an die übergeben execute() Methode.

Kurz gesagt, um eine Tabelle mit Python zu erstellen -

• Importieren mysql.connector Paket.

• Erstellen Sie ein Verbindungsobjekt mit dem mysql.connector.connect() Methode, indem Benutzername, Kennwort, Host (optionaler Standard: localhost) und Datenbank (optional) als Parameter übergeben werden.

• Erstellen Sie ein Cursorobjekt, indem Sie das aufrufen cursor() Methode für das oben erstellte Verbindungsobjekt.

• Führen Sie dann die Anweisung CREATE TABLE aus, indem Sie sie als Parameter an die übergebenexecute() Methode.

Beispiel

Das folgende Beispiel erstellt eine Tabelle mit dem Namen Employee in der Datenbank 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()

Sie können einer vorhandenen Tabelle von MySQL mit dem Befehl neue Zeilen hinzufügen INSERT INTOErklärung. In diesem Fall müssen Sie den Namen der Tabelle, die Spaltennamen und die Werte angeben (in derselben Reihenfolge wie die Spaltennamen).

Syntax

Es folgt die Syntax der INSERT INTO-Anweisung von MySQL.

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

Beispiel

Die folgende Abfrage fügt einen Datensatz mit dem Namen EMPLOYEE in die Tabelle ein.

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

Sie können die Datensätze der Tabelle nach dem Einfügen mit der Anweisung SELECT als - überprüfen

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

Es ist nicht zwingend erforderlich, die Namen der Spalten immer anzugeben. Wenn Sie Werte eines Datensatzes in derselben Reihenfolge wie die Spalten der Tabelle übergeben, können Sie die SELECT-Anweisung ohne die Spaltennamen wie folgt ausführen:

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

Einfügen von Daten in MySQL-Tabelle mit Python

Das execute()Die Methode (die für das Cursorobjekt aufgerufen wird) akzeptiert eine Abfrage als Parameter und führt die angegebene Abfrage aus. Um Daten einzufügen, müssen Sie die MySQL INSERT-Anweisung als Parameter an sie übergeben.

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

So fügen Sie mit Python Daten in eine Tabelle in MySQL ein:

• importieren mysql.connector Paket.

• Erstellen Sie ein Verbindungsobjekt mit dem mysql.connector.connect() Methode, indem Benutzername, Kennwort, Host (optionaler Standard: localhost) und Datenbank (optional) als Parameter übergeben werden.

• Erstellen Sie ein Cursorobjekt, indem Sie das aufrufen cursor() Methode für das oben erstellte Verbindungsobjekt.

• Führen Sie dann die aus INSERT Anweisung durch Übergabe als Parameter an die execute() Methode.

Beispiel

Im folgenden Beispiel wird die SQL INSERT- Anweisung ausgeführt, um einen Datensatz in die EMPLOYEE-Tabelle einzufügen.

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

Werte dynamisch einfügen

Sie können auch verwenden “%s” anstelle von Werten in der INSERT Abfrage von MySQL und Übergabe von Werten an sie als Listen wie unten gezeigt -

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

Beispiel

Im folgenden Beispiel wird ein Datensatz dynamisch in die Employee-Tabelle eingefügt.

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

Ausgabe

Data inserted

Mit der SELECT-Abfrage können Sie Daten aus einer Tabelle in MySQL abrufen / abrufen. Diese Abfrage / Anweisung gibt den Inhalt der angegebenen Tabelle in Tabellenform zurück und wird als Ergebnismenge aufgerufen.

Syntax

Es folgt die Syntax der SELECT-Abfrage -

SELECT column1, column2, columnN FROM table_name;

Beispiel

Angenommen, wir haben in MySQL eine Tabelle mit dem Namen cricketers_data als - erstellt

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

Und wenn wir 5 Datensätze mit INSERT-Anweisungen als - eingefügt haben

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

Die folgende Abfrage ruft die Werte FIRST_NAME und Country aus der Tabelle ab.

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)

Sie können auch alle Werte jedes Datensatzes mit * abrufen, wobei der Name der Spalten als - angegeben wird

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)

Lesen von Daten aus einer MYSQL-Tabelle mit Python

READ Operation für eine beliebige Datenbank bedeutet, einige nützliche Informationen aus der Datenbank abzurufen. Sie können Daten aus MYSQL mit dem abrufenfetch() Methode von der MySQL-Connector-Python zur Verfügung gestellt.

Die cursor.MySQLCursor- Klasse bietet nämlich drei Methodenfetchall(), fetchmany() und, fetchone() wo,

• Das fetchall()Die Methode ruft alle Zeilen in der Ergebnismenge einer Abfrage ab und gibt sie als Liste der Tupel zurück. (Wenn wir dies ausführen, nachdem wir einige Zeilen abgerufen haben, werden die verbleibenden zurückgegeben.)

• Das fetchone() Die Methode ruft die nächste Zeile im Ergebnis einer Abfrage ab und gibt sie als Tupel zurück.

• Das fetchmany() Die Methode ähnelt der Methode fetchone (), ruft jedoch anstelle einer einzelnen Zeile die nächste Reihe von Zeilen in der Ergebnismenge einer Abfrage ab.

Note - Eine Ergebnismenge ist ein Objekt, das zurückgegeben wird, wenn ein Cursorobjekt zum Abfragen einer Tabelle verwendet wird.

rowcount - Dies ist ein schreibgeschütztes Attribut und gibt die Anzahl der Zeilen zurück, die von einer execute () -Methode betroffen waren.

Beispiel

Im folgenden Beispiel werden alle Zeilen der EMPLOYEE-Tabelle mit der SELECT-Abfrage abgerufen. Aus der erhaltenen Ergebnismenge wird zunächst die erste Zeile mit der Methode fetchone () und anschließend die verbleibenden Zeilen mit der Methode fetchall () abgerufen.

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

Ausgabe

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

Das folgende Beispiel ruft die ersten beiden Zeilen der EMPLOYEE-Tabelle mit der Methode fetchmany () ab.

Beispiel

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

Ausgabe

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

Wenn Sie bestimmte Zeilen einer Tabelle in MySQL abrufen, löschen oder aktualisieren möchten, müssen Sie die where-Klausel verwenden, um die Bedingung zum Filtern der Tabellenzeilen für die Operation anzugeben.

Wenn Sie beispielsweise eine SELECT-Anweisung mit der where-Klausel haben, werden nur die Zeilen abgerufen, die die angegebene Bedingung erfüllen.

Syntax

Es folgt die Syntax der WHERE-Klausel -

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

Beispiel

Angenommen, wir haben in MySQL eine Tabelle mit dem Namen EMPLOYEES als - erstellt

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)

Und wenn wir 4 Datensätze mit INSERT-Anweisungen als - eingefügt haben.

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

Nach der MySQL-Anweisung werden die Aufzeichnungen der Mitarbeiter abgerufen, deren Einkommen mehr als 4000 beträgt.

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-Klausel mit Python

So rufen Sie mit dem Python-Programm bestimmte Datensätze aus einer Tabelle ab:

• importieren mysql.connector Paket.

• Erstellen Sie ein Verbindungsobjekt mit dem mysql.connector.connect() Methode, indem Benutzername, Kennwort, Host (optionaler Standard: localhost) und Datenbank (optional) als Parameter übergeben werden.

• Erstellen Sie ein Cursorobjekt, indem Sie das aufrufen cursor() Methode für das oben erstellte Verbindungsobjekt.

• Führen Sie dann die SELECT- Anweisung mit der WHERE- Klausel aus, indem Sie sie als Parameter an die übergebenexecute() Methode.

Beispiel

Im folgenden Beispiel wird eine Tabelle mit dem Namen "Mitarbeiter" erstellt und gefüllt. Mit der where-Klausel werden dann die Datensätze mit einem Alterswert von weniger als 23 abgerufen.

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

Ausgabe

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

Beim Abrufen von Daten mithilfe der SELECT-Abfrage können Sie die Ergebnisse mithilfe der OrderBy-Klausel in der gewünschten Reihenfolge (aufsteigend oder absteigend) sortieren. Standardmäßig sortiert diese Klausel die Ergebnisse in aufsteigender Reihenfolge. Wenn Sie sie in absteigender Reihenfolge anordnen müssen, müssen Sie "DESC" explizit verwenden.

Syntax

Es folgt die Syntax SELECT Spaltenliste

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

Beispiel

Angenommen, wir haben in MySQL eine Tabelle mit dem Namen EMPLOYEES als - erstellt

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)

Und wenn wir 4 Datensätze mit INSERT-Anweisungen als - eingefügt haben.

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

Die folgende Anweisung ruft den Inhalt der EMPLOYEE-Tabelle in aufsteigender Reihenfolge des Alters ab.

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)

Sie können Daten auch in absteigender Reihenfolge mit DESC abrufen als -

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-Klausel mit Python

Rufen Sie das auf, um den Inhalt einer Tabelle in einer bestimmten Reihenfolge abzurufen execute() Methode für das Cursorobjekt und übergeben Sie die SELECT-Anweisung zusammen mit der ORDER BY-Klausel als Parameter.

Beispiel

Im folgenden Beispiel erstellen wir eine Tabelle mit Name und Mitarbeiter, füllen sie aus und rufen ihre Datensätze mithilfe der ORDER BY-Klausel in der (aufsteigenden) Reihenfolge ihres Alters wieder ab.

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

Ausgabe

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

Auf die gleiche Weise können Sie mit der ORDER BY-Klausel Daten aus einer Tabelle in absteigender Reihenfolge abrufen.

Beispiel

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

Ausgabe

[
   ('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 Der Vorgang für eine Datenbank aktualisiert einen oder mehrere Datensätze, die bereits in der Datenbank verfügbar sind. Sie können die Werte vorhandener Datensätze in MySQL mithilfe der UPDATE-Anweisung aktualisieren. Um bestimmte Zeilen zu aktualisieren, müssen Sie die WHERE-Klausel verwenden.

Syntax

Es folgt die Syntax der UPDATE-Anweisung in MySQL -

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

Sie können N Bedingungen mit den Operatoren AND oder OR kombinieren.

Beispiel

Angenommen, wir haben in MySQL eine Tabelle mit dem Namen EMPLOYEES als - erstellt

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)

Und wenn wir 4 Datensätze mit INSERT-Anweisungen als - eingefügt haben.

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

Nach der MySQL-Erklärung erhöht sich das Alter aller männlichen Mitarbeiter um ein Jahr -

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

Wenn Sie den Inhalt der Tabelle abrufen, sehen Sie die aktualisierten Werte als -

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)

Aktualisieren des Inhalts einer Tabelle mit Python

So aktualisieren Sie die Datensätze in einer Tabelle in MySQL mit Python:

• importieren mysql.connector Paket.

• Erstellen Sie ein Verbindungsobjekt mit dem mysql.connector.connect() Methode, indem Benutzername, Kennwort, Host (optionaler Standard: localhost) und Datenbank (optional) als Parameter übergeben werden.

• Erstellen Sie ein Cursorobjekt, indem Sie das aufrufen cursor() Methode für das oben erstellte Verbindungsobjekt.

• Führen Sie dann die UPDATE- Anweisung aus, indem Sie sie als Parameter an die übergebenexecute() Methode.

Beispiel

Das folgende Beispiel erhöht das Alter aller Männer um ein Jahr.

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

Ausgabe

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

Um Datensätze aus einer MySQL-Tabelle zu löschen, müssen Sie die verwenden DELETE FROMErklärung. Um bestimmte Datensätze zu entfernen, müssen Sie die WHERE-Klausel verwenden.

Syntax

Es folgt die Syntax der DELETE-Abfrage in MYSQL -

DELETE FROM table_name [WHERE Clause]

Beispiel

Angenommen, wir haben in MySQL eine Tabelle mit dem Namen EMPLOYEES als - erstellt

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)

Und wenn wir 4 Datensätze mit INSERT-Anweisungen als - eingefügt haben.

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

Die folgende MySQL-Anweisung löscht den Datensatz des Mitarbeiters mit FIRST_NAME ”Mac” .

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

Wenn Sie den Inhalt der Tabelle abrufen, werden nur 3 Datensätze angezeigt, da wir einen gelöscht haben.

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)

Wenn Sie die DELETE-Anweisung ohne die WHERE-Klausel ausführen, werden alle Datensätze aus der angegebenen Tabelle gelöscht.

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

Wenn Sie den Inhalt der Tabelle abrufen, erhalten Sie einen leeren Satz wie unten gezeigt -

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

Entfernen von Datensätzen einer Tabelle mit Python

Der Vorgang LÖSCHEN ist erforderlich, wenn Sie einige Datensätze aus Ihrer Datenbank löschen möchten.

So löschen Sie die Datensätze in einer Tabelle:

• importieren mysql.connector Paket.

• Erstellen Sie ein Verbindungsobjekt mit dem mysql.connector.connect() Methode, indem Benutzername, Kennwort, Host (optionaler Standard: localhost) und Datenbank (optional) als Parameter übergeben werden.

• Erstellen Sie ein Cursorobjekt, indem Sie die Methode cursor () für das oben erstellte Verbindungsobjekt aufrufen.

• Führen Sie dann die aus DELETE Anweisung durch Übergabe als Parameter an die execute() Methode.

Beispiel

Das folgende Programm löscht alle Datensätze von MITARBEITERN, deren ALTER mehr als 20 Jahre beträgt.

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

Ausgabe

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

Sie können eine ganze Tabelle mit dem entfernen DROP TABLEErklärung. Sie müssen nur den Namen der Tabelle angeben, die Sie löschen möchten.

Syntax

Es folgt die Syntax der DROP TABLE-Anweisung in MySQL -

DROP TABLE table_name;

Beispiel

Bevor Sie eine Tabelle löschen, rufen Sie die Liste der Tabellen mit der Anweisung SHOW TABLES wie folgt ab:

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

Die folgende Anweisung entfernt die Tabelle mit dem Namen sample vollständig aus der Datenbank.

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

Da wir die Tabelle mit dem Namen sample aus MySQL gelöscht haben, finden Sie die Tabelle mit dem Tabellennamen nicht darin, wenn Sie die Liste der Tabellen erneut erhalten.

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

Entfernen einer Tabelle mit Python

Sie können eine Tabelle jederzeit mit der DROP-Anweisung von MYSQL löschen. Sie müssen jedoch beim Löschen einer vorhandenen Tabelle sehr vorsichtig sein, da die verlorenen Daten nach dem Löschen einer Tabelle nicht wiederhergestellt werden.

Um eine Tabelle mit Python aus einer MYSQL-Datenbank zu löschen, rufen Sie die auf execute() Methode für das Cursorobjekt und übergeben Sie die drop-Anweisung als Parameter an dieses.

Beispiel

Die folgende Tabelle löscht eine Tabelle mit dem Namen EMPLOYEE aus der Datenbank.

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

Ausgabe

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

Tabelle nur löschen, wenn vorhanden

Wenn Sie versuchen, eine Tabelle zu löschen, die nicht in der Datenbank vorhanden ist, tritt ein Fehler wie folgt auf:

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

Sie können diesen Fehler verhindern, indem Sie vor dem Löschen überprüfen, ob die Tabelle vorhanden ist, indem Sie der Anweisung DELETE IF EXISTS hinzufügen.

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

Wenn Sie Datensätze abrufen, um sie auf eine bestimmte Anzahl zu beschränken, können Sie dies mithilfe der LIMIT-Klausel von MYSQL tun.

Beispiel

Angenommen, wir haben in MySQL eine Tabelle mit dem Namen EMPLOYEES als - erstellt

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)

Und wenn wir 4 Datensätze mit INSERT-Anweisungen als - eingefügt haben.

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

Die folgende SQL-Anweisung ruft die ersten beiden Datensätze der Employee-Tabelle mithilfe der LIMIT-Klausel ab.

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)

Begrenzungsklausel mit Python

Wenn Sie die aufrufen execute() Methode für das Cursorobjekt Durch Übergeben der SELECT-Abfrage zusammen mit der LIMIT-Klausel können Sie die erforderliche Anzahl von Datensätzen abrufen.

Beispiel

Das folgende Python-Beispiel erstellt und füllt eine Tabelle mit dem Namen EMPLOYEE und ruft mithilfe der LIMIT-Klausel die ersten beiden Datensätze ab.

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

Ausgabe

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

LIMIT mit OFFSET

Wenn Sie die Datensätze ab dem n-ten Datensatz (nicht dem ersten) einschränken müssen, können Sie dies mit OFFSET zusammen mit LIMIT tun.

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

Wenn Sie die Daten in zwei Tabellen aufgeteilt haben, können Sie mithilfe von Joins kombinierte Datensätze aus diesen beiden Tabellen abrufen.

Beispiel

Angenommen, wir haben eine Tabelle mit dem Namen EMPLOYEE erstellt und Daten wie unten gezeigt darin ausgefüllt.

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

Wenn wir dann eine andere Tabelle erstellt und als - ausgefüllt haben

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

Die folgende Anweisung ruft Daten ab, die die Werte in diesen beiden Tabellen kombinieren.

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 Mit Python

Im folgenden Beispiel werden Daten aus den beiden oben genannten Tabellen abgerufen, die durch die Kontaktspalte der Tabelle EMPLOYEE und die Spalte ID der Tabelle CONTACT kombiniert sind.

Beispiel

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

Ausgabe

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

Der MySQLCursor von mysql-connector-python (und ähnlichen Bibliotheken) wird verwendet, um Anweisungen für die Kommunikation mit der MySQL-Datenbank auszuführen.

Mit den Methoden können Sie SQL-Anweisungen ausführen, Daten aus den Ergebnismengen abrufen und Prozeduren aufrufen.

Sie können erstellen Cursor Objekt mit der cursor () -Methode des Verbindungsobjekts / der Verbindungsklasse.

Beispiel

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

Methoden

Im Folgenden sind die verschiedenen Methoden aufgeführt, die von der Cursor-Klasse / dem Cursor-Objekt bereitgestellt werden.

Sr.Nr.	Methoden & Beschreibung
1	callproc() Diese Methode wird verwendet, um vorhandene Prozeduren MySQL-Datenbank aufzurufen.
2	close() Diese Methode wird verwendet, um das aktuelle Cursorobjekt zu schließen.
3	Info() Diese Methode gibt Auskunft über die letzte Abfrage.
4	executemany() Diese Methode akzeptiert eine Liste mit Parametern. Bereitet eine MySQL-Abfrage vor und führt sie mit allen Parametern aus.
5	execute() Diese Methode akzeptiert eine MySQL-Abfrage als Parameter und führt die angegebene Abfrage aus.
6	fetchall() Diese Methode ruft alle Zeilen in der Ergebnismenge einer Abfrage ab und gibt sie als Liste von Tupeln zurück. (Wenn wir dies nach dem Abrufen einiger Zeilen ausführen, werden die verbleibenden zurückgegeben.)
7	fetchone() Diese Methode ruft die nächste Zeile im Ergebnis einer Abfrage ab und gibt sie als Tupel zurück.
8	fetchmany() Diese Methode ähnelt der Methode fetchone (), ruft jedoch anstelle einer einzelnen Zeile die nächste Reihe von Zeilen in der Ergebnismenge einer Abfrage ab.
9	fetchwarnings() Diese Methode gibt die Warnungen zurück, die von der zuletzt ausgeführten Abfrage generiert wurden.

Eigenschaften

Im Folgenden sind die Eigenschaften der Cursor-Klasse aufgeführt:

Sr.Nr.	Objektbeschreibung
1	column_names Dies ist eine schreibgeschützte Eigenschaft, die die Liste mit den Spaltennamen einer Ergebnismenge zurückgibt.
2	description Dies ist eine schreibgeschützte Eigenschaft, die die Liste mit der Beschreibung der Spalten in einer Ergebnismenge zurückgibt.
3	lastrowid Dies ist eine schreibgeschützte Eigenschaft. Wenn die Tabelle automatisch inkrementierte Spalten enthält, wird der Wert zurückgegeben, der für diese Spalte in der letzten INSERT- oder UPDATE-Operation generiert wurde.
4	rowcount Dies gibt die Anzahl der zurückgegebenen / aktualisierten Zeilen bei SELECT- und UPDATE-Operationen zurück.
5	statement Diese Eigenschaft gibt die zuletzt ausgeführte Anweisung zurück.