Python SQLite - Guide rapide
SQLite3 peut être intégré à Python à l'aide du module sqlite3, qui a été écrit par Gerhard Haring. Il fournit une interface SQL conforme à la spécification DB-API 2.0 décrite par PEP 249. Vous n'avez pas besoin d'installer ce module séparément car il est livré par défaut avec Python version 2.5.x et suivantes.
Pour utiliser le module sqlite3, vous devez d'abord créer un objet de connexion qui représente la base de données, puis éventuellement, vous pouvez créer un objet curseur, qui vous aidera à exécuter toutes les instructions SQL.
API du module Python SQLite3
Voici les routines importantes du module sqlite3, qui peuvent suffire à votre besoin pour travailler avec la base de données SQLite à partir de votre programme Python. Si vous recherchez une application plus sophistiquée, vous pouvez consulter la documentation officielle du module Python sqlite3.
| N ° Sr. | API et description |
|---|---|
| 1 | sqlite3.connect(database [,timeout ,other optional arguments]) Cette API ouvre une connexion au fichier de base de données SQLite. Vous pouvez utiliser ": memory:" pour ouvrir une connexion de base de données à une base de données qui réside dans la RAM plutôt que sur le disque. Si la base de données est ouverte avec succès, elle renvoie un objet de connexion. |
| 2 | connection.cursor([cursorClass]) Cette routine crée un curseur qui sera utilisé tout au long de la programmation de votre base de données avec Python. Cette méthode accepte un seul paramètre facultatif cursorClass. S'il est fourni, il doit s'agir d'une classe de curseur personnalisée qui étend sqlite3.Cursor. |
| 3 | cursor.execute(sql [, optional parameters]) Cette routine exécute une instruction SQL. L'instruction SQL peut être paramétrée (c'est-à-dire des espaces réservés au lieu de littéraux SQL). Le module sqlite3 prend en charge deux types d'espaces réservés: les points d'interrogation et les espaces réservés nommés (style nommé). For example - cursor.execute ("insérer dans les valeurs des personnes (?,?)", (Qui, âge)) |
| 4 | connection.execute(sql [, optional parameters]) Cette routine est un raccourci de la méthode d'exécution ci-dessus fournie par l'objet curseur et elle crée un objet curseur intermédiaire en appelant la méthode curseur, puis appelle la méthode d'exécution du curseur avec les paramètres donnés. |
| 5 | cursor.executemany(sql, seq_of_parameters) Cette routine exécute une commande SQL sur toutes les séquences de paramètres ou mappages trouvés dans la séquence sql. |
| 6 | connection.executemany(sql[, parameters]) Cette routine est un raccourci qui crée un objet curseur intermédiaire en appelant la méthode cursor, puis appelle la méthode executemany cursor.s avec les paramètres donnés. |
| sept | cursor.executescript(sql_script) Cette routine exécute plusieurs instructions SQL à la fois fournies sous forme de script. Il émet d'abord une instruction COMMIT, puis exécute le script SQL qu'il obtient en tant que paramètre. Toutes les instructions SQL doivent être séparées par un point-virgule (;). |
| 8 | connection.executescript(sql_script) Cette routine est un raccourci qui crée un objet curseur intermédiaire en appelant la méthode cursor, puis appelle la méthode executescript du curseur avec les paramètres donnés. |
| 9 | connection.total_changes() Cette routine renvoie le nombre total de lignes de base de données qui ont été modifiées, insérées ou supprimées depuis l'ouverture de la connexion à la base de données. |
| dix | connection.commit() Cette méthode valide la transaction en cours. Si vous n'appelez pas cette méthode, tout ce que vous avez fait depuis le dernier appel à commit () n'est pas visible depuis les autres connexions à la base de données. |
| 11 | connection.rollback() Cette méthode annule toutes les modifications apportées à la base de données depuis le dernier appel à commit (). |
| 12 | connection.close() Cette méthode ferme la connexion à la base de données. Notez que cela n'appelle pas automatiquement commit (). Si vous fermez simplement votre connexion à la base de données sans appeler commit () au préalable, vos modifications seront perdues! |
| 13 | cursor.fetchone() Cette méthode récupère la ligne suivante d'un jeu de résultats de requête, renvoyant une seule séquence, ou None lorsque aucune donnée n'est disponible. |
| 14 | cursor.fetchmany([size = cursor.arraysize]) Cette routine récupère l'ensemble suivant de lignes d'un résultat de requête, renvoyant une liste. Une liste vide est renvoyée lorsqu'il n'y a plus de lignes disponibles. La méthode tente d'extraire autant de lignes que l'indique le paramètre size. |
| 15 | cursor.fetchall() Cette routine récupère toutes les lignes (restantes) d'un résultat de requête, renvoyant une liste. Une liste vide est renvoyée lorsqu'aucune ligne n'est disponible. |
Pour établir une connexion avec l'invite de commande SQLite Open, parcourez l'emplacement où vous avez installé SQLite et exécutez simplement la commande sqlite3 comme indiqué ci-dessous -
Établir une connexion à l'aide de Python
Vous pouvez communiquer avec la base de données SQLite2 à l'aide du module python SQLite3. Pour ce faire, vous devez tout d'abord établir une connexion (créer un objet de connexion).
Pour établir une connexion avec la base de données SQLite3 à l'aide de python, vous devez -
Importez le module sqlite3 à l'aide de l'instruction import.
La méthode connect () accepte le nom de la base de données à laquelle vous devez vous connecter en tant que paramètre et renvoie un objet Connection.
Exemple
import sqlite3
conn = sqlite3.connect('example.db')Production
print("Connection established ..........")À l'aide de l'instruction SQLite CREATE TABLE, vous pouvez créer une table dans une base de données.
Syntaxe
Voici la syntaxe pour créer une table dans la base de données SQLite -
CREATE TABLE database_name.table_name(
column1 datatype PRIMARY KEY(one or more columns),
column2 datatype,
column3 datatype,
.....
columnN datatype
);Exemple
La requête / instruction SQLite suivante crée une table avec un nom CRICKETERS dans la base de données SQLite -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Créons un autre tableau OdiStats décrivant les statistiques de cricket d'un jour de chaque joueur dans le tableau CRICKETERS.
sqlite> CREATE TABLE ODIStats (
First_Name VARCHAR(255),
Matches INT,
Runs INT,
AVG FLOAT,
Centuries INT,
HalfCenturies INT
);
sqlite>Vous pouvez obtenir la liste des tables d'une base de données dans la base de données SQLite à l'aide du .tablescommander. Après avoir créé une table, si vous pouvez vérifier la liste des tables, vous pouvez y observer la table nouvellement créée comme -
sqlite> . tables
CRICKETERS ODIStats
sqlite>Créer une table à l'aide de Python
L'objet Cursor contient toutes les méthodes pour exécuter des requêtes et récupérer des données, etc. La méthode de curseur de la classe de connexion renvoie un objet de curseur.
Par conséquent, pour créer une table dans la base de données SQLite en utilisant python -
Établissez une connexion avec une base de données à l'aide de la méthode connect ().
Créez un objet curseur en appelant la méthode cursor () sur l'objet de connexion créé ci-dessus.
Exécutez maintenant l'instruction CREATE TABLE à l'aide de la méthode execute () de la classe Cursor.
Exemple
Le programme Python suivant crée une table nommée Employee dans 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()Production
Table created successfully........Vous pouvez ajouter de nouvelles lignes à une table existante de SQLite à l'aide de l'instruction INSERT INTO. Dans ce cas, vous devez spécifier le nom de la table, les noms de colonne et les valeurs (dans le même ordre que les noms de colonne).
Syntaxe
Voici la syntaxe recommandée de l'instruction INSERT -
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);Où, colonne1, colonne2, colonne3, .. sont les noms des colonnes d'une table et valeur1, valeur2, valeur3, ... sont les valeurs que vous devez insérer dans la table.
Exemple
Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant l'instruction CREATE TABLE comme indiqué ci-dessous -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>L'instruction PostgreSQL suivante insère une ligne dans la table créée ci-dessus.
sqlite> insert into CRICKETERS (First_Name, Last_Name, Age, Place_Of_Birth, Country)
values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite>Lors de l'insertion d'enregistrements à l'aide de l' instruction INSERT INTO , si vous ignorez les noms de colonnes, cet enregistrement sera inséré en laissant des espaces vides dans les colonnes que vous avez ignorées.
sqlite> insert into CRICKETERS (First_Name, Last_Name, Country)
values ('Jonathan', 'Trott', 'SouthAfrica');
sqlite>Vous pouvez également insérer des enregistrements dans une table sans spécifier les noms de colonne, si l'ordre des valeurs que vous passez est le même que leurs noms de colonne respectifs dans la table.
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>Après avoir inséré les enregistrements dans une table, vous pouvez vérifier son contenu à l'aide de l'instruction SELECT comme indiqué ci-dessous -
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>Insertion de données à l'aide de Python
Pour ajouter des enregistrements à une table existante dans la base de données SQLite -
Importez le package sqlite3.
Créez un objet de connexion à l'aide de la méthode connect () en lui passant le nom de la base de données comme paramètre.
le cursor()renvoie un objet curseur à l'aide duquel vous pouvez communiquer avec SQLite3. Créez un objet curseur en invoquant l'objet curseur () sur l'objet Connection (créé ci-dessus).
Ensuite, appelez la méthode execute () sur l'objet curseur, en lui passant une instruction INSERT en tant que paramètre.
Exemple
L'exemple python suivant insère des enregistrements dans une table nommée 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()Production
Records inserted........Vous pouvez récupérer des données à partir d'une table SQLite à l'aide de la requête SELECT. Cette requête / instruction renvoie le contenu de la relation (table) spécifiée sous forme de tableau et elle est appelée comme ensemble de résultats.
Syntaxe
Voici la syntaxe de l'instruction SELECT dans SQLite -
SELECT column1, column2, columnN FROM table_name;Exemple
Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -
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 requête SELECT suivante récupère les valeurs des colonnes FIRST_NAME, LAST_NAME et COUNTRY de la table 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>Comme vous le voyez, l'instruction SELECT de la base de données SQLite renvoie simplement les enregistrements des tables spécifiées. Pour obtenir une sortie formatée, vous devez définir leheader, et mode en utilisant les commandes respectives avant l'instruction SELECT comme indiqué ci-dessous -
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 IndiaSi vous souhaitez récupérer toutes les colonnes de chaque enregistrement, vous devez remplacer les noms des colonnes par "*" comme indiqué ci-dessous -
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>Dans SQLite par défaut, la largeur des colonnes est de 10 valeurs au-delà de cette largeur sont hachées (observez la colonne country de la 2 ème ligne dans le tableau ci-dessus). Vous pouvez définir la largeur de chaque colonne sur la valeur requise à l'aide du.width commande, avant de récupérer le contenu d'un tableau comme indiqué ci-dessous -
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>Récupération de données à l'aide de Python
LIRE L'opération sur n'importe quelle base de données signifie récupérer des informations utiles dans la base de données. Vous pouvez récupérer les données de MYSQL en utilisant la méthode fetch () fournie par le module python sqlite.
La classe sqlite3.Cursor fournit trois méthodes à savoir fetchall (), fetchmany () et, fetchone () où,
La méthode fetchall () récupère toutes les lignes du jeu de résultats d'une requête et les renvoie sous forme de liste de tuples. (Si nous exécutons ceci après avoir récupéré quelques lignes, il renvoie les autres).
La méthode fetchone () récupère la ligne suivante dans le résultat d'une requête et la renvoie sous forme de tuple.
La méthode fetchmany () est similaire à la méthode fetchone (), mais elle récupère le jeu de lignes suivant dans le jeu de résultats d'une requête, au lieu d'une seule ligne.
Note - Un jeu de résultats est un objet renvoyé lorsqu'un objet curseur est utilisé pour interroger une table.
Exemple
L'exemple suivant récupère toutes les lignes de la table EMPLOYEE à l'aide de la requête SELECT et à partir du jeu de résultats obtenu initialement, nous récupérons la première ligne à l'aide de la méthode fetchone (), puis les lignes restantes à l'aide de la méthode fetchall ().
Le programme Python suivant montre comment récupérer et afficher les enregistrements de la table COMPANY créée dans l'exemple ci-dessus.
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()Production
('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)
]Si vous souhaitez extraire, supprimer ou mettre à jour des lignes particulières d'une table dans SQLite, vous devez utiliser la clause where pour spécifier la condition de filtrage des lignes de la table pour l'opération.
Par exemple, si vous avez une instruction SELECT avec la clause where, seules les lignes qui satisfont à la condition spécifiée seront récupérées.
Syntaxe
Voici la syntaxe de la clause WHERE dans SQLite -
SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]Vous pouvez spécifier une condition de recherche à l'aide de comparaison ou d'opérateurs logiques. comme>, <, =, LIKE, NOT, etc. Les exemples suivants clarifieraient ce concept.
Exemple
Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -
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>L'instruction SELECT suivante récupère les enregistrements dont l'âge est supérieur à 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>Clause Where utilisant Python
L'objet / la classe Cursor contient toutes les méthodes pour exécuter des requêtes et extraire des données, etc. La méthode de curseur de la classe de connexion renvoie un objet curseur.
Par conséquent, pour créer une table dans la base de données SQLite en utilisant python -
Établissez une connexion avec une base de données à l'aide de la méthode connect ().
Créez un objet curseur en appelant la méthode cursor () sur l'objet de connexion créé ci-dessus.
Exécutez maintenant l'instruction CREATE TABLE à l'aide de la méthode execute () de la classe Cursor.
Exemple
L'exemple suivant crée une table nommée Employee et la remplit. Ensuite, à l'aide de la clause where, il récupère les enregistrements dont l'âge est inférieur à 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()Production
[('Vinay', 'Battacharya', 20, 'M', 6000.0)]Lors de la récupération des données à l'aide de la requête SELECT, vous obtiendrez les enregistrements dans le même ordre dans lequel vous les avez insérés.
Vous pouvez trier les résultats dans l'ordre souhaité (croissant ou décroissant) à l'aide du Order Byclause. Par défaut, cette clause trie les résultats dans l'ordre croissant, si vous devez les organiser par ordre décroissant, vous devez utiliser explicitement «DESC».
Syntaxe
Voici la syntaxe de la clause ORDER BY dans SQLite.
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];Exemple
Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -
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>L'instruction SELECT suivante récupère les lignes de la table CRICKETERS dans l'ordre croissant de leur âge -
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>Vous pouvez utiliser plusieurs colonnes pour trier les enregistrements d'une table. Les instructions SELECT suivantes trient les enregistrements de la table CRICKETERS en fonction des colonnes AGE et 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>Par défaut, le ORDER BY clause trie les enregistrements d'une table dans l'ordre croissant, vous pouvez organiser les résultats dans l'ordre décroissant en utilisant DESC comme -
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>Clause ORDER BY à l'aide de Python
Pour récupérer le contenu d'une table dans un ordre spécifique, appelez la méthode execute () sur l'objet curseur et passez l'instruction SELECT avec la clause ORDER BY, en tant que paramètre.
Exemple
Dans l'exemple suivant, nous créons une table avec le nom et l'employé, la remplissons et récupérons ses enregistrements dans l'ordre (croissant) de leur âge, à l'aide de la clause 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()Production
[
('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)
]UPDATE L'opération sur n'importe quelle base de données implique de modifier les valeurs d'un ou plusieurs enregistrements d'une table, qui sont déjà disponibles dans la base de données. Vous pouvez mettre à jour les valeurs des enregistrements existants dans SQLite à l'aide de l'instruction UPDATE.
Pour mettre à jour des lignes spécifiques, vous devez utiliser la clause WHERE avec elle.
Syntaxe
Voici la syntaxe de l'instruction UPDATE dans SQLite -
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];Exemple
Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -
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 déclaration suivante modifie l'âge du joueur de cricket, dont le prénom est Shikhar -
sqlite> UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
sqlite>Si vous récupérez l'enregistrement dont FIRST_NAME est Shikhar, vous constatez que la valeur d'âge a été modifiée à 45 -
sqlite> SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- --------
Shikhar Dhawan 45 Delhi India
sqlite>Si vous n'avez pas utilisé la clause WHERE, les valeurs de tous les enregistrements seront mises à jour. L'instruction UPDATE suivante augmente l'âge de tous les enregistrements de la table CRICKETERS de 1 -
sqlite> UPDATE CRICKETERS SET AGE = AGE+1;
sqlite>Si vous récupérez le contenu de la table à l'aide de la commande SELECT, vous pouvez voir les valeurs mises à jour comme -
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>Mettre à jour des enregistrements existants à l'aide de Python
Pour ajouter des enregistrements à une table existante dans la base de données SQLite -
Importez le package sqlite3.
Créez un objet de connexion à l'aide de la méthode connect () en lui passant le nom de la base de données comme paramètre.
le cursor()renvoie un objet curseur à l'aide duquel vous pouvez communiquer avec SQLite3. Créez un objet curseur en invoquant l'objet curseur () sur l'objet Connection (créé ci-dessus).
Ensuite, appelez la méthode execute () sur l'objet curseur, en lui passant une instruction UPDATE comme paramètre.
Exemple
En suivant l'exemple Python, crée une table avec le nom EMPLOYEE, y insère 5 enregistrements et augmente l'âge de tous les employés masculins de 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()Production
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)
]Pour supprimer des enregistrements d'une table SQLite, vous devez utiliser l'instruction DELETE FROM. Pour supprimer des enregistrements spécifiques, vous devez utiliser la clause WHERE avec elle.
Syntaxe
Voici la syntaxe de la requête DELETE dans SQLite -
DELETE FROM table_name [WHERE Clause]Exemple
Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -
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 déclaration suivante supprime l'enregistrement du joueur de cricket dont le nom de famille est «Sangakkara».
sqlite> DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
sqlite>Si vous récupérez le contenu de la table à l'aide de l'instruction SELECT, vous ne pouvez voir que 4 enregistrements puisque nous en avons supprimé un.
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>Si vous exécutez l'instruction DELETE FROM sans la clause WHERE, tous les enregistrements de la table spécifiée seront supprimés.
sqlite> DELETE FROM CRICKETERS;
sqlite>Puisque vous avez supprimé tous les enregistrements, si vous essayez de récupérer le contenu de la table CRICKETERS, en utilisant l'instruction SELECT, vous obtiendrez un jeu de résultats vide comme indiqué ci-dessous -
sqlite> SELECT * FROM CRICKETERS;
sqlite>Suppression de données à l'aide de Python
Pour ajouter des enregistrements à une table existante dans la base de données SQLite -
Importez le package sqlite3.
Créez un objet de connexion à l'aide de la méthode connect () en lui passant le nom de la base de données comme paramètre.
le cursor()renvoie un objet curseur à l'aide duquel vous pouvez communiquer avec SQLite3. Créez un objet curseur en invoquant l'objet curseur () sur l'objet Connection (créé ci-dessus).
Ensuite, invoquez la méthode execute () sur l'objet curseur, en passant un DELETE instruction en tant que paramètre.
Exemple
L'exemple python suivant supprime les enregistrements de la table EMPLOYEE avec une valeur d'âge supérieure à 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()Production
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)
]Vous pouvez supprimer une table entière à l'aide de l'instruction DROP TABLE. Il vous suffit de spécifier le nom de la table à supprimer.
Syntaxe
Voici la syntaxe de l'instruction DROP TABLE dans PostgreSQL -
DROP TABLE table_name;Exemple
Supposons que nous ayons créé deux tables avec le nom CRICKETERS et EMPLOYEES en utilisant les requêtes suivantes -
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>Maintenant, si vous vérifiez la liste des tables à l'aide du .tables commande, vous pouvez voir les tables créées ci-dessus (liste) comme -
sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>L'instruction suivante supprime la table nommée Employee de la base de données -
sqlite> DROP table employee;
sqlite>Puisque vous avez supprimé la table Employee, si vous récupérez à nouveau la liste des tables, vous ne pouvez y observer qu'une seule table.
sqlite> .tables
CRICKETERS
sqlite>Si vous essayez de supprimer à nouveau la table des employés, puisque vous l'avez déjà supprimée, vous obtiendrez une erreur indiquant "pas de table de ce type" comme indiqué ci-dessous -
sqlite> DROP table employee;
Error: no such table: employee
sqlite>Pour résoudre ce problème, vous pouvez utiliser la clause IF EXISTS avec l'instruction DELETE. Cela supprime la table si elle existe sinon ignore l'opération DELETE.
sqlite> DROP table IF EXISTS employee;
sqlite>Supprimer une table à l'aide de Python
Vous pouvez supprimer une table chaque fois que vous en avez besoin, en utilisant l'instruction DROP de MYSQL, mais vous devez être très prudent lorsque vous supprimez une table existante car les données perdues ne seront pas récupérées après la suppression d'une table.
Exemple
Pour supprimer une table d'une base de données SQLite3 à l'aide de python, appelez le execute() sur l'objet de curseur et passez l'instruction drop en tant que paramètre.
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()Production
Table dropped...Lors de la récupération des enregistrements si vous souhaitez les limiter par un nombre particulier, vous pouvez le faire en utilisant la clause LIMIT de SQLite.
Syntaxe
Voici la syntaxe de la clause LIMIT dans SQLite -
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]Exemple
Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -
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>L'instruction suivante récupère les 3 premiers enregistrements de la table Cricketers à l'aide de la clause 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>Si vous devez limiter les enregistrements à partir du nième enregistrement (et non du 1 er ), vous pouvez le faire, en utilisant OFFSET avec 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>Clause LIMIT utilisant Python
Si vous appelez la méthode execute () sur l'objet curseur en transmettant la requête SELECT avec la clause LIMIT, vous pouvez récupérer le nombre d'enregistrements requis.
Exemple
L'exemple python suivant récupère les deux premiers enregistrements de la table EMPLOYEE à l'aide de la clause 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()Production
[
('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0)
]Lorsque vous avez divisé les données en deux tables, vous pouvez extraire des enregistrements combinés de ces deux tables à l'aide des jointures.
Exemple
Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>Créons un autre tableau OdiStats décrivant les statistiques de cricket d'un jour de chaque joueur dans le tableau CRICKETERS.
sqlite> CREATE TABLE ODIStats (
First_Name VARCHAR(255),
Matches INT,
Runs INT,
AVG FLOAT,
Centuries INT,
HalfCenturies INT
);
sqlite>L'instruction suivante récupère les données combinant les valeurs de ces deux tables -
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>Clause de jointure à l'aide de Python
L'exemple SQLite suivant montre la clause JOIN en utilisant 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()Production
[
('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 est une instance à l'aide de laquelle vous pouvez appeler des méthodes qui exécutent des instructions SQLite, extraire des données des ensembles de résultats des requêtes. Vous pouvez créer un objet Cursor à l'aide de la méthode cursor () de l'objet / de la classe Connection.
Exemple
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()Méthodes
Voici les différentes méthodes fournies par la classe / objet Cursor.
| Méthode | La description |
|---|---|
| exécuter() | Cette routine exécute une instruction SQL. L'instruction SQL peut être paramétrée (c'est-à-dire, des espaces réservés au lieu de littéraux SQL). Le module psycopg2 prend en charge l'espace réservé à l'aide du signe% s Par exemple: cursor.execute ("insérer dans les valeurs des personnes (% s,% s)", (qui, âge)) |
| executemany () | Cette routine exécute une commande SQL sur toutes les séquences de paramètres ou mappages trouvés dans la séquence sql. |
| fetchone () | Cette méthode récupère la ligne suivante d'un jeu de résultats de requête, renvoyant une seule séquence, ou None lorsque aucune donnée n'est disponible. |
| fetchmany () | Cette routine récupère l'ensemble suivant de lignes d'un résultat de requête, renvoyant une liste. Une liste vide est renvoyée lorsqu'il n'y a plus de lignes disponibles. La méthode tente d'extraire autant de lignes que l'indique le paramètre size. |
| fetchall () | Cette routine récupère toutes les lignes (restantes) d'un résultat de requête, renvoyant une liste. Une liste vide est renvoyée lorsqu'aucune ligne n'est disponible. |
Propriétés
Voici les propriétés de la classe Cursor -
| Méthode | La description |
|---|---|
| arraySize | Il s'agit d'une propriété de lecture / écriture, vous pouvez définir le nombre de lignes renvoyées par la méthode fetchmany (). |
| la description | Il s'agit d'une propriété en lecture seule qui renvoie la liste contenant la description des colonnes dans un jeu de résultats. |
| lastrowid | Il s'agit d'une propriété en lecture seule, s'il y a des colonnes auto-incrémentées dans la table, cela renvoie la valeur générée pour cette colonne lors de la dernière opération INSERT ou UPDATE. |
| nombre de lignes | Cela renvoie le nombre de lignes renvoyées / mises à jour en cas d'opérations SELECT et UPDATE. |
| connexion | Cet attribut en lecture seule fournit la connexion à la base de données SQLite utilisée par l'objet Cursor. |