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