Python SQLite - Guida rapida
SQLite3 può essere integrato con Python utilizzando il modulo sqlite3, che è stato scritto da Gerhard Haring. Fornisce un'interfaccia SQL conforme alla specifica DB-API 2.0 descritta da PEP 249. Non è necessario installare questo modulo separatamente perché viene fornito per impostazione predefinita insieme alla versione Python 2.5.x in poi.
Per utilizzare il modulo sqlite3, devi prima creare un oggetto di connessione che rappresenta il database e poi opzionalmente puoi creare un oggetto cursore, che ti aiuterà nell'esecuzione di tutte le istruzioni SQL.
API del modulo Python SQLite3
Di seguito sono riportate importanti routine del modulo sqlite3, che possono essere sufficienti per il tuo requisito per lavorare con il database SQLite dal tuo programma Python. Se stai cercando un'applicazione più sofisticata, puoi esaminare la documentazione ufficiale del modulo sqlite3 di Python.
| Sr.No. | API e descrizione |
|---|---|
| 1 | sqlite3.connect(database [,timeout ,other optional arguments]) Questa API apre una connessione al file di database SQLite. È possibile utilizzare ": memory:" per aprire una connessione database a un database che risiede nella RAM invece che su disco. Se il database viene aperto correttamente, restituisce un oggetto di connessione. |
| 2 | connection.cursor([cursorClass]) Questa routine crea un cursore che verrà utilizzato durante la programmazione del database con Python. Questo metodo accetta un singolo parametro opzionale cursorClass. Se fornito, deve essere una classe cursore personalizzata che estende sqlite3.Cursor. |
| 3 | cursor.execute(sql [, optional parameters]) Questa routine esegue un'istruzione SQL. L'istruzione SQL può essere parametrizzata (cioè segnaposto invece di letterali SQL). Il modulo sqlite3 supporta due tipi di segnaposto: punti interrogativi e segnaposto con nome (stile con nome). For example - cursor.execute ("inserisci nei valori delle persone (?,?)", (Who, age)) |
| 4 | connection.execute(sql [, optional parameters]) Questa routine è una scorciatoia del metodo di esecuzione sopra fornito dall'oggetto cursore e crea un oggetto cursore intermedio chiamando il metodo cursore, quindi chiama il metodo di esecuzione del cursore con i parametri forniti. |
| 5 | cursor.executemany(sql, seq_of_parameters) Questa routine esegue un comando SQL su tutte le sequenze di parametri o le mappature trovate nella sequenza sql. |
| 6 | connection.executemany(sql[, parameters]) Questa routine è una scorciatoia che crea un oggetto cursore intermedio chiamando il metodo del cursore, quindi chiama il metodo cursor.s executemany con i parametri forniti. |
| 7 | cursor.executescript(sql_script) Questa routine esegue più istruzioni SQL contemporaneamente fornite sotto forma di script. Emette prima un'istruzione COMMIT, quindi esegue lo script SQL che ottiene come parametro. Tutte le istruzioni SQL devono essere separate da un punto e virgola (;). |
| 8 | connection.executescript(sql_script) Questa routine è una scorciatoia che crea un oggetto cursore intermedio chiamando il metodo del cursore, quindi chiama il metodo executescript del cursore con i parametri forniti. |
| 9 | connection.total_changes() Questa routine restituisce il numero totale di righe del database che sono state modificate, inserite o eliminate dall'apertura della connessione al database. |
| 10 | connection.commit() Questo metodo esegue il commit della transazione corrente. Se non chiami questo metodo, tutto ciò che hai fatto dall'ultima chiamata a commit () non è visibile da altre connessioni al database. |
| 11 | connection.rollback() Questo metodo ripristina tutte le modifiche al database dall'ultima chiamata a commit (). |
| 12 | connection.close() Questo metodo chiude la connessione al database. Nota che questo non chiama automaticamente commit (). Se chiudi semplicemente la connessione al database senza chiamare prima commit (), le tue modifiche andranno perse! |
| 13 | cursor.fetchone() Questo metodo recupera la riga successiva di un set di risultati di query, restituendo una singola sequenza o Nessuno quando non sono disponibili più dati. |
| 14 | cursor.fetchmany([size = cursor.arraysize]) Questa routine recupera la serie successiva di righe del risultato di una query, restituendo un elenco. Quando non sono disponibili più righe, viene restituito un elenco vuoto. Il metodo cerca di recuperare tutte le righe indicate dal parametro size. |
| 15 | cursor.fetchall() Questa routine recupera tutte le righe (rimanenti) di un risultato di query, restituendo un elenco. Quando non sono disponibili righe, viene restituito un elenco vuoto. |
Per stabilire una connessione con il prompt dei comandi di SQLite Apri, sfoglia il percorso in cui hai installato SQLite ed esegui semplicemente il comando sqlite3 come mostrato di seguito -
Stabilire una connessione usando Python
È possibile comunicare con il database SQLite2 utilizzando il modulo python SQLite3. Per fare ciò, prima di tutto devi stabilire una connessione (creare un oggetto di connessione).
Per stabilire una connessione con il database SQLite3 utilizzando Python è necessario:
Importare il modulo sqlite3 utilizzando l'istruzione import.
Il metodo connect () accetta il nome del database a cui è necessario connettersi come parametro e restituisce un oggetto Connection.
Esempio
import sqlite3
conn = sqlite3.connect('example.db')Produzione
print("Connection established ..........")Utilizzando l'istruzione SQLite CREATE TABLE è possibile creare una tabella in un database.
Sintassi
Di seguito è riportata la sintassi per creare una tabella nel database SQLite:
CREATE TABLE database_name.table_name(
column1 datatype PRIMARY KEY(one or more columns),
column2 datatype,
column3 datatype,
.....
columnN datatype
);Esempio
La seguente query / istruzione SQLite crea una tabella con il nome CRICKETERS nel database SQLite -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Creiamo un altro tavolo OdiStats che descrive le statistiche del cricket di un giorno di ciascun giocatore nel tavolo CRICKETERS.
sqlite> CREATE TABLE ODIStats (
First_Name VARCHAR(255),
Matches INT,
Runs INT,
AVG FLOAT,
Centuries INT,
HalfCenturies INT
);
sqlite>È possibile ottenere l'elenco delle tabelle in un database nel database SQLite utilizzando il .tablescomando. Dopo aver creato una tabella, se puoi verificare l'elenco delle tabelle puoi osservare la tabella appena creata al suo interno come:
sqlite> . tables
CRICKETERS ODIStats
sqlite>Creazione di una tabella utilizzando Python
L'oggetto Cursor contiene tutti i metodi per eseguire query e recuperare dati, ecc. Il metodo cursore della classe di connessione restituisce un oggetto cursore.
Pertanto, per creare una tabella nel database SQLite utilizzando python -
Stabilire una connessione con un database utilizzando il metodo connect ().
Crea un oggetto cursore invocando il metodo cursor () sull'oggetto connessione creato sopra.
Ora esegui l'istruzione CREATE TABLE utilizzando il metodo execute () della classe Cursor.
Esempio
Il seguente programma Python crea una tabella denominata Employee in 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()Produzione
Table created successfully........È possibile aggiungere nuove righe a una tabella esistente di SQLite utilizzando l'istruzione INSERT INTO. In questo caso, è necessario specificare il nome della tabella, i nomi delle colonne e i valori (nello stesso ordine dei nomi delle colonne).
Sintassi
Di seguito è riportata la sintassi consigliata dell'istruzione INSERT:
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);Dove, colonna1, colonna2, colonna3, .. sono i nomi delle colonne di una tabella e valore1, valore2, valore3, ... sono i valori che devi inserire nella tabella.
Esempio
Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando l'istruzione CREATE TABLE come mostrato di seguito -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>La seguente istruzione PostgreSQL inserisce una riga nella tabella creata sopra.
sqlite> insert into CRICKETERS (First_Name, Last_Name, Age, Place_Of_Birth, Country)
values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite>Durante l'inserimento di record utilizzando l' istruzione INSERT INTO , se si salta qualsiasi nome di colonna, questo record verrà inserito lasciando spazi vuoti nelle colonne che sono state ignorate.
sqlite> insert into CRICKETERS (First_Name, Last_Name, Country)
values ('Jonathan', 'Trott', 'SouthAfrica');
sqlite>Puoi anche inserire record in una tabella senza specificare i nomi delle colonne, se l'ordine dei valori passati è lo stesso dei rispettivi nomi delle colonne nella tabella.
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>Dopo aver inserito i record in una tabella è possibile verificarne il contenuto utilizzando l'istruzione SELECT come mostrato di seguito -
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>Inserimento di dati utilizzando Python
Per aggiungere record a una tabella esistente nel database SQLite:
Importa pacchetto sqlite3.
Creare un oggetto connessione utilizzando il metodo connect () passando il nome del database come parametro ad esso.
Il cursor()restituisce un oggetto cursore utilizzando il quale è possibile comunicare con SQLite3. Crea un oggetto cursore invocando l'oggetto cursore () sull'oggetto Connection (creato sopra).
Quindi, invoca il metodo execute () sull'oggetto cursore, passando un'istruzione INSERT come parametro ad esso.
Esempio
L'esempio seguente di Python inserisce i record in una tabella denominata 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()Produzione
Records inserted........È possibile recuperare i dati da una tabella SQLite utilizzando la query SELECT. Questa query / istruzione restituisce il contenuto della relazione specificata (tabella) in forma tabulare e viene chiamata come set di risultati.
Sintassi
Di seguito è riportata la sintassi dell'istruzione SELECT in SQLite:
SELECT column1, column2, columnN FROM table_name;Esempio
Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:
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 abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -
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>La seguente query SELECT recupera i valori delle colonne FIRST_NAME, LAST_NAME e COUNTRY dalla tabella 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>Come si osserva, l'istruzione SELECT del database SQLite restituisce solo i record delle tabelle specificate. Per ottenere un output formattato è necessario impostare l'estensioneheader, e mode utilizzando i rispettivi comandi prima dell'istruzione SELECT come mostrato di seguito -
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 IndiaSe desideri recuperare tutte le colonne di ogni record, devi sostituire i nomi delle colonne con "*" come mostrato di seguito -
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>In SQLite per difetto la larghezza delle colonne è di 10 valori oltre questa larghezza vengono tagliate (osservare la colonna paese di 2 ° riga nella tabella sopra). È possibile impostare la larghezza di ogni colonna sul valore richiesto utilizzando il.width comando, prima di recuperare il contenuto di una tabella come mostrato di seguito -
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>Recupero dei dati utilizzando Python
READ Operare su qualsiasi database significa prelevare alcune informazioni utili dal database. È possibile recuperare i dati da MYSQL utilizzando il metodo fetch () fornito dal modulo sqlite python.
La classe sqlite3.Cursor fornisce tre metodi: fetchall (), fetchmany () e, fetchone () dove,
Il metodo fetchall () recupera tutte le righe nel set di risultati di una query e le restituisce come elenco di tuple. (Se lo eseguiamo dopo aver recuperato poche righe, restituisce quelle rimanenti).
Il metodo fetchone () recupera la riga successiva nel risultato di una query e la restituisce come una tupla.
Il metodo fetchmany () è simile a fetchone () ma recupera il set di righe successivo nel set di risultati di una query, invece di una singola riga.
Note - Un set di risultati è un oggetto restituito quando un oggetto cursore viene utilizzato per interrogare una tabella.
Esempio
L'esempio seguente recupera tutte le righe della tabella EMPLOYEE utilizzando la query SELECT e dal set di risultati ottenuto inizialmente, stiamo recuperando la prima riga utilizzando il metodo fetchone () e quindi recuperando le righe rimanenti utilizzando il metodo fetchall ().
Il seguente programma Python mostra come recuperare e visualizzare i record dalla tabella COMPANY creata nell'esempio precedente.
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()Produzione
('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 si desidera recuperare, eliminare o aggiornare particolari righe di una tabella in SQLite, è necessario utilizzare la clausola where per specificare la condizione per filtrare le righe della tabella per l'operazione.
Ad esempio, se si dispone di un'istruzione SELECT con la clausola where, verranno recuperate solo le righe che soddisfano la condizione specificata.
Sintassi
Di seguito è riportata la sintassi della clausola WHERE in SQLite:
SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]È possibile specificare una condizione_ricerca utilizzando il confronto o gli operatori logici. come>, <, =, LIKE, NOT, ecc. I seguenti esempi renderebbero chiaro questo concetto.
Esempio
Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:
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 abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -
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>La seguente istruzione SELECT recupera i record la cui età è maggiore di 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>Clausola Where utilizzando Python
L'oggetto / classe Cursor contiene tutti i metodi per eseguire query e recuperare dati, ecc. Il metodo cursore della classe di connessione restituisce un oggetto cursore.
Pertanto, per creare una tabella nel database SQLite utilizzando python -
Stabilire una connessione con un database utilizzando il metodo connect ().
Crea un oggetto cursore invocando il metodo cursor () sull'oggetto connessione creato sopra.
Ora esegui l'istruzione CREATE TABLE utilizzando il metodo execute () della classe Cursor.
Esempio
L'esempio seguente crea una tabella denominata Employee e la popola. Quindi, utilizzando la clausola where, recupera i record con un valore di età inferiore a 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()Produzione
[('Vinay', 'Battacharya', 20, 'M', 6000.0)]Durante il recupero dei dati utilizzando la query SELEZIONA, otterrai i record nello stesso ordine in cui li hai inseriti.
È possibile ordinare i risultati nell'ordine desiderato (crescente o decrescente) utilizzando il Order Byclausola. Per impostazione predefinita, questa clausola ordina i risultati in ordine crescente, se è necessario disporli in ordine decrescente è necessario utilizzare esplicitamente "DESC".
Sintassi
Di seguito è riportata la sintassi della clausola ORDER BY in SQLite.
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];Esempio
Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:
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 abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -
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>La seguente istruzione SELECT recupera le righe della tabella CRICKETERS in ordine crescente in base alla loro età -
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>È possibile utilizzare più di una colonna per ordinare i record di una tabella. Le seguenti istruzioni SELECT ordinano i record della tabella CRICKETERS in base alle colonne 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>Per impostazione predefinita, il ORDER BY la clausola ordina i record di una tabella in ordine crescente puoi disporre i risultati in ordine decrescente usando DESC come -
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>Clausola ORDER BY utilizzando Python
Per recuperare il contenuto di una tabella in un ordine specifico, richiamare il metodo execute () sull'oggetto cursore e passare l'istruzione SELECT insieme alla clausola ORDER BY, come parametro ad esso.
Esempio
Nell'esempio seguente stiamo creando una tabella con nome e Employee, popolandola e recuperando i suoi record nell'ordine (crescente) della loro età, utilizzando la clausola 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()Produzione
[
('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)
]AGGIORNAMENTO L'operazione su qualsiasi database implica la modifica dei valori di uno o più record di una tabella, che sono già disponibili nel database. È possibile aggiornare i valori dei record esistenti in SQLite utilizzando l'istruzione UPDATE.
Per aggiornare righe specifiche, è necessario utilizzare la clausola WHERE insieme ad essa.
Sintassi
Di seguito è riportata la sintassi dell'istruzione UPDATE in SQLite:
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];Esempio
Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:
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 abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -
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>La seguente dichiarazione modifica l'età del giocatore di cricket, il cui nome è Shikhar -
sqlite> UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
sqlite>Se recuperi il record il cui FIRST_NAME è Shikhar, osservi che il valore dell'età è stato modificato in 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 non hai utilizzato la clausola WHERE, i valori di tutti i record verranno aggiornati. La seguente istruzione UPDATE aumenta l'età di tutti i record nella tabella CRICKETERS di 1 -
sqlite> UPDATE CRICKETERS SET AGE = AGE+1;
sqlite>Se recuperi il contenuto della tabella utilizzando il comando SELEZIONA, puoi vedere i valori aggiornati come -
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>Aggiornamento dei record esistenti utilizzando Python
Per aggiungere record a una tabella esistente nel database SQLite:
Importa pacchetto sqlite3.
Creare un oggetto connessione utilizzando il metodo connect () passando il nome del database come parametro ad esso.
Il cursor()restituisce un oggetto cursore utilizzando il quale è possibile comunicare con SQLite3. Crea un oggetto cursore invocando l'oggetto cursore () sull'oggetto Connection (creato sopra).
Quindi, invoca il metodo execute () sull'oggetto cursore, passando un'istruzione UPDATE come parametro ad esso.
Esempio
Seguendo l'esempio di Python, crea una tabella con il nome DIPENDENTE, inserisce 5 record al suo interno e aumenta l'età di tutti i dipendenti maschi di 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()Produzione
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)
]Per eliminare i record da una tabella SQLite, è necessario utilizzare l'istruzione DELETE FROM. Per rimuovere record specifici, è necessario utilizzare la clausola WHERE insieme ad essa.
Sintassi
Di seguito è riportata la sintassi della query DELETE in SQLite:
DELETE FROM table_name [WHERE Clause]Esempio
Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:
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 abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -
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>La seguente dichiarazione cancella il record del giocatore di cricket il cui cognome è "Sangakkara".
sqlite> DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
sqlite>Se recuperi il contenuto della tabella utilizzando l'istruzione SELECT, puoi vedere solo 4 record poiché ne abbiamo eliminato uno.
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 si esegue l'istruzione DELETE FROM senza la clausola WHERE, verranno eliminati tutti i record dalla tabella specificata.
sqlite> DELETE FROM CRICKETERS;
sqlite>Poiché hai cancellato tutti i record, se provi a recuperare il contenuto della tabella CRICKETERS, usando l'istruzione SELECT otterrai un set di risultati vuoto come mostrato di seguito -
sqlite> SELECT * FROM CRICKETERS;
sqlite>Eliminazione dei dati utilizzando Python
Per aggiungere record a una tabella esistente nel database SQLite:
Importa pacchetto sqlite3.
Creare un oggetto connessione utilizzando il metodo connect () passando il nome del database come parametro ad esso.
Il cursor()restituisce un oggetto cursore utilizzando il quale è possibile comunicare con SQLite3. Crea un oggetto cursore invocando l'oggetto cursore () sull'oggetto Connection (creato sopra).
Quindi, invoca il metodo execute () sull'oggetto cursore, passando un DELETE dichiarazione come parametro ad esso.
Esempio
Il seguente esempio di Python elimina i record dalla tabella EMPLOYEE con un valore di età maggiore di 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()Produzione
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)
]È possibile rimuovere un'intera tabella utilizzando l'istruzione DROP TABLE. Devi solo specificare il nome della tabella che devi eliminare.
Sintassi
Di seguito è riportata la sintassi dell'istruzione DROP TABLE in PostgreSQL:
DROP TABLE table_name;Esempio
Supponiamo di aver creato due tabelle con il nome CRICKETERS e EMPLOYEES utilizzando le seguenti query:
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>Ora se verifichi l'elenco delle tabelle utilizzando il file .tables comando, puoi vedere le tabelle create sopra (elenco) come -
sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>La seguente istruzione elimina la tabella denominata Employee dal database:
sqlite> DROP table employee;
sqlite>Poiché hai eliminato la tabella Employee, se recuperi nuovamente l'elenco delle tabelle, puoi osservare solo una tabella al suo interno.
sqlite> .tables
CRICKETERS
sqlite>Se provi a eliminare di nuovo la tabella Employee, poiché l'hai già eliminata, verrà visualizzato un messaggio di errore che dice "nessuna tabella di questo tipo" come mostrato di seguito -
sqlite> DROP table employee;
Error: no such table: employee
sqlite>Per risolvere questo problema, è possibile utilizzare la clausola IF EXISTS insieme all'istruzione DELETE. Questo rimuove la tabella se esiste altrimenti salta l'operazione DELETE.
sqlite> DROP table IF EXISTS employee;
sqlite>Eliminare una tabella usando Python
È possibile eliminare una tabella ogni volta che è necessario, utilizzando l'istruzione DROP di MYSQL, ma è necessario fare molta attenzione durante l'eliminazione di qualsiasi tabella esistente perché i dati persi non verranno recuperati dopo aver eliminato una tabella.
Esempio
Per eliminare una tabella da un database SQLite3 utilizzando python, richiamare il file execute() sull'oggetto cursore e passargli l'istruzione drop come parametro.
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()Produzione
Table dropped...Mentre si recuperano i record se si desidera limitarli a un numero particolare, è possibile farlo utilizzando la clausola LIMIT di SQLite.
Sintassi
Di seguito è riportata la sintassi della clausola LIMIT in SQLite:
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]Esempio
Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:
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 abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -
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>La seguente dichiarazione recupera i primi 3 record della tabella Cricketers utilizzando la clausola 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 è necessario per limitare i record a partire dal ennesimo record (non 1 st ), è possibile farlo, in offset con 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>Clausola LIMIT utilizzando Python
Se si richiama il metodo execute () sull'oggetto cursore passando la query SELECT insieme alla clausola LIMIT, è possibile recuperare il numero di record richiesto.
Esempio
L'esempio seguente di Python recupera i primi due record della tabella EMPLOYEE utilizzando la clausola 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()Produzione
[
('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0)
]Dopo aver diviso i dati in due tabelle, è possibile recuperare i record combinati da queste due tabelle utilizzando i join.
Esempio
Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Creiamo un altro tavolo OdiStats che descrive le statistiche del cricket di un giorno di ciascun giocatore nel tavolo CRICKETERS.
sqlite> CREATE TABLE ODIStats (
First_Name VARCHAR(255),
Matches INT,
Runs INT,
AVG FLOAT,
Centuries INT,
HalfCenturies INT
);
sqlite>La seguente istruzione recupera i dati combinando i valori in queste due tabelle:
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>Clausola Join utilizzando Python
Seguendo l'esempio SQLite, dimostra la clausola 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()Produzione
[
('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')
]La classe sqlite3.Cursor è un'istanza che consente di richiamare metodi che eseguono istruzioni SQLite, recuperando dati dai set di risultati delle query. È possibile creare un oggetto Cursor utilizzando il metodo cursor () dell'oggetto / classe Connection.
Esempio
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()Metodi
Di seguito sono riportati i vari metodi forniti dalla classe / oggetto Cursor.
| Metodo | Descrizione |
|---|---|
| eseguire() | Questa routine esegue un'istruzione SQL. L'istruzione SQL può essere parametrizzata (cioè, segnaposto invece di letterali SQL). Il modulo psycopg2 supporta segnaposto utilizzando il segno% s Ad esempio: cursor.execute ("insert into people values (% s,% s)", (who, age)) |
| esecutoremi () | Questa routine esegue un comando SQL su tutte le sequenze di parametri o le mappature trovate nella sequenza sql. |
| fetchone () | Questo metodo recupera la riga successiva di un set di risultati di query, restituendo una singola sequenza o Nessuno quando non sono disponibili più dati. |
| fetchmany () | Questa routine recupera la serie successiva di righe del risultato di una query, restituendo un elenco. Quando non sono disponibili più righe, viene restituito un elenco vuoto. Il metodo cerca di recuperare tutte le righe indicate dal parametro size. |
| fetchall () | Questa routine recupera tutte le righe (rimanenti) di un risultato di query, restituendo un elenco. Quando non sono disponibili righe, viene restituito un elenco vuoto. |
Proprietà
Di seguito sono riportate le proprietà della classe Cursor:
| Metodo | Descrizione |
|---|---|
| arraySize | Questa è una proprietà di lettura / scrittura che puoi impostare il numero di righe restituite dal metodo fetchmany (). |
| descrizione | Questa è una proprietà di sola lettura che restituisce l'elenco contenente la descrizione delle colonne in un set di risultati. |
| lastrowid | Questa è una proprietà di sola lettura, se nella tabella sono presenti colonne con incremento automatico, restituisce il valore generato per quella colonna nell'ultima operazione INSERT o UPDATE. |
| Rowcount | Restituisce il numero di righe restituite / aggiornate in caso di operazioni SELECT e UPDATE. |
| connessione | Questo attributo di sola lettura fornisce la connessione al database SQLite utilizzata dall'oggetto Cursor. |