Python Sqlite Selecione

SQLite é uma biblioteca de banco de dados incorporada C-escrita. Outros sistemas de banco de dados, como PostgreSQL ou MySQL, possivelmente alguns que você já conhece. Eles empregam uma arquitetura cliente-servidor, na qual o banco de dados é configurado como servidor e acessado por um cliente. Como o SQLite é incorporado a um programa como uma biblioteca, é diferente e é referido como um banco de dados incorporado. Todos os dados são mantidos em um arquivo, normalmente com um .Extensão de banco de dados e usando as funções definidas, podemos executar/executar instruções SQL. Além disso, o uso dessas funções nos permite realizar várias operações de banco de dados. Este tutorial abrange como usar ou executar uma consulta selecionada para recuperar dados da tabela SQLite usando o módulo SQLITE3, que é uma biblioteca embutida do Python.

Qual é a instrução SELECT no SQLITE Python?

A declaração principal que usamos para consultar um banco de dados SQLite é a cláusula selecionada. O que selecionar ou buscar é especificado na cláusula selecionada. A cláusula de From geralmente é usada com a cláusula selecionada para especificar de onde queremos acessar ou recuperar os dados.

Pré -requisito

Você deve primeiro se conectar ao banco de dados e uma tabela com linhas e colunas de dados devem estar disponíveis. Você deve estar familiarizado com o nome da tabela sqlite e os detalhes de suas colunas antes de executar o seguinte aplicativo.

Como usar a consulta selecionada em Python?

Os usuários do Python podem usar as seguintes etapas para selecionar/recuperar dados da tabela de banco de dados:

1. Para se conectar ao banco de dados SQLite, crie um objeto de conexão.
2. Em seguida, use a função do cursor do objeto de conexão para criar um objeto de cursor.
3. Depois disso, você pode executar uma instrução SELECT usando SQLITE3.função execute ().

Conectando ao banco de dados SQLite

1. Importar o módulo SQLITE3 primeiro para o programa. As classes e funções fornecidas pelo módulo SQLITE3 nos ajudam a interagir com o banco de dados.
2. Em seguida, use o nome do banco de dados na função Connect () da classe Connector. Os bancos de dados aos quais você deseja se conectar devem ser fornecidos para se conectar ao sqlite. Ele criará uma conexão com o banco de dados SQLite que você fornece se já estiver existente no sistema. No entanto, um novo banco de dados será criado se o banco de dados com o nome especificado não existir.
3. Crie um cursor usando a função cursor () para executar declarações e consultas SQLite do Python.
4. A consulta SQL é executada pelos métodos Execute () e a saída é retornada.

Código:

Importar SQLite3
SQLCON = SQLITE3.Connect ('my_db.dB ')
cursor = sqlcon.cursor()
Imprimir ("conectado ao sqlite")
Query = "Selecione SQLITE_VERSION ();"
cursor.executar (consulta)
v = cursor.Fetchall ()
print ("A versão do banco de dados SQLite é:", v)
cursor.fechar()
Se SQLCON:
SQLCON.fechar()
print ("A conexão sqlite está fechada")

Saída:

Depois de estabelecer a conexão, passamos uma consulta para recuperar a versão do nosso banco de dados SQLite. A função “cursor.fetchall () ”foi usado para ler os resultados da consulta. Depois de terminar a tarefa, podemos usar o clsoe () e a conexão.Métodos clsoe () para fechar as conexões cursor e sqlite.

Aprendemos a se conectar ao banco de dados SQLite. Agora, precisamos de uma tabela da qual possamos recuperar dados e mostrar como usar a cláusula selecionada para atingir nosso objetivo.

Criando tabela de banco de dados AG e inserindo dados nela

Criando tabela de banco de dados AG e inserindo dados nela
Aprenderemos nesta seção como usar o Python para criar uma tabela de banco de dados SQLite em um banco de dados SQLite. Criar uma tabela é uma declaração de linguagem de definição de dados (DDL). No programa abaixo, criaremos uma tabela "aluno" no "my_db.banco de dados DB ”. As etapas fornecidas abaixo podem ser usadas para criar uma tabela no banco de dados SQLite:

1. Usando SQLite3.Método Connect () para conectar -se ao sqlite.
2. Crie uma consulta de tabela.
3. Usando um cursor.execute (consulta), execute a consulta.

Código:

Importar SQLite3
SQLCON = SQLITE3.Connect ('my_db.dB ')
Query = "Crie alunos da tabela (
Id Integer Primary Key,
Texto do nome,
Texto de e -mail não nulo único,
marcas inteiras); "
cursor = sqlcon.cursor()
Imprimir ("conectado ao sqlite")
cursor.executar (consulta)
SQLCON.comprometer-se()
Print ("Tabela é criada")
cursor.fechar()
Se SQLCON:
SQLCON.fechar()
impressão ("conexão está fechada")

Saída:

Criamos uma tabela “alunos” usando a cláusula/consulta Create Table e a executamos usando o cursor.função execute (). Em seguida, usamos a função de confirmação para garantir que as alterações do banco de dados sejam consistentes. Agora, para inserir dados em nossa tabela 'alunos', repetiremos o mesmo procedimento que fizemos para criar nossa tabela, mas desta vez usaremos uma consulta diferente. A consulta de inserção é usada para adicionar/inserir/inserir dados em uma tabela de banco de dados já existente. A cláusula de valores é usada para especificar o valor para cada linha de dados dentro da tabela. A consulta de inserção pode parecer o seguinte:

Insira na tabela (col1, col2,…) valores (val1, val2,…);

Onde col1, col2 ... são os nomes das colunas e Val1, Val2 ... são os valores para cada coluna das linhas em nossa mesa.

Vamos agora adicionar alguns dados à tabela de banco de dados.

Código:

Importar SQLite3
SQLCON = SQLITE3.Connect ('my_db.dB ')
cursor = sqlcon.cursor()
cursor.Execute ("" "Inserir nos alunos (ID, nome, e -mail, marcas)
Valores (10, 'Rocky', '[email protected] ', 13) "" ")
cursor.Execute ("" "Inserir nos alunos (ID, nome, e -mail, marcas)
Valores (11, 'Morgan', '[email protected] ', 14) "" ")
cursor.Execute ("" "Inserir nos alunos (ID, nome, e -mail, marcas)
Valores (12, 'Nancy', '[email protected] ', 10) "" ")
cursor.Execute ("" "Inserir nos alunos (ID, nome, e -mail, marcas)
Valores (13, 'Lucy', '[email protected] ', 13) "" ")
cursor.Execute ("" "Inserir nos alunos (ID, nome, e -mail, marcas)
Valores (14, 'John', '[email protected] ', 12) "" ")
SQLCON.comprometer-se()
print ("dados são inseridos")
cursor.fechar()
Se SQLCON:
SQLCON.fechar()
impressão ("conexão está fechada")

Saída:

Passamos a consulta de inserção dentro do cursor.Execute () Função e chamado de função multiplicam o tempo com dados diferentes a cada vez para inserir linhas de dados em nossa tabela de 'alunos'.

Agora vamos ver como recuperar/buscar dados da tabela SQLite usando uma instrução SELECT em Python.

Etapas para recuperar dados usando selecionar

1. Usando o módulo SQLITE3, conecte -se ao banco de dados SQLite.
2. Para recuperar linhas de uma tabela, defina uma consulta selecionada. Dependendo dos requisitos, você pode extrair todas ou apenas algumas linhas.
3. O próximo passo é criar um cursor usando a “conexão.Método Cursor () ”. A consulta não pode ser executada sem o objeto do cursor.
4. Execute a consulta selecionada.
5. Para recuperar todas as linhas, use a função fetchall () de um objeto cursor. Ele retornará uma lista de linhas de tabela.
6. Usando um loop for para iterar uma lista de linhas e acessar cada linha separadamente.
7. Os objetos de conexão do cursor e do banco de dados podem ser fechados usando o cursor.fechar () e conexão.Métodos Close (), respectivamente.

Exemplo 1:

Aqui, usaremos a consulta selecionada para obter ou recuperar todos os dados da tabela de 'alunos'. Para isso, usaremos '*' com a instrução SELECT e usaremos o nome da tabela 'Alunos' com a declaração de From para especificar a tabela da qual queremos recuperar dados.

Código:

Importar SQLite3
SQLCON = SQLITE3.Connect ('my_db.dB ')
cursor = sqlcon.cursor()
cursor.execute ("selecione * dos alunos;")
r = cursor.Fetchall ()
para linhas em r:
Imprimir (linhas)
SQLCON.comprometer-se()
cursor.fechar()
Se SQLCON:
SQLCON.fechar()
impressão ("conexão está fechada")

Saída:

Todos os dados que armazenamos ao criar a tabela são recuperados usando o programa. A consulta “Selecione * dos alunos;” é usado para obter todos os dados da tabela 'alunos'. O cursor.Função FetchAll () recuperada/buscada todas as linhas da consulta e retornou uma lista de tuplas.

Exemplo # 2:

Em vez de usar o cursor.função fetchall (), também podemos usar a função fetchMany () se quisermos uma certa quantidade de linhas apenas. Às vezes, se uma tabela tiver milhares de linhas, pode levar muito tempo para buscar todos os dados. Exigimos maior poder de processamento e armazenamento, porque devemos usar mais recursos para buscar todas as linhas. Usando o método FetchMany (tamanho) da classe cursor, podemos buscar menos linhas e melhorar a eficiência.

Código:

Importar SQLite3
def Rowslimit (tamanho):
SQLCON = SQLITE3.Connect ('my_db.dB ')
cursor = sqlcon.cursor()
cursor.execute ("" "selecione * dos alunos" "")
Imprimir ("recuperar", tamanho, "linhas")
r = cursor.FetchMany (tamanho)
Imprima ("Impressão de cada linha \ n")
para linhas em r:
Imprimir (linhas)
cursor.fechar()
Se SQLCON:
SQLCON.fechar()
print ("A conexão sqlite está fechada")
ROWSLIMIT (3)

Saída:

Este programa é semelhante ao programa que usamos no Exemplo 1, mas a diferença é que, em vez de usar a função fetchall () que usamos fetchMany () que assume um valor inteiro como entrada para recuperar algumas linhas limitadas. Criamos uma função 'rowlimit' para passar o valor do tamanho do parâmetro para o cursor.função fetchmany (). Para recuperar três registros, o tamanho fornecido no script acima mencionado é 3. Menos linhas serão devolvidas se a tabela tiver linhas menores que o tamanho especificado.

Conclusão

Neste tutorial, vimos pela primeira vez uma introdução ao SQLite e como você pode acessar o SQLite usando o Python. O objetivo deste artigo é ensinar como podemos usar a consulta selecionada no SQLITE Python. Para recuperar dados de uma tabela de banco de dados. Primeiro discutimos como uma conexão pode ser estabelecida entre Python e Sqlite. Em seguida, explicamos como criar uma tabela de banco de dados e inserir valores nela. Então, no último, vimos como podemos usar uma consulta selecionada para recuperar todas ou um certo número de linhas com a ajuda de funções Fetchall () e FetchMany ().