¿Cuál es el cursor ejecutar en python??

¿Cuál es el cursor ejecutar en python??
Un cursor es un objeto que ayuda a ejecutar la consulta y obtener los registros de la base de datos. El cursor juega un papel muy importante en la ejecución de la consulta. Este artículo aprenderá información profunda sobre los métodos de ejecución y cómo usar esos métodos en Python.

Podemos crear el objeto cursor a través del mysql.

Crear un objeto cursor:

#python cursor_object.py
#Importa la biblioteca
importar mysql.conector
# Creación de conexión
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña"
)
#Imprima la conexión
Imprimir (Conn)
# Importar el cursor desde la conexión (Conn)
Micursor = Conn.cursor()
#Print el micursor
Imprimir (micrursor)

Producción: python cursor_object.py


CMYSQLCURSOR: (Nada ejecutado todavía)

Línea 4: Importamos la clase de conector de mysql.

Línea 7 a 11: Accedemos al método de conexión a través de la clase de conector, que ya importamos a nuestro programa. Ahora, estamos pasando nuestros parámetros de conexión al método de conexión. El nombre de usuario y la contraseña serán diferentes según su proceso de instalación.

Línea 16: Importamos el método del cursor desde el objeto de conexión establecido (Conn) y creamos el objeto cursor (micursor).

Línea 18: Ahora, solo imprimimos este micursor que creamos en la línea 16, y la salida muestra que CMYSQLCURSOR: (nada ejecutado todavía).

Método cursor.ejecutar ():

El método Execute () nos ayuda a ejecutar la consulta y devolver los registros de acuerdo con la consulta. La sintaxis de la función Execute () es:

ejecutar (consulta, args = ninguno)

Parámetros:

  • consulta: Esto debería ser un tipo de cadena.
  • Argumentos: Por defecto, los argumentos son Ninguno porque a veces solo podemos pasar una consulta como una SELECCIONAR consulta que obtiene los registros y no requiere ningún valor. Entonces esa es la razón del Args = ninguno por defecto. Pero si queremos pasar los valores en el caso del INSERTAR consulta, entonces el tipo de argumentos debe ser una tupla, lista o solo dict.

Devoluciones:

  • Devolverá el recuento de los números de filas afectadas durante la consulta.

Tipo de retorno:

  • El tipo de retorno será un entero (En t).
    Ahora, vamos a mostrar algunos ejemplos.

Ejemplo 1: usar el método Execute () solo para consulta

#python simple_execute_function.py
#Importa la biblioteca
importar mysql.conector
# Creación de conexión
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
# Importar el cursor desde la conexión (Conn)
Micursor = Conn.cursor()
micursor.ejecutar ("Seleccionar * de la película")
# iterar sobre el resultado
para fila en micrursor:
Imprimir (fila)
# Cerramos el cursor y Conn ambos
micursor.cerca()
conn.cerca()

Producción: Python simple_execute_function.py

(1, 'Bruce Todopoderoso', 2003)
(2, 'Kung Fu Panda', 2014)
(3, 'Kung Fu Panda', 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, 'Iron Man', 2013)

Línea 11: Agregamos un nombre de parámetro más a la base de datos. Ahora, nuestro código Python intentará conectarse con esta base de datos MySQL (DBTEST) solamente.

Línea 15: Creamos un objeto cursor (micrursor).

Línea 17: Ejecutamos una selección de consulta simple a través de la función de ejecución.

Línea 20 a 21: Iteramos sobre los resultados obtenidos por el objeto del cursor y notamos que todos los registros se devuelven en tuplas.

Ejemplo_2: Use el método Execute () para inserción de registro único

#python insert_record_execute.py
#Importa la biblioteca
importar mysql.conector
# Crear conexión a la base de datos
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
Micursor = Conn.cursor()
# Ejecutar la consulta con su valor registrado
Query = 'Insertar en la película (ID, nombre, año) Valores ( %s, %s, %s)'
val = (7, "Merlín", 2001)
micursor.ejecutar (consulta, val)
# cometimos (guardamos) los registros en la tabla
conn.comprometerse()
Imprimir (micrursor.RowCount, "Registro (s) insertado.")

Producción: python insert_record_execute.py

mysql> usar dbtest;
Lectura de la información de la tabla para completar los nombres de la tabla y la columna
Puede desactivar esta función para obtener una inicio más rápida con -a
Base de datos cambiada
mysql> seleccionar * de la película;
+----+----------------+------+
| ID | nombre | Año |
+----+----------------+------+
| 1 | Bruce Todopoderoso | 2003 |
| 2 | Kung Fu Panda | 2014 |
| 3 | Kung Fu Panda | 2014 |
| 4 | Congelado | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Iron Man | 2013 |
| 7 | Merlín | 2001 |
+----+----------------+------+
7 filas en el set (0.00 seg)
mysql>

Línea 11: Agregamos un nombre de parámetro más a la base de datos. Ahora, nuestro código Python intentará conectarse con esta base de datos MySQL (DBTEST) solamente.

Línea 17: Creamos nuestra consulta para los datos de inserción.

Línea 18: Creamos el valor para que esa consulta se inserte en la tabla.

Línea 21: Usamos la función Execute () y les pasamos tanto consulta como a Val como parámetro.

Y la salida anterior muestra que el registro se insertó con éxito en la tabla.

Método Detalles del método
Fetchone () Esto devolverá la fila única del resultado, y si no hay un registro para devolver, entonces no volverá como ninguno.
fetchmany ([tamaño]) Esto devolverá el número de filas como tamaño especificado de los conjuntos de resultados, y si no hay un registro para devolver, entonces devolverá []. El tamaño predeterminado es 1.
Fetchall () Devuelve las filas todas o restantes del conjunto de resultados.

Expliquemos los métodos anteriores utilizando un ejemplo.

#python cursor_method.py
#Importa la biblioteca
importar mysql.conector
# Creación de conexión
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
# Importar el cursor desde la conexión (Conn)
Micursor = Conn.cursor()
micursor.ejecutar ("Seleccionar * de la película")
Imprimir (micrursor.fetchone ()) # busca la primera fila
Imprimir (micrursor.fetchmany (4)) # buscar las siguientes 2 filas
Imprimir (micrursor.fetchall ()) # buscar todas las filas restantes
Imprimir (micrursor.fetchmany ()) # El conjunto de resultados ahora está vacío
# Cerramos el cursor y Conn ambos
micursor.cerca()
conn.cerca()

Producción: python cursor_method.py

(1, 'Bruce Todopoderoso', 2003)
[(2, 'Kung Fu Panda', 2014), (3, 'Kung Fu Panda', 2014), (4, 'Frozen', 2014), (5, 'Frozen2', 2020)]]
[(6, 'Iron Man', 2013), (7, 'Merlín', 2001)]
[(6, 'Iron Man', 2013)]

Línea 19: El método fetchone () obtiene el primer registro de los conjuntos de resultados.

Línea 20: El método Fetchmany (4) obtiene los cuatro registros de los conjuntos de resultados.

Línea 21: El método fetchall () obtiene todos los registros restantes de los conjuntos de resultados.

Línea 22: El fetchmany () tiene un tamaño predeterminado 1, por lo que nuevamente intenta obtener un registro de los conjuntos de resultados. Pero a medida que el método Fetchmany (4) ya accede a los 4 registros y el método Fetchone () accede al primer registro, por lo que trata de obtener la sexta tupla de los conjuntos de registros.

Método cursor.Executemany ():

El método ExecutEmany () nos ayuda a insertar o reemplazar múltiples registros a la vez. La sintaxis de la función EXECTEMAny () es:

Executemany (consulta, args)

Parámetros:

  • consulta: Esto debería ser un tipo de cadena.
  • Argumentos: Por defecto, los argumentos son Ninguno, Por eso no podemos ejecutar el SELECCIONAR consulta en eso. Podemos pasar los valores cualquier tipo de Tuple o lista solo.

Devoluciones:

  • Devolverá el recuento de los números de filas afectadas durante la consulta si.

Tipo de retorno:

  • El tipo de retorno será un entero (int o ninguno).

Ahora, vamos a mostrar un ejemplo del método anterior.

#Python Executemany.py
#Importa la biblioteca
importar mysql.conector
# Crear conexión a la base de datos
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
Micursor = Conn.cursor()
# Ejecutar la consulta con su valor registrado
Query = 'Insertar en la película (ID, nombre, año) Valores ( %s, %s, %s)'
Val = [(2, "Kung Fu Panda", 2014),
(4, "Frozen", 2014),
(5, "Frozen2", 2020),
(6, "Iron Man", 2013)
]
micursor.Executemany (consulta, val)
# cometimos (guardamos) los registros en la tabla
conn.comprometerse()
Imprimir (micrursor.RowCount, "Registro (s) insertado.")

Línea 17: Creamos nuestra consulta para los datos de inserción.

Línea 18: Creamos una lista de valores que queremos insertar en la tabla.

Línea 25: Utilizamos el método ExeckEmany () para ingresar los múltiples registros.

Producción: Python Executemany.py

mysql> seleccionar * de la película;
+----+----------------+------+
| ID | nombre | Año |
+----+----------------+------+
| 1 | Bruce Todopoderoso | 2003 |
| 2 | Kung Fu Panda | 2014 |
| 3 | Kung Fu Panda | 2014 |
| 4 | Congelado | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Iron Man | 2013 |
+----+----------------+------+
6 filas en el set (0.00 seg)

Ejecutar muchas consultas usando una sola función Execute ():

También podemos ejecutar múltiples consultas utilizando la función ejecutada () única (). La función ejecutar () acepta un parámetro adicional, multi. El multi = falso por defecto. Si guardamos multi = verdadero, Entonces podemos ejecutar una consulta multi-SQL usando el separador Semicolon (;).

# Python Execute_multi.py
#Importa la biblioteca
importar mysql.conector
# Creación de conexión
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
# Importar el cursor desde la conexión (Conn)
Micursor = Conn.cursor()
# Consulta con estilo de parámetro de formato
Query_1 = "Seleccionar * de la película"
Query_2 = 'Insertar en la película (ID, nombre, año) Valores ( %s, %s, %s)'
consultas = [Query_1, Query_2]
val = (8, "Serie", 2001)
Multirlults = Micursor.ejecutar(";".unir (consultas), val, multi = true)
recuento = 1
Para el resultado en multirrultos:
# El resultado es como un cursor, por lo que podemos acceder a todos
# Atributos del cursor
print ("Query_ 0 - 1:".formato (recuento, resultado.declaración))
Si resultado.with_rows:
Para la fila en el resultado:
Imprimir (fila)
recuento = recuento + 1
demás:
Imprimir ("Sin resultado")
imprimir()
micursor.cerca()
conn.cerca()

Producción: Python Execute_multi.py

Query_1 - Seleccione * de la película:
(1, 'Bruce Todopoderoso', 2003)
(2, 'Kung Fu Panda', 2014)
(3, 'Kung Fu Panda', 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, 'Iron Man', 2013)
(7, 'Merlín', 2001)
Query_2 - Inserte en la película (ID, nombre, año) Valores (8, 'Serie', 2001):
Sin resultados

Línea 23: Creamos una lista de dos consultas.

Línea 28: Pasamos la lista de consultas, val y separador (;) al método Execute (). También cambiamos el valor de multi de falso a verdad.

En la salida anterior, podemos ver nuestros resultados del múltiple que.

Conclusión:

En este artículo, estudiamos el método Execute (). También hemos visto diferentes tipos de métodos Execute () como el método ExecioMany (). También estudiamos cómo consultar el cursor. Método ejecutar () y diferentes parámetros de ese método. Por fin, también hemos visto cómo podemos hacer múltiples curas utilizando el método Execute ().

El código de este artículo está disponible en el enlace GitHub:
https: // github.com/shekharpandey89/cursor-execute-python