Syntaxe SQL prise en charge

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

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

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.

CREATE TABLE

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

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.

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 :

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 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.

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.

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.

Formats horaires

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

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é).