Python MySQL - Guía rápida
El estándar de Python para interfaces de bases de datos es Python DB-API. La mayoría de las interfaces de bases de datos de Python se adhieren a este estándar.
Puede elegir la base de datos adecuada para su aplicación. La API de base de datos de Python admite una amplia gama de servidores de bases de datos, como:
- GadFly
- mSQL
- MySQL
- PostgreSQL
- Microsoft SQL Server 2000
- Informix
- Interbase
- Oracle
- Sybase
Aquí está la lista de interfaces de base de datos de Python disponibles: interfaces de base de datos de Python y API . Debe descargar un módulo DB API por separado para cada base de datos a la que necesite acceder. Por ejemplo, si necesita acceder a una base de datos Oracle y una base de datos MySQL, debe descargar los módulos de base de datos Oracle y MySQL.
¿Qué es mysql-connector-python?
MySQL Python / Connector es una interfaz para conectarse a un servidor de base de datos MySQL desde Python. Implementa la API de base de datos de Python y está construido sobre MySQL.
¿Cómo instalo mysql-connector-python?
En primer lugar, debe asegurarse de haber instalado Python en su máquina. Para hacerlo, abra el símbolo del sistema y escriba python en él y presione Entrar . Si Python ya está instalado en su sistema, este comando mostrará su versión como se muestra a continuación:
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.
>>>
Ahora presione ctrl + zy luego Enter para salir del shell de Python y crear una carpeta (en la que pretendía instalar el conector Python-MySQL) llamada Python_MySQL como -
>>> ^Z
C:\Users\Tutorialspoint>d:
D:\>mkdir Python_MySQL
Verificar PIP
PIP es un administrador de paquetes en Python mediante el cual puede instalar varios módulos / paquetes en Python. Por lo tanto, para instalar Mysql-python mysql-connector-python, debe asegurarse de tener PIP instalado en su computadora y que su ubicación se agregue a la ruta.
Puede hacerlo ejecutando el comando pip. Si no tenía PIP en su sistema o, si no ha agregado su ubicación en elPath variable de entorno, obtendrá un mensaje de error como -
D:\Python_MySQL>pip
'pip' is not recognized as an internal or external command,
operable program or batch file.
Para instalar PIP, descargue get-pip.py en la carpeta creada anteriormente y, desde el comando, navegue e instale pip de la siguiente manera:
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
Instalación de mysql-connector-python
Una vez que haya instalado Python y PIP, abra el símbolo del sistema y actualice pip (opcional) como se muestra a continuación:
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
Luego abra el símbolo del sistema en modo de administrador e instale python MySQL connect como -
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
Verificación
Para verificar la instalación, cree un script de muestra de Python con la siguiente línea.
import mysql.connector
Si la instalación es exitosa, cuando la ejecute, no debería recibir ningún error:
D:\Python_MySQL>python test.py
D:\Python_MySQL>
Instalación de Python desde cero
Simplemente, si necesita instalar Python desde cero. Visite la página de inicio de Python .
Clickea en el Downloads , será redirigido a la página de descargas que proporciona enlaces para la última versión de Python para varias plataformas, elija una y descárguela.
Por ejemplo, hemos descargado python-3.7.4.exe (para Windows). Inicie el proceso de instalación haciendo doble clic en el archivo .exe descargado.
Marque la opción Agregar Python 3.7 a la ruta y continúe con la instalación. Después de completar este proceso, Python se instalará en su sistema.
Para conectarse con MySQL, (una forma es) abrir el símbolo del sistema de MySQL en su sistema como se muestra a continuación:
Aquí pide contraseña; debe escribir la contraseña que ha establecido para el usuario predeterminado (root) en el momento de la instalación.
Luego se establece una conexión con MySQL que muestra el siguiente mensaje:
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.
Puede desconectarse de la base de datos MySQL en cualquier momento utilizando el exitcomando en mysql> indicador.
mysql> exit
Bye
Estableciendo conexión con MySQL usando Python
Antes de establecer una conexión a la base de datos MySQL usando python, asuma -
Que hemos creado una base de datos con el nombre mydb.
Hemos creado una tabla EMPLEADO con columnas PRIMER NOMBRE, APELLIDO, EDAD, SEXO e INGRESOS.
Las credenciales que estamos usando para conectarnos con MySQL son nombre de usuario - root, contraseña - password.
Puede establecer una conexión utilizando el constructor connect () . Esto acepta nombre de usuario, contraseña, host y el nombre de la base de datos con la que necesita conectarse (opcional) y devuelve un objeto de la clase MySQLConnection.
Ejemplo
A continuación se muestra el ejemplo de conexión con la base de datos 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()
Salida
Al ejecutarse, este script produce la siguiente salida:
D:\Python_MySQL>python EstablishCon.py
Connection established to: ('mydb',)
También puede establecer una conexión con MySQL pasando credenciales (nombre de usuario, contraseña, nombre de host y nombre de la base de datos) a connection.MySQLConnection() como se muestra a continuación -
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()
Puede crear una base de datos en MYSQL utilizando la consulta CREATE DATABASE.
Sintaxis
A continuación se muestra la sintaxis de la consulta CREATE DATABASE:
CREATE DATABASE name_of_the_database
Ejemplo
La siguiente declaración crea una base de datos con el nombre mydb en MySQL:
mysql> CREATE DATABASE mydb;
Query OK, 1 row affected (0.04 sec)
Si observa la lista de bases de datos utilizando la instrucción SHOW DATABASES, puede observar la base de datos recién creada en ella como se muestra a continuación:
mysql> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| information_schema |
| logging |
| mydatabase |
| mydb |
| performance_schema |
| students |
| sys |
+--------------------+
26 rows in set (0.15 sec)
Creando una base de datos en MySQL usando Python
Después de establecer la conexión con MySQL, para manipular los datos en él, debe conectarse a una base de datos. Puede conectarse a una base de datos existente o crear la suya propia.
Necesitaría privilegios especiales para crear o eliminar una base de datos MySQL. Entonces, si tiene acceso al usuario raíz, puede crear cualquier base de datos.
Ejemplo
El siguiente ejemplo establece una conexión con MYSQL y crea una base de datos en él.
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()
Salida
List of databases:
[
('information_schema',),
('dbbug61332',),
('details',),
('exampledatabase',),
('mydatabase',),
('mydb',),
('mysql',),
('performance_schema',)
]
La declaración CREATE TABLE se utiliza para crear tablas en la base de datos MYSQL. Aquí, debe especificar el nombre de la tabla y la definición (nombre y tipo de datos) de cada columna.
Sintaxis
A continuación se muestra la sintaxis para crear una tabla en MySQL:
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
);
Ejemplo
La siguiente consulta crea una tabla llamada EMPLEADO en MySQL con cinco columnas, a saber, PRIMER NOMBRE, ÚLTIMO NOMBRE, EDAD, SEXO e INGRESOS.
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)
La declaración DESC le da la descripción de la tabla especificada. Con esto, puede verificar si la tabla se ha creado o no como se muestra a continuación:
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)
Creando una tabla en MySQL usando Python
El método llamado execute () (invocado en el objeto cursor) acepta dos variables
Un valor de cadena que representa la consulta que se ejecutará.
Un parámetro opcional de args que puede ser una tupla o una lista o un diccionario, que representa los parámetros de la consulta (valores de los marcadores de posición).
Devuelve un valor entero que representa el número de filas efectuadas por la consulta.
Una vez que se establece una conexión a la base de datos, puede crear tablas pasando la consulta CREATE TABLE al execute() método.
En resumen, para crear una tabla usando python -
Importar mysql.connector paquete.
Cree un objeto de conexión utilizando el mysql.connector.connect() método, pasando el nombre de usuario, contraseña, host (predeterminado opcional: localhost) y base de datos (opcional) como parámetros.
Cree un objeto de cursor invocando el cursor() método en el objeto de conexión creado anteriormente.
Luego, ejecute la instrucción CREATE TABLE pasándola como parámetro alexecute() método.
Ejemplo
El siguiente ejemplo crea una tabla llamada Employee en la base de datos 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()
Puede agregar nuevas filas a una tabla existente de MySQL usando el INSERT INTOdeclaración. En esto, debe especificar el nombre de la tabla, los nombres de las columnas y los valores (en el mismo orden que los nombres de las columnas).
Sintaxis
A continuación se muestra la sintaxis de la instrucción INSERT INTO de MySQL.
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);
Ejemplo
La siguiente consulta inserta un registro en la tabla llamado EMPLEADO.
INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000);
Puede verificar los registros de la tabla después de la operación de inserción usando la instrucción SELECT como:
mysql> select * from Employee;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE | SEX | INCOME |
+------------+-----------+------+------+--------+
| Mac | Mohan | 20| M | 2000 |
+------------+-----------+------+------+--------+
1 row in set (0.00 sec)
No es obligatorio especificar los nombres de las columnas siempre, si pasa valores de un registro en el mismo orden de las columnas de la tabla, puede ejecutar la instrucción SELECT sin los nombres de columna de la siguiente manera:
INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000);
Insertar datos en una tabla MySQL usando Python
los execute()método (invocado en el objeto cursor) acepta una consulta como parámetro y ejecuta la consulta dada. Para insertar datos, debe pasarle la instrucción INSERT de MySQL como parámetro.
cursor.execute("""INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000)""")
Para insertar datos en una tabla en MySQL usando python:
importar mysql.connector paquete.
Cree un objeto de conexión utilizando el mysql.connector.connect() método, pasando el nombre de usuario, contraseña, host (predeterminado opcional: localhost) y base de datos (opcional) como parámetros.
Cree un objeto de cursor invocando el cursor() método en el objeto de conexión creado anteriormente.
Luego, ejecute el INSERT declaración pasándola como parámetro a la execute() método.
Ejemplo
El siguiente ejemplo ejecuta la instrucción SQL INSERT para insertar un registro en la tabla 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()
Insertar valores dinámicamente
También puedes usar “%s” en lugar de valores en el INSERT consulta de MySQL y pasarles valores como listas como se muestra a continuación -
cursor.execute("""INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000)""",
('Ramya', 'Ramapriya', 25, 'F', 5000))
Ejemplo
El siguiente ejemplo inserta un registro en la tabla Empleado de forma dinámica.
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()
Salida
Data inserted
Puede recuperar / buscar datos de una tabla en MySQL usando la consulta SELECT. Esta consulta / declaración devuelve el contenido de la tabla especificada en forma tabular y se llama como conjunto de resultados.
Sintaxis
A continuación se muestra la sintaxis de la consulta SELECT:
SELECT column1, column2, columnN FROM table_name;
Ejemplo
Supongamos que hemos creado una tabla en MySQL con el nombre cricketers_data como -
CREATE TABLE cricketers_data(
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Date_Of_Birth date,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
Y si hemos insertado 5 registros usando instrucciones INSERT como:
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');
La siguiente consulta recupera los valores de FIRST_NAME y Country de la tabla.
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)
También puede recuperar todos los valores de cada registro usando * instalados del nombre de las columnas como -
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)
Leer datos de una tabla MYSQL usando Python
READ Operar en cualquier base de datos significa obtener información útil de la base de datos. Puede recuperar datos de MYSQL utilizando elfetch() método proporcionado por mysql-connector-python.
La clase cursor.MySQLCursor proporciona tres métodos:fetchall(), fetchmany() y, fetchone() dónde,
los fetchall()El método recupera todas las filas del conjunto de resultados de una consulta y las devuelve como una lista de tuplas. (Si ejecutamos esto después de recuperar algunas filas, devuelve las restantes).
los fetchone() El método obtiene la siguiente fila en el resultado de una consulta y la devuelve como una tupla.
los fetchmany() El método es similar al fetchone () pero recupera el siguiente conjunto de filas en el conjunto de resultados de una consulta, en lugar de una sola fila.
Note - Un conjunto de resultados es un objeto que se devuelve cuando se utiliza un objeto de cursor para consultar una tabla.
rowcount - Este es un atributo de solo lectura y devuelve el número de filas que fueron afectadas por un método execute ().
Ejemplo
El siguiente ejemplo recupera todas las filas de la tabla EMPLOYEE usando la consulta SELECT y del conjunto de resultados obtenido inicialmente, estamos recuperando la primera fila usando el método fetchone () y luego recuperando las filas restantes usando el método 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()
Salida
('Krishna', 'Sharma', 19, 'M', 2000.0)
[('Raj', 'Kandukuri', 20, 'M', 7000.0), ('Ramya', 'Ramapriya', 25, 'M', 5000.0)]
El siguiente ejemplo recupera las dos primeras filas de la tabla EMPLOYEE utilizando el método fetchmany ().
Ejemplo
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()
Salida
[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]
Si desea obtener, eliminar o actualizar filas particulares de una tabla en MySQL, debe usar la cláusula where para especificar la condición para filtrar las filas de la tabla para la operación.
Por ejemplo, si tiene una instrucción SELECT con la cláusula where, solo se recuperarán las filas que satisfagan la condición especificada.
Sintaxis
A continuación se muestra la sintaxis de la cláusula WHERE:
SELECT column1, column2, columnN
FROM table_name
WHERE [condition]
Ejemplo
Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -
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)
Y si hemos insertado 4 registros usando instrucciones INSERT como:
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);
La siguiente declaración de MySQL recupera los registros de los empleados cuyos ingresos son superiores a 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)
Cláusula WHERE usando Python
Para obtener registros específicos de una tabla usando el programa Python:
importar mysql.connector paquete.
Cree un objeto de conexión utilizando el mysql.connector.connect() método, pasando el nombre de usuario, contraseña, host (predeterminado opcional: localhost) y base de datos (opcional) como parámetros.
Cree un objeto de cursor invocando el cursor() método en el objeto de conexión creado anteriormente.
Luego, ejecute la instrucción SELECT con la cláusula WHERE , pasándola como parámetro alexecute() método.
Ejemplo
El siguiente ejemplo crea una tabla llamada Empleado y la llena. Luego, utilizando la cláusula where, recupera los registros con un valor de edad inferior a 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()
Salida
[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]
Mientras obtiene datos mediante la consulta SELECT, puede ordenar los resultados en el orden deseado (ascendente o descendente) mediante la cláusula OrderBy. De forma predeterminada, esta cláusula ordena los resultados en orden ascendente; si necesita organizarlos en orden descendente, debe utilizar "DESC" explícitamente.
Sintaxis
A continuación se muestra la lista de columnas SELECT de sintaxis
FROM table_name
[WHERE condition]
[ORDER BY column1, column2,.. columnN] [ASC | DESC]; of the ORDER BY clause:
Ejemplo
Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -
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)
Y si hemos insertado 4 registros usando instrucciones INSERT como:
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);
La siguiente instrucción recupera el contenido de la tabla EMPLOYEE en orden ascendente de edad.
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)
También puede recuperar datos en orden descendente usando DESC como:
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)
Cláusula ORDER BY usando Python
Para recuperar el contenido de una tabla en un orden específico, invoque el execute() en el objeto cursor y pasar la instrucción SELECT junto con la cláusula ORDER BY, como parámetro.
Ejemplo
En el siguiente ejemplo, estamos creando una tabla con el nombre y el Empleado, la rellenamos y recuperamos sus registros en el orden (ascendente) de su antigüedad, utilizando la cláusula 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()
Salida
[
('Raj', 'Kandukuri', 20, 'M', 7000.0),
('Krishna', 'Sharma', 26, 'M', 2000.0),
('Mac', 'Mohan', 26, 'M', 2000.0),
('Ramya', 'Ramapriya', 29, 'F', 5000.0)
]
De la misma manera, puede recuperar datos de una tabla en orden descendente utilizando la cláusula ORDER BY.
Ejemplo
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()
Salida
[
('Raj', 'Kandukuri', 20, 'M', 7000.0),
('Ramya', 'Ramapriya', 29, 'F', 5000.0),
('Krishna', 'Sharma', 26, 'M', 2000.0),
('Mac', 'Mohan', 26, 'M', 2000.0)
]
ACTUALIZAR La operación en cualquier base de datos actualiza uno o más registros, que ya están disponibles en la base de datos. Puede actualizar los valores de los registros existentes en MySQL usando la instrucción UPDATE. Para actualizar filas específicas, debe usar la cláusula WHERE junto con ella.
Sintaxis
A continuación se muestra la sintaxis de la declaración UPDATE en MySQL:
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];
Puede combinar N número de condiciones utilizando los operadores AND u OR.
Ejemplo
Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -
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)
Y si hemos insertado 4 registros usando instrucciones INSERT como:
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);
Seguir la declaración de MySQL aumenta la edad de todos los empleados masculinos en un año:
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
Si recupera el contenido de la tabla, puede ver los valores actualizados como:
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)
Actualizar el contenido de una tabla con Python
Para actualizar los registros en una tabla en MySQL usando python:
importar mysql.connector paquete.
Cree un objeto de conexión utilizando el mysql.connector.connect() método, pasando el nombre de usuario, contraseña, host (predeterminado opcional: localhost) y base de datos (opcional) como parámetros.
Cree un objeto de cursor invocando el cursor() método en el objeto de conexión creado anteriormente.
Luego, ejecute la instrucción UPDATE pasándola como parámetro alexecute() método.
Ejemplo
El siguiente ejemplo aumenta la edad de todos los hombres en un año.
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()
Salida
[
('Krishna', 'Sharma', 22, 'M', 2000.0),
('Raj', 'Kandukuri', 23, 'M', 7000.0),
('Ramya', 'Ramapriya', 26, 'F', 5000.0)
]
Para eliminar registros de una tabla MySQL, debe usar el DELETE FROMdeclaración. Para eliminar registros específicos, debe usar la cláusula WHERE junto con ella.
Sintaxis
A continuación se muestra la sintaxis de la consulta DELETE en MYSQL:
DELETE FROM table_name [WHERE Clause]
Ejemplo
Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -
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)
Y si hemos insertado 4 registros usando instrucciones INSERT como:
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);
La siguiente declaración de MySQL borra el registro del empleado con FIRST_NAME ”Mac” .
mysql> DELETE FROM EMPLOYEE WHERE FIRST_NAME = 'Mac';
Query OK, 1 row affected (0.12 sec)
Si recupera el contenido de la tabla, puede ver solo 3 registros ya que hemos eliminado uno.
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)
Si ejecuta la instrucción DELETE sin la cláusula WHERE, se eliminarán todos los registros de la tabla especificada.
mysql> DELETE FROM EMPLOYEE;
Query OK, 3 rows affected (0.09 sec)
Si recupera el contenido de la tabla, obtendrá un conjunto vacío como se muestra a continuación:
mysql> select * from EMPLOYEE;
Empty set (0.00 sec)
Eliminar registros de una tabla con Python
La operación DELETE es necesaria cuando desea eliminar algunos registros de su base de datos.
Para eliminar los registros en una tabla:
importar mysql.connector paquete.
Cree un objeto de conexión utilizando el mysql.connector.connect() método, pasando el nombre de usuario, contraseña, host (predeterminado opcional: localhost) y base de datos (opcional) como parámetros.
Cree un objeto de cursor invocando el método cursor () en el objeto de conexión creado anteriormente.
Luego, ejecute el DELETE declaración pasándola como parámetro a la execute() método.
Ejemplo
El siguiente programa borra todos los registros del EMPLEADO cuya EDAD es mayor de 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()
Salida
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)
]
Puede eliminar una tabla completa utilizando el DROP TABLEdeclaración. Solo necesita especificar el nombre de la tabla que necesita eliminar.
Sintaxis
A continuación se muestra la sintaxis de la declaración DROP TABLE en MySQL:
DROP TABLE table_name;
Ejemplo
Antes de eliminar una tabla, obtenga la lista de tablas utilizando la instrucción SHOW TABLES de la siguiente manera:
mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb |
+-----------------+
| contact |
| cricketers_data |
| employee |
| sample |
| tutorials |
+-----------------+
5 rows in set (0.00 sec)
La siguiente declaración elimina completamente la tabla llamada muestra de la base de datos:
mysql> DROP TABLE sample;
Query OK, 0 rows affected (0.29 sec)
Dado que hemos eliminado la tabla llamada muestra de MySQL, si vuelve a obtener la lista de tablas, no encontrará la muestra del nombre de la tabla en ella.
mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb |
+-----------------+
| contact |
| cricketers_data |
| employee |
| tutorials |
+-----------------+
4 rows in set (0.00 sec)
Eliminar una tabla con Python
Puede eliminar una tabla siempre que lo necesite, utilizando la declaración DROP de MYSQL, pero debe tener mucho cuidado al eliminar cualquier tabla existente porque los datos perdidos no se recuperarán después de eliminar una tabla.
Para eliminar una tabla de una base de datos MYSQL usando python, invoque el execute() en el objeto cursor y pasarle la sentencia drop como parámetro.
Ejemplo
La siguiente tabla quita una tabla llamada EMPLEADO de la base de datos.
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()
Salida
List of tables in the database:
[('employee',), ('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',), ('tutorials',)]
Descartar tabla solo si existe
Si intenta eliminar una tabla que no existe en la base de datos, se produce un error como:
mysql.connector.errors.ProgrammingError: 1051 (42S02): Unknown table 'mydb.employee'
Puede evitar este error verificando si la tabla existe antes de eliminarla, agregando IF EXISTS a la instrucción 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',)]
Al buscar registros si desea limitarlos a un número en particular, puede hacerlo utilizando la cláusula LIMIT de MYSQL.
Ejemplo
Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -
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)
Y si hemos insertado 4 registros usando instrucciones INSERT como:
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);
La siguiente instrucción SQL recupera los dos primeros registros de la tabla Empleado utilizando la cláusula 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)
Limitar cláusula usando Python
Si invoca el execute() en el objeto cursor al pasar la consulta SELECT junto con la cláusula LIMIT, puede recuperar el número requerido de registros.
Ejemplo
El siguiente ejemplo de Python crea y llena una tabla con el nombre EMPLOYEE y, usando la cláusula LIMIT, obtiene los dos primeros registros de la misma.
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()
Salida
[('Krishna', 'Sharma', 26, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]
LIMIT con OFFSET
Si necesita limitar los registros comenzando desde el n-ésimo registro (no el primero), puede hacerlo usando OFFSET junto con 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)]
Cuando haya dividido los datos en dos tablas, puede obtener registros combinados de estas dos tablas utilizando Combinaciones.
Ejemplo
Supongamos que hemos creado una tabla con el nombre EMPLEADO y los datos introducidos en ella como se muestra a continuación:
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
Entonces, si hemos creado otra tabla y la hemos llenado como -
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
La siguiente declaración recupera datos que combinan los valores en estas dos tablas:
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 usando Python
El siguiente ejemplo recupera datos de las dos tablas anteriores combinadas por la columna de contacto de la tabla EMPLEADO y la columna ID de la tabla CONTACTO.
Ejemplo
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()
Salida
[
('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')
]
El MySQLCursor de mysql-connector-python (y bibliotecas similares) se usa para ejecutar declaraciones para comunicarse con la base de datos MySQL.
Utilizando sus métodos, puede ejecutar sentencias SQL, obtener datos de los conjuntos de resultados, llamar a procedimientos.
Puedes crear Cursor objeto utilizando el método cursor () del objeto / clase Connection.
Ejemplo
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()
Métodos
A continuación se muestran los diversos métodos proporcionados por la clase / objeto Cursor.
No Señor | Métodos y descripción |
---|---|
1 | callproc() Este método se utiliza para llamar a la base de datos MySQL de procedimientos existentes. |
2 | close() Este método se utiliza para cerrar el objeto de cursor actual. |
3 | Info() Este método proporciona información sobre la última consulta. |
4 | executemany() Este método acepta una lista de series de parámetros. Prepara una consulta MySQL y la ejecuta con todos los parámetros. |
5 | execute() Este método acepta una consulta MySQL como parámetro y ejecuta la consulta dada. |
6 | fetchall() Este método recupera todas las filas del conjunto de resultados de una consulta y las devuelve como una lista de tuplas. (Si ejecutamos esto después de recuperar algunas filas, devuelve las restantes) |
7 | fetchone() Este método obtiene la siguiente fila en el resultado de una consulta y la devuelve como una tupla. |
8 | fetchmany() Este método es similar al fetchone () pero recupera el siguiente conjunto de filas en el conjunto de resultados de una consulta, en lugar de una sola fila. |
9 | fetchwarnings() Este método devuelve las advertencias generadas por la última consulta ejecutada. |
Propiedades
A continuación se muestran las propiedades de la clase Cursor:
No Señor | Descripción de propiedad |
---|---|
1 | column_names Esta es una propiedad de solo lectura que devuelve la lista que contiene los nombres de columna de un conjunto de resultados. |
2 | description Esta es una propiedad de solo lectura que devuelve la lista que contiene la descripción de las columnas en un conjunto de resultados. |
3 | lastrowid Esta es una propiedad de solo lectura, si hay columnas autoincrementadas en la tabla, esto devuelve el valor generado para esa columna en la última operación INSERT o UPDATE. |
4 | rowcount Esto devuelve el número de filas devueltas / actualizadas en caso de operaciones SELECT y UPDATE. |
5 | statement Esta propiedad devuelve la última sentencia ejecutada. |