O que o cursor é executado em python?

O que o cursor é executado em python?
Um cursor é um objeto que ajuda a executar a consulta e buscar os registros do banco de dados. O cursor desempenha um papel muito importante na execução da consulta. Este artigo aprenderá algumas informações profundas sobre os métodos de execução e como usar esses métodos no Python.

Podemos criar o objeto Cursor através do MySQL.

Crie um objeto de cursor:

#python cursor_object.py
#import a biblioteca
importar mysql.conector
# criando conexão
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha"
)
#print a conexão
Imprimir (Conn)
# Importe o cursor da conexão (Conn)
mycursor = Conn.cursor()
#Print The Mycursor
Imprimir (MyCursor)

Saída: python cursor_object.py


Cmysqlcursor: (nada executado ainda)

Linha 4: Nós importamos a classe do conector do mysql.

Linha 7 a 11: Acessamos o método de conexão através da classe do conector, que já importamos para o nosso programa. Agora, estamos passando nossos parâmetros de conexão para o método de conexão. O nome de usuário e a senha serão diferentes de acordo com o seu processo de instalação.

Linha 16: Importamos o método cursor do objeto de conexão estabelecida (Conn) e criamos o objeto Cursor (MyCursor).

Linha 18: Agora, apenas imprimimos esse mycursor que criamos na linha 16, e a saída mostra que o CMYSQLCursor: (nada executado ainda).

Cursor do método.execute ():

O método Execute () nos ajuda a executar a consulta e retornar registros de acordo com a consulta. A sintaxe da função Execute () é:

execute (consulta, args = nenhum)

Parâmetros:

  • consulta: Este deve ser um tipo de string.
  • Argumentos: Por padrão, os argumentos são Nenhum Porque às vezes podemos passar apenas uma consulta como um Selecione Consulta que busca os registros e não requer valores. Então essa é a razão do args = nenhum por padrão. Mas se queremos passar os valores no caso do INSERIR Consulta, então o tipo de argumento deve ser uma tupla, lista ou dicto apenas.

Retornos:

  • Ele retornará a contagem do número de linhas afetadas durante a consulta.

Tipo de retorno:

  • O tipo de retorno será um número inteiro (int).
    Agora, vamos mostrar alguns exemplos.

Exemplo 1: Use o método Execute () apenas para consulta

#python simples_execute_function.py
#import a biblioteca
importar mysql.conector
# criando conexão
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
# Importe o cursor da conexão (Conn)
mycursor = Conn.cursor()
mycursor.execute ("selecione * do filme")
# itera sobre o resultado
Para fila em Mycursor:
Imprimir (linha)
# nós fechamos o cursor e conn os dois
mycursor.fechar()
Conn.fechar()

Saída: python simples_execute_function.py

(1, 'Bruce Almighty', 2003)
(2, 'Kung Fu Panda', 2014)
(3, 'kung fu panda', 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, 'Homem de Ferro', 2013)

Linha 11: Adicionamos mais um nome de parâmetro ao banco de dados. Agora, nosso código Python tentará se conectar apenas com este banco de dados MySQL (DBTest).

Linha 15: Criamos um objeto cursor (mycursor).

Linha 17: Executamos uma consulta simples selecionada através da função de execução.

Linha 20 a 21: Iteramos sobre os resultados obtidos pelo objeto Cursor e notamos que todos os registros são devolvidos em tuplas.

Exemplo_2: Use o método Execute () para inserção

#python insert_record_execute.py
#import a biblioteca
importar mysql.conector
# Criando conexão com o banco de dados
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
mycursor = Conn.cursor()
# Execute a consulta com seu valor recorde
Query = 'inserir no filme (id, nome, ano) valores ( %s, %s, %s)'
Val = (7, "Merlin", 2001)
mycursor.executar (consulta, Val)
# Nós comprometemos (salve) os registros na tabela
Conn.comprometer-se()
Imprimir (MyCursor.Rowcount, "Record (s) inserido.")

Saída: python insert_record_execute.py

mysql> use dbtest;
Leitura Informações da tabela para conclusão de nomes de tabela e colunas
Você pode desativar esse recurso para obter uma inicialização mais rápida com -a
Banco de dados alterado
mysql> selecione * do filme;
+----+----------------+------+
| id | nome | Ano |
+----+----------------+------+
| 1 | Bruce Todo -Poderoso | 2003 |
| 2 | Kung fu panda | 2014 |
| 3 | Kung fu panda | 2014 |
| 4 | Congelado | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Homem de Ferro | 2013 |
| 7 | Merlin | 2001 |
+----+----------------+------+
7 linhas no set (0.00 seg)
mysql>

Linha 11: Adicionamos mais um nome de parâmetro ao banco de dados. Agora, nosso código Python tentará se conectar apenas com este banco de dados MySQL (DBTest).

Linha 17: Criamos nossa consulta para os dados de inserção.

Linha 18: Criamos o valor para essa consulta inserir na tabela.

Linha 21: Usamos a função Execute () e passamos a consulta e Val como um parâmetro.

E a saída acima mostra que o registro foi inserido com sucesso na tabela.

Método Detalhes do método
FetchOne () Isso retornará a linha única do resultado e, se não houver registro para retornar, ele retornará como nenhum.
FetchMany ([tamanho]) Isso retornará o número de linhas conforme o tamanho especificado nos conjuntos de resultados e, se não houver registro para retornar, ele retornará []. O tamanho padrão é 1.
Fetchall () Retorna as linhas todas ou restantes do conjunto de resultados.

Vamos explicar os métodos acima usando um exemplo.

#python cursor_method.py
#import a biblioteca
importar mysql.conector
# criando conexão
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
# Importe o cursor da conexão (Conn)
mycursor = Conn.cursor()
mycursor.execute ("selecione * do filme")
Imprimir (MyCursor.fetchOne ()) # busque a primeira linha
Imprimir (MyCursor.FetchMany (4)) # busca as próximas 2 linhas
Imprimir (MyCursor.fetchall ()) # busque todas as linhas restantes
Imprimir (MyCursor.FetchMany ()) # O conjunto de resultados agora está vazio
# nós fechamos o cursor e conn os dois
mycursor.fechar()
Conn.fechar()

Saída: python cursor_method.py

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

Linha 19: O método FetchOne () busca o primeiro registro dos conjuntos de resultados.

Linha 20: O método FetchMany (4) busca os quatro registros dos conjuntos de resultados.

Linha 21: O método fetchall () busca todos os registros restantes dos conjuntos de resultados.

Linha 22: O FetchMany () tem tamanho 1 padrão, então ele tenta novamente buscar um registro dos conjuntos de resultados. Mas como o método FetchMany (4) já acessa o método 4 registros e o método FetchOne () acesse o 1º registro, por isso tenta buscar a 6ª tupla dos conjuntos de registros.

Cursor do método.executemany ():

O método executemany () nos ajuda a inserir ou substituir vários registros de uma só vez. A sintaxe da função executemany () é:

Executemany (consulta, args)

Parâmetros:

  • consulta: Este deve ser um tipo de string.
  • Argumentos: Por padrão, os argumentos são não nenhum, É por isso que não somos capazes de executar o Selecione Consulta nisso. Podemos passar os valores de tipos de tupla ou lista apenas.

Retornos:

  • Ele retornará a contagem do número de linhas afetadas durante a consulta, se houver.

Tipo de retorno:

  • O tipo de retorno será um número inteiro (int ou nenhum).

Agora, vamos mostrar um exemplo do método acima.

#python executemany.py
#import a biblioteca
importar mysql.conector
# Criando conexão com o banco de dados
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
mycursor = Conn.cursor()
# Execute a consulta com seu valor recorde
Query = 'inserir no filme (id, nome, ano) valores ( %s, %s, %s)'
Val = [(2, "Kung Fu Panda", 2014),
(4, "Frozen", 2014),
(5, "Frozen2", 2020),
(6, "Homem de Ferro", 2013)
]
mycursor.Executemany (Query, Val)
# Nós comprometemos (salve) os registros na tabela
Conn.comprometer-se()
Imprimir (MyCursor.Rowcount, "Record (s) inserido.")

Linha 17: Criamos nossa consulta para os dados de inserção.

Linha 18: Criamos uma lista de valores que queremos inserir na tabela.

Linha 25: Usamos o método executemany () para inserir os vários registros.

Saída: Python Execememany.py

mysql> selecione * do filme;
+----+----------------+------+
| id | nome | Ano |
+----+----------------+------+
| 1 | Bruce Todo -Poderoso | 2003 |
| 2 | Kung fu panda | 2014 |
| 3 | Kung fu panda | 2014 |
| 4 | Congelado | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Homem de Ferro | 2013 |
+----+----------------+------+
6 linhas no set (0.00 seg)

Execute muitas consultas usando uma única função execute ():

Também podemos executar várias consultas usando a função única execute (). A função Execute () aceita um parâmetro extra, Multi. O Multi = false por padrão. Se mantivermos multi = true, Em seguida, podemos executar uma consulta multi-sql usando o separador de semicolon (;).

# python execute_multi.py
#import a biblioteca
importar mysql.conector
# criando conexão
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
# Importe o cursor da conexão (Conn)
mycursor = Conn.cursor()
# consulta com estilo de parâmetro de formato
Query_1 = "Selecione * do filme"
query_2 = 'inserir no filme (id, nome, ano) valores ( %s, %s, %s)'
Queries = [Query_1, Query_2]
val = (8, "série", 2001)
Multiresults = MyCursor.executar(";".junte -se (consultas), val, multi = true)
contagem = 1
Para resultar em multiresultos:
# O resultado é como um cursor, para que possamos acessar todos
# atributos do cursor
print ("Query_ 0 - 1:".formato (contagem, resultado.declaração))
se resultado.with_rows:
para linha em resultado:
Imprimir (linha)
contagem = contagem + 1
outro:
print ("sem resultado")
imprimir()
mycursor.fechar()
Conn.fechar()

Saída: python execute_multi.py

Query_1 - Selecione * do filme:
(1, 'Bruce Almighty', 2003)
(2, 'Kung Fu Panda', 2014)
(3, 'kung fu panda', 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, 'Homem de Ferro', 2013)
(7, 'Merlin', 2001)
Query_2 - Inserir no filme (id, nome, ano) valores (8, 'série', 2001):
Nenhum resultado

Linha 23: Criamos uma lista de duas consultas.

Linha 28: Passamos a lista de consultas, Val e separador (;) para o método execute (). Nós também mudamos o valor de Multi de falso para verdadeiro.

Na saída acima, podemos ver nossos resultados do multi-médio.

Conclusão:

Neste artigo, estudamos o método Execute (). Também vimos diferentes tipos de métodos execute () como o método executemany (). Também estudamos como consultar o cursor. Método Execute () e diferentes parâmetros desse método. Por fim, também vimos como podemos fazer várias questões usando o método execute ().

O código deste artigo está disponível no link do GitHub:
https: // github.com/shekharpandey89/cursor-executo-python