Voir la source de SQLite

{{Infobox Logiciel
 | couleur boîte            = 92D5F5
 | nom                      = SQLite
 | logo                     = 
 | image                    = 
 | légende                  = 
 | développeur              = 
 | exécutable               = 
 | date de première version = 
 | dernière version         = 
 | date de dernière version = 
 | version avancée          = 
 | date de version avancée  = 
 | dépôt                    = 
 | état                     = 
 | langage de programmation = 
 | environnement            = 
 | langues                  = 
 | type                     = 
 | politique de prix        = 
 | licence                  = Domaine public
 | site web                 = 
 | wikidata                 = 
 | créateur                 = 
 | version précédente       = 
 | version suivante         = 
}}
'''''SQLite''''' (prononcé [{{API|ɛs.ky.ɛl.ajt}}]) est une [[bibliothèque logicielle|bibliothèque]] écrite en [[Langage de programmation|langage]] [[C (langage)|C]] qui propose un [[moteur de base de données|moteur]] de [[base de données relationnelle]] accessible par le langage [[Structured Query Language|SQL]]. SQLite implémente en grande partie le standard [[Structured Query Language#Historique|SQL-92]] et des [[Transaction informatique|propriétés ACID]].

Contrairement aux [[Serveur informatique#Base de données|serveurs]] de bases de données traditionnels, tels que [[MySQL]], [[MariaDB|MariaDb]] ou [[PostgreSQL]], sa particularité est de ne pas reproduire le schéma habituel [[client-serveur]] mais d'être directement intégrée aux [[Programme informatique|programmes]]. L'intégralité de la [[base de données]] (déclarations, [[Table (base de données)|tables]], [[Index (base de données)|index]] et données) est stockée dans un [[Fichier informatique|fichier]] [[Logiciel multiplateforme|indépendant de la plateforme]].

[[D. Richard Hipp]], le créateur de SQLite, a choisi de mettre cette bibliothèque ainsi que son [[code source]] dans le [[domaine public (propriété intellectuelle)|domaine public]], ce qui permet son utilisation sans restriction aussi bien dans les projets [[open source]] que dans les projets [[Propriété intellectuelle|propriétaires]]. Le créateur ainsi qu'une partie des développeurs principaux de SQLite sont employés par la société [[États-Unis|américaine]] [[Hwaci]]<ref>{{lien web|url=https://www.sqlite.org/copyright.html|titre=SQLite Copyright|site=www.sqlite.org}}</ref>.

SQLite est le moteur de base de données le plus utilisé au monde, grâce à son utilisation :

* dans de nombreux [[Logiciel|logiciels]] grand public comme [[Mozilla Firefox|Firefox]], [[Skype]], [[Gears|Google Gears]], 
* dans certains produits d'[[Apple]], d'[[Adobe (entreprise)|Adobe]] et de [[McAfee]],
* dans les [[Bibliothèque logicielle|bibliothèques]] standards de nombreux langages comme [[PHP]] ou [[Python (langage)|Python]].

De par son extrême légèreté (moins de 600 [[Octet#Multiples normalis.C3.A9s|Kio]]<ref name="About SQLite">{{lien web|url=https://www.sqlite.org/about.html|titre=About SQLite|site=www.sqlite.org}}</ref>), il est également très populaire sur les [[Système embarqué|systèmes embarqués]], notamment sur la plupart des [[smartphone]]s et [[Tablette tactile|tablettes]] modernes : les [[système d'exploitation|systèmes d'exploitation]] mobiles [[iOS]], [[Android]] et [[Symbian OS|Symbian]] l'utilisent comme base de données embarquée<ref name="Well-Known Users Of SQLite">{{lien web|url=https://www.sqlite.org/famous.html|titre=Well-Known Users Of SQLite|site=www.sqlite.org}}</ref>. Au total, on peut dénombrer plus d'un milliard de copies connues et déclarées de la bibliothèque<ref>{{lien web|url=https://www.sqlite.org/mostdeployed.html|titre=Most Widely Deployed SQL Database Engine|site=www.sqlite.org}}</ref>.

== Historique ==

[[D. Richard Hipp]] et un collègue commencèrent la conception de SQLite début [[2000 en informatique|2000]] lorsqu'ils travaillaient chez [[General Dynamics]], alors en contrat avec l'[[US Navy]]. SQLite devait être utilisée dans des [[Missile#Guidage|missiles guidés]], dans le but de remplacer des [[base de données|bases de données]] [[IBM]] [[Informix]] fonctionnant sur des machines [[HP-UX]]. Le principal objectif était de pouvoir s'affranchir de toute installation ou administration : l'installation ou la mise à jour de la base de données Informix pouvait prendre une journée entière<ref name="Owens06">{{Ouvrage|langue= anglais |prénom1= Michael |nom1= Owens |titre= The Definitive Guide to SQLite |éditeur= Apress |lieu= Berkeley |année= 2006 |isbn= 978-1-59059-673-9 |lire en ligne=|doi= 10.1007/978-1-4302-0172-4_1 }}</ref>.

En {{date|août 2000}}, la première version de SQLite est publiée. Elle utilisait [[gdbm]] ([[GNU]] Database Manager) pour manipuler des [[arbre B|arbres B]].

SQLite 2.0 supprime la dépendance à [[Dbm|gdbm]] et ajoute la prise en charge des transactions.

SQLite 3.0, produite avec l'aide d'[[America Online|AOL]], est publiée en {{date|2004|en informatique}} et ajoute, entre autres, la [[Internationalisation de logiciel|régionalisation]] (avec le support des [[collation (informatique)|collations]] et de l'[[Unicode]]) et la déclaration des [[Type (informatique)|types de données]].

En {{date|2011}}, Hipp annonce souhaiter ajouter une interface [[NoSQL]] à SQLite{{référence souhaitée}}, ainsi que UnQL, un sur-ensemble fonctionnel de SQL, conçu pour les [[Base de données orientée documents|bases de données orientées document]].{{référence souhaitée}}

SQLite est l'un des quatre formats recommandés par la [[Bibliothèque du Congrès]] pour le stockage à long terme des ensembles de données<ref>{{Lien web|url=https://sqlite.org/locrsf.html|titre=LoC Recommended Storage Format|consulté le=2023-11-01}}</ref>{{,}}<ref>{{Lien web|url=https://www.loc.gov/preservation/digital/formats/fdd/fdd000461.shtml#local|titre= Sustainability of Digital Formats: Planning for Library of Congress Collections — SQLite, Version 3|lang=en|consulté le=2023-11-01}}</ref>.

== Caractéristiques ==

=== Base de données embarquée ===

[[Image:SQLite Architecture French.svg|right]]
La majorité des [[SGBD|systèmes de gestion de base de données]] sont construits selon le [[paradigme]] [[client-serveur]], c'est-à-dire qu'une [[bibliothèque logicielle]] cliente est intégrée et utilisée dans une ou plusieurs applications alors que le [[moteur de base de données]] fonctionne dans un espace d'exécution qui lui est propre, voire sur une machine différente, en tant que [[Daemon (informatique)|service informatique]].

SQLite, au contraire, est directement intégrée dans l'application qui utilise sa bibliothèque logicielle, avec son moteur de base de données. L'accès à une [[base de données]] avec SQLite se fait par l'ouverture du fichier correspondant à celle-ci : chaque base de données est enregistrée dans un fichier qui lui est propre, avec ses déclarations, ses tables et ses index mais aussi ses données.

Cette caractéristique rend SQLite intéressante comme alternative aux [[Fichier texte|fichiers textes]], utilisés comme moyen de stockage intégré dans beaucoup d'applications ([[Paramètre (programmation informatique)#Informatique|paramètres]], [[Historique (informatique)|historique]], [[Mémoire cache|cache]]...), car elle rend l'accès aux données plus rapide, plus sécurisé, plus structuré, plus facile et totalement [[Multiplate-forme|indépendant de la plateforme]], tout en ne portant pas atteinte à la facilité de déploiement de l'application qui l'utilise.

La suppression de l'intermédiaire entre l'application et les données permet également de réduire légèrement la latence d'accès aux données comparée aux systèmes utilisant le [[paradigme]] client-serveur.

Cependant, cette architecture pose plusieurs problèmes :
* lorsqu'un nombre important de clients accèdent à une même base, si un des clients commence la lecture d'une partie, la totalité de la base est bloquée en écriture pour les autres clients, et inversement si un des clients démarre l'écriture dans une partie, la totalité de la base est bloquée en lecture pour les autres clients. Ces derniers sont alors mis en attente durant ce laps de temps, ce qui peut être contre-performant ;
* il est très compliqué de répartir la charge sur plusieurs machines : l'utilisation d'un [[Système de fichiers#Réseau (NFS : network file system en anglais)|système de fichiers sur le réseau]] engendre des [[Latence (informatique)|latences]] et un trafic considérable, du fait que la base doit être rechargée chez le client à chaque ouverture. Ce problème est encore plus important avec des [[Site web|sites web]] où la base est rouverte pour chaque page demandée. De plus, il peut se produire des erreurs dans la [[Synchronisation de fichiers|synchronisation]] des [[Verrou (informatique)|verrous]] sur les fichiers qui pourraient autoriser l'écriture simultanée à deux clients différents sur une même partie de la base et ainsi aboutir à la corruption de la base de données ;
* avec des bases de grande envergure, il est impossible de diviser la base en plusieurs parties ou fichiers dans le but de distribuer la charge sur plusieurs machines. Certains systèmes de fichiers, comme le [[FAT 32]], ont une taille maximale de fichier qui pourrait rapidement limiter l'expansion d'une base.

Il n'y a pas d'[[Extension de nom de fichier|extension]] propre aux fichiers de base de données de SQLite, mais il est courant de rencontrer des extensions comme <tt>.sqlite</tt> ou <tt>.db</tt>, parfois suivie du numéro de version de la bibliothèque (<tt>.sqlite3</tt>, <tt>.db2</tt>, etc.). Il est possible d'utiliser une base de données uniquement sauvegardée en [[mémoire vive]], sans créer de fichier de base de données sur le disque, via le nom de fichier spécial <tt>:memory:</tt>.

D'une manière générale, il est conseillé d'utiliser SQLite là où les données ne sont pas centralisées et où l'expansion de la taille de la base ne risque pas de devenir critique. Si la base de données a pour but de centraliser une grande masse de données et de les fournir à un grand nombre de clients, il est préférable d'utiliser des [[SGBD]] basés sur le paradigme client-serveur. SQLite a pour objectif de remplacer les fichiers texte et non les serveurs de base de données traditionnels<ref name="About SQLite"/>.

=== Compilateur et machine virtuelle ===

[[Image:SQLite Internal Architecture French.svg|right]]
Lorsqu'une requête SQL est transmise à SQLite par l'intermédiaire de l'[[interface de programmation]], elle est [[compilation (informatique)|compilée]] avant d'être exécutée.

Le séquenceur du [[compilateur]] divise les commandes données en parties traitables séparément (une requête et sa sous-requête par exemple), celles-ci sont passées à l'[[Analyse syntaxique|analyseur syntaxique]] qui s'occupe de décomposer les requêtes en différents objets qui représentent les différents ordres et clauses du langage SQL. Ces objets sont passés au générateur de code qui crée un code intermédiaire de bas niveau, ou [[bytecode]].

Le code obtenu est un ensemble d'[[Instruction informatique|instructions]] (137 instructions différentes) appelées [[Langage machine#Opcode|OpCodes]]<ref>{{lien web|url=https://www.sqlite.org/opcode.html|titre=The SQLite Bytecode Engine|site=www.sqlite.org}}</ref>. Celui-ci est lancé dans la [[machine virtuelle]] de SQLite, qui les voit comme de petits programmes décrivant des opérations de recherche, de lecture et de modifications des données<ref>{{lien web|url=https://www.sqlite.org/vdbe.html|titre=The Virtual Database Engine of SQLite|site=www.sqlite.org}}</ref>.

Lorsque la machine virtuelle interprète ces instructions, elle fait appel au gestionnaire d'[[arbre B]] qui repose sur des couches de plus bas niveau dont le [[Mémoire cache|cache]] des [[Pagination (informatique)|pages]] [[disque dur|disque]] et sa [[couche d'abstraction matérielle]]<ref>{{lien web|url=https://www.sqlite.org/arch.html|titre=Architecture of SQLite|site=www.sqlite.org}}</ref>.

=== Gestion des droits ===
SQLite n'intègre pas de gestion des [[Droit d'accès (informatique)|droits d'accès]] et de modification des données. La gestion est faite par le [[système de fichiers]] du [[système d'exploitation]] : si le fichier contenant la base de données n'est pas accessible en écriture à un utilisateur, ce dernier ne pourra également pas modifier les [[Enregistrement (base de données)|enregistrements]] et la structure de la base de données.

La gestion des droits avec <tt>GRANT</tt> et <tt>REVOKE</tt> est donc inexistante, bien que ceux-ci fassent partie de la spécification [[Structured Query Language#Historique|SQL-92]]<ref name="SQL Features That SQLite Does Not Implement">{{lien web|url=https://www.sqlite.org/omitted.html|titre=SQL Features That SQLite Does Not Implement|site=www.sqlite.org}}</ref>.

L'utilisation d'une base SQLite ne nécessite aucune procédure d'installation ou de configuration<ref>{{lien web|url=https://www.sqlite.org/zeroconf.html|titre=Zero-Configuration|site=www.sqlite.org}}</ref>.

=== Portabilité ===

La bibliothèque est entièrement écrite en [[C (langage)#Normalisation|C-ANSI]], la version normalisée du [[langage de programmation]] [[C (langage)|C]], et n'utilise aucune autre bibliothèque externe que la [[Bibliothèque standard du C|bibliothèque standard]] du langage. Ceci rend SQLite [[Compilateur|compilable]] sans modification majeure sur toutes les [[architecture informatique|architectures informatiques]] mettant à disposition un compilateur C respectant la norme ANSI<ref>{{lien web|url=https://www.sqlite.org/selfcontained.html|titre=SQLite is a Self Contained System|site=www.sqlite.org}}</ref>.

Les fichiers de base de données de SQLite sont entièrement indépendants du système d'exploitation et de l'architecture sur laquelle ils sont utilisés. Le même fichier de base de données peut être utilisé sur deux architectures ayant un fonctionnement radicalement différent, SQLite fournissant une [[Abstraction (informatique)|couche d'abstraction]] transparente pour le développeur. Les fichiers sont [[Compatibilité ascendante et descendante|compatibles entre eux]] pour chaque version majeure de la bibliothèque depuis la version <tt>3.0.0</tt> de SQLite, ainsi un fichier créé avec la version <tt>3.0.0</tt> sera utilisable avec la version <tt>3.6.19</tt> et vice-versa, les fichiers créés entre deux versions majeures différentes (<tt>2.0.0</tt> et <tt>3.0.0</tt> par exemple) peuvent s'avérer compatibles (en particulier en compatibilité ascendante), mais ce n'est pas toujours le cas<ref>{{lien web|url=https://www.sqlite.org/onefile.html|titre=SQLite: Single File Database|site=www.sqlite.org}}</ref>.

=== Types de données ===

SQLite utilise un [[typage]] [[typage dynamique|dynamique]] pour le contenu des cellules, contrairement à la quasi-totalité des [[SGBD]] qui utilisent un [[type statique|typage statique]] : lors de la création d'une nouvelle table dans la base de données, c'est un type recommandé ou d'affinité, non forcé, de la donnée à stocker dans la colonne qui est renseigné et non un type qui définit la façon dont celle-ci sera représentée en mémoire, cette tâche étant réservée à la cellule elle-même. Lorsque des données seront entrées dans la base, SQLite tentera de convertir les nouvelles données vers le type recommandé mais ne le fera pas si cela s'avère impossible<ref name="Datatypes In SQLite Version 3">{{lien web|url=https://www.sqlite.org/datatype3.html|titre=Datatypes In SQLite Version 3|site=www.sqlite.org}}</ref>.

Il existe plusieurs types d'affinité dans SQLite, ceux-ci définissant la façon dont SQLite va travailler lors de l'entrée des nouvelles données<ref name="Datatypes In SQLite Version 3"/> :
* <tt>TEXT</tt> : enregistre la donnée comme une [[chaine de caractères]], sans limite de taille. Si un nombre est entré dans une colonne de ce type, il sera automatiquement converti en une chaine de caractères ;
* <tt>NUMERIC</tt> : tente d'enregistrer la donnée comme un [[Entier (informatique)|entier]] ou comme un [[Nombre réel|réel]], mais si cela s'avère impossible, la donnée sera enregistrée comme une chaine de caractères ;
* <tt>INTEGER</tt> : enregistre la donnée comme un entier si celle-ci peut être encodée sans perte, mais peut utiliser les types <tt>REAL</tt> ou <tt>TEXT</tt> si ça ne peut être fait ;
* <tt>REAL</tt> : enregistre la donnée comme un réel, même s'il s'agit d'un entier. Si la valeur est trop grande, la donnée sera convertie en chaine de caractères ;
* <tt>NONE</tt> : la donnée est enregistrée telle quelle, sans conversion.

Ainsi, chaque type d'affinité peut accepter n'importe quel type de donnée, la seule exception est le type particulier <tt>INTEGER PRIMARY KEY</tt>, lorsqu'il est appliqué sur une seule colonne, car il ne s'agit pas d'un type habituel mais d'un alias à la colonne interne au moteur <tt>[[#ROWID et AUTOINCREMENT|ROWID]]</tt> qui correspond à l'adresse de l'enregistrement, unique à travers la table<ref name="SQLite Query Language: CREATE TABLE">{{lien web|url=https://www.sqlite.org/lang_createtable.html|titre=SQLite Query Language: CREATE TABLE|site=www.sqlite.org}}</ref>.

L'utilisation d'un typage dynamique améliore l'homogénéité entre les données de la base de données et les types du langage utilisé pour l'interroger si celui-ci est également un langage au typage dynamique (comme [[Python (langage)|Python]], [[PHP]], [[Perl (langage)|Perl]] ou [[Ruby]]) sans poser de réels problèmes avec les langages utilisant un typage statique (comme [[C (langage)|C]]/[[C++]] ou [[Java (langage)|Java]]).

==== Détermination du type d'affinité ====

Pour maintenir la compatibilité avec les autres [[Base de données relationnelle|bases de données relationnelles]], SQLite convertit automatiquement les noms des types déclarés dans le type d'affinité correspondant le mieux, ainsi :
* tous les noms de type contenant le mot clé <tt>INT</tt> seront reconnus comme des champs <tt>INTEGER</tt>. Cependant, seule la déclaration <tt>INTEGER PRIMARY KEY</tt> sera reconnue comme un alias du <tt>ROWID</tt> ;
* tous les noms de type contenant un des [[Mot clé|mots clés]] suivants : <tt>CHAR</tt> (ceci comprend <tt>VARCHAR</tt>), <tt>CLOB</tt> ou <tt>TEXT</tt> seront reconnus comme des champs <tt>TEXT</tt> ;
* tous les noms de type contenant le mot clé <tt>BLOB</tt> seront reconnus comme des champs à l'affinité <tt>NONE</tt> ;
* tous les noms de type contenant un des mots clés suivants : <tt>REAL</tt>, <tt>FLOAT</tt> ou <tt>DOUBLE</tt> seront reconnus comme des champs <tt>REAL</tt> ;
* dans tous les autres cas, ou si le type n'est pas renseigné, c'est l'affinité <tt>NUMERIC</tt> qui sera utilisée.

==== Classes de stockage ====

Bien que SQLite utilise un typage dynamique, la représentation en mémoire et les traitements effectués sur les données nécessitent l'utilisation de différentes classes de stockage. Ceci est uniquement valable pour la version 3 et ses versions ultérieures, car les données étaient enregistrées comme des chaines de caractères dans les versions antérieures.

Toutes les données manipulées par le moteur de base de données utilisent l'un des types suivants<ref name="Datatypes In SQLite Version 3"/> :
* <tt>NULL</tt> : la donnée correspond au type spécial <tt>[[NULL]]</tt>, qui indique l'absence d'information ou une valeur non définie ;
* <tt>INTEGER</tt> : la donnée est un [[Format de données#Nombres entiers|nombre entier signé]] et celui-ci est enregistré, en fonction de son [[ordre de grandeur]], sur 1, 2, 3, 4, 6 ou 8 [[octet]]s, mais en mémoire, c'est converti en 8 octets (8-byte signed integer<ref name="Datatypes In SQLite Version 3"/>) ;
* <tt>REAL</tt> : la donnée est un nombre à [[virgule flottante]] enregistré sur {{unité|8|octets}} selon la [[IEEE 754|norme IEEE]] ;
* <tt>TEXT</tt> : la donnée est une chaine de caractères, encodée en [[UTF-8]] (par défaut<ref>{{lien web|url=https://www.sqlite.org/version3.html|titre=SQLite Version 3 Overview|site=www.sqlite.org}}</ref>), [[UTF-16|UTF-16-BE]] ou [[UTF-16|UTF-16-LE]] ;
* <tt>BLOB</tt> : la donnée est enregistrée comme elle a été donnée.

==== Type <tt>NULL</tt> ====

La norme ne définit pas exactement de quelle façon doit être traité le type <tt>[[NULL]]</tt>.

Comme pour la majorité des bases de données relationnelles, tous les enregistrements <tt>NULL</tt> sont considérés comme distincts par la contrainte <tt>UNIQUE</tt> mais sont considérés comme identiques par l'opérateur <tt>UNION</tt> et par le mot clé <tt>DISTINCT</tt><ref>{{lien web|url=https://www.sqlite.org/nulls.html|titre=NULL Handling in SQLite|site=www.sqlite.org}}</ref>.

Les opérations arithmétiques comprenant un type <tt>NULL</tt> dans leur expression retournent la valeur <tt>UNKNOWN</tt> (valeur indéterminée). Dans les [[Algèbre de Boole (logique)|opérations booléennes]], la valeur de retour pourrait être <tt>UNKNOWN</tt> si un type <tt>NULL</tt> intervient et que le résultat ne peut être déterminé avec certitude : <tt>NULL OR 1</tt> donnera la valeur <tt>1</tt>, mais <tt>NULL OR 0</tt> donnera la valeur <tt>UNKNOWN</tt> car l'opération ne peut être résolue avec certitude.

==== Dates ====

SQLite ne possède pas de type pour représenter des dates. Cependant, un ensemble de fonctions existe pour manipuler celles-ci. Le stockage d'une date peut se faire dans une chaine de caractères sous sa forme [[ISO 8601]] ou dans un entier sous la forme d'un [[Timestamp (informatique)|timestamp UNIX]]<ref>{{lien web|url=https://www.sqlite.org/lang_datefunc.html|titre=SQLite Query Language: Date And Time Functions|site=www.sqlite.org}}</ref>.

=== Contraintes ===

SQLite gère les contraintes sur une ou plusieurs colonnes. Les contraintes <tt>NOT NULL</tt>, <tt>CHECK</tt>, <tt>DEFAULT</tt> et <tt>COLLATE</tt> sont déclarées sur la colonne<ref name=syntax>{{lien web|url=https://www.sqlite.org/syntaxdiagrams.html|titre=Syntax Diagrams For SQLite|site=www.sqlite.org}}</ref> alors que les contraintes <tt>PRIMARY KEY</tt>, <tt>UNIQUE</tt>, <tt>CHECK</tt> et <tt>FOREIGN KEY</tt> peuvent être déclarées sur une ou plusieurs colonnes<ref name=syntax/>.

La contrainte <tt>UNIQUE</tt> crée automatiquement un [[Index (base de données)|index]] sur la ou les colonnes sur lesquelles elle est appliquée<ref name="SQLite Query Language: CREATE TABLE"/>.

==== <tt>PRIMARY KEY</tt> ====

La contrainte de [[clé primaire]] va créer une contrainte <tt>UNIQUE</tt> sur la ou les colonnes concernées, cependant, et contrairement à [[Structured Query Language|la norme]], la contrainte <tt>PRIMARY KEY</tt> de SQLite autorise des entrées ayant la valeur <tt>NULL</tt>. Il s'agit d'un non-respect de la norme, et cet écart pourrait être réglé dans les prochaines versions<ref name="SQLite Query Language: CREATE TABLE"/>. Il est donc conseillé de rajouter la contrainte <tt>NOT NULL</tt> à la déclaration d'une clé primaire.

===== <tt>ROWID</tt> et <tt>AUTOINCREMENT</tt> =====

Chaque ligne d'une table est identifiée par un entier signé de 64 bits appelé <tt>ROWID</tt>. Lorsqu'une table est déclarée avec une et une seule colonne <tt>INTEGER PRIMARY KEY</tt>, cette colonne devient un alias du <tt>ROWID</tt>. L'utilisation d'un alias à l'identifiant <tt>ROWID</tt> permet d'augmenter la vitesse des recherches, celles-ci pouvant être jusqu'à deux fois plus rapides qu'avec une clé primaire normale associée à son index d'unicité<ref name="SQLite Query Language: CREATE TABLE"/>.

Lorsque la table est vide, l'algorithme attribue la valeur <tt>1</tt> à l'identifiant, qu'il incrémente pour chaque nouvel enregistrement, jusqu'à atteindre la limite d'un entier signé de 64 bits (<math>2^{63} - 1 = 9223372036854775807</math>). Une fois cette limite atteinte, il va réutiliser les espaces libérés par les enregistrements supprimés. L'attribution des identifiants n'est donc plus incrémentale mais aléatoire<ref name="SQLite Autoincrement">{{lien web|url=https://www.sqlite.org/autoinc.html|titre=SQLite Autoincrement|site=www.sqlite.org}}</ref>.

Il est possible d'utiliser le mot clé <tt>AUTOINCREMENT</tt>. Ce dernier modifie légèrement l'algorithme : une fois la limite d'un entier atteinte, il ne sera plus possible d'insérer un nouvel enregistrement. Ceci permet de garantir qu'un même identifiant ne sera jamais porté par deux enregistrements distincts, même s'ils ne coexistent pas à un même moment<ref name="SQLite Autoincrement"/>.

==== <tt>FOREIGN KEY</tt> ====

Depuis la version <tt>3.6.19</tt>, SQLite est apte à gérer les contraintes de [[clé étrangère]].

Pour des raisons de compatibilité descendante, le support des clés étrangères n'est pas activé par défaut. L'activation se fait par le [[#Pragmas|pragma]] <tt>foreign_keys</tt><ref name=foreign>{{lien web|url=https://www.sqlite.org/foreignkeys.html|titre=SQLite Foreign Key Support|site=www.sqlite.org}}</ref>.

Toute colonne référencée par une clé étrangère doit être déclarée comme <tt>UNIQUE</tt> (<tt>PRIMARY KEY</tt> crée une clé d'unicité)<ref name=foreign/>. SQLite ne prend pas encore en compte la clause <tt>MATCH</tt> dans la définition des clés étrangères<ref name=foreign/>.

=== Déclencheurs ===

SQLite gère d'une manière assez complète les déclencheurs (triggers en anglais). Des déclencheurs <tt>BEFORE</tt>, <tt>AFTER</tt> ou <tt>INSTEAD OF</tt> peuvent être déclarés. SQLite supporte l'option <tt>FOR EACH ROW</tt> (fonctionnement par défaut) mais pas <tt>FOR EACH STATEMENT</tt><ref>{{lien web|url=https://www.sqlite.org/lang_createtrigger.html|titre=SQLite Query Language: CREATE TRIGGER|site=www.sqlite.org}}</ref>.

=== Vues ===

SQLite permet la création de [[Vue (base de données)|vues]] pour alléger la longueur des requêtes.

Les vues sont en lecture seule, mais il est possible d'utiliser des déclencheurs avec la propriété <tt>INSTEAD OF</tt> pour simuler la possibilité de modifier celles-ci<ref name="SQLite Query Language: CREATE VIEW">{{lien web|url=https://www.sqlite.org/lang_createview.html|titre=SQLite Query Language: CREATE VIEW|site=www.sqlite.org}}</ref>.

=== Transactions ===

Toutes les commandes SQL visant à modifier l'état de la base de données (à peu près tout autre ordre que <tt>SELECT</tt>) impliquent la création d'une [[Transaction (base de données)|transaction]] qui leur est dédiée, pour autant qu'une transaction qui inclut la commande ne soit déjà créée. Ceci signifie que toutes les commandes sont [[Atomicité (Informatique)|atomiques]]. Si l'exécution de la commande ne provoque pas d'erreur, la modification est automatiquement validée ([[autocommit]]), mais si ce n'est pas le cas, l'intégralité des modifications effectuées par la commande est annulée.

Toutes les modifications sur la base de données sont sérialisées : une seule modification est effectuée à la fois et la base est [[Verrou (informatique)|verrouillée]] en lecture lors d'une modification.

SQLite permet la création de transactions ainsi que la création de points de retour<ref>{{lien web|url=https://www.sqlite.org/lang_savepoint.html|titre=SQLite Query Language: SAVEPOINT|site=www.sqlite.org}}</ref> (<tt>SAVEPOINT</tt>) mais ne permet pas de gérer différents degrés d'isolation. Dans une transaction, lors du premier appel à une commande de lecture, un verrou partagé<ref>{{lien web|url=https://www.sqlite.org/lockingv3.html|titre=File Locking And Concurrency In SQLite Version 3|site=www.sqlite.org}}</ref> est activé qui autorise l'accès en lecture mais interdit toute modification des données par une autre transaction, lors du premier appel en écriture, l'ensemble de la base est verrouillée en lecture et en écriture pour les autres transactions<ref name="SQLite Query Language: BEGIN TRANSACTION">{{lien web|url=https://www.sqlite.org/lang_transaction.html|titre=SQLite Query Language: BEGIN TRANSACTION|site=www.sqlite.org}}</ref>.

==== ACID ====

Même si SQLite respecte à première vue l'ensemble des [[propriétés ACID]], qui déterminent la fiabilité d'un système transactionnel, il reste possible de placer la base de données dans un état incohérent du fait que les types ne sont pas forcés : il est possible, par exemple, d'insérer une [[chaine de caractères]] dans une colonne dont le type d'affinité est défini comme un [[Entier (informatique)|entier]]. Dans leurs interprétations strictes, SQLite ne respecte pas l'ensemble des propriétés ACID.

=== Tables temporaires ===

SQLite permet la création de [[tables temporaires]] dont la définition, les données et les index ne sont pas enregistrés dans le fichier de la base de données et sont donc perdus lors de la fermeture de celle-ci<ref name="SQLite Query Language: CREATE TABLE"/>.

=== Tables virtuelles ===

Il est possible de créer, directement depuis la bibliothèque, son propre moteur de stockage pour simuler une table de la base de données. La création d'une table virtuelle se fait par l'implémentation d'un ensemble de fonctions. L'accès à la table se fait de façon tout à fait transparente, hormis l'absence de certaines fonctionnalités (impossible de créer des déclencheurs ou des index ou de modifier la structure de la table)<ref name="The Virtual Table Mechanism Of SQLite">{{lien web|url=https://www.sqlite.org/vtab.html|titre=The Virtual Table Mechanism Of SQLite|site=www.sqlite.org}}</ref>.

Ce mécanisme permet l'accès à l'aide du langage SQL à toute sorte de source de données, comme des fichiers [[Comma-separated values|CSV]] ou [[XML]].

=== Fonctions utilisateur ===

SQLite offre une interface de programmation, via sa bibliothèque, pour la création de [[Fonction (informatique)|fonctions]] utilisateur. L'ensemble de fonctions définies par la bibliothèque peuvent être [[Surcharge des opérateurs|surchargées]], pour redéfinir leur implémentation. Certains opérateurs, comme <tt>LIKE</tt> utilisent en sous-couche des fonctions éponymes qui peuvent elles aussi être remplacées par des fonctions définies par l'utilisateur<ref>{{lien web|url=https://www.sqlite.org/lang_corefunc.html|titre=SQLite Query Language: Core Functions|site=www.sqlite.org}}</ref>.

SQLite ne supporte pas la création de [[Procédure (informatique)|procédures]], mais leur nécessité est moindre du fait de l'architecture embarquée.

=== Index ===

SQLite permet la création d'[[Index (base de données)|index]] sur une ou plusieurs colonnes. Les index peuvent être montants (<tt>ASC</tt>) ou descendants (<tt>DESC</tt>) ainsi qu'uniques (ceci s'apparente à la création d'une contrainte d'unicité)<ref>{{lien web|url=https://www.sqlite.org/lang_createindex.html|titre=SQLite Query Language: CREATE INDEX|site=www.sqlite.org}}</ref>. SQLite utilise ses index en [[arbre B]].

SQLite introduit le mot clé <tt>EXPLAIN</tt> qui permet de décrire les étapes nécessaires à l'exécution d'une commande ainsi que les index utilisés<ref>{{lien web|url=https://www.sqlite.org/lang_explain.html|titre=SQLite Query Language: EXPLAIN|site=www.sqlite.org}}</ref>.

=== Pragmas ===

Les pragmas sont des paires de clés/valeurs de configuration de SQLite. Ils sont internes à une base de données et permettent de décrire de quelle façon SQLite doit interpréter certaines opérations<ref>{{lien web|url=https://www.sqlite.org/pragma.html|titre=Pragma statements supported by SQLite|site=www.sqlite.org}}</ref>. Ils permettent également d'activer ou de désactiver certaines fonctionnalités, notamment pour des raisons de compatibilité descendante.

=== Adoption ===

Outre son implantation officielle en [[C (langage)|C]], des [[Binding|bindings]] pour d'autres [[Langage de programmation|langages]] existent ([[C++]], [[Perl (langage)|Perl]], [[Ruby]], [[Tool Command Language|TCL]], les langages utilisant le [[.NET Framework|framework .NET]] via un pilote [[ADO.NET]]<ref name="System.Data.SQLite">http://sqlite.phxsoftware.com/</ref>...).

Quelques langages de programmation incluent SQLite dans leur [[bibliothèque standard]], c'est le cas, entre autres, de [[Python (langage)|Python]]<ref>{{lien web|url=https://docs.python.org/3/library/sqlite3.html|titre=sqlite3 — DB-API 2.0 interface for SQLite databases — Python 3.7.3 documentation|site=docs.python.org}}</ref> (depuis la version 2.5) et de [[PHP: Hypertext Preprocessor|PHP]]<ref>{{lien web|url=https://www.php.net/|titre=PHP: Hypertext Preprocessor|site=www.php.net}}</ref> (depuis la version 5).

SQLite est utilisée dans de nombreux [[Logiciel libre|logiciels libres]], comme [[Mozilla Firefox]] ou [[SPIP (logiciel)|SPIP]] (depuis 2007)<ref>{{Lien web |langue=fr |auteur=Déesse A. |auteur2=Matthieu Marcillaud |titre=Portage de SPIP en SQLite |url=https://contrib.spip.net/Portage-de-SPIP-en-SQLite |site=contrib.spip.net |date=16 décembre 2007 |consulté le=14 décembre 2021}}</ref>, dans de nombreuses distributions [[GNU/Linux]], dans les [[système d'exploitation|systèmes d'exploitation]] serveurs et de bureau comme [[Solaris (système d'exploitation)|Solaris]] ou mobiles comme [[Android]], [[Firefox OS]] ou [[Symbian OS|Symbian]], dans certains logiciels d'[[Apple]], de [[Google]], d'[[Adobe Systems|Adobe]] et de [[McAfee]] ainsi que dans certains appareils de [[Philips]]<ref name="Well-Known Users Of SQLite"/>.

SQLite est également offerte avec la version 8.4 du Logiciel Primavera P6 d'Oracle.

Le brouillon concernant le stockage d'une base de données SQL du côté du [[navigateur web]] publiée par le [[W3C]] stipule également que les logiciels implémentant cette fonctionnalité doivent être capable d'interpréter correctement le dialecte de SQLite dans sa version ''3.6.19''<ref>{{lien web|url=https://dev.w3.org/html5/webdatabase/|titre=Web SQL Database|site=dev.w3.org}}</ref>. Même si SQLite n'est pas imposé par le W3C, [[Google Chrome]]<ref>{{lien web|url=https://blog.chromium.org/2010/01/more-resources-for-developers.html|titre=More Resources for Developers}}</ref>, [[Safari (logiciel)|Apple Safari]]<ref>{{lien web|url=https://webkit.org/demos/sticky-notes/index.html|titre=WebKit HTML 5 SQL Storage Notes Demo|site=webkit.org}}</ref> et [[Opera Browser]]<ref>{{lien web|url=https://dev.opera.com/blog/|titre=Dev.Opera — Blog|site=dev.opera.com}}</ref> l'utilisent pour cet usage.
<!--

 Orginal (restructuré et complété par Rapha222)

Parmi ses principales caractéristiques, on notera :
* l'absence de procédure d'installation et de configuration. Cela inclut l'absence de gestion de comptes et de droits utilisateurs ;
* toute la base est stockée dans un seul fichier multi-plateforme ;
* {{Référence nécessaire|le type de chaque donnée stockée en base est une propriété de la donnée, pas de la colonne. Une colonne peut donc contenir des données de type différent|date=19 octobre 2009}} ;
* l'utilisateur peut créer {{Référence nécessaire|ses propres [[type de donnée|types de données]]|date=19 octobre 2009}}, ainsi que ses propres [[fonctions]]<ref>{{lien web|url=http://www.sqlite.org/c3ref/create_function.html|titre=Create Or Redefine SQL Functions|site=www.sqlite.org}}</ref> ou des [[tables virtuelles]]<ref name="The Virtual Table Mechanism Of SQLite"/> en utilisant des fonctions de la bibliothèque ;
* la bibliothèque est très légère (environ {{Unité|300|ko}}), stable et éprouvée par une batterie de [[Test (informatique)|tests]]<ref>{{lien web|url=https://www.sqlite.org/testing.html|titre=How SQLite Is Tested|site=www.sqlite.org}}</ref> ;
* {{Référence nécessaire|un [[index spatial]] de type [[R-Tree]] est intégré au moteur|date=19 octobre 2009}} ;
* la gestion des [[Clé étrangère|clés étrangères]]<ref name=foreign/> ;
* la gestion des [[Vue_(base_de_données)|vues]]<ref name="SQLite Query Language: CREATE VIEW"/> ;
* la gestion des [[transactions]]<ref name="SQLite Query Language: BEGIN TRANSACTION"/> ;
* la gestion des [[sous-requêtes]] ;
* la gestion des champs [[auto-increment|auto-incrémentés]]<ref name="SQLite Autoincrement"/> ;
* la gestion avancée des [[Contrainte_d'intégrité|contraintes]] (<tt>PRIMARY KEY</tt>, <tt>UNIQUE</tt>, <tt>DEFAULT</tt>, <tt>NOT NULL</tt>, <tt>CHECK</tt>, <tt>REFERENCES</tt> et <tt>COLLATE</tt>)<ref name="SQLite Query Language: CREATE TABLE"/>, cependant, il n'est pas encore possible d'insérer des structures complexes ([[sous-requêtes]], [[fonctions]], ...) dans celles-ci<ref name=syntax/> ;
* {{Référence nécessaire|l'indexation peut être optimisée pour des [[Recherche plein texte|recherches de texte libre]]|date=19 octobre 2009}}.

SQLite implémente la majorité de la norme SQL 92<ref name="SQL Features That SQLite Does Not Implement"/> à l'exception de :
* la gestion des droits avec <tt>GRANT</tt> et <tt>REVOKE</tt> ;
* les [[jointure (informatique)|jointures]] de type <tt>RIGHT OUTER JOIN</tt> et <tt>FULL OUTER JOIN</tt> (mais prend en charge le <tt>LEFT OUTER JOIN</tt>) ;
* les [[déclencheur]]s ne sont que partiellement pris en compte (<tt>FOR EACH STATEMENT</tt> non supporté) ;
* les vues modifiables ne sont pas implémentées, cependant il est possible de passer outre cette limite en utilisant des [[déclencheur]]s <tt>INSTEAD OF</tt><ref name="SQLite Query Language: CREATE VIEW"/> ;
* les possibilités de modifier la structure d'une table sont limitées : on peut renommer une table et y ajouter des colonnes, mais pas modifier ou supprimer des colonnes.

Les [[Procédure stockée|procédures stockées]] ne sont pas disponibles, mais leur utilité est moindre que dans une architecture client/serveur.

SQLite peut se révéler intéressant au niveau des performances et être utile dans bien des cas (impossibilité d'utiliser un serveur de bases de données, pour des sites internet ou dispositifs et applications embarquées, etc.), mais il ne permet pas à différents [[Processus (informatique)|processus]] ou [[Processus léger|thread]] d'accéder simultanément en écriture à la même base de données et n'est donc pas conçu pour gérer de nombreux accès concurrents.

La bibliothèque peut être utilisée en [[Python (langage)|Python]], [[C (langage)|C]] et [[C++]]. Des modules pour [[Perl (langage)|Perl]], [[PHP: Hypertext Preprocessor|PHP]], [[Tool Command Language|TCL]] et d'autres [[Langage de script|langages de scripts]] sont disponibles. Il existe également un client [[ADO.NET]] pour les langages basé sur le [[.NET Framework|framework .NET]]<ref name="System.Data.SQLite"/>.

[[PHP: Hypertext Preprocessor|PHP]] inclut SQLite dans la distribution de base depuis sa version 5, alors qu'il n'était disponible sous la version 4 que sous la forme d'une extension [[PEAR|PECL]].

[[Python (langage)|Python]] inclut également SQLite 3 dans ses bibliothèques standard depuis la version 2.5.

-->

== Différentes versions ==
SQLite existe sous 2 principales versions : 2.x et 3.x. Les versions 2 et 3 de SQLite se distinguent par plusieurs évolutions :
* les fichiers des bases ne sont pas toujours compatibles entre eux. Cela signifie qu’une base au format SQLite 2 ne pourra pas être lue à coup sûr par SQLite 3 et <em>vice versa</em> ;
* des syntaxes SQL ne sont pas présentes en SQLite 2 : <tt>IF NOT EXISTS</tt> pour les requêtes, et <tt>CREATE TABLE</tt>, <tt>ADD COLUMN</tt> et <tt>RENAME COLUMN</tt> pour les requêtes <tt>ALTER TABLE</tt> ;
* seules les versions les plus récentes de SQLite prennent en charge certaines fonctionnalités plus avancées, comme la gestion des [[clé étrangère|clés étrangères]] ou les contraintes <tt>CHECK</tt> ;
* SQLite 3 prend en charge les normes [[UTF-8]] et [[UTF-16]] ;
* SQLite 3 encode les identifiants de lignes sur [[64 bits]] et non plus sur [[32 bits]], ce qui permet un nombre de lignes quasiment illimité ;
* PHP utilise une classe [[PHP Data Objects|PDO]] ou, avec PHP 5.3, des fonctions <tt>sqlite3_*()</tt> pour gérer SQLite 3 alors qu’il utilise des fonctions <tt>sqlite_*()</tt> pour SQLite 2.

== Utilisations ==

=== Systèmes d'exploitation ===
SQLite est installé par défaut sur les systèmes suivants : 

* [[Android]]
* [[BlackBerry 10|BlackBerry 10 OS]]
* [[FreeBSD]]
* [[illumos]]
* [[iOS]]
* [[Mac OS X v10.4|Mac OS X 10.4]] (et les versions suivantes de [[MacOS|Mac OS]]) 
* [[Maemo]]
* [[MeeGo]]
* [[MorphOS]]
* [[NetBSD]]
* [[Solaris (système d'exploitation)|Solaris 10]]
* [[Symbian OS]]
* [[Tizen]]
* [[webOS]]
* [[Windows 10]], et les versions suivantes de Windows

== Notes et références ==
{{Références|colonnes=2}}

== Liens externes ==
* [https://www.sqlite.org Site officiel]
* {{en}} [http://blog.lizardwrangler.com/2008/02/27/the-sqlite-consortium/ ''The SQLite Consortium''], [[Mitchell Baker]], le 27 février 2008.
* [http://www.01net.com/editorial/372465/sqlite-devient-la-base-de-donnees-standard-du-web-deconnecte/ SQLite devient la base de données standard du Web déconnecté], David Maume, [[01net (site web)|01net]], {{Date|29|février|2008}}.

{{Palette|Systèmes de gestion de base de données}}
{{Portail|bases de données|logiciels libres}}

{{DEFAULTSORT:Sqlite}}
[[Catégorie:Système de gestion de base de données]]
[[Catégorie:Composant logiciel]]
[[Catégorie:Logiciel dans le domaine public]]