Como podemos executar a consulta MySQL em Python
Antes do início, temos que instalar o conector MySQL em nosso ambiente de sistema local.
Existem dois métodos para instalar:
Método 1:
Podemos baixar e instalar diretamente o conector MySQL em seu site oficial de acordo com nossa compatibilidade e versão do sistema operacional.
Method_2:
A maneira mais fácil é usar o método pip.
PIP Instale o MySQL Connector-pythonSe estivermos usando uma versão específica, precisamos atribuir o nome da versão como dado abaixo:
pip install mysql-conector-python ==Criação de conexão:
Agora, no primeiro passo após a instalação bem -sucedida do MySQL em nosso sistema local, tentamos criar uma conexão. Se a conexão for bem -sucedida, podemos mudar para a próxima etapa.
#python Eastablish_connection.py#import a biblioteca
importar mysql.conector
# criando conexão
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha"
)
# imprima o conn
Imprimir (Conn)
Saída:
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 13:
Por fim, apenas imprimimos a conexão e ela mostra na conexão de saída feita ao MySQL e retorna um objeto com seu endereço de memória.
Crie um banco de dados:
Agora, criamos um banco de dados com a ajuda do Python.
#python create_a_database.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)
mycursor.execute ("Criar banco de dados DBTest")
Saída:
Cmysqlcursor: (nada executado ainda)
Linha 16:
Nós importamos o método cursor do objeto de conexão estabelecida (Conn).
Linha 18:
Agora, apenas imprimimos esse mycursor que criamos na linha 16, e a saída mostra que o CMYSQLCursor: (nada executado ainda).
Linha 20:
Estamos executando uma consulta para criar um banco de dados, mas não retorna nada. Então, se imprimirmos (MyCursor.Execute ("Criar banco de dados DBTest")), não obteremos nenhum como tipo de retorno.
Se verificarmos nosso banco de dados MySQL, podemos ver que nosso novo banco de dados (DBTest) é criado com sucesso.
➜ ~ mysql -u sammy -pDigite a senha:
Bem -vindo ao monitor MySQL. Os comandos terminam com; ou \ g.
Seu ID de conexão MySQL é 17
Versão do servidor: 8.0.26-0UBUNTU0.20.04.2 (Ubuntu)
Copyright (c) 2000, 2021, Oracle e/ou suas afiliadas.
Oracle é uma marca registrada da Oracle Corporation e/ou de sua
afiliados. Outros nomes podem ser marcas comerciais de seus respectivos
os Proprietários.
Digite 'ajuda;' ou '\ h' para obter ajuda. Digite '\ c' para limpar a instrução de entrada atual.
MySQL> Mostrar bancos de dados;
+--------------------+
| Banco de dados |
+--------------------+
| dbtest |
| Information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
5 linhas no set (0.00 seg)
mysql>
Conexão com o banco de dados:
Agora, estamos tentando nos conectar com nosso banco de dados recém -criado (DBTest) com Python. O código para isso é dado abaixo:
#python conn_to_database.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"
)
# imprima o conn
Imprimir (Conn)
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).
Crie uma tabela:
- Vamos criar uma nova tabela (filme) no banco de dados recém -criado (DBTest).
- As três colunas que vamos usar são ID, nome e ano. O ID e o ano serão do tipo int (número inteiro), e o nome será do tipo Varchar. Também definiremos uma coluna (ID) como uma chave primária.
- O nome da coluna armazenará o número máximo de caracteres 30, à medida que definimos Varchar (30).
#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"
)
# criamos um objeto MyCursor usando o Conn.cursor()
mycursor = Conn.cursor()
mycursor.Execute ("Tabela de soltar se existir filme")
# Escrevemos uma consulta para criar uma tabela
Query = "Crie filme de tabela (ID int Primary Key, Nome Varchar (30), Ano Int)"
# Nós executamos a consulta aqui
mycursor.executar (consulta)
# Depois de concluir o processo, fechamos a conexão
Conn.fechar()
Linha 14:
Criamos um objeto do cursor.
Linha 15:
Também estamos executando uma consulta aqui com o método executivo de que, se o nome da tabela (filme) já existir no banco de dados MySQL, ele excluirá essa tabela. Caso contrário, receberemos o erro que já existe.
Linha 18 a 21:
Criamos uma consulta para criar uma tabela e executar essa consulta na linha número 21 com a função Execute.
Linha 24:
Por fim, fechamos nossa conexão.
Abaixo está a saída MySQL, onde confirmamos que nossa tabela é criada com sucesso dentro do banco de dados MySQL.
MySQL> Mostrar bancos de dados;+--------------------+
| Banco de dados |
+--------------------+
| dbtest |
| Information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
5 linhas no set (0.00 seg)
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> Mostrar tabelas;
+------------------+
| Tables_in_dbtest |
+------------------+
| Filme |
+------------------+
1 linha no conjunto (0.00 seg)
mysql> selecione * do filme;
Conjunto vazio (0.00 seg)
mysql> selecione * do filme;
Erro 1146 (42S02): Tabela 'DBTest.filme 'não existe
MySQL> Descr filme;
+-------+-------------+------+-----+---------+-------+
| Campo | Tipo | Nulo | Chave | Padrão | Extra |
+-------+-------------+------+-----+---------+-------+
| id | int | Não | PRI | Nulo | |
| nome | Varchar (30) | Sim | | Nulo | |
| ano | int | Sim | | Nulo | |
+-------+-------------+------+-----+---------+-------+
3 linhas no set (0.00 seg)
mysql>
Adicione um registro à tabela:
Agora, vamos inserir um registro na tabela. O código python para isso é dado abaixo.
#python registro_insertion.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 (1, "Bruce Todo -Poderoso", 2003) '
mycursor.executar (consulta)
# Nós comprometemos (salve) os registros na tabela
Conn.comprometer-se()
Linha 17:
Criamos uma consulta para inserir um registro no filme da tabela.
Linha 19:
Nós executamos essa consulta.
Linha 22:
Finalmente comprometemos o registro.
Saída:
A saída abaixo mostra que registramos com sucesso o filme da tabela.
mysql> selecione * do filme;+----+----------------+------+
| id | nome | ano |
+----+----------------+------+
| 1 | Bruce Todo -Poderoso | 2003 |
+----+----------------+------+
1 linha no conjunto (0.00 seg)
mysql>
Inserção de registro múltiplo:
Também podemos adicionar vários registros de uma vez na tabela. Então, neste programa, vamos ver esse método. Para inserir os vários registros, precisamos usar o método executemany () em vez do método execute ().
#python insert_record_multiple.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:
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)
Selecione Registro na tabela:
Neste programa, adicionaremos outra consulta Selecione para buscar os registros da tabela.
#python select_query.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 e busque todos os registros
Query = 'Selecione * do filme'
mycursor.executar (consulta)
resultado = mycursor.Fetchall ()
# Nós imprimimos nosso resultado
Imprimir (resultado)
# Agora, fazemos iteração em cada registro e imprimimos
Para registro no resultado:
Imprimir (registro)
Linha 17 a 19:
Criamos uma consulta selecionada e executamos essa consulta. O método fetchall () é usado para buscar todos os registros dessa tabela em particular.
Linha 22:
Imprimos o resultado e descobrimos que todos os registros são tupla e dentro de uma lista. A saída abaixo está mostrando a lista.
Linha 25 a 26:
Nós iteramos a lista e imprimimos cada registro de tupla.
Saída:
[(1, 'Bruce Almighty', 2003), (2, 'Kung Fu Panda', 2014), (3, 'Kung Fu Panda', 2014), (4, 'Frozen', 2014), (5, ' Frozen2 ', 2020), (6,' Iron Man ', 2013)](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)
Conclusão:
Neste artigo, vimos como criar uma conexão com o MySQL usando o Python. Também estudamos os diferentes métodos de inserção de dados, como inserções de registros de dados únicos ou múltiplos na tabela. Também vimos como podemos executar a consulta através do Python. Temos que criar uma consulta e depois passar essa consulta ao método execute () para a execução e armazenar que resulta em alguma variável.
O código deste artigo está disponível no link do GitHub:
https: // github.com/shekharpandey89/mysql-quadery-conexão