Syntaxe SQL prise en charge

Les listes de syntaxe SQL suivantes sont prises en charge par le moteur de base de données SQL d’Adobe AIR. Elles sont divisées en explications de divers types d’instructions et de clauses, d’expressions, de fonctions intégrées et d’opérateurs. Les sujets suivants sont passés en revue :
  • Syntaxe SQL générale

  • Instructions de manipulation des données (SELECT, INSERT, UPDATE et DELETE)

  • Instructions de définition des données (CREATE, ALTER et instructions DROP associées aux tables, aux index, aux vues et aux déclencheurs)

  • Instructions et clauses spéciales

  • Fonctions intégrées (fonctions d’agrégation, fonctions scalaires et fonctions de formatage de la date et de l’heure)

  • Opérateurs

  • Paramètres

  • Fonctions SQL non prises en charge

  • Autres fonctions SQL

Syntaxe SQL générale

Outre la syntaxe spécifique des diverses instructions et expressions, les règles générales de la syntaxe SQL sont les suivantes :
Respect de la casse
Les instructions SQL, y compris les noms d’objet, ne sont pas sensibles à la casse. Néanmoins, les instructions SQL sont fréquemment écrites avec des mots-clés SQL en majuscules et ce document utilise cette convention. Bien que la syntaxe SQL ne soit pas sensible à la casse, les valeurs de texte littéral incluses dans une requête SQL le sont, et les opérations de comparaison et de tri respectent parfois la casse, selon les spécifications de la séquence de classement définie pour une colonne ou une opération. Pour plus d’informations, voir COLLATE.

Espace blanc
Un caractère espace blanc (espace, tabulation, nouvelle ligne, etc.) doit séparer chaque mot dans une instruction SQL. Toutefois, cet espace blanc est facultatif entre les mots et les symboles Le type et la quantité de caractères d’espace blanc dans une instruction SQL ne sont pas significatifs. Vous pouvez utiliser un espace blanc, par exemple une mise en retrait et des sauts de ligne, pour formater des instructions SQL et améliorer leur lisibilité, sans que le sens de l’instruction n’en soit modifié.

Instructions de manipulation des données

Les instructions de manipulation des données sont les instructions SQL les plus courantes. Ces instructions sont utilisées pour récupérer, ajouter, modifier et supprimer des données dans des tables de bases de données. Les instructions de manipulation de données suivantes sont prises en charge : SELECT, INSERT, UPDATE et DELETE.

SELECT

L’instruction SELECT permet d’interroger la base de données. Le résultat d’une instruction SELECT est zéro ou plusieurs lignes de données, chaque ligne contenant un nombre fixe de colonnes. Le nombre de colonnes du résultat est indiqué par le nom de la colonne de résultat ou la liste d’expressions entre SELECT et les mots-clés facultatifs FROM.

sql-statement   ::=  SELECT [ALL | DISTINCT] result 
                     [FROM table-list] 
                     [WHERE expr] 
                     [GROUP BY expr-list] 
                     [HAVING expr] 
                     [compound-op select-statement]* 
                     [ORDER BY sort-expr-list] 
                     [LIMIT integer [( OFFSET | , ) integer]] 
result          ::=  result-column [, result-column]* 
result-column   ::=  * | table-name . * | expr [[AS] string] 
table-list      ::=  table [ join-op table join-args ]* 
table           ::=  table-name [AS alias] | 
                     ( select ) [AS alias] 
join-op         ::=  , | [NATURAL] [LEFT | RIGHT | FULL] [OUTER | INNER | CROSS] JOIN 
join-args       ::=  [ON expr] [USING ( id-list )] 
compound-op     ::=  UNION | UNION ALL | INTERSECT | EXCEPT 
sort-expr-list  ::=  expr [sort-order] [, expr [sort-order]]* 
sort-order      ::=  [COLLATE collation-name] [ASC | DESC] 
collation-name  ::=  BINARY | NOCASE

Toute expression arbitraire peut servir de résultat. Si une expression de résultat est *, toutes les colonnes de toutes les tables sont substituées à cette expression. Si l’expression correspond à un nom de table suivi de .*, le résultat est l’ensemble des colonnes de cette table.

Le mot-clé DISTINCT entraîne le renvoi d’un sous-ensemble de lignes de résultat, dans lequel chaque ligne résultante est différente. Toutes les valeurs NULL sont considérées comme identiques. Le comportement par défaut consiste à renvoyer toutes les lignes de résultat, ce que le mot-clé ALL peut rendre explicite.

La requête est exécutée sur une ou plusieurs tables spécifiées après le mot-clé FROM. Si plusieurs noms de table sont séparés par des virgules, la requête utilise alors la jointure croisée des différentes tables. La syntaxe JOIN permet également de spécifier le mode de jointure des tables. L’unique type de jointure externe pris en charge est LEFT OUTER JOIN. L’expression de clause ON dans les éléments join-arg doit donner une valeur booléenne. Une sous-requête placée entre parenthèses peut être utilisée comme table dans la clause FROM. La clause FROM peut être omise dans sa totalité, auquel cas le résultat est une ligne unique composée des valeurs de la liste d’expressions.

La clause WHERE permet de restreindre le nombre de lignes récupérées par la requête. Les expressions de clause WHERE doivent donner une valeur booléenne. Un filtrage des clauses WHERE étant effectué avant tout regroupement, les expressions de la clause WHERE risquent de ne pas inclure de fonction d’agrégation.

La clause GROUP BY combine une ou plusieurs lignes du résultat en une ligne de résultat unique. Une clause GROUP BY se révèle particulièrement utile lorsque le résultat contient des fonctions d’agrégation. Les expressions de la clause GROUP BY ne doivent pas nécessairement apparaître dans la liste d’expressions SELECT.

La clause HAVING est similaire à la clause WHERE, car elle limite le nombre de lignes renvoyées par l’instruction. La clause HAVING est toutefois appliquée après l’exécution d’un regroupement spécifié par une clause GROUP BY. Par conséquent, l’expression HAVING peut faire référence aux valeurs qui incluent des fonctions d’agrégation. Une expression de clause HAVING ne doit pas obligatoirement apparaître dans la liste SELECT. Telle une expression WHERE, une expression HAVING doit donner une valeur booléenne.

La clause ORDER BY entraîne le tri des lignes de résultat. L’argument sort-expr-list de la clause ORDER BY est une liste d’expressions servant de clé du tri. Il n’est pas nécessaire que les expressions fassent partie du résultat d’une instruction SELECT simple, mais dans une instruction SELECT composée (instruction SELECT utilisant l’un des opérateurs compound-op), chaque expression de tri doit correspondre exactement à l’une des colonnes de résultats. Chaque expression de tri peut éventuellement être suivie d’une clause sort-order composée du mot-clé COLLATE et du nom d’une fonction de classement utilisée pour organiser le texte et/ou du mot-clé ASC ou DESC pour spécifier l’ordre de tri (croissant ou décroissant). Vous pouvez omettre la clause sort-order, auquel cas l’ordre par défaut (croissant) est utilisé. Pour consulter une définition de la clause COLLATE et des fonctions de classement, voir COLLATE.

La clause LIMIT définit le nombre maximal de lignes de résultat renvoyées. Une clause LIMIT négative indique qu’il n’existe pas de limite supérieure. Le mot-clé OFFSET facultatif qui suit la clause LIMIT spécifie le nombre de lignes à ignorer au début du jeu de résultats. Dans une requête SELECT composée, la clause LIMIT peut n’apparaître qu’après l’instruction SELECT finale, et la limite s’applique à l’ensemble de la requête. Notez que si le mot-clé OFFSET est utilisé dans la clause LIMIT, la limite correspond au premier nombre entier et le décalage au second nombre entier. Si une virgule est utilisée au lieu du mot-clé OFFSET, le décalage correspond au premier nombre et la limite au second nombre. Cette contradiction apparente est intentionnelle, car elle assure une compatibilité accrue avec les systèmes de bases de données SQL hérités.

Une instruction SELECT composée est constituée de plusieurs instructions SELECT simples connectées par l’un des opérateurs UNION, UNION ALL, INTERSECT ou EXCEPT. Dans une instruction SELECT composée, toutes les instructions SELECT constituantes doivent spécifier le même nombre de colonnes de résultats. Une seule clause ORDER BY doit suivre l’instruction SELECT finale (et précéder l’unique clause LIMIT si elle est spécifiée). Les opérateurs UNION et UNION ALL combinent les résultats des instructions SELECT précédentes et suivantes dans une même table. Avec l’opérateur UNION, toutes les lignes de résultat sont distinctes, alors qu’avec l’opérateur UNION ALL, il peut exister des doublons. L’opérateur INTERSECT prend l’intersection des résultats des instructions SELECT précédentes et suivantes. L’opérateur EXCEPT prend le résultat de l’instruction SELECT précédente après avoir supprimé les résultats de l’instruction SELECT suivante. Lorsque trois instructions SELECT ou plus sont connectées dans une instruction composée, elles sont groupées de la première à la dernière.

Pour consulter une définition des expressions autorisées, voir Expressions.

Depuis AIR 2.5, l’opérateur SQL CAST est pris en charge en lecture pour convertir des données BLOB en objets ActionScript ByteArray. Par exemple, le code suivant lit les données brutes qui ne sont pas stockées au format AMF et les stocke dans un objet ByteArray :

stmt.text = "SELECT CAST(data AS ByteArray) AS data FROM pictures;"; 
stmt.execute(); 
var result:SQLResult = stmt.getResult(); 
var bytes:ByteArray = result.data[0].data;

INSERT

L’instruction INSERT, dont il existe deux formes de base, permet d’entrer des données dans les tables.
sql-statement  ::=  INSERT [OR conflict-algorithm] INTO [database-name.] table-name [(column-list)] VALUES (value-list) | 
                    INSERT [OR conflict-algorithm] INTO [database-name.] table-name [(column-list)] select-statement 
                    REPLACE INTO [database-name.] table-name [(column-list)] VALUES (value-list) | 
                    REPLACE INTO [database-name.] table-name [(column-list)] select-statement

La première forme (qui contient le mot-clé VALUES) crée une ligne unique dans une table existante. Si aucun élément column-list n’est spécifié, le nombre de valeurs doit correspondre au nombre de colonnes de la table. Si un élément column-list est spécifié, le nombre de valeurs doit correspondre au nombre de colonnes spécifié. Les colonnes de la table qui n’apparaissent pas dans la liste de colonnes sont remplies avec les valeurs par défaut définies lors de la création de la table ou avec NULL si aucune valeur par défaut n’est définie.

La seconde forme de l’instruction INSERT extrait ses données d’une instruction SELECT. Le nombre de colonnes du résultat de l’instruction SELECT doit correspondre exactement au nombre de colonnes de la table si aucun élément column-list n’est spécifié, ou au nombre de colonnes nommées dans l’élément column-list. Une nouvelle entrée est créée dans la table pour chaque ligne du résultat de l’instruction SELECT. L’instruction SELECT peut être simple ou composée. Pour consulter la définition des instructions SELECT autorisées, voir SELECT.

Le paramètre conflict-algorithm facultatif permet de spécifier un autre algorithme de résolution de conflits de contraintes à utiliser pendant l’exécution de cette commande. Pour une explication et une définition des algorithmes de conflit, voir Instructions et clauses spéciales.

Les deux formes REPLACE INTO de l’instruction reviennent à utiliser la forme INSERT standard [OR conflict-algorithm] avec l’algorithme de conflit REPLACE (c’est-à-dire la forme INSERT OR REPLACE...).

Les deux formes REPLACE INTO de l’instruction reviennent à utiliser la forme INSERT standard [OR conflict-algorithm] avec l’algorithme de conflit REPLACE (c’est-à-dire la forme INSERT OR REPLACE...).

UPDATE

La commande de mise à jour modifie les enregistrements existants d’un tableau.

sql-statement  ::=  UPDATE [database-name.] table-name SET column1=value1, column2=value2,... [WHERE expr]

La commande se compose du mot-clé UPDATE, suivi du nom du tableau dont vous souhaitez mettre à jour les enregistrements. Après le mot-clé SET, saisissez le nom de la colonne et la valeur cible de la colonne, sous forme de liste de valeurs séparées par une virgule. L’expression de clause WHERE indique les lignes des enregistrements à mettre à jour.

DELETE

La commande delete permet de supprimer des enregistrements dans une table.
sql-statement  ::=  DELETE FROM [database-name.] table-name [WHERE expr]

Elle se compose des mots-clés DELETE FROM, suivis du nom de la table dans laquelle seront supprimés les enregistrements.

S’il n’existe pas de clause WHERE, toutes les lignes de la table sont supprimées. S’il existe une clause WHERE, seules les lignes qui correspondent à l’expression sont supprimées. L’expression de clause WHERE doit donner une valeur booléenne. Pour consulter une définition des expressions autorisées, voir Expressions.

Instructions de définition de données

Les instructions de définition des données permettent de créer, de modifier et de supprimer des objets de base de données, tels que des tables, des vues, des index et des déclencheurs. Les instructions de définition de données suivantes sont prises en charge :
  • Tables :
    • CREATE TABLE

    • ALTER TABLE

    • DROP TABLE

  • Index :
    • CREATE INDEX

    • DROP INDEX

  • Vues :
    • CREATE VIEWS

    • DROP VIEWS

  • Déclencheurs :
    • CREATE TRIGGERS

    • DROP TRIGGERS

CREATE TABLE

Une instruction CREATE TABLE se compose des mots-clés CREATE TABLE, suivis du nom de la nouvelle table, puis (entre parenthèses) d’une liste de contraintes et de définitions de colonne. Le nom de la table peut être un identificateur ou une chaîne.
sql-statement       ::=  CREATE [TEMP | TEMPORARY] TABLE [IF NOT EXISTS] [database-name.] table-name 
                         ( column-def [, column-def]* [, constraint]* ) 
sql-statement       ::=  CREATE [TEMP | TEMPORARY] TABLE [database-name.] table-name AS select-statement 
column-def          ::=  name [type] [[CONSTRAINT name] column-constraint]* 
type                ::=  typename | typename ( number ) | typename ( number , number ) 
column-constraint   ::=  NOT NULL [ conflict-clause ] | 
                         PRIMARY KEY [sort-order] [ conflict-clause ] [AUTOINCREMENT] | 
                         UNIQUE [conflict-clause] | 
                         CHECK ( expr ) | 
                         DEFAULT default-value | 
                         COLLATE collation-name 
constraint          ::=  PRIMARY KEY ( column-list ) [conflict-clause] | 
                         UNIQUE ( column-list ) [conflict-clause] | 
                         CHECK ( expr ) 
conflict-clause     ::=  ON CONFLICT conflict-algorithm 
conflict-algorithm  ::=  ROLLBACK | ABORT | FAIL | IGNORE | REPLACE 
default-value       ::=  NULL | string | number | CURRENT_TIME | CURRENT_DATE | CURRENT_TIMESTAMP 
sort-order          ::=  ASC | DESC 
collation-name      ::=  BINARY | NOCASE 
column-list         ::=  column-name [, column-name]*

Chaque définition de colonne se compose du nom de la colonne, suivi de son type de données, puis d’une ou de plusieurs contraintes de colonne facultatives. Le type de données de la colonne limite les données pouvant y être stockées. Si vous tentez de stocker une valeur dans une colonne dotée d’un type de données différent, le moteur d’exécution convertit cette valeur en une valeur du type approprié (le cas échéant) ou renvoie une erreur. Pour plus d’informations, voir la section Prise en charge des types de données.

La contrainte de colonne NOT NULL indique que la colonne ne doit pas contenir de valeurs NULL.

Une contrainte UNIQUE entraîne la création d’un index sur les colonnes spécifiées. Cet index doit contenir des clés uniques. Deux lignes ne peuvent pas contenir de valeurs ou de combinaisons de valeurs identiques pour les colonnes spécifiées. Une instruction CREATE TABLE peut comporter plusieurs contraintes UNIQUE, y compris plusieurs colonnes associées à une contrainte UNIQUE dans la définition des colonnes et/ou plusieurs contraintes UNIQUE au niveau de la table.

Une contrainte CHECK définit une expression qui est évaluée et doit être vraie pour que les données d’une ligne soient insérées ou mises à jour. L’expression CHECK doit donner une valeur booléenne.

Une clause COLLATE dans une définition de colonne spécifie la fonction de classement à utiliser pour comparer les entrées texte de la colonne. La fonction de classement BINARY est utilisée par défaut. Pour plus d’informations sur la clause COLLATE et les fonctions de classement, voir COLLATE.

Les contraintes DEFAULT spécifient la valeur par défaut à utiliser avec une instruction INSERT. La valeur peut être NULL, une constante de chaîne ou un nombre. La valeur par défaut peut également être l’un des mots-clés spéciaux indépendants de la casse CURRENT_TIME, CURRENT_DATE ou CURRENT_TIMESTAMP. Si la valeur est NULL, une constante de chaîne ou un nombre, elle est insérée littéralement dans la colonne à chaque fois qu’une instruction INSERT ne spécifie pas de valeur pour cette colonne. Si la valeur est CURRENT_TIME, CURRENT_DATE ou CURRENT_TIMESTAMP, la date UTC et/ou l’heure est insérée dans la colonne. CURRENT_TIME gère le format HH:MM:SS. CURRENT_DATE gère le format AAAA-MM-JJ. CURRENT_TIMESTAMP gère le format AAAA-MM-JJ HH:MM:SS.

La définition d’une contrainte PRIMARY KEY crée généralement un index UNIQUE sur les colonnes correspondantes. Toutefois, si la contrainte PRIMARY KEY s’applique à une seule colonne dont le type de données est INTEGER (ou l’un de ses synonymes, tels qu’int), cette colonne est alors utilisée par la base de données en tant que clé primaire réelle de la table. En d’autres termes, la colonne ne doit contenir que des valeurs entières uniques. (Notez que dans de nombreuses implémentations de SQLite, seul le type de colonne INTEGER entraîne l’utilisation de la colonne en tant que clé primaire interne. Néanmoins, dans Adobe AIR, les synonymes d’INTEGER, tels que int, spécifient également ce comportement.)

Si une table ne possède pas de colonne INTEGER PRIMARY KEY, une clé de type entier est automatiquement générée à chaque fois qu’une ligne est insérée. L’accès à la clé primaire d’une ligne s’effectue toujours par l’un des noms spéciaux ROWID, OID ou _ROWID_. Ces noms peuvent être utilisés qu’il s’agisse d’une valeur INTEGER PRIMARY KEY déclarée de façon explicite ou d’une valeur générée en interne. Toutefois, si la table contient une valeur INTEGER PRIMARY KEY explicite, le nom de la colonne dans les données de résultat correspond au nom de la colonne en tant que tel et non au nom spécial.

Une colonne INTEGER PRIMARY KEY peut également inclure le mot-clé AUTOINCREMENT. Si le mot-clé AUTOINCREMENT est utilisé, la base de données génère et insère automatiquement une clé de type entier incrémentée séquentiellement dans la colonne INTEGER PRIMARY KEY lorsqu’elle exécute une instruction INSERT qui ne spécifie aucune valeur explicite pour la colonne.

Une instruction CREATE TABLE ne peut comporter qu’une seule contrainte PRIMARY KEY. Elle peut faire partie de la définition d’une colonne ou d’une contrainte PRIMARY KEY unique au niveau de la table. Une colonne de clé primaire possède implicitement la valeur NOT NULL.

Le paramètre conflict-clause facultatif qui suit plusieurs contraintes permet de spécifier un autre algorithme de résolution de conflits de contraintes par défaut pour cette contrainte. La valeur par défaut est ABORT. Les différentes contraintes d’une même table peuvent gérer différents algorithmes de résolution de conflits par défaut. Si une instruction INSERT ou UPDATE spécifie un autre algorithme de résolution de conflits, celui-ci est utilisé à la place de l’algorithme spécifié dans l’instruction CREATE TABLE. Pour plus d’informations, voir la section ON CONFLICT sous Instructions et clauses spéciales.

Les contraintes complémentaires, telle FOREIGN KEY, ne génèrent pas d’erreur, mais sont ignorées par le moteur d’exécution.

Si le mot-clé TEMP ou TEMPORARY figure entre CREATE et TABLE, la table créée n’est alors visible que dans le cadre de la même connexion à la base de données (occurrence de SQLConnection). Elle est automatiquement supprimée lors de la fermeture de la connexion à la base de données. Tous les index associés à une table temporaire sont également temporaires. Les tables et index temporaires sont stockés dans un fichier distinct du fichier de base de données principal.

Si le préfixe database-name facultatif est spécifié, la table est alors créée dans une base de données nommée (la base de données connectée à l’occurrence de SQLConnection en appelant la méthode attach() avec le nom de base de données spécifié). Spécifier à la fois un préfixe database-name et le mot-clé TEMP est une erreur, sauf si le préfixe database-name est temp. Lorsqu’aucun nom de base de données n’est spécifié et que le mot-clé TEMP n’est pas présent, la table est créée dans la base de données principale (la base de données connectée à l’occurrence de SQLConnection par la méthode open() ou openAsync()).

Le nombre de colonnes ou de contraintes présentes dans une table n’est sujet à aucune limite arbitraire. Le volume de données présent dans une ligne n’est pas non plus limité.

La forme CREATE TABLE AS définit la table en tant que jeu de résultats d’une requête. Les noms des colonnes de la table sont identiques à ceux des colonnes de résultat.

Si la clause IF NOT EXISTS facultative est présente et qu’une autre table porte déjà le même nom, la base de données ignore alors la commande CREATE TABLE.

L’instruction DROP TABLE permet de supprimer une table et l’instruction ALTER TABLE d’apporter des modifications limitées.

ALTER TABLE

La commande ALTER TABLE permet à l’utilisateur de renommer une table existante ou de lui ajouter une nouvelle colonne. Il est impossible de supprimer une colonne dans une table.

sql-statement ::= ALTER TABLE [database-name.] table-name alteration 
alteration    ::= RENAME TO new-table-name 
alteration    ::= ADD [COLUMN] column-def

La syntaxe RENAME TO permet de renommer la table identifiée par [database-name.] table-name en new-table-name. Cette commande ne permet pas de déplacer une table entre les bases de données jointes, mais uniquement de renommer une table dans la même base de données.

Si la table renommée contient des déclencheurs ou des index, ils demeurent joints à la table après son changement de nom. Toutefois, si des définitions de vue ou des instructions sont exécutées par des déclencheurs faisant référence à la table renommée, elles ne sont pas modifiées automatiquement de sorte à utiliser le nouveau nom de la table. Si une table renommée est associée à des vues ou des déclencheurs, vous devez supprimer et recréer manuellement les déclencheurs ou les définitions de vue en utilisant le nouveau nom de la table.

La syntaxe ADD [COLUMN] permet d’ajouter une colonne à une table existante. La nouvelle colonne est toujours ajoutée à la fin de la liste de colonnes existantes. La clause column-def peut prendre toutes les formes autorisées dans une instruction CREATE TABLE, mais est sujette aux restrictions suivantes :

  • La colonne ne doit pas contenir de contrainte PRIMARY KEY ou UNIQUE.

  • La colonne ne doit pas posséder la valeur par défaut CURRENT_TIME, CURRENT_DATE ou CURRENT_TIMESTAMP.

  • Si une contrainte NOT NULL est spécifiée, la colonne doit posséder une valeur par défaut autre que NULL.

La durée d’exécution de l’instruction ALTER TABLE n’est pas affectée par la quantité de données que contient la table.

DROP TABLE

L’instruction DROP TABLE supprime une table ajoutée à l’aide de l’instruction CREATE TABLE. C’est la table contenant le paramètre table-name spécifié qui est supprimée. Elle disparaît totalement de la base de donnée et du fichier sur disque. Il est impossible de restaurer la table. Tous les index associés à la table sont également supprimés.
sql-statement  ::=  DROP TABLE [IF EXISTS] [database-name.] table-name

Par défaut, l’instruction DROP TABLE ne réduit pas la taille du fichier de base de données. L’espace vide de la base de données est conservé et exploité lors des opérations INSERT suivantes. Pour supprimer l’espace libre dans la base de données, utilisez la méthode SQLConnection.clean(). Si le paramètre autoClean est défini sur true lors de la création initiale de la base de données, l’espace est automatiquement libéré.

La clause IF EXISTS facultative supprime l’erreur qui se produit normalement si la table n’existe pas.

CREATE INDEX

La commande CREATE INDEX se compose des mots-clés CREATE INDEX, suivis du nom du nouvel index, du mot-clé ON, du nom de la table créée précédemment à indexer et d’une liste de noms de colonnes de la table (entre parenthèses) dont les valeurs sont utilisées pour la clé d’index.

sql-statement  ::=  CREATE [UNIQUE] INDEX [IF NOT EXISTS] [database-name.] index-name 
                    ON table-name ( column-name [, column-name]* ) 
column-name    ::=  name [COLLATE collation-name] [ASC | DESC]

Chaque nom de colonne peut être suivi des mots-clés ASC ou DESC pour indiquer l’ordre de tri, mais cette indication est ignorée par le moteur d’exécution. Un tri est toujours exécuté par ordre croissant.

La clause COLLATE qui suit chaque nom de colonne définit une séquence de classement utilisée pour les valeurs texte de la colonne. La séquence de classement par défaut est définie pour cette colonne dans l’instruction CREATE TABLE. Si aucune séquence de classement n’est spécifiée, la séquence de classement BINARY est utilisée. Pour consulter une définition de la clause COLLATE et des fonctions de classement, voir COLLATE.

Le nombre d’index pouvant être associés à une même table n’est sujet à aucune restriction arbitraire. Le nombre de colonnes d’un index n’est pas non plus restreint.

DROP INDEX

L’instruction DROP INDEX supprime un index ajouté à l’aide de l’instruction CREATE INDEX. L’index spécifié est totalement supprimé du fichier de base de données. L’unique façon de restaurer l’index consiste à entrer à nouveau la commande CREATE INDEX appropriée.

sql-statement ::= DROP INDEX [IF EXISTS] [database-name.] index-name

Par défaut, l’instruction DROP INDEX ne réduit pas la taille du fichier de base de données. L’espace vide de la base de données est conservé et exploité lors des opérations INSERT suivantes. Pour supprimer l’espace libre dans la base de données, utilisez la méthode SQLConnection.clean(). Si le paramètre autoClean est défini sur true lors de la création initiale de la base de données, l’espace est automatiquement libéré.

CREATE VIEW

La commande CREATE VIEW affecte un nom à une instruction SELECT prédéfinie. Ce nouveau nom peut ensuite être utilisé dans une clause FROM d’une autre instruction SELECT au lieu d’un nom de table. Les vues permettent généralement de simplifier les requêtes en combinant un ensemble de données complexe (et fréquemment utilisé) en une structure exploitable dans d’autres opérations.

sql-statement ::= CREATE [TEMP | TEMPORARY] VIEW [IF NOT EXISTS] [database-name.] view-name AS select-statement

Si le mot-clé TEMP ou TEMPORARY figure entre CREATE et VIEW, la vue créée est réservée à l’occurrence de SQLConnection qui a ouvert la base de données et est automatiquement supprimée lors de la fermeture de cette dernière.

Si un élément [database-name] est spécifié, la table est créée dans la base de données nommée (une base de données connectée à l’occurrence de SQLConnection en appelant la méthode attach() avec l’argument name spécifié). Spécifier à la fois un élément [database-name] et le mot-clé TEMP est une erreur, sauf si [database-name] correspond à temp. Lorsqu’aucun nom de base de données n’est spécifié et que le mot-clé TEMP n’est pas présent, la vue est créée dans la base de données principale (la base de données connectée à l’occurrence de SQLConnection avec la méthode open() ou openAsync()).

Les vues sont disponibles en lecture seule. Il est impossible d’utiliser une instruction DELETE, INSERT ou UPDATE sur une vue, sauf si un déclencheur au moins du type associé (INSTEAD OF DELETE, INSTEAD OF INSERT, INSTEAD OF UPDATE) est défini. Pour plus d’informations sur la création d’un déclencheur associé à une vue, voir CREATE TRIGGER.

Pour supprimer une vue d’une base de données, utilisez l’instruction DROP VIEW.

DROP VIEW

L’instruction DROP VIEW supprime une vue créée par une instruction CREATE VIEW.

sql-statement ::= DROP VIEW [IF EXISTS] view-name

Le paramètre view-name spécifié indique le nom de la vue à supprimer. Elle est supprimée de la base de données, mais aucune donnée figurant dans les tables sous-jacentes n’est modifiée.

CREATE TRIGGER

L’instruction CREATE TRIGGER permet d’ajouter des déclencheurs au schéma de la base de données. Un déclencheur est une opération de base de données (trigger-action) exécutée automatiquement lorsqu’un événement de base de données spécifié (database-event) se produit.

sql-statement   ::=  CREATE [TEMP | TEMPORARY] TRIGGER [IF NOT EXISTS] [database-name.] trigger-name 
                     [BEFORE | AFTER] database-event 
                     ON table-name 
                     trigger-action 
sql-statement   ::=  CREATE [TEMP | TEMPORARY] TRIGGER [IF NOT EXISTS] [database-name.] trigger-name 
                     INSTEAD OF database-event 
                     ON view-name 
                     trigger-action 
database-event  ::=  DELETE | 
                     INSERT | 
                     UPDATE | 
                     UPDATE OF column-list 
trigger-action  ::=  [FOR EACH ROW] [WHEN expr] 
                     BEGIN 
                       trigger-step ; 
                       [ trigger-step ; ]* 
                     END 
trigger-step    ::=  update-statement | 
                     insert-statement | 
                     delete-statement | 
                     select-statement 
column-list     ::=  column-name [, column-name]*

L’exécution d’un déclencheur est spécifiée à chaque fois qu’une instruction DELETE, INSERT ou UPDATE se produit sur une table de base de données donnée, ou à chaque fois qu’une instruction UPDATE associée à une ou plusieurs colonnes spécifiées d’une table est implémentée. A moins d’utiliser le mot-clé TEMP ou TEMPORARY, les déclencheurs sont permanents. Si tel est le cas, le déclencheur est supprimé lors de la fermeture de la connexion à la base de données principale liée à l’occurrence de SQLConnection. Lorsqu’aucun repère temporel n’est spécifié (BEFORE or AFTER), le déclencheur est défini par défaut sur BEFORE.

Etant donné que seuls les déclencheurs FOR EACH ROW sont pris en charge, le texte FOR EACH ROW est facultatif. Avec un déclencheur FOR EACH ROW, les instructions trigger-step sont exécutées pour chaque ligne de base de données insérée, mise à jour ou supprimée par l’instruction qui entraîne l’exécution du déclencheur, si l’expression de la clause WHEN est true.

Si une clause WHEN est stipulée, les instructions SQL spécifiées en tant « qu’étapes du déclencheur » ne sont exécutées que pour les lignes pour lesquelles la clause WHEN est true. Si aucune clause WHEN n’est stipulée, les instructions SQL sont exécutées pour toutes les lignes.

Dans le corps d’un déclencheur (clause trigger-action), les valeurs de la table affectée avant et après la modification sont disponibles à l’aide des noms de table spéciaux OLD et NEW. La structure des tables OLD et NEW correspond à la structure de la table sur laquelle est créé le déclencheur. La table OLD contient les lignes modifiées ou supprimées par l’instruction de déclenchement, dans l’état qui précède les opérations de cette dernière. La table NEW contient les lignes modifiées ou supprimées par l’instruction de déclenchement, dans l’état qui suit les opérations de cette dernière. La clause WHEN et les instructions trigger-step peuvent accéder aux valeurs des lignes insérées, supprimées ou mises à jour à l’aide de références exprimées sous la forme NEW.column-name et OLD.column-name, où column-name est le nom d’une colonne de la table à laquelle est associé le déclencheur. La disponibilité des références de table OLD et NEW varie selon le type d’événement de base de données géré par le déclencheur :

  • INSERT : les références NEW sont valides.

  • UPDATE : les références NEW et OLD sont valides.

  • DELETE : les références OLD sont valides.

Le repère temporel spécifié (BEFORE, AFTER ou INSTEAD OF) détermine le moment où les instructions trigger-step sont exécutées par rapport à l’insertion, la modification ou la suppression de la ligne associée. Une clause ON CONFLICT peut être spécifiée dans le cadre d’une instruction UPDATE ou INSERT dans une instruction trigger-step. Toutefois, si une clause ON CONFLICT est spécifiée dans le cadre de l’instruction responsable de l’exécution du déclencheur, la règle de gestion des conflits correspondante est alors utilisée.

Outre les déclencheurs de table, un déclencheur INSTEAD OF peut être associé à une vue. Si un ou plusieurs déclencheurs INSTEAD OF INSERT, INSTEAD OF DELETE ou INSTEAD OF UPDATE sont définis sur une vue, l’exécution du type associé d’instruction (INSERT, DELETE ou UPDATE) sur la vue est considérée comme correcte. Dans ce cas, l’exécution d’une instruction INSERT, DELETE ou UPDATE sur la vue entraîne l’activation des déclencheurs associés. Etant donné qu’il s’agit d’un déclencheur INSTEAD OF, les tables sous-jacentes de la vue ne sont pas modifiées par l’instruction qui entraîne l’activation du déclencheur. Les déclencheurs permettent cependant d’exécuter des opérations de modification sur les tables sous-jacentes.

Lors de la création d’un déclencheur sur une table contenant une colonne INTEGER PRIMARY KEY, il est important de ne pas oublier l’élément suivant. Si un déclencheur BEFORE modifie la colonne INTEGER PRIMARY KEY d’une ligne qui doit être mise à jour par l’instruction responsable de l’activation du déclencheur, la mise à jour ne se produit pas. La solution consiste à créer la table avec une colonne PRIMARY KEY au lieu d’une colonne INTEGER PRIMARY KEY.

L’instruction DROP TRIGGER permet de supprimer un déclencheur. Lors de la suppression d’une table ou d’une vue, tous les déclencheurs associés à la table ou à la vue sont automatiquement supprimés.

Fonction RAISE ()

Une fonction SQL spéciale RAISE() peut être utilisée dans une instruction trigger-step de déclencheur. La syntaxe de cette fonction est la suivante :

raise-function  ::=  RAISE ( ABORT, error-message ) | 
                     RAISE ( FAIL, error-message ) | 
                     RAISE ( ROLLBACK, error-message ) | 
                     RAISE ( IGNORE )

Lorsque l’une des trois premières formes est appelée pendant l’exécution du déclencheur, l’action de traitement ON CONFLICT spécifiée (ABORT, FAIL ou ROLLBACK) est exécutée et l’exécution de l’instruction en cours se termine. L’action ROLLBACK étant considérée comme un échec de l’exécution de l’instruction, l’occurrence de SQLStatement dont la méthode execute() était exécutée distribue un événement d’erreur (SQLErrorEvent.ERROR). L’objet SQLError de la propriété error de l’objet d’événement distribué voit sa propriété details définie sur le message d’erreur spécifié par la fonction RAISE().

Lors de l’appel de la fonction RAISE(IGNORE), la suite du déclencheur en cours, ainsi que l’instruction responsable de son activation et les déclencheurs éventuellement exécutés par la suite sont abandonnés. Les modifications apportées à la base de données ne sont pas annulées. Si l’instruction responsable de l’exécution du déclencheur fait elle-même partie d’un déclencheur, ce programme est réactivé au début de l’étape suivante. Pour plus d’informations sur les algorithmes de résolution de conflit, voir la section ON CONFLICT (algorithmes de conflit).

DROP TRIGGER

L’instruction DROP TRIGGER supprime un déclencheur créé par l’instruction CREATE TRIGGER.

sql-statement  ::=  DROP TRIGGER [IF EXISTS] [database-name.] trigger-name

Le déclencheur est supprimé de la base de données. Notez que les déclencheurs sont automatiquement supprimés lors de la suppression de la table associée.

Instructions et clauses spéciales

Cette section décrit plusieurs clauses qui sont des extensions de SQL fournies par le moteur d’exécution, ainsi que deux éléments de langage utilisables dans de nombreux commentaires, instructions et expressions.

COLLATE

La clause COLLATE est utilisée dans les instructions SELECT, CREATE TABLE et CREATE INDEX pour définir l’algorithme de comparaison qui permet de comparer et trier des valeurs.

sql-statement   ::=  COLLATE collation-name 
collation-name  ::=  BINARY | NOCASE

Le type de classement par défaut des colonnes est BINARY. Lorsque le classement BINARY est utilisé avec des valeurs de la classe de stockage TEXT, un classement binaire est effectué en comparant les octets en mémoire qui représentent la valeur, quel que soit le codage du texte.

La séquence de classement NOCASE n’est appliquée qu’aux valeurs de la classe de stockage TEXT. Lorsqu’il est utilisé, le classement NOCASE effectue une comparaison sans respecter la casse.

Aucune séquence de classement n’est utilisée pour les classes de stockage de type NULL, BLOB, INTEGER ou REAL.

Pour utiliser un type de classement autre que BINARY avec une colonne, une clause COLLATE doit être spécifiée dans le cadre de la définition de la colonne dans l’instruction CREATE TABLE. Chaque fois que deux valeurs TEXT sont comparées, une séquence de classement permet de déterminer les résultats de la comparaison, selon les règles suivantes :

  • Pour les opérateurs de comparaison binaire, si l’un des deux opérandes est une colonne, le type de classement par défaut de la colonne détermine la séquence de classement utilisée pour la comparaison. Si les deux opérandes sont des colonnes, le type de classement de l’opérande de gauche détermine la séquence de classement utilisée. Si aucun des opérandes n’est une colonne, la séquence de classement BINARY est utilisée.

  • L’opérateur BETWEEN...AND revient à utiliser deux expressions avec les opérateurs >= et <=. Par exemple, l’expression x BETWEEN y AND z est équivalente à x >= y AND x <= z. Par conséquent, l’opérateur BETWEEN...AND suit la règle précédente pour identifier la séquence de classement.

  • L’opérateur IN se comporte comme l’opérateur = pour déterminer la séquence de classement à utiliser. Par exemple, la séquence de classement utilisée pour l’expression IN (y, z) est le type de classement par défaut de x si x est une colonne. Dans le cas contraire, le classement BINARY est utilisé.

  • Une clause ORDER BY faisant partie d’une instruction SELECT peut se voir affecter explicitement une séquence de classement à utiliser pour l’opération de tri. Dans ce cas, la séquence de classement explicite est toujours utilisée. Si tel n’est pas le cas, lorsque l’expression triée par une clause ORDER BY est une colonne, le type de classement par défaut de cette colonne est utilisé pour déterminer l’ordre de tri. Si l’expression n’est pas une colonne, la séquence de classement BINARY est utilisée.

EXPLAIN

Le modificateur de commande EXPLAIN est une extension non standard de SQL.

sql-statement  ::=  EXPLAIN sql-statement

Si le mot-clé EXPLAIN apparaît avant une autre instruction SQL, au lieu d’exécuter la commande, le résultat signale la séquence des instructions d’un ordinateur virtuel qu’il aurait utilisée pour exécuter la commande si le mot-clé EXPLAIN n’avait pas été présent. EXPLAIN est une fonctionnalité avancée qui permet aux développeurs de modifier le texte d’une instruction SQL dans le but d’optimiser les performances ou de déboguer une instruction qui ne semble pas fonctionner correctement.

ON CONFLICT (algorithmes de conflit)

La clause ON CONFLICT n’est pas une commande SQL distincte, mais une clause non standard susceptible de figurer dans un grand nombre d’autres commandes SQL.

conflict-clause     ::=  ON CONFLICT conflict-algorithm 
conflict-clause     ::=  OR conflict-algorithm 
conflict-algorithm  ::=  ROLLBACK | 
                         ABORT | 
                         FAIL | 
                         IGNORE | 
                         REPLACE

La première forme de la clause ON CONFLICT, qui fait appel à des mots-clés ON CONFLICT, permet de créer une instruction CREATE TABLE. Pour une instruction INSERT ou UPDATE, la seconde forme est utilisée, ON CONFLICT étant remplacé par OR pour rendre la syntaxe plus naturelle. Ainsi, au lieu d’INSERT ON CONFLICT IGNORE, l’instruction devient INSERT OR IGNORE. Bien que les mots-clés soient différents, la signification de la clause est identique pour les deux formes.

La clause ON CONFLICT définit l’algorithme requis pour résoudre les conflits de contraintes. Les algorithmes sont au nombre de cinq, ROLLBACK, ABORT, FAIL, IGNORE et REPLACE. L’algorithme par défaut est ABORT. Les cinq algorithmes de conflit sont expliqués ci-après :

ROLLBACK
Lorsqu’une violation de contrainte se produit, ROLLBACK survient immédiatement et met fin à la transaction en cours. La commande est annulée et l’occurrence de SQLStatement distribue un événement d’erreur. Si aucune transaction n’est active (mise à part la transaction implicite créée pour chaque commande), cet algorithme fonctionne comme ABORT.

ABORT
Lorsqu’une violation de contrainte se produit, la commande retire toute modification précédente éventuellement exécutée et l’occurrence de SQLStatement distribue un événement d’erreur. Aucun algorithme ROLLBACK n’étant exécuté, les modifications apportées par les commandes précédentes dans une transaction sont donc conservées. ABORT correspond au comportement par défaut.

FAIL
Lorsqu’une violation de contrainte se produit, la commande est annulée et l’occurrence de SQLStatement distribue un événement d’erreur. Toutefois, toutes les modifications apportées à la base de données par l’instruction avant l’identification de la violation de contrainte sont conservées et ne sont pas retirées. Par exemple, si une instruction UPDATE rencontre une violation de contrainte au niveau de la centième ligne lors de la tentative de mise à jour, les modifications apportées aux 99 premières lignes sont conservées, mais la ligne 100 et les suivantes ne sont pas modifiées.

IGNORE
Lorsqu’une violation de contrainte se produit, la ligne concernée n’est ni insérée, ni modifiée. Mise à part la non -prise en compte de cette ligne, la commande poursuit son exécution normalement. L’insertion ou la mise à jour des lignes qui précèdent et qui suivent la ligne contenant la violation de contrainte se poursuit normalement. Aucune erreur n’est renvoyée.

REPLACE
Lorsqu’une violation de contrainte UNIQUE se produit, les lignes préexistantes à l’origine de cette violation sont supprimées avant l’insertion ou la mise à jour de la ligne en cours. Par conséquent, l’insertion ou la mise à jour se produit toujours, et l’exécution de la commande se poursuit normalement. Aucune erreur n’est renvoyée. Si une violation de contrainte NOT NULL se produit, la valeur NULL est remplacée par la valeur par défaut de la colonne. Si la colonne n’a pas de valeur par défaut, l’algorithme ABORT est utilisé. Si une violation de contrainte CHECK se produit, l’algorithme IGNORE est utilisé. Lorsque cette stratégie de résolution de conflits supprime des lignes pour respecter une contrainte, elle n’invoque pas de déclencheurs de suppression sur ces lignes.

L’algorithme spécifié dans la clause OR d’une instruction INSERT ou UPDATE remplace tout algorithme spécifié dans une instruction CREATE TABLE. Si aucun algorithme n’est spécifié dans l’instruction CREATE TABLE ou dans l’instruction INSERT ou UPDATE en cours d’exécution, l’algorithme ABORT est utilisé.

REINDEX

La commande REINDEX permet de supprimer et de recréer un ou plusieurs index. Elle s’avère utile lorsque la définition d’une séquence de classement a été modifiée.

sql-statement  ::=  REINDEX collation-name 
sql-statement  ::=  REINDEX [database-name .] ( table-name | index-name )

Dans la première forme, tous les index de toutes les bases de données jointes qui utilisent la séquence de classement nommée sont recréés. Dans la seconde forme, lorsqu’un paramètre table-name est spécifié, tous les index associés à la table sont reconstruits. Si un paramètre index-name est spécifié, seul l’index spécifié est supprimé et recréé.

COMMENTAIRES

Les commentaires ne sont pas des commandes SQL, mais ils peuvent survenir dans des requêtes SQL. Ils sont traités comme des espaces blancs par le moteur d’exécution. Ils peuvent débuter à chaque fois qu’un espace blanc est détecté, y compris à l’intérieur d’expressions réparties sur plusieurs lignes.

comment             ::=  single-line-comment | 
                         block-comment 
single-line-comment ::=  -- single-line 
block-comment       ::=  /* multiple-lines or block [*/]

Un commentaire d’une seule ligne est indiqué par deux tirets. Un commentaire d’une seule ligne ne dépasse pas la fin de la ligne en cours.

Les blocs de commentaires peuvent s’étendre sur un nombre illimité de lignes ou être intégrés à une seule ligne. Si aucun délimiteur de terminaison n’a été défini, un bloc de commentaires atteint la fin de l’entrée. Cette situation n’est pas traitée comme une erreur. Une nouvelle instruction SQL peut débuter sur une ligne après la fin d’un bloc de commentaires. Les blocs de commentaires peuvent être intégrés à tout emplacement susceptible d’être occupé par un espace blanc, y compris dans des expressions et au milieu d’autres instructions SQL. Les blocs de commentaires ne s’imbriquent pas. Les commentaires d’une seule ligne placés dans un bloc de commentaires sont ignorés.

EXPRESSIONS

Les expressions sont des sous-commandes placées dans d’autres blocs SQL. La syntaxe valide d’une expression placée dans une instruction SQL est la suivante :

expr            ::=  expr binary-op expr | 
                     expr [NOT] like-op expr [ESCAPE expr] | 
                     unary-op expr | 
                     ( expr ) | 
                     column-name | 
                     table-name.column-name | 
                     database-name.table-name.column-name | 
                     literal-value | 
                     parameter | 
                     function-name( expr-list | * ) | 
                     expr ISNULL | 
                     expr NOTNULL | 
                     expr [NOT] BETWEEN expr AND expr | 
                     expr [NOT] IN ( value-list ) | 
                     expr [NOT] IN ( select-statement ) | 
                     expr [NOT] IN [database-name.] table-name | 
                     [EXISTS] ( select-statement ) | 
                     CASE [expr] ( WHEN expr THEN expr )+ [ELSE expr] END | 
                     CAST ( expr AS type ) | 
                     expr COLLATE collation-name 
like-op         ::=  LIKE | GLOB 
binary-op       ::=  see Operators 
unary-op        ::=  see Operators 
parameter       ::=  :param-name | @param-name | ? 
value-list      ::=  literal-value [, literal-value]* 
literal-value   ::=  literal-string | literal-number | literal-boolean | literal-blob | literal-null 
literal-string  ::=  'string value' 
literal-number  ::=  integer | number 
literal-boolean  ::=  true | false 
literal-blob  ::=  X'string of hexadecimal data' 
literal-null  ::=  NULL

Une expression correspond à toute combinaison de valeurs et d’opérateurs pouvant être résolue en tant que valeur unique. Les expressions se divisent en deux types généraux, selon qu’elles donnent une valeur booléenne (true ou false) ou non.

Dans nombre de situations courantes, y compris dans une clause WHERE, une clause HAVING, l’expression ON dans une clause JOIN et une expression CHECK, l’expression doit donner une valeur booléenne. Les types d’expressions suivants remplissent cette condition :

  • ISNULL

  • NOTNULL

  • IN ()

  • EXISTS ()

  • LIKE

  • GLOB

  • Certaines fonctions

  • Certains opérateurs (spécifiquement les opérateurs de comparaison)

Valeurs littérales

Une valeur numérique littérale est écrite sous forme de nombre entier ou de nombre à virgule flottante. La notation scientifique est prise en charge. Le caractère . (point) fait toujours office de caractère décimal.

Pour indiquer une chaîne littérale, placez-la entre guillemets droits simples (’). Pour inclure un guillemet droit simple dans une chaîne, insérez successivement deux guillemets droits simples, comme suit : ’’.

Une valeur booléenne littérale est indiquée par la valeur true ou false. Les valeurs booléennes littérales sont utilisées avec le type de données de colonne booléen.

Un littéral BLOB est un littéral de chaîne contenant des données hexadécimales et précédé d’un seul caractère x ou X, tel que X'53514697465'.

Une valeur littérale peut également être le jeton NULL.

Nom de colonne

Un nom de colonne peut être tout nom défini dans l’instruction CREATE TABLE ou l’un des identifiants spéciaux suivants : ROWID, OID ou _ROWID_. Ces identifiants spéciaux décrivent tous la clé aléatoire unique de type entier (« clé de la ligne »), associée à chaque ligne de chaque table. Les identifiants spéciaux ne font référence à la clé de la ligne que si l’instruction CREATE TABLE ne définit pas de colonne réelle portant le même nom. Les clés des lignes se comportent comme des colonnes en lecture seule. Une clé de ligne peut se substituer à toute colonne ordinaire, mais vous ne pouvez pas en modifier la valeur dans une instruction UPDATE ou INSERT. Le jeu de résultats de l’instruction de table SELECT * FROM ne comprend pas de clé de ligne.

Instruction SELECT

Une instruction SELECT peut apparaître dans une expression comme opérande de droite de l’opérateur IN, comme quantité scalaire (valeur de résultat unique) ou comme opérande d’un opérateur EXISTS. Lorsqu’elle est utilisée en tant que quantité scalaire ou qu’opérande d’un opérateur IN, le résultat de l’instruction SELECT ne peut contenir qu’une seule colonne. Une instruction SELECT composée (connectée par des mots-clés tels qu’UNION ou EXCEPT) est autorisée. Avec l’opérateur EXISTS, les colonnes du jeu de résultats de SELECT sont ignorées et l’expression renvoie TRUE si le jeu de résultats contient une ou plusieurs lignes, FALSE s’il est vide. Lorsqu’aucun terme de l’expression SELECT ne fait référence à la valeur de la requête conteneur, l’expression est évaluée une fois avant tout autre traitement et le résultat est réutilisé selon les besoins. Si l’expression SELECT contient des variables issues de la requête externe, appelée sous-requête corrélée, l’instruction SELECT est réévaluée à chaque fois que cela est nécessaire.

Lorsqu’une expression SELECT est l’opérande de droite de l’opérateur IN, l’opérateur IN renvoie TRUE si le résultat de l’opérande de gauche est égal à l’une des valeurs du jeu de résultats de l’instruction SELECT. L’opérateur IN peut être précédé du mot-clé NOT pour inverser le sens du test.

Lorsqu’une instruction SELECT apparaît dans une expression, mais n’est pas l’opérande droit d’un opérateur IN, la première ligne du résultat de SELECT devient la valeur utilisée dans l’expression. Si l’instruction SELECT produit plusieurs lignes de résultat, seule la première ligne est prise en compte. Si l’instruction SELECT ne produit pas de ligne de résultats, sa valeur est NULL.

Expression CAST

Une expression CAST remplace le type de données de la valeur spécifiée par le type donné. Le type spécifié peut être tout nom de type non vide géré par le type dans la définition de colonne d’une instruction CREATE TABLE. Pour plus d’informations, voir Prise en charge des types de données.

Autres éléments d’une expression

Vous pouvez également utiliser les éléments SQL suivants dans une expression :

  • Fonctions intégrées : fonctions d’agrégation, fonctions scalaires et fonctions de formatage de la date et de l’heure

  • Opérateurs

  • Paramètres

Fonctions intégrées

Les fonctions intégrées sont divisées en trois catégories principales :
  • Fonctions d’agrégation

  • Fonctions scalaires

  • Fonctions de date et d’heure

Outre ces fonctions, la fonction spéciale RAISE() permet de signaler une erreur lors de l’exécution d’un déclencheur. Cette fonction ne peut être utilisée que dans le corps d’une instruction CREATE TRIGGER. Pour plus d’informations sur la fonction RAISE(), voir CREATE TRIGGER > RAISE().

Comme tous les mots-clés dans SQL, les noms de fonction ne respectent pas la casse.

Fonctions d’agrégation

Les fonctions d’agrégation exécutent des opérations sur des valeurs issues de plusieurs lignes. Elles sont principalement utilisées dans des instructions SELECT en conjonction avec la clause GROUP BY.

AVG(X)

Renvoie la valeur moyenne de tous les X non NULL d’un groupe. Les valeurs de chaîne et les valeurs BLOB qui ne ressemblent pas à des nombres sont interprétées comme des 0. Le résultat d’AVG() est toujours une valeur à virgule flottante, même si toutes les entrées sont des nombres entiers.

COUNT(X) COUNT(*)

La première forme renvoie le nombre de fois que X n’est pas NULL dans un groupe. La seconde forme (associée à l’argument *) renvoie le nombre total de lignes du groupe.

MAX(X)

Renvoie la valeur maximale de toutes les valeurs du groupe. Pour déterminer cette valeur maximale, l’ordre de tri standard est utilisé.

MIN(X)

Renvoie la valeur minimale non NULL de toutes les valeurs du groupe. Pour déterminer cette valeur minimale, l’ordre de tri standard est utilisé. Si toutes les valeurs du groupe sont NULL, NULL est renvoyé.

SUM(X)

TOTAL(X)

Renvoie la somme numérique de toutes les valeurs non NULL du groupe. Si toutes les valeurs sont NULL, SUM() renvoie NULL et TOTAL() renvoie 0.0. Le résultat de TOTAL() est toujours une valeur à virgule flottante. SUM() a pour résultat une valeur entière si toutes les entrées non NULL sont des nombres entiers. Si l’une des entrées de SUM() n’est pas un nombre entier et n’est pas NULL, SUM() renvoie une valeur à virgule flottante. Cette valeur peut être une approximation de la somme réelle.

Dans toutes les fonctions d’agrégation précédentes qui gèrent un seul argument, celui-ci peut être précédé du mot-clé DISTINCT. Dans ce cas, les éléments en double sont filtrés avant d’être transmis à la fonction d’agrégation. Par exemple, l’appel de la fonction COUNT(DISTINCT x) renvoie le nombre de valeurs distinctes de la colonne X au lieu du nombre total de valeurs non NULL que contient la colonne x.

Fonctions scalaires

Les fonctions scalaires opèrent sur les valeurs d’une ligne à la fois.

ABS(X)

Renvoie la valeur absolue de l’argument X.

COALESCE(X, Y, ...)

Renvoie une copie du premier argument non NULL. Si tous les arguments sont NULL, NULL est renvoyé. Deux arguments au moins doivent être définis.

GLOB(X, Y)

Cette fonction permet de mettre en œuvre la syntaxe X GLOB Y.

IFNULL(X, Y)

Renvoie une copie du premier argument non NULL. Si les deux arguments sont NULL, NULL est renvoyé. Cette fonction se comporte comme COALESCE().

HEX(X)

L’argument est interprété en tant que valeur de type de stockage BLOB. Le résultat est un rendu hexadécimal du contenu de cette valeur.

LAST_INSERT_ROWID()

Renvoie l’identifiant de ligne (clé primaire générée) de la dernière ligne insérée dans la base de données via l’occurrence de SQLConnection en cours. Cette valeur est identique à la valeur renvoyée par la propriété SQLConnection.lastInsertRowID.

LENGTH(X)

Renvoie la longueur de la chaîne de X en caractères.

LIKE(X, Y [, Z])

Cette fonction permet de mettre en œuvre la syntaxe X LIKE Y [ESCAPE Z] de SQL. Si la clause ESCAPE facultative est présente, la fonction est appelée avec trois arguments. Dans le cas contraire, elle est appelée avec deux arguments seulement.

LOWER(X)

Renvoie une copie de la chaîne X dont tous les caractères sont convertis en minuscules.

LTRIM(X) LTRIM(X, Y)

Renvoie une chaîne qui résulte de la suppression des espaces du côté gauche de X. Si un argument Y est spécifié, la fonction supprime tous les caractères de Y du côté gauche de X.

MAX(X, Y, ...)

Renvoie l’argument possédant la valeur maximale. Outre les nombres, les arguments peuvent être des chaînes. La valeur maximale est déterminée par l’ordre de tri défini. Notez que MAX() est une fonction simple lorsqu’elle possède plusieurs arguments, mais une fonction d’agrégation lorsqu’elle n’en a qu’un seul.

MIN(X, Y, ...)

Renvoie l’argument possédant la valeur minimale. Outre les nombres, les arguments peuvent être des chaînes. La valeur minimale est déterminée par l’ordre de tri défini. Notez que MIN() est une fonction simple lorsqu’elle possède plusieurs arguments, mais une fonction d’agrégation lorsqu’elle n’en a qu’un seul.

NULLIF(X, Y)

Renvoie le premier argument si les arguments diffèrent, sinon elle renvoie NULL.

QUOTE(X)

Cette routine renvoie une chaîne correspondant à la valeur de l’argument pouvant être inclus dans une autre instruction SQL. Les chaînes sont entourées de guillemets simples avec caractères d’échappement sur les guillemets intérieurs si nécessaire. Les classes de stockage BLOB sont codées comme des littéraux hexadécimaux. La fonction s’avère utile lors de l’écriture de déclencheurs pour implémenter la fonctionnalité d’annulation et de rétablissement.

RANDOM(*)

Renvoie un nombre entier pseudo-aléatoire compris entre -9223372036854775808 et 9223372036854775807. Cette valeur aléatoire n’est pas chiffrée en dur.

RANDOMBLOB(N)

Renvoie un BLOB N-octets contenant des octets pseudo-aléatoires. N doit être un nombre entier positif. Cette valeur aléatoire n’est pas chiffrée en dur. Si la valeur de N est négative, un octet unique est renvoyé.

ROUND(X) ROUND(X, Y)

Arrondit le nombre X à Y chiffres après la virgule. Si l’argument Y est omis, 0 est utilisé.

RTRIM(X) RTRIM(X, Y)

Renvoie une chaîne qui résulte de la suppression des espaces du côté droit de X. Si un argument Y est spécifié, la fonction supprime tous les caractères de Y du côté droit de X.

SUBSTR(X, Y, Z)

Renvoie une sous-chaîne de la chaîne d’entrée X commençant par le Yième caractère et longue de Z caractères. Le caractère le plus à gauche de X est la position d’index 1. Si Y est négatif, le premier caractère de la sous-chaîne est détecté en comptant à partir de la droite et non à partir de la gauche.

TRIM(X) TRIM(X, Y)

Renvoie une chaîne qui résulte de la suppression des espaces du côté droit de X. Si un argument Y est spécifié, la fonction supprime tous les caractères de Y du côté droit de X.

TYPEOF(X)

Renvoie le type de l’expression X. Les valeurs gérées sont « null », « integer », « real », « text » et « blob ». Pour plus d’informations sur les types de données, voir Prise en charge des types de données.

UPPER(X)

Renvoie une copie de la chaîne d’entrée X convertie en majuscules.

ZEROBLOB(N)

Renvoie un BLOB contenant N octets de 0x00.

Fonctions de formatage de la date et de l’heure

Les fonctions de formatage de la date et de l’heure sont un groupe de fonctions scalaires qui permettent de créer des données de date et d’heure formatées. Notez que ces fonctions traitent et renvoient des valeurs de chaîne et des valeurs numériques. Elles ne sont pas conçues pour être utilisées avec le type de données DATE. Si vous utilisez ces fonctions sur les données d’une colonne dont le type de données déclaré est DATE, leur comportement est imprévisible.

DATE(T, ...)

La fonction DATE() renvoie une chaîne contenant la date au format AAAA-MM-JJ. Le premier paramètre (T) spécifie une chaîne horaire au format indiqué à la section Formats horaires. Vous pouvez spécifier un nombre illimité de modificateurs après la chaîne horaire. Les modificateurs sont recensés à la section Modificateurs.

TIME(T, ...)

La fonction TIME() renvoie une chaîne contenant l’heure exprimée au format HH:MM:SS. Le premier paramètre (T) spécifie une chaîne horaire au format indiqué à la section Formats horaires. Vous pouvez spécifier un nombre illimité de modificateurs après la chaîne horaire. Les modificateurs sont recensés à la section Modificateurs.

DATETIME(T, ...)

La fonction DATETIME() renvoie une chaîne contenant la date et l’heure au format AAAA-MM-JJ HH:MM:SS. Le premier paramètre (T) spécifie une chaîne horaire au format indiqué à la section Formats horaires. Vous pouvez spécifier un nombre illimité de modificateurs après la chaîne horaire. Les modificateurs sont recensés à la section Modificateurs.

JULIANDAY(T, ...)

La fonction JULIANDAY() renvoie un nombre qui indique le nombre de jours écoulés depuis midi heure de Greenwich le 24 novembre 4714 av. J.-C. et la date stipulée. Le premier paramètre (T) spécifie une chaîne horaire au format indiqué à la section Formats horaires. Vous pouvez spécifier un nombre illimité de modificateurs après la chaîne horaire. Les modificateurs sont recensés à la section Modificateurs.

STRFTIME(F, T, ...)

La routine STRFTIME() renvoie la date formatée selon la chaîne de format spécifiée en tant que premier argument F. La chaîne de format prend en charge les substitutions suivantes :

%d : jour du mois

%f : secondes fractionnaires (SS.SSS)

%H : heure (00-24)

%j : jour de l’année (001-366)

%J : nombre de jours Julien

%m : mois (01-12)

%M : minute (00-59)

%s : secondes depuis le 01-01-1970

%S : secondes (00-59)

%w : jour de la semaine (0-6, dimanche = 0)

%W : semaine de l’année (00-53)

%Y : année (0000-9999)

%% - %

Le second paramètre (T) spécifie une chaîne horaire au format indiqué à la section Formats horaires. Vous pouvez spécifier un nombre illimité de modificateurs après la chaîne horaire. Les modificateurs sont recensés à la section Modificateurs.

Formats horaires

Une chaîne horaire gère les formats suivants :

AAAA-MM-JJ

2007-06-15

AAAA-MM-JJ HH:MM

2007-06-15 07:30

AAAA-MM-JJ HH:MM:SS

2007-06-15 07:30:59

AAAA-MM-JJ HH:MM:SS.SSS

2007-06-15 07:30:59.152

AAAA-MM-JJTHH:MM

2007-06-15T07:30

AAAA-MM-JJTHH:MM:SS

2007-06-15T07:30:59

AAAA-MM-JJTHH:MM:SS.SSS

2007-06-15T07:30:59.152

HH:MM

07:30 (la date est le 01-01-2000)

HH:MM:SS

07:30:59 (la date est le 01-01-2000)

HH:MM:SS.SSS

07:30:59:152 (la date est le 01-01-2000)

now

Date et heure en cours exprimées au format UCT (Universal Coordinated Time)

DDDD.DDDD

Nombre de jours Julien exprimé sous forme de nombre à virgule flottante.

Le caractère T figurant dans ces formats est un caractère littéral « T » qui sépare la date et l’heure. Les formats qui ne contiennent qu’une heure partent du principe que la date correspond au 01-01-2001.

Modificateurs

La chaîne horaire peut être suivie d’aucun ou de plusieurs modificateurs qui modifient la date ou en changent l’interprétation. Les modificateurs disponibles sont les suivants :

NNN days

Nombre de jours à ajouter à l’heure.

NNN hours

Nombre d’heures à ajouter à l’heure.

NNN minutes

Nombre de minutes à ajouter à l’heure.

NNN.NNNN seconds

Nombre de secondes et de millisecondes à ajouter à l’heure.

NNN months

Nombre de mois à ajouter à l’heure.

NNN years

Nombre d’années à ajouter à l’heure.

start of month

Ramène l’heure au début du mois.

start of year

Ramène l’heure au début de l’année.

start of day

Ramène l’heure au début de la journée.

weekday N

Fait avancer l’heure jusqu’au jour de la semaine spécifié. (0 = dimanche, 1 = lundi, etc.).

localtime

Convertit la date au format local.

utc

Convertit la date au format UCT (Universal Coordinated Time).

Opérateurs

SQL prend en charge un grand nombre d’opérateurs, dont les opérateurs courants qui existent dans la plupart des langages de programmation, ainsi que plusieurs opérateurs propres à SQL.

Opérateurs courants

Les opérateurs binaires suivants sont autorisés dans un bloc SQL et sont recensés par ordre de priorité décroissant :

*    /    % 
+    - 
<< >> &     | 
< >=   > >= 
=    ==   !=   <> IN 
AND 
OR

Opérateurs de préfixe unaires pris en charge :

 !    ~    NOT

L’opérateur COLLATE peut être considéré comme un opérateur de suffixe unaire. Il possède la priorité la plus élevée. Il établit toujours une liaison plus étroite que tout opérateur de préfixe unaire ou opérateur binaire.

Notez qu’il existe deux variantes des opérateurs égal et différent. L’opérateur égal peut être = ou ==. L’opérateur différent peut être != ou <>.

L’opérateur || est l’opérateur de concaténation de chaînes. Il relie les deux chaînes de ses opérandes.

L’opérateur % a pour résultat le reste de son opérande de gauche modulo son opérande de droite.

Le résultat de tout opérateur binaire est une valeur numérique, à l’exception de l’opérateur de concaténation ||, dont le résultat est une chaîne.

Opérateurs SQL

LIKE

L’opérateur LIKE effectue une comparaison de correspondance basée sur un modèle.

expr     ::=  (column-name | expr) LIKE pattern 
pattern  ::=  '[ string | % | _ ]'

L’opérande de droite de l’opérateur LIKE contient le modèle, tandis que l’opérande de gauche contient la chaîne à comparer au modèle. Un symbole de pourcentage (%) dans le modèle représente un caractère générique. Il correspond à toute séquence de zéro, un ou plusieurs caractères de la chaîne. Un caractère de soulignement (_) dans le modèle correspond à tout caractère unique de la chaîne. Tous les autres caractères correspondent à leur valeur ou à leur équivalent majuscule/minuscule. En d’autres termes, la correspondance ne respecte pas la casse. (Remarque : le moteur de base de données gère la casse des caractères latins 7 bits uniquement. Par conséquent, l’opérateur LIKE respecte la casse des caractères UTF-8 ou iso8859 8 bits. Ainsi, l’expression 'a' LIKE 'A' est TRUE, mais 'æ' LIKE 'Æ' est FALSE). La propriété SQLConnection.caseSensitiveLike permet de modifier le respect de la casse pour les caractères latins.

Si la clause facultative ESCAPE est présente, l’expression qui suit le mot-clé ESCAPE doit correspondre à une chaîne composée d’un seul caractère. Ce caractère peut être utilisé dans le modèle LIKE pour correspondre aux caractères littéraux de pourcentage ou de soulignement. Le caractère échappement suivi du symbole de pourcentage, d’un soulignement ou de lui-même correspond respectivement à un symbole de pourcentage, à un soulignement ou à un caractère d’échappement littéral dans la chaîne.

GLOB

L’opérateur GLOB est similaire à LIKE, mais utilise la syntaxe globbing de fichier Unix pour ses caractères génériques. A l’encontre de LIKE, GLOB respecte la casse.

IN

L’opérateur IN calcule si son opérande de gauche est égal à l’une des valeurs de son opérande de droite (ensemble de valeurs entre parenthèses).

in-expr         ::=  expr [NOT] IN ( value-list ) | 
                     expr [NOT] IN ( select-statement ) | 
                     expr [NOT] IN [database-name.] table-name 
value-list      ::=  literal-value [, literal-value]*

L’opérande de droite peut être un ensemble de valeurs littérales séparées par des virgules ou le résultat d’une instruction SELECT. Pour plus d’informations et pour connaître les restrictions d’utilisation d’une instruction SELECT en tant qu’opérande de droite de l’opérateur IN, voir les instructions SELECT dans les expressions.

BETWEEN...AND

L’opérateur BETWEEN...AND revient à utiliser deux expressions avec les opérateurs >= et <=. Par exemple, l’expression x BETWEEN y AND z est équivalente à x >= y AND x <= z.

NOT

L’opérateur NOT est un opérateur de négation. Les opérateurs GLOB, LIKE et IN peuvent être précédés du mot-clé NOT pour inverser le sens du test (en d’autres termes, pour vérifier qu’une valeur ne correspond pas au modèle indiqué).

Paramètres

Un paramètre spécifie dans l’expression un espace réservé associé à une valeur littérale renseignée au moment de l’exécution en affectant une valeur au tableau associatif SQLStatement.parameters. Les paramètres gèrent trois formes :

?

Un point d’interrogation indique un paramètre indexé. Des valeurs d’index numériques (de base zéro) sont affectées aux paramètres en fonction de leur ordre d’apparition dans l’instruction.

:AAAA

Un caractère deux-points suivi d’un nom d’identifiant conserve un espace au paramètre nommé AAAA. Les paramètres nommés sont également numérotés en fonction de leur ordre d’apparition dans l’instruction SQL. Pour éviter toute confusion, il est préférable d’éviter de combiner les paramètres numérotés et nommés.

@AAAA

Le symbole arrobas est l’équivalent du caractère deux-points.

Fonctions SQL non prises en charge

La liste ci-dessous recense les éléments SQL standard qui ne sont pas pris en charge dans Adobe AIR :
Contraintes FOREIGN KEY
Les contraintes FOREIGN KEY sont analysées, mais ne sont pas imposées.

Déclencheurs
Les déclencheurs FOR EACH STATEMENT ne sont pas pris en charge (tous les déclencheurs doivent correspondre à FOR EACH ROW). Les déclencheurs INSTEAD OF ne sont pas pris en charge dans les tables (ils ne sont autorisés que dans les vues). Les déclencheurs récursifs (autrement dit, qui se déclenchent eux-mêmes) ne sont pas pris en charge.

ALTER TABLE
Seules les variantes RENAME TABLE et ADD COLUMN de la commande ALTER TABLE sont prises en charge. Les autres types d’opérations ALTER TABLE, tels que DROP COLUMN, ALTER COLUMN, ADD CONSTRAINT, etc. sont ignorés.

Transactions imbriquées
Une seule transaction active est autorisée.

RIGHT OUTER JOIN et FULL OUTER JOIN
RIGHT OUTER JOIN et FULL OUTER JOIN ne sont pas pris en charge.

VIEW actualisable
Une vue est disponible en lecture seule. Il est impossible d’exécuter une instruction DELETE, INSERT ou UPDATE sur une vue. Un déclencheur INSTEAD OF exécuté lors d’une tentative d’instruction DELETE, INSERT ou UPDATE sur une vue est pris en charge et permet de mettre à jour les tables de soutien dans le corps du déclencheur.

GRANT et REVOKE
Une base de données est un fichier de disque ordinaire ; les seules autorisations d’accès à appliquer sont les autorisations d’accès au fichier standard du système d’exploitation sous-jacent. Les commandes GRANT et REVOKE fréquemment détectées sur les systèmes SGBDR client/serveur ne sont pas implémentées.

Les éléments SQL et fonctionnalités SQLite suivants sont pris en charge dans certaines implémentations SQLite, mais ne le sont pas dans Adobe AIR. La plupart de ces fonctionnalités sont disponibles par le biais des méthodes de la classe SQLConnection :
Eléments SQL liés aux transactions (BEGIN, END, COMMIT, ROLLBACK)
Cette fonctionnalité est disponible par le biais des méthodes liées aux transactions de la classe SQLConnection, SQLConnection.begin(), SQLConnection.commit() et SQLConnection.rollback().

ANALYZE
Cette fonctionnalité est disponible par le biais de la méthode SQLConnection.analyze().

ATTACH
Cette fonctionnalité est disponible par le biais de la méthode SQLConnection.attach().

COPY
Cette instruction n’est pas prise en charge.

CREATE VIRTUAL TABLE
Cette instruction n’est pas prise en charge.

DETACH
Cette fonctionnalité est disponible par le biais de la méthode SQLConnection.detach().

PRAGMA
Cette instruction n’est pas prise en charge.

VACUUM
Cette fonctionnalité est disponible par le biais de la méthode SQLConnection.compact().

L’accès aux tables système n’est pas disponible.
Les tables système, y compris sqlite_master et d’autres tables dotées du préfixe « sqlite_ » ne sont pas disponibles dans les instructions SQL. Le moteur d’exécution comprend une API de schéma qui permet d’accéder aux données du schéma par le biais d’une solution orientée objets. Pour plus d’informations, voir la méthode SQLConnection.loadSchema().

Fonctions d’expression régulière (MATCH() et REGEX())
Ces fonctions ne sont pas disponibles dans les instructions SQL.

La fonctionnalité suivante varie selon les nombreuses implémentations de SQLite et Adobe AIR :

Paramètres d’instruction indexés
Dans de nombreuses implémentations, les paramètres d’instruction indexés sont basés sur un. Toutefois, dans Adobe AIR, les paramètres d’instruction indexés sont basés sur zéro (en d’autres termes, le premier paramètre est doté de l’index 0, le deuxième de l’index 1, etc.).

Définitions de colonne INTEGER PRIMARY KEY
Dans de nombreuses implémentations, seules les colonnes définies exactement en tant qu’INTEGER PRIMARY KEY servent de colonne de clé primaire réelle de table. Dans ces implémentations, l’utilisation d’un type de données distinct, généralement synonyme d’INTEGER (tel qu’int), n’implique pas l’utilisation de la colonne comme clé primaire interne. Toutefois, dans Adobe AIR, le type de données int (ainsi que d’autres synonymes d’INTEGER) est considéré comme étant exactement équivalent à INTEGER. Par conséquent, une colonne définie en tant qu’INTEGER PRIMARY KEY sert de clé primaire interne de table. Pour plus d’informations, voir les sections CREATE TABLE et Affinité de colonne.

Autres fonctions SQL

Les types d’affinité de colonne suivants ne sont pas pris en charge par défaut dans SQLite, mais le sont dans Adobe AIR (notez qu’à l’instar de tous les mots-clés dans SQL, ces noms de types de données ne respectent pas la casse) :
Boolean
correspond à la classe Boolean.

Date
correspond à la classe Date.

int
correspond à la classe int (équivaut à l’affinité de colonne INTEGER).

Number
correspond à la classe Number (équivaut à l’affinité de colonne REAL).

Object
correspond à la classe Object ou à toute sous-classe pouvant être sérialisée ou désérialisée par le biais d’AMF3. (Inclut la plupart des classes, y compris les classes personnalisées, mais exclut certaines classes telles que les objets d’affichage et les objets qui incluent des objets d’affichage en tant que propriétés.)

String
correspond à la classe String (équivaut à l’affinité de colonne TEXT).

XML
correspond à la classe XML d’ActionScript (E4X).

XMLList
correspond à la classe XMLList d’ActionScript (E4X).

Les valeurs littérales suivantes ne sont pas prises en charge par défaut dans SQLite, mais le sont dans Adobe AIR :

true
permet de représenter la valeur booléenne littérale true, avec les colonnes BOOLEAN.

false
permet de représenter la valeur booléenne littérale false, avec les colonnes BOOLEAN.