Python SQLite - Guia rápido

SQLite3 pode ser integrado com Python usando o módulo sqlite3, que foi escrito por Gerhard Haring. Ele fornece uma interface SQL compatível com a especificação DB-API 2.0 descrita pelo PEP 249. Você não precisa instalar este módulo separadamente porque ele é enviado por padrão junto com o Python versão 2.5.x em diante.

Para usar o módulo sqlite3, você deve primeiro criar um objeto de conexão que represente o banco de dados e depois, opcionalmente, pode criar um objeto cursor, que o ajudará na execução de todas as instruções SQL.

APIs de módulo Python SQLite3

A seguir estão importantes rotinas do módulo sqlite3, que podem ser suficientes para seus requisitos para trabalhar com o banco de dados SQLite de seu programa Python. Se você está procurando um aplicativo mais sofisticado, pode consultar a documentação oficial do módulo sqlite3 do Python.

Sr. Não. API e descrição
1

sqlite3.connect(database [,timeout ,other optional arguments])

Esta API abre uma conexão com o arquivo de banco de dados SQLite. Você pode usar ": memory:" para abrir uma conexão de banco de dados a um banco de dados que reside na RAM em vez de no disco. Se o banco de dados for aberto com sucesso, ele retorna um objeto de conexão.

2

connection.cursor([cursorClass])

Essa rotina cria um cursor que será usado em toda a programação do banco de dados com Python. Este método aceita um único parâmetro opcional cursorClass. Se fornecido, deve ser uma classe de cursor personalizada que estende sqlite3.Cursor.

3

cursor.execute(sql [, optional parameters])

Esta rotina executa uma instrução SQL. A instrução SQL pode ser parametrizada (ou seja, marcadores em vez de literais SQL). O módulo sqlite3 suporta dois tipos de marcadores de posição: pontos de interrogação e marcadores de posição nomeados (estilo nomeado).

For example - cursor.execute ("inserir valores de pessoas (?,?)", (Quem, idade))

4

connection.execute(sql [, optional parameters])

Esta rotina é um atalho do método execute acima fornecido pelo objeto cursor e cria um objeto cursor intermediário chamando o método cursor, a seguir chama o método execute do cursor com os parâmetros fornecidos.

5

cursor.executemany(sql, seq_of_parameters)

Esta rotina executa um comando SQL em todas as sequências de parâmetros ou mapeamentos encontrados na sequência sql.

6

connection.executemany(sql[, parameters])

Esta rotina é um atalho que cria um objeto cursor intermediário chamando o método cursor e, em seguida, chama o método cursor.s executemany com os parâmetros fornecidos.

7

cursor.executescript(sql_script)

Essa rotina executa várias instruções SQL de uma vez fornecidas na forma de script. Ele emite uma instrução COMMIT primeiro e, em seguida, executa o script SQL obtido como parâmetro. Todas as instruções SQL devem ser separadas por ponto e vírgula (;).

8

connection.executescript(sql_script)

Essa rotina é um atalho que cria um objeto de cursor intermediário chamando o método do cursor e, em seguida, chama o método executa script do cursor com os parâmetros fornecidos.

9

connection.total_changes()

Essa rotina retorna o número total de linhas do banco de dados que foram modificadas, inseridas ou excluídas desde que a conexão com o banco de dados foi aberta.

10

connection.commit()

Este método confirma a transação atual. Se você não chamar este método, tudo o que você fez desde a última chamada para commit () não será visível em outras conexões de banco de dados.

11

connection.rollback()

Este método reverte qualquer mudança no banco de dados desde a última chamada para commit ().

12

connection.close()

Este método fecha a conexão com o banco de dados. Observe que isso não chama commit () automaticamente. Se você apenas fechar a conexão do banco de dados sem chamar commit () primeiro, suas alterações serão perdidas!

13

cursor.fetchone()

Este método busca a próxima linha de um conjunto de resultados de consulta, retornando uma única sequência, ou Nenhum quando não há mais dados disponíveis.

14

cursor.fetchmany([size = cursor.arraysize])

Esta rotina busca o próximo conjunto de linhas de um resultado de consulta, retornando uma lista. Uma lista vazia é retornada quando não há mais linhas disponíveis. O método tenta buscar quantas linhas forem indicadas pelo parâmetro de tamanho.

15

cursor.fetchall()

Esta rotina busca todas as linhas (restantes) de um resultado de consulta, retornando uma lista. Uma lista vazia é retornada quando nenhuma linha está disponível.

Para estabelecer a conexão com o prompt de comando SQLite Open, navegue até o local onde você instalou o SQLite e apenas execute o comando sqlite3 como mostrado abaixo -

Estabelecendo conexão usando Python

Você pode se comunicar com o banco de dados SQLite2 usando o módulo python SQLite3. Para fazer isso, em primeiro lugar, você precisa estabelecer uma conexão (criar um objeto de conexão).

Para estabelecer uma conexão com o banco de dados SQLite3 usando python, você precisa -

  • Importe o módulo sqlite3 usando a instrução import.

  • O método connect () aceita o nome do banco de dados com o qual você precisa se conectar como um parâmetro e retorna um objeto Connection.

Exemplo

import sqlite3
conn = sqlite3.connect('example.db')

Resultado

print("Connection established ..........")

Usando a instrução SQLite CREATE TABLE, você pode criar uma tabela em um banco de dados.

Sintaxe

A seguir está a sintaxe para criar uma tabela no banco de dados SQLite -

CREATE TABLE database_name.table_name(
   column1 datatype PRIMARY KEY(one or more columns),
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype
);

Exemplo

A consulta / instrução SQLite seguinte cria uma tabela com o nome CRICKETERS no banco de dados SQLite -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Vamos criar mais uma tabela OdiStats descrevendo as estatísticas de críquete de um dia de cada jogador na mesa CRICKETERS.

sqlite> CREATE TABLE ODIStats (
   First_Name VARCHAR(255),
   Matches INT,
   Runs INT,
   AVG FLOAT,
   Centuries INT,
   HalfCenturies INT 
);
sqlite>

Você pode obter a lista de tabelas em um banco de dados no banco de dados SQLite usando o .tablescomando. Depois de criar uma tabela, se você pode verificar a lista de tabelas, você pode observar a tabela recém-criada nela como -

sqlite> . tables
CRICKETERS ODIStats
sqlite>

Criação de uma tabela usando Python

O objeto Cursor contém todos os métodos para executar quires e buscar dados, etc. O método cursor da classe de conexão retorna um objeto cursor.

Portanto, para criar uma tabela no banco de dados SQLite usando python -

  • Estabeleça conexão com um banco de dados usando o método connect ().

  • Crie um objeto cursor invocando o método cursor () no objeto de conexão criado acima.

  • Agora execute a instrução CREATE TABLE usando o método execute () da classe Cursor.

Exemplo

O seguinte programa Python cria uma tabela chamada Employee no SQLite3 -

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
print("Table created successfully........")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Resultado

Table created successfully........

Você pode adicionar novas linhas a uma tabela existente de SQLite usando a instrução INSERT INTO. Nesse caso, você precisa especificar o nome da tabela, os nomes das colunas e os valores (na mesma ordem dos nomes das colunas).

Sintaxe

A seguir está a sintaxe recomendada da instrução INSERT -

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
   VALUES (value1, value2, value3,...valueN);

Onde, coluna1, coluna2, coluna3, .. são os nomes das colunas de uma tabela e valor1, valor2, valor3, ... são os valores que você precisa inserir na tabela.

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a instrução CREATE TABLE conforme mostrado abaixo -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

A instrução PostgreSQL a seguir insere uma linha na tabela criada acima.

sqlite> insert into CRICKETERS (First_Name, Last_Name, Age, Place_Of_Birth, Country) 
   values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite>

Ao inserir registros usando a instrução INSERT INTO , se você ignorar quaisquer nomes de colunas, este registro será inserido deixando espaços vazios nas colunas que você ignorou.

sqlite> insert into CRICKETERS (First_Name, Last_Name, Country) 
   values ('Jonathan', 'Trott', 'SouthAfrica');
sqlite>

Você também pode inserir registros em uma tabela sem especificar os nomes das colunas, se a ordem dos valores transmitidos for a mesma dos respectivos nomes das colunas na tabela.

sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

Depois de inserir os registros em uma tabela, você pode verificar seu conteúdo usando a instrução SELECT conforme mostrado abaixo -

sqlite> select * from cricketers;
Shikhar  |Dhawan     | 33 | Delhi | India
Jonathan |Trott      |    |       | SouthAfrica
Kumara   |Sangakkara | 41 | Matale| Srilanka
Virat    |Kohli      | 30 | Delhi | India
Rohit    |Sharma     | 32 | Nagpur| India
sqlite>

Inserindo dados usando Python

Para adicionar registros a uma tabela existente no banco de dados SQLite -

  • Importe o pacote sqlite3.

  • Crie um objeto de conexão usando o método connect () passando o nome do banco de dados como um parâmetro para ele.

  • o cursor()método retorna um objeto cursor usando o qual você pode se comunicar com SQLite3. Crie um objeto cursor invocando o objeto cursor () no objeto Connection (criado acima).

  • Em seguida, invoque o método execute () no objeto cursor, passando uma instrução INSERT como parâmetro para ele.

Exemplo

O seguinte exemplo de python insere registros em uma tabela chamada EMPLOYEE -

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Ramya', 'Rama Priya', 27, 'F', 9000)'''
)
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Vinay', 'Battacharya', 20, 'M', 6000)''')

cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Sharukh', 'Sheik', 25, 'M', 8300)''')

cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Sarmista', 'Sharma', 26, 'F', 10000)''')

cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Tripthi', 'Mishra', 24, 'F', 6000)''')

# Commit your changes in the database
conn.commit()

print("Records inserted........")

# Closing the connection
conn.close()

Resultado

Records inserted........

Você pode recuperar dados de uma tabela SQLite usando a consulta SELECT. Esta consulta / instrução retorna o conteúdo da relação especificada (tabela) em forma tabular e é chamada de conjunto de resultados.

Sintaxe

A seguir está a sintaxe da instrução SELECT no SQLite -

SELECT column1, column2, columnN FROM table_name;

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

E se tivermos inserido 5 registros nele usando instruções INSERT como -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

A consulta SELECT seguinte recupera os valores das colunas FIRST_NAME, LAST_NAME e, COUNTRY da tabela CRICKETERS.

sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
Shikhar   |Dhawan       |India
Jonathan  |Trott        |SouthAfrica
Kumara    |Sangakkara   |Srilanka
Virat     |Kohli        |India
Rohit     |Sharma       |India
sqlite>

Como você pode observar, a instrução SELECT do banco de dados SQLite apenas retorna os registros das tabelas especificadas. Para obter uma saída formatada, você precisa definir oheader, e mode usando os respectivos comandos antes da instrução SELECT, conforme mostrado abaixo -

sqlite> .header on
sqlite> .mode column
sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
First_Name   Last_Name    Country
----------   ----------   ----------
Shikhar      Dhawan       India
Jonathan     Trott        SouthAfric
Kumara       Sangakkara   rilanka
Virat        Kohli        India
Rohit        Sharma       India

Se você deseja recuperar todas as colunas de cada registro, você precisa substituir os nomes das colunas por "*" conforme mostrado abaixo -

sqlite> .header on
sqlite> .mode column
sqlite> SELECT * FROM CRICKETERS;
First_Name   Last_Name    Age        Place_Of_Birth   Country
----------   ----------   -------    --------------   ----------
Shikhar      Dhawan       33         Delhi            India
Jonathan     Trott        38         CapeTown         SouthAfric
Kumara       Sangakkara   41         Matale           Srilanka
Virat        Kohli        30         Delhi            India
Rohit        Sharma       32         Nagpur           India
sqlite>

No SQLite, por padrão, a largura das colunas é de 10 valores além desta largura são cortados (observe a coluna do país da linha na tabela acima). Você pode definir a largura de cada coluna para o valor necessário usando o.width comando, antes de recuperar o conteúdo de uma tabela como mostrado abaixo -

sqlite> .width 10, 10, 4, 10, 13
sqlite> SELECT * FROM CRICKETERS;
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   --------
Shikhar      Dhawan       33     Delhi        India
Jonathan     Trott        38     CapeTown     SouthAfrica
Kumara       Sangakkara   41     Matale       Srilanka
Virat        Kohli        30     Delhi        India
Rohit        Sharma       32     Nagpur       India
sqlite>

Recuperando dados usando Python

A operação READ em qualquer banco de dados significa buscar algumas informações úteis do banco de dados. Você pode buscar dados do MYSQL usando o método fetch () fornecido pelo módulo sqlite python.

A classe sqlite3.Cursor fornece três métodos: fetchall (), fetchmany () e fetchone () onde,

  • O método fetchall () recupera todas as linhas no conjunto de resultados de uma consulta e as retorna como uma lista de tuplas. (Se executarmos isso depois de recuperar algumas linhas, ele retornará as restantes).

  • O método fetchone () busca a próxima linha no resultado de uma consulta e a retorna como uma tupla.

  • O método fetchmany () é semelhante ao fetchone (), mas recupera o próximo conjunto de linhas no conjunto de resultados de uma consulta, em vez de uma única linha.

Note - Um conjunto de resultados é um objeto que é retornado quando um objeto cursor é usado para consultar uma tabela.

Exemplo

O exemplo a seguir busca todas as linhas da tabela EMPLOYEE usando a consulta SELECT e, do conjunto de resultados obtido inicialmente, estamos recuperando a primeira linha usando o método fetchone () e, em seguida, obtendo as linhas restantes usando o método fetchall ().

O programa Python a seguir mostra como buscar e exibir registros da tabela COMPANY criada no exemplo acima.

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Resultado

('Ramya', 'Rama priya', 27, 'F', 9000.0)
[
   ('Vinay', 'Battacharya', 20, 'M', 6000.0),
   ('Sharukh', 'Sheik', 25, 'M', 8300.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)
]

Se você deseja buscar, excluir ou atualizar linhas específicas de uma tabela no SQLite, você precisa usar a cláusula where para especificar a condição para filtrar as linhas da tabela para a operação.

Por exemplo, se você tiver uma instrução SELECT com a cláusula where, apenas as linhas que satisfaçam a condição especificada serão recuperadas.

Sintaxe

A seguir está a sintaxe da cláusula WHERE no SQLite -

SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]

Você pode especificar um search_condition usando comparação ou operadores lógicos. like>, <, =, LIKE, NOT, etc. Os exemplos a seguir tornariam esse conceito claro.

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

E se tivermos inserido 5 registros nele usando instruções INSERT como -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

A seguinte instrução SELECT recupera os registros cuja idade é maior que 35 -

sqlite> SELECT * FROM CRICKETERS WHERE AGE > 35;
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   -----------
Jonathan     Trott        38     CapeTown     SouthAfrica
Kumara       Sangakkara   41     Matale       Srilanka
sqlite>

Cláusula Where usando Python

O objeto / classe Cursor contém todos os métodos para executar consultas e buscar dados, etc. O método cursor da classe de conexão retorna um objeto cursor.

Portanto, para criar uma tabela no banco de dados SQLite usando python -

  • Estabeleça conexão com um banco de dados usando o método connect ().

  • Crie um objeto cursor invocando o método cursor () no objeto de conexão criado acima.

  • Agora execute a instrução CREATE TABLE usando o método execute () da classe Cursor.

Exemplo

O exemplo a seguir cria uma tabela chamada Employee e a preenche. Em seguida, usando a cláusula where, ele recupera os registros com valor de idade menor que 23.

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Ramya', 'Rama priya', 27, 'F', 9000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Vinay', 'Battacharya', 20, 'M', 6000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Sharukh', 'Sheik', 25, 'M', 8300)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Sarmista', 'Sharma', 26, 'F', 10000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Tripthi', 'Mishra', 24, 'F', 6000)''')

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")

print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Resultado

[('Vinay', 'Battacharya', 20, 'M', 6000.0)]

Ao buscar dados usando a consulta SELECT, você obterá os registros na mesma ordem em que os inseriu.

Você pode classificar os resultados na ordem desejada (crescente ou decrescente) usando o Order Bycláusula. Por padrão, esta cláusula classifica os resultados em ordem crescente, se você precisar organizá-los em ordem decrescente, você precisará usar “DESC” explicitamente.

Sintaxe

A seguir está a sintaxe da cláusula ORDER BY no SQLite.

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

E se tivermos inserido 5 registros nele usando instruções INSERT como -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

A instrução SELECT seguinte recupera as linhas da tabela CRICKETERS na ordem crescente de sua idade -

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE;
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   -----------
Virat        Kohli        30     Delhi        India
Rohit        Sharma       32     Nagpur       India
Shikhar      Dhawan       33     Delhi        India
Jonathan     Trott        38     CapeTown     SouthAfrica
Kumara       Sangakkara   41     Matale       Srilanka
sqlite>

Você pode usar mais de uma coluna para classificar os registros de uma tabela. As seguintes instruções SELECT classificam os registros da tabela CRICKETERS com base nas colunas AGE e FIRST_NAME .

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   -------------
Virat        Kohli        30     Delhi        India
Rohit        Sharma       32     Nagpur       India
Shikhar      Dhawan       33     Delhi        India
Jonathan     Trott        38     CapeTown     SouthAfrica
Kumara       Sangakkara   41     Matale       Srilanka
sqlite>

Por padrão, o ORDER BY cláusula classifica os registros de uma tabela em ordem crescente, você pode organizar os resultados em ordem decrescente usando DESC como -

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE DESC;
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   -------------
Kumara       Sangakkara   41     Matale       Srilanka
Jonathan     Trott        38     CapeTown     SouthAfrica
Shikhar      Dhawan       33     Delhi        India
Rohit        Sharma       32     Nagpur       India
Virat        Kohli        30     Delhi        India
sqlite>

Cláusula ORDER BY usando Python

Para recuperar o conteúdo de uma tabela em uma ordem específica, invoque o método execute () no objeto cursor e passe a instrução SELECT junto com a cláusula ORDER BY como um parâmetro para ela.

Exemplo

No exemplo a seguir, estamos criando uma tabela com nome e Funcionário, preenchendo-a e recuperando seus registros na ordem (crescente) de sua idade, usando a cláusula ORDER BY.

import psycopg2
#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT, SEX CHAR(1),
   INCOME INT,
   CONTACT INT
)'''
cursor.execute(sql)
#Populating the table
#Populating the table
cursor.execute(
   '''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000), 
   ('Sharukh', 'Sheik', 25, 'M', 8300), 
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")

print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Resultado

[
   ('Vinay', 'Battacharya', 20, 'M', 6000, None),
   ('Tripthi', 'Mishra', 24, 'F', 6000, None),
   ('Sharukh', 'Sheik', 25, 'M', 8300, None),
   ('Sarmista', 'Sharma', 26, 'F', 10000, None),
   ('Ramya', 'Rama priya', 27, 'F', 9000, None)
]

ATUALIZAÇÃO A operação em qualquer base de dados implica na modificação dos valores de um ou mais registros de uma tabela, que já estão disponíveis na base de dados. Você pode atualizar os valores dos registros existentes no SQLite usando a instrução UPDATE.

Para atualizar linhas específicas, você precisa usar a cláusula WHERE junto com ela.

Sintaxe

A seguir está a sintaxe da instrução UPDATE no SQLite -

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

E se tivermos inserido 5 registros nele usando instruções INSERT como -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

A seguinte declaração modifica a idade do jogador de críquete, cujo primeiro nome é Shikhar -

sqlite> UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
sqlite>

Se você recuperar o registro cujo FIRST_NAME é Shikhar, você observará que o valor da idade foi alterado para 45 -

sqlite> SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   --------
Shikhar      Dhawan       45     Delhi        India
sqlite>

Se você não usou a cláusula WHERE, os valores de todos os registros serão atualizados. A instrução UPDATE seguinte aumenta a idade de todos os registros na tabela CRICKETERS em 1 -

sqlite> UPDATE CRICKETERS SET AGE = AGE+1;
sqlite>

Se você recuperar o conteúdo da tabela usando o comando SELECT, poderá ver os valores atualizados como -

sqlite> SELECT * FROM CRICKETERS;
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   -------------
Shikhar      Dhawan       46     Delhi        India
Jonathan     Trott        39     CapeTown     SouthAfrica
Kumara       Sangakkara   42     Matale       Srilanka
Virat        Kohli        31     Delhi        India
Rohit        Sharma       33     Nagpur       India
sqlite>

Atualizando registros existentes usando Python

Para adicionar registros a uma tabela existente no banco de dados SQLite -

  • Importe o pacote sqlite3.

  • Crie um objeto de conexão usando o método connect () passando o nome do banco de dados como um parâmetro para ele.

  • o cursor()método retorna um objeto cursor usando o qual você pode se comunicar com SQLite3. Crie um objeto cursor invocando o objeto cursor () no objeto Connection (criado acima).

  • Em seguida, invoque o método execute () no objeto cursor, passando uma instrução UPDATE como um parâmetro para ele.

Exemplo

Seguindo o exemplo do Python, cria uma tabela com o nome EMPLOYEE, insere 5 registros nela e aumenta a idade de todos os funcionários do sexo masculino em 1 -

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Inserting data
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
VALUES ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000), 
   ('Sharukh', 'Sheik', 25, 'M', 8300), 
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

#Fetching all the rows before the update
print("Contents of the Employee table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Updating the records
sql = '''UPDATE EMPLOYEE SET AGE=AGE+1 WHERE SEX = 'M' '''
cursor.execute(sql)
print("Table updated...... ")

#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Resultado

Contents of the Employee table:
[
   ('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)
]
Table updated......
Contents of the Employee table after the update operation:
[
   ('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)
]

Para excluir registros de uma tabela SQLite, você precisa usar a instrução DELETE FROM. Para remover registros específicos, você precisa usar a cláusula WHERE junto com ele.

Sintaxe

A seguir está a sintaxe da consulta DELETE no SQLite -

DELETE FROM table_name [WHERE Clause]

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

E se tivermos inserido 5 registros nele usando instruções INSERT como -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

A declaração a seguir exclui o registro do jogador de críquete cujo sobrenome é 'Sangakkara'.

sqlite> DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
sqlite>

Se você recuperar o conteúdo da tabela usando a instrução SELECT, poderá ver apenas 4 registros, já que excluímos um.

sqlite> SELECT * FROM CRICKETERS;
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   --------
Shikhar      Dhawan       46     Delhi        India
Jonathan     Trott        39     CapeTown     SouthAfrica
Virat        Kohli        31     Delhi        India
Rohit        Sharma       33     Nagpur       India
sqlite>

Se você executar a instrução DELETE FROM sem a cláusula WHERE, todos os registros da tabela especificada serão excluídos.

sqlite> DELETE FROM CRICKETERS;
sqlite>

Uma vez que você excluiu todos os registros, se você tentar recuperar o conteúdo da tabela CRICKETERS, usando a instrução SELECT, você obterá um conjunto de resultados vazio conforme mostrado abaixo -

sqlite> SELECT * FROM CRICKETERS;
sqlite>

Exclusão de dados usando Python

Para adicionar registros a uma tabela existente no banco de dados SQLite -

  • Importe o pacote sqlite3.

  • Crie um objeto de conexão usando o método connect () , passando o nome do banco de dados como um parâmetro para ele.

  • o cursor()método retorna um objeto cursor usando o qual você pode se comunicar com SQLite3. Crie um objeto cursor invocando o objeto cursor () no objeto Connection (criado acima).

  • Em seguida, invoque o método execute () no objeto cursor, passando um DELETE declaração como um parâmetro para ele.

Exemplo

O exemplo de python a seguir exclui os registros da tabela EMPLOYEE com valor de idade maior que 25.

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')

#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Resultado

Contents of the table:
[
   ('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)
]
Contents of the table after delete operation
[
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)
]

Você pode remover uma tabela inteira usando a instrução DROP TABLE. Você só precisa especificar o nome da tabela que você precisa excluir.

Sintaxe

A seguir está a sintaxe da instrução DROP TABLE no PostgreSQL -

DROP TABLE table_name;

Exemplo

Suponha que criamos duas tabelas com o nome CRICKETERS e EMPLOYEES usando as seguintes consultas -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
sqlite> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT, 
   SEX CHAR(1), INCOME FLOAT
);
sqlite>

Agora, se você verificar a lista de tabelas usando o .tables comando, você pode ver as tabelas criadas acima nele (lista) como -

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

A declaração a seguir exclui a tabela chamada Employee do banco de dados -

sqlite> DROP table employee;
sqlite>

Visto que você excluiu a tabela Employee, se você recuperar a lista de tabelas novamente, poderá observar apenas uma tabela nela.

sqlite> .tables
CRICKETERS
sqlite>

Se você tentar excluir a tabela Employee novamente, uma vez que você já a excluiu, obterá um erro dizendo "nenhuma tabela", conforme mostrado abaixo -

sqlite> DROP table employee;
Error: no such table: employee
sqlite>

Para resolver isso, você pode usar a cláusula IF EXISTS junto com a instrução DELETE. Isso remove a tabela se ela existir, caso contrário, ignora a operação DELETE.

sqlite> DROP table IF EXISTS employee;
sqlite>

Descartando uma tabela usando Python

Você pode eliminar uma tabela sempre que precisar, usando a instrução DROP do MYSQL, mas você precisa ter muito cuidado ao excluir qualquer tabela existente, pois os dados perdidos não serão recuperados após a exclusão de uma tabela.

Exemplo

Para eliminar uma tabela de um banco de dados SQLite3 usando python invoque o execute() no objeto cursor e passe a instrução drop como um parâmetro para ele.

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Resultado

Table dropped...

Ao buscar registros, se quiser limitá-los a um determinado número, você pode fazer isso usando a cláusula LIMIT do SQLite.

Sintaxe

A seguir está a sintaxe da cláusula LIMIT no SQLite -

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

E se tivermos inserido 5 registros nele usando instruções INSERT como -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

A instrução a seguir recupera os primeiros 3 registros da tabela de Cricketers usando a cláusula LIMIT -

sqlite> SELECT * FROM CRICKETERS LIMIT 3;
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   -------------
Shikhar      Dhawan       33     Delhi        India
Jonathan     Trott        38     CapeTown     SouthAfrica
Kumara       Sangakkara   41     Matale       Srilanka
sqlite>

Se você precisa para limitar os registros a partir de registro n (não 1 st ), você pode fazê-lo, usando OFFSET juntamente com LIMIT.

sqlite> SELECT * FROM CRICKETERS LIMIT 3 OFFSET 2;
First_Name   Last_Name    Age    Place_Of_B   Country
----------   ----------   ----   ----------   --------
Kumara       Sangakkara   41     Matale       Srilanka
Virat        Kohli        30     Delhi        India
Rohit        Sharma       32     Nagpur       India
sqlite>

Cláusula LIMIT usando Python

Se você invocar o método execute () no objeto cursor, passando a consulta SELECT junto com a cláusula LIMIT, poderá recuperar o número necessário de registros.

Exemplo

O exemplo python a seguir recupera os dois primeiros registros da tabela EMPLOYEE usando a cláusula LIMIT.

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 3'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Resultado

[
   ('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0)
]

Depois de dividir os dados em duas tabelas, você pode buscar registros combinados dessas duas tabelas usando Joins.

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

Vamos criar mais uma tabela OdiStats descrevendo as estatísticas de críquete de um dia de cada jogador na mesa CRICKETERS.

sqlite> CREATE TABLE ODIStats (
   First_Name VARCHAR(255),
   Matches INT,
   Runs INT,
   AVG FLOAT,
   Centuries INT,
   HalfCenturies INT
);
sqlite>

A instrução a seguir recupera dados combinando os valores nessas duas tabelas -

sqlite> SELECT
   Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
   OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
   from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
First_Name  Last_Name   Country  Matches  Runs   Centuries   HalfCenturies
----------  ----------  -------  -------  ----   ---------   -------------- 
Shikhar     Dhawan      Indi     133      5518   17          27
Jonathan    Trott       Sout     68       2819   4           22
Kumara      Sangakkara  Sril     404      14234  25          93
Virat       Kohli       Indi     239      11520  43          54
Rohit       Sharma      Indi     218      8686   24          42
sqlite>

Cláusula de junção usando Python

Seguindo o exemplo do SQLite, demonstra a cláusula JOIN usando python -

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();

print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

Resultado

[
   ('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, '[email protected]', 'Hyderabad'), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102,'[email protected]', 'Vishakhapatnam'), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected]', 'Pune'), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')
]

A classe sqlite3.Cursor é uma instância usando a qual você pode invocar métodos que executam instruções SQLite, buscam dados dos conjuntos de resultados das consultas. Você pode criar o objeto Cursor usando o método cursor () do objeto / classe Connection.

Exemplo

import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

Métodos

A seguir estão os vários métodos fornecidos pela classe / objeto Cursor.

Método Descrição
executar()

Esta rotina executa uma instrução SQL. A instrução SQL pode ser parametrizada (ou seja, marcadores de posição em vez de literais SQL). O módulo psycopg2 suporta placeholder usando o sinal% s

Por exemplo: cursor.execute ("inserir valores de pessoas (% s,% s)", (quem, idade))

executemany ()

Esta rotina executa um comando SQL em todas as sequências de parâmetros ou mapeamentos encontrados na sequência sql.

fetchone ()

Este método busca a próxima linha de um conjunto de resultados de consulta, retornando uma única sequência, ou Nenhum quando não há mais dados disponíveis.

fetchmany ()

Esta rotina busca o próximo conjunto de linhas de um resultado de consulta, retornando uma lista. Uma lista vazia é retornada quando não há mais linhas disponíveis. O método tenta buscar quantas linhas forem indicadas pelo parâmetro de tamanho.

fetchall ()

Esta rotina busca todas as linhas (restantes) de um resultado de consulta, retornando uma lista. Uma lista vazia é retornada quando nenhuma linha está disponível.

Propriedades

A seguir estão as propriedades da classe Cursor -

Método Descrição
arraySize

Esta é uma propriedade de leitura / gravação que você pode definir o número de linhas retornadas pelo método fetchmany ().

descrição

Esta é uma propriedade somente leitura que retorna a lista contendo a descrição das colunas em um conjunto de resultados.

lastrowid

Esta é uma propriedade somente leitura; se houver alguma coluna com incremento automático na tabela, ela retornará o valor gerado para aquela coluna na última operação INSERT ou UPDATE.

Contagem de linhas

Isso retorna o número de linhas retornadas / atualizadas no caso de operações SELECT e UPDATE.

conexão

Este atributo somente leitura fornece a conexão de banco de dados SQLite usada pelo objeto Cursor.