Adobe AIR comprend un moteur de base de données SQL avec prise en charge des bases de données SQL locales et de nombreuses fonctionnalités SQL standard, à l'aide du système de base de données SQLite open source. Le moteur d'exécution ne spécifie pas comment ni où les données de la base de données sont stockées dans le système de fichiers. Chaque base de données est stockée dans son intégralité au sein d'un seul fichier. Le développeur peut spécifier l'emplacement de stockage du fichier de bases de données au sein du système de fichiers, et une même application AIR peut accéder à une ou plusieurs bases de données distinctes (c'est-à-dire à des fichiers de base de données distincts).
Ce document décrit la syntaxe SQL et la prise en charge des types de données pour les bases de données SQL locales Adobe AIR. Il n'a pas pour objectif de servir de référence SQL complète, mais de décrire les détails spécifiques du langage SQL pris en charge par Adobe AIR. Le moteur d'exécution prend en charge la plupart du langage SQL standard SQL-92. Comme nombre de références, sites Web, livres et matériaux de formation enseignent SQL, ce document n'a pas pour objectif de devenir une référence SQL ni un didacticiel complet. Il se concentre de façon spécifique sur la syntaxe SQL prise en charge par Apollo AIR et sur les différences entre SQL-92 et le langage SQL pris en charge.
Les rubriques suivantes sont traitées :
Cette section décrit la syntaxe SQL prise en charge par le moteur de base de données Adobe AIR SQL. Ces listes sont divisées en description des diverses instructions et des différents types de clauses, expressions, fonctions intégrées et opérateurs. Les rubriques suivantes sont traitées :
SELECT, INSERT, UPDATE et DELETE)CREATE, ALTER et DROP pour les tables, les index, les vues et les déclencheurs)Outre la syntaxe spécifique des diverses instructions et expressions, les règles générales de la syntaxe SQL sont les suivantes :
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 :
L'instruction SELECT est utilisée pour interroger la base de données. Le résultat d'une instruction SELECT est zéro ou plusieurs lignes de données, où chaque ligne a un nombre fixe de colonnes. Le nombre de colonnes du résultat est spécifié par le nom de la colonne result ou par la liste des expressions entre l'instruction SELECT et les mots-clés FROM facultatifs.
N'importe quelle expression arbitraire peut être utilisée comme résultat. Lorsqu'une expression de résultat est *, toutes les colonnes de toutes les tables sont substituées pour cette expression. Si l'expression est le nom d'une table suivi de .*, le résultat est toutes les 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. Les valeurs NULL ne sont pas traitées différemment des autres. Le comportement par défaut est le renvoi de toutes les lignes résultantes, 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érents tables. La syntaxe JOIN peut également être utilisée pour spécifier comment les tables sont reliées entre elles. Le seul type de jointure externe pris en charge est LEFT OUTER JOIN. L'expression de clause ON dans join-args 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 seule ligne composée des valeurs de la liste d'expressions result.
La clause WHERE est utilisée pour limiter le nombre de lignes récupérées par la requête. Les expressions de la clause WHERE doivent donner une valeur booléenne. Un filtrage des clauses WHERE étant effectué avant tout regroupement, les expressions de la clause WHERE peuvent ne pas inclure de fonction d'agrégation.
La clause GROUP BY combine une ou plusieurs lignes du résultat en une seule ligne de résultat. La 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 par le fait qu'elle limite le nombre de lignes renvoyées par l'instruction. Toutefois, la clause HAVING s'applique après la survenue 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 la clause HAVING n'est pas obligée d'apparaître dans la liste SELECT. Comme une expression WHERE, une expression HAVING doit donner une valeur booléenne.
La clause ORDER BY entraîne le tri des lignes du résultat. L'argument sort-expr-list de la clause ORDER BY est une liste d'expressions utilisée comme 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 à 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). La clause sort-order peut être omise et l'ordre par défaut (croissant) est utilisé. Pour une définition de la clause COLLATE et des fonctions de classement, voir COLLATE.
La clause LIMIT place une limite supérieure pour le nombre de lignes renvoyées dans le résultat. Une clause LIMIT négative indique qu'il n'y a pas de limite supérieure. Le mot-clé OFFSET facultatif qui suit 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 est le premier nombre entier et le décalage, le second nombre entier. Si une virgule est utilisée à la place du mot-clé OFFSET, le décalage est le premier nombre entier et la limite, le second nombre entier. La contradiction apparente est volontaire — ; elle maximise la compatibilité avec les systèmes de bases de données SQL hérités.
Une instruction SELECT composée est constituée à partir 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. Il ne peut y avoir qu'une seule clause ORDER BY après instruction SELECT finale (et avant la seule clause LIMIT, lorsqu'une telle clause 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. La différence est que, dans l'opérateur UNION, toutes les lignes résultantes sont distinctes, alors que dans l'opérateur UNION ALL, elles peuvent être en double. L'opérateur INTERSECT prend l'intersection des résultats des instructions SELECT précédente et suivante. 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 davantage sont connectées dans une instruction composée, elles sont groupées de la première à la dernière.
Pour une définition des expressions autorisées, voir Expressions.
L'instruction INSERT existe en deux formes de base et est utilisée pour remplir des tables avec des données.
La première forme (avec le mot-clé VALUES) crée une unique nouvelle ligne dans une table existante. Lorsque aucune liste column-list n'est spécifiée, le nombre de valeurs doit correspondre au nombre de colonnes de la table. Si une liste column-list est spécifiée, le nombre de valeurs doit correspondre au nombre de colonnes spécifiées. 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 lorsque aucune valeur par défaut n'est définie.
La seconde forme de l'instruction INSERT prend 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 lorsque aucune liste column-list n'est spécifiée, où doit correspondre au nombre de colonnes nommées dans la liste 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 une 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 description et une définition des algorithmes de conflit, voir ON CONFLICT (algorithmes de conflit).
Les deux formes REPLACE INTO de l'instruction reviennent à utiliser la forme INSERT [OR conflict-algorithm] avec l'algorithme de conflit REPLACE (c'est-à-dire avec la forme INSERT OR REPLACE...).
L'instruction UPDATE est utilisée pour modifier la valeur des colonnes dans un ensemble de lignes d'une table.
Chaque affectation d'une instruction UPDATE spécifie un nom de colonne à gauche du signe égal et une expression arbitraire à droite. L'expression peut utiliser les valeurs d'autres colonnes. Toutes les expressions sont évaluées avant les affectations. Pour une définition des expressions autorisées, voir Expressions.
La clause WHERE est utilisée pour limiter les lignes mises à jour. L'expression de la clause WHERE doit donner une valeur booléenne.
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 description et une définition des algorithmes de conflit, voir ON CONFLICT (algorithmes de conflit).
La commande delete permet de supprimer des enregistrements dans une table.
La commande se compose des mots-clés DELETE FROM, suivis du nom de la table dans laquelle les enregistrements doivent être supprimés.
Sans clause WHERE, toutes les lignes de la table sont supprimées. Lorsqu'une clause WHERE est fournie, seules les lignes qui correspondent à l'expression sont supprimées. L'expression de la clause WHERE doit donner une valeur booléenne. Pour une définition des expressions autorisées, voir Expressions.
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 :
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 définitions des colonnes et des contraintes. Le nom de la table peut être un identifiant ou une chaîne.
Chaque définition de colonne est composée du nom de la colonne, suivi de son type de données, puis d'une ou plusieurs contraintes de colonne facultatives. Le type de données de la colonne limite les données pouvant y être stockées. Si une tentative de stockage d'une valeur dans une colonne est effectuée avec un type de données différent, le moteur d'exécution convertit la valeur dans le type approprié si possible, ou renvoie une erreur. Consultez la section Prise en charge des types de données pour plus d'informations.
La contrainte de colonne NOT NULL indique que la colonne ne peut pas contenir de valeurs NULL.
Une contrainte UNIQUE entraîne la création d'un index sur la ou 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 la ou les colonnes spécifiées. Une instruction CREATE TABLE peut avoir plusieurs contraintes UNIQUE, y compris plusieurs colonnes avec 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 de texte à utiliser pour comparer les entrées de texte de la colonne. La fonction de classement BINARY est utilisée par défaut. Pour plus d'informations sur la clause COLLATE et sur les fonctions de classement, voir COLLATE.
La contrainte DEFAULT définit une valeur par défaut à utiliser lors d'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. Pour CURRENT_TIME, le format est HH:MM:SS. Pour CURRENT_DATE, le format est YYYY-MM-DD. Le format de CURRENT_TIMESTAMP est YYYY-MM-DD HH:MM:SS.
Le fait de spécifier une PRIMARY KEY crée habituellement un simple index UNIQUE sur la ou les colonnes correspondantes. Toutefois, si la contrainte PRIMARY KEY s'applique à une seule colonne dont le type de données est INTEGER, cette colonne est alors utilisée en interne en tant que clé primaire réelle de la table. Cela signifie que la colonne peut ne contenir que des valeurs de type entier uniques. Si la table n'a pas de colonne INTEGER PRIMARY KEY, une clé de type entier est automatiquement générée à chaque insertion d'une ligne. 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'ils soient ou non une INTEGER PRIMARY KEY déclarée de façon explicite ou une valeur générée en interne. Une colonne INTEGER PRIMARY KEY peut également inclure le mot-clé AUTOINCREMENT. Lorsque 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'une instruction INSERT est exécutée.
Il ne peut y avoir qu'une seule contrainte PRIMARY KEY dans une instruction CREATE TABLE. Elle peut faire partie de la définition d'une colonne ou d'une seule contrainte PRIMARY KEY au niveau de la table. Une colonne de clé primaire est implicitement NOT NULL.
Le paramètre conflict-clause facultatif suivant 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 avoir différents algorithmes de résolution de conflits par défaut. Si une instruction INSERT ou UPDATE spécifie un algorithme de résolution de conflits différent, celui-ci est utilisé à la place de l'algorithme spécifié dans l'instruction CREATE TABLE. Pour plus d'informations, consultez la section ON CONFLICT (algorithmes de conflits).
D'autres contraintes, comme 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 intervient entre CREATE et TABLE, la table créée n'est alors visible que dans la même connexion de base de données (occurrence SQLConnection). Elle est automatiquement supprimée lors de la fermeture de la connexion de base de données. Tous les index créés sur une table temporaire sont également temporaires. Les tables et les index temporaires sont stockés dans un fichier distinct, autre que le 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 (connectée à l'occurrence SQLConnection par l'appel à 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. Lorsque 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 (connectée à l'occurrence SQLConnection par la méthode open() ou openAsync()).
Il n'y a pas de limite arbitraire quant au nombre de colonnes ou de contraintes présentes dans une table. Il n'y a pas non plus de limite arbitraire quant à la quantité de données présente dans une ligne.
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 les mêmes dans le 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.
La commande ALTER TABLE permet à l'utilisateur de renommer une table existante ou de lui ajouter une nouvelle colonne. Il n'est pas possible de supprimer une colonne dans une table.
La syntaxe RENAME TO est utilisée pour 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 associées, mais uniquement de renommer une table dans la même base de données.
Si la table renommée a des déclencheurs ou des index, ils restent attachés à 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 à cette table renommée, elles ne sont pas modifiées automatiquement pour utiliser le nouveau nom de la table. Si une table renommée a des vues ou des déclencheurs associés, vous devez les supprimer manuellement et recréer des déclencheurs ou les définitions de vue en utilisant le nouveau nom de la table.
La syntaxe ADD [COLUMN] permet d'ajouter une nouvelle colonne à une table existante. La nouvelle colonne est toujours ajoutée à la fin de la liste des colonnes existantes. La clause column-def peut prendre toutes les formes autorisées dans une instruction CREATE TABLE, avec les limites suivantes :
PRIMARY KEY ou UNIQUE.CURRENT_TIME, CURRENT_DATE ou CURRENT_TIMESTAMP.NOT NULL est spécifiée, la colonne doit avoir 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 de la table.
L'instruction DROP TABLE supprime une table ajoutée avec l'instruction CREATE TABLE. La table avec le table-name spécifié est la table qui est abandonnée. Elle est entièrement supprimée de la base de données et du fichier sur disque. La table ne peut pas être récupérée. Tous les index associés à cette table sont également supprimés.
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 prochaines opérations INSERT. Pour supprimer l'espace libre dans la base de données, utilisez la méthode SQLConnection.clean(). Si, lors de la création initiale de la base de données, le paramètre autoClean est défini sur true, l'espace est libéré automatiquement.
La clause IF EXISTS facultative supprime l'erreur qui se produit normalement si la table n'existe pas.
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 et devant être indexée et d'une liste entre parenthèses des noms de colonnes de la table dont les valeurs sont utilisées pour la clé d'index.
Chaque nom de colonne peut être suivi des mots-clés ASC ou DESC pour indiquer l'ordre de tri, mais cette désignation est ignorée par le moteur d'exécution. Le tri est toujours effectué par ordre croissant.
La clause COLLATE, qui suit chaque nom de colonne, définit une séquence de classement utilisée pour les valeurs de texte de cette colonne. La séquence de classement par défaut est celle qui 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 une définition de la clause COLLATE et des fonctions de classement, voir COLLATE.
Il n'y a pas de limite arbitraire quant au nombre d'index pouvant être attachés à une même table. Il n'y a pas non plus de limite arbitraire quant au nombre de colonnes présentes dans un index.
L'instruction DROP INDEX supprime un index ajouté par l'instruction CREATE INDEX. L'index spécifié est entièrement supprimé du fichier de base de données. La seule manière de le récupérer consiste à entrer de nouveau la commande CREATE INDEX appropriée.
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 prochaines opérations INSERT. Pour supprimer l'espace libre dans la base de données, utilisez la méthode SQLConnection.clean(). Si, lors de la création initiale de la base de données, le paramètre autoClean est défini sur true, l'espace est libéré automatiquement.
La commande CREATE VIEW affecte un nom à une instruction SELECT prédéfinie. Ce nouveau nom peut être utilisé dans une clause FROM d'une autre instruction SELECT, à la place d'un nom de table. Les vues sont généralement utilisées pour 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.
Si le mot-clé TEMP ou TEMPORARY intervient entre CREATE et VIEW, la vue créée n'est alors visible que pour l'occurrence SQLConnection qui a ouvert la base de données et est automatiquement supprimée lors de la fermeture de la base de données.
Si un préfixe [database-name] est spécifié, la table est créée dans la base de données nommée (connectée à l'occurrence SQLConnection par l'appel à la méthode attach() avec l'argument name 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. Lorsque 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 (connectée à l'occurrence SQLConnection par la méthode open() ou openAsync()).
Les vues sont en lecture seule. Une instruction DELETE, INSERT ou UPDATE ne peut pas être utilisée sur une vue, sauf si au moins un déclencheur 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 pour une vue, voir CREATE TRIGGER.
Une vue est supprimée dans une base de données à l'aide de l'instruction DROP VIEW.
L'instruction DROP VIEW supprime une vue créée par une instruction CREATE VIEW.
Le paramètre view-name est le nom de la vue à supprimer. Celle-ci est supprimée de la base de données, mais les données des tables sous-jacentes ne sont pas modifiées.
L'instruction CREATE TRIGGER est utilisée pour 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.
Un déclencheur est défini pour se déclencher chaque fois qu'une instruction DELETE, INSERT ou UPDATE se produit sur une table de base de données particulière, ou chaque fois qu'une instruction UPDATE d'une ou plusieurs colonnes spécifiées d'une table sont mises à jour. Les déclencheurs sont permanents, sauf si le mot-clé TEMP ou TEMPORARY est utilisé. Dans ce cas, le déclencheur est supprimé lors de la fermeture de la connexion de base de données principale à l'occurrence SQLConnection. Lorsque aucun repère temporel n'est spécifié (BEFORE ou AFTER), le déclencheur est défini par défaut sur BEFORE.
Seuls les déclencheurs FOR EACH ROW sont pris en charge, donc 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 entraînant l'action du déclencheur, si l'expression de la clause WHEN est true.
Si une clause WHEN est fournie, 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. Lorsque aucune clause WHEN n'est fournie, 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 le déclencheur est créé. La table OLD contient les lignes modifiées ou supprimées par l'instruction de déclenchement, dans l'état où elles étaient avant les opérations. La table NEW contient les lignes modifiées ou créées par l'instruction de déclenchement, dans leur état après les opérations. 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 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 dépend du type de database-event géré par le déclencheur :
INSERT – références NEW validesUPDATE – références NEW et OLD validesDELETE – références OLD validesLe 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 d'une instruction responsable de la mise en marche du déclencheur, cette règle de gestion des conflits est utilisée à la place.
Outre les déclencheurs de table, un déclencheur INSTEAD OF peut être créé sur une vue. Si un ou plusieurs déclencheurs INSTEAD OF INSERT, INSTEAD OF DELETE ou INSTEAD OF UPDATE sont définis sur une vue, il n'est pas considéré comme une erreur d'exécuter le type associé d'instruction (INSERT, DELETE ou UPDATE) sur la vue. Dans ce cas, l'exécution d'une instruction INSERT, DELETE ou UPDATE sur la vue entraîne l'action des déclencheurs associés. Comme il s'agit d'un déclencheur INSTEAD OF, les tables sous-jacentes à la vue ne sont pas modifiées par l'instruction qui entraîne l'action du déclencheur. Les déclencheurs peuvent cependant être utilisés pour exécuter des opérations de modification sur les tables sous-jacentes.
Lors de la création d'un déclencheur sur une table avec 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 à l'origine de l'action du déclencheur, la mise à jour n'a pas lieu. Pour contourner le problème, il est possible de créer la table avec une colonne PRIMARY KEY plutôt qu'avec une colonne INTEGER PRIMARY KEY.
Un déclencheur peut être supprimé à l'aide de l'instruction DROP TRIGGER. Lorsqu'une table ou une vue est supprimée, tous les déclencheurs qui leur sont associés le sont également automatiquement.
Une fonction SQL spéciale RAISE() peut être utilisée dans une instruction trigger-step d'un déclencheur. La syntaxe de cette fonction est la suivante :
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 SQLStatement dont la méthode execute() était exécutée distribue un événement error (SQLErrorEvent.ERROR). L'objet SQLError dans la propriété error de l'objet événement distribué voit sa propriété details définie sur le error-message de la fonction RAISE().
Lorsque l'instruction RAISE(IGNORE) est appelée, le reste du déclencheur en cours, l'instruction à l'origine de l'exécution du déclencheur et tous les déclencheurs suivants qui auraient dû être exécutés, sont abandonnés. Les modifications apportées à la base de données ne sont pas annulées. Si l'instruction à l'origine de l'exécution du déclencheur fait elle-même partie d'un déclencheur, ce programme du déclencheur reprend son exécution au début de l'étape suivante. Pour plus d'informations sur les algorithmes de résolution de conflits, consultez la section ON CONFLICT (algorithmes de conflits).
L'instruction DROP TRIGGER supprime un déclencheur créé par l'instruction CREATE TRIGGER.
Le déclencheur est supprimé de la base de données. Notez que les déclencheurs sont automatiquement supprimés lorsque leur table associée est supprimée.
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. Les éléments de cette section sont :
La clause COLLATE est utilisée dans les instructions SELECT, CREATE TABLE et CREATE INDEX pour définir l'algorithme de comparaison utilisé pour comparer et trier des valeurs.
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 respect de 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 est utilisée pour déterminer les résultats de la comparaison, selon les règles suivantes :
=, <, >, <= et >=), si l'opérande 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 aucune des opérandes n'est une colonne, la séquence de classement BINARY est utilisée.BETWEEN...AND revient à utiliser deux expressions avec les opérateurs >= et <=. Par exemple, l'expression x BETWEEN y AND z équivaut à 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.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 x IN (y, z) est le type de classement par défaut de x si x est une colonne. Sinon, le classement BINARY est utilisé.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. Autrement, si 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.Le modificateur de commande EXPLAIN est une extension non standard de SQL.
Si le mot-clé EXPLAIN apparaît avant une autre instruction SQL, au lieu d'exécuter la commande, le résultat rapporte la séquence des instructions d'un ordinateur virtuel qu'il aurait utilisé pour exécuter la commande si le mot-clé EXPLAIN n'avait pas été présent. La fonctionnalité 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.
La clause ON CONFLICT n'est pas une commande SQL distincte. Il s'agit d'une clause non standard qui peut apparaître dans de nombreuses autres commandes SQL.
La première forme de la clause ON CONFLICT, avec des mots-clés ON CONFLICT, est utilisée dans 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. Par exemple, au lieu de 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 la même pour les deux formes.
La clause ON CONFLICT définit l'algorithme utilisé pour résoudre les conflits de contraintes. Les cinq algorithmes sont ROLLBACK, ABORT, FAIL, IGNORE et REPLACE. L'algorithme par défaut est ABORT. Les cinq algorithmes de conflits sont décrits ci-après :
ROLLBACK survient immédiatement et met fin à la transaction en cours. La commande est annulée et l'occurrence SQLStatement distribue un événement error. Si aucune transaction n'est active (autre que la transaction implicite créée sur chaque commande), cet algorithme fonctionne de la même façon que ABORT.error. Aucun algorithme ROLLBACK n'étant exécuté, les modifications apportées par les commandes précédentes dans une transaction sont donc préservées. ABORT est le comportement par défaut.error. Toutefois, toutes les modifications apportées à la base de données par l'instruction avant la violation de contrainte sont préservé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 préservées, mais la ligne 100 et les suivantes ne sont pas modifiées.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 pour cette 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é.
La commande REINDEX est utilisée pour supprimer et recréer un ou plusieurs index. Cette commande s'avère très utile lorsque la définition d'une séquence de classement a été modifiée.
Dans la première forme, tous les index de toutes les bases de données attachées qui utilisent la séquence de classement nommée sont recréés. Dans la seconde forme, lorsqu'un table-name est spécifié, tous les index associés à la table sont reconstruits. Si un index-name est fourni, seul l'index spécifié est supprimé et recréé.
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 commencer chaque fois qu'un espace blanc est détecté, y compris à l'intérieur d'expressions réparties sur plusieurs lignes.
Un commentaire d'une seule ligne est indiqué par deux tirets. Un commentaire d'une seule ligne peut aller jusqu'à la fin de la ligne en cours.
Les blocs de commentaires peuvent s'étendre sur un certain nombre de lignes ou être intégrés dans une seule ligne. En l'absence de délimiteur de terminaison, un bloc de commentaires va jusqu'à la fin de l'entrée. Cette situation n'est pas traitée comme une erreur. Une nouvelle instruction SQL peut commencer sur une ligne après la fin d'un bloc de commentaires. Les blocs de commentaires peuvent être intégrés chaque fois qu'un espace blanc survient, 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.
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 :
Une expression est toute combinaison de valeurs et d'opérateurs pouvant être résolue en tant que valeur unique. Les expressions peuvent être divisées en deux types généraux, selon si 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'expression suivants répondent à cette condition :
ISNULLNOTNULLIN ()EXISTS ()LIKEGLOBUne 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) est toujours utilisé comme 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, placez deux guillemets droits simples dans une ligne, comme dans cet exemple : ''.
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 BLOB littéral est une chaîne littérale contenant des données hexadécimales et suivie d'un seul caractère x ou X, tel que X'53514697465'.
Une valeur littérale peut également être un symbole NULL.
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 être utilisée chaque fois qu'une colonne ordinaire peut l'être, mais vous ne pouvez pas en modifier la valeur dans une instruction UPDATE ou INSERT. L'instruction SELECT * FROM table n'inclut pas la clé de la ligne dans son jeu de résultats.
Une instruction SELECT peut apparaître dans une expression comme opérande de partie droite de l'opérateur IN, comme quantité scalaire (seule valeur de résultat) 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 avoir qu'une seule colonne. Une instruction SELECT composée (connectée avec des mots-clés tels que 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 s'il existe une ou plusieurs lignes et FALSE si le jeu de résultats est vide. Lorsque aucun terme de l'expression SELECT ne fait référence à la valeur dans la requête conteneur, l'expression est évaluée avant tout autre traitement et le résultat est réutilisé selon les besoins. Si l'expression SELECT contient des variables provenant de la requête externe, appelée sous-requête corrélée, l'instruction SELECT est réévaluée chaque fois que nécessaire.
Lorsque SELECT est l'opérande de partie droite de l'opérateur IN, l'opérateur IN renvoie TRUE si le résultat de l'opérande de partie 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 de partie droite 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, toutes les lignes suivant la première sont ignorées. Si l'instruction SELECT ne produit aucune ligne, la valeur de SELECT est NULL.
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 l'un des noms de type non vide valides pour ce type dans une définition de colonne d'une instruction CREATE TABLE. Consultez la section Prise en charge des types de données pour plus d'informations.
Les sections suivantes décrivent d'autres éléments SQL utilisables dans des expressions :
Les fonctions intégrées se répartissent en trois catégories principales :
Outre ces fonctions, la fonction spéciale RAISE() est utilisée pour notifier une erreur dans 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 SQL, les noms de fonctions ne sont pas sensibles à la casse.
Les fonctions d'agrégation exécutent des opérations sur des valeurs provenant de plusieurs lignes. Ces fonctions sont essentiellement utilisées dans des instructions SELECT en combinaison avec la clause GROUP BY.
AVG(X) |
Renvoie la valeur moyenne de tous les X non NULL d'un groupe. Les chaînes et les valeurs BLOB qui ne ressemblent pas à des nombres sont interprétées comme des 0. Le résultat de AVG() est toujours une valeur à virgule flottante, même lorsque toutes les entrées sont des nombres entiers. |
|
La première forme renvoie le nombre de fois où X n'est pas NULL dans un groupe. La seconde forme (avec l'argument *) renvoie le nombre total de lignes dans le groupe. |
MAX(X) |
Renvoie la valeur maximale de toutes les valeurs du groupe. Pour déterminer ce maximum, l'ordre de tri habituel est utilisé. |
MIN(X) |
Renvoie la valeur minimale non NULL de toutes les valeurs du groupe. Pour déterminer ce minimum, l'ordre de tri habituel est utilisé. Si toutes les valeurs du groupe sont NULL, NULL est renvoyé. |
|
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. Le résultat de SUM() est 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. |
Si l'une des fonctions d'agrégation précédentes prend un seul argument, cet argument 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 à la fonction COUNT(DISTINCT x) renvoie le nombre de valeurs distinctes de la colonne X au lieu du nombre total de valeurs non NULL présentes dans la colonne x.
Les fonctions scalaires opèrent sur les valeurs d'une ligne à la fois. Voici la liste de ces fonctions :
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é. Il doit y avoir au moins deux arguments. |
GLOB(X, Y) |
Cette fonction est utilisée pour implémenter 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 du 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 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 est utilisée pour implémenter la syntaxe X LIKE Y [ESCAPE Z] de SQL. Si la clause facultative ESCAPE est présente, la fonction est invoquée avec trois arguments. Autrement, elle n'est invoquée qu'avec deux arguments. |
LOWER(X) |
Renvoie une copie de la chaîne X avec tous les caractères convertis en minuscules. |
|
Renvoie une chaîne formée par 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 depuis le côté gauche de X. |
MAX(X, Y, ...) |
Renvoie l'argument avec la valeur maximale. En plus des nombres, les arguments peuvent être des chaînes. La valeur maximale est déterminée par l'ordre de tri défini. Notez queMAX() est une fonction simple lorsqu'elle a plusieurs arguments, mais est une fonction d'agrégation lorsqu'elle n'en a qu'un. |
MIN(X, Y, ...) |
Renvoie l'argument avec la valeur minimale. En plus des nombres, les arguments peuvent être des chaînes. La valeur minimale est déterminée par l'ordre de tri défini. Notez queMIN() est une fonction simple lorsqu'elle a plusieurs arguments, mais est une fonction d'agrégation lorsqu'elle n'en a qu'un. |
NULLIF(X, Y) |
Renvoie le premier argument si les arguments diffèrent, sinon renvoie NULL. |
QUOTE(X) |
Cette routine renvoie une chaîne correspondant à la valeur de son 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écessaires. 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 crypté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 cryptée en dur. Si la valeur de N est négative, un seul octet est renvoyé. |
|
Arrondi le nombre X à Y chiffres après la virgule. Si l'argument Y est omis, 0 est utilisé. |
|
Renvoie une chaîne formée par 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 depuis le côté droit de X. |
SUBSTR(X, Y, Z) |
Renvoie une sous-chaîne de chaîne d'entrée X commençant par le Y-è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. |
|
Renvoie une chaîne formée par la suppression des espaces des côtés gauche et droit de X. Si un argument Y est spécifié, la fonction supprime tous les caractères de Y des côtés gauche et droit de X. |
TYPEOF(X) |
Renvoie le type de l'expression X. Les valeurs pouvant être renvoyées sont 'null', 'integer', 'real', 'text' et 'blob'. Pour plus d'informations sur les types de données, consultez la section Prise en charge des types de données. |
UPPER(X) |
Renvoie une copie de la chaîne d'entrée X convertie en lettres majuscules. |
ZEROBLOB(N) |
Envoie un BLOB contenant N octets de 0x00. |
Les fonctions de mise en forme de la date et de l'heure sont un groupe de fonctions scalaires utilisées pour créer des données de date et d'heure formatées. Notez que ces fonctions opèrent sur et renvoient des valeurs de chaîne et de nombre. Ces fonctions ne sont pas destinées à ê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, elles ne se comportent pas comme prévu.
DATE(T, ...) |
La fonction DATE() renvoie une chaîne contenant la date au format : YYYY-MM-DD. Le premier paramètre (T) spécifie une chaîne de temps au format trouvé sous Formats de l'heure. Autant de modificateurs que nécessaire peuvent être spécifiés après la chaîne d'heure. Les modificateurs sont disponibles sous Modificateurs. |
||||||||||||||||||||||||||
TIME(T, ...) |
La fonction TIME() renvoie une chaîne contenant l'heure au format HH:MM:SS. Le premier paramètre (T) spécifie une chaîne de temps au format trouvé sous Formats de l'heure. Autant de modificateurs que nécessaire peuvent être spécifiés après la chaîne d'heure. Les modificateurs sont disponibles sous 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 de temps au format trouvé sous Formats de l'heure. Autant de modificateurs que nécessaire peuvent être spécifiés après la chaîne d'heure. Les modificateurs sont disponibles sous Modificateurs. |
||||||||||||||||||||||||||
| JULIANDAY(T, ...) | La fonction JULIANDAY() renvoie un nombre indiquant le nombre de jours écoulés depuis midi heure de Greenwich le 24 novembre 4714 av. J.-C. et la date fournie. Le premier paramètre (T) spécifie une chaîne de temps au format trouvé sous Formats de l'heure. Autant de modificateurs que nécessaire peuvent être spécifiés après la chaîne d'heure. Les modificateurs sont disponibles sous Modificateurs. |
||||||||||||||||||||||||||
| STRFTIME(F, T, ...) | La routine STRFTIME() renvoie la date mise en forme 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 :
Le second paramètre ( T) spécifie une chaîne de temps au format détecté sous Formats de l'heure. Autant de modificateurs que nécessaire peuvent être spécifiés après la chaîne d'heure. Les modificateurs sont disponibles sous Modificateurs. |
Une chaîne d'heure peut prendre l'un des formats suivants :
| YYYY-MM-DD | 2007-06-15 |
| YYYY-MM-DD HH:MM | 2007-06-15 07:30 |
| YYYY-MM-DD HH:MM:SS | 2007-06-15 07:30:59 |
| YYYY-MM-DD HH:MM:SS.SSS | 2007-06-15 07:30:59.152 |
| YYYY-MM-DDTHH:MM | 2007-06-15T07:30 |
| YYYY-MM-DDTHH:MM:SS | 2007-06-15T07:30:59 |
| YYYY-MM-DDTHH:MM:SS.SSS | 2007-06-15T07:30:59.152 |
| HH:MM | 07:30 (date 01-01-2000) |
| HH:MM:SS | 07:30:59 (date 01-01-2000) |
| HH:MM:SS.SSS | 07:30:59:152 (date 01-01-2000) |
| now | Date et heure en temps UTC (temps universel coordonné). |
| DDDD.DDDD | Nombre de jours Julien sous forme de nombre à virgule flottante |
Le caractère T de ces formats est un caractère littéral « T » séparant la date et l'heure. Les formats qui ne comprennent que l'heure suggèrent que la date est le 01-01-2001.
La chaîne d'heure peut être suivie d'aucun ou de plusieurs modificateurs qui modifient la date ou en altèrent 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 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 du jour. |
| weekday N | Renvoie l'heure au jour de la semaine spécifié. (0 = Dimanche, 1 = Lundi, etc.) |
| localtime | Convertit la date en temps local. |
| utc | Convertit la date en temps UTC. |
SQL prend en charge un grand nombre d'opérateurs, dont les opérateurs courants existant dans la plupart des langages de programmation, ainsi que plusieurs opérateurs spécifiques à SQL.
Les opérateurs binaires suivants sont autorisés dans un bloc SQL et sont énumérés par ordre de priorité, de la plus élevée à la plus faible :
Les opérateurs de préfixe unaires pris en charge sont :
L'opérateur COLLATE peut être considéré comme un opérateur de suffixe unaire. L'opérateur COLLATE a la priorité la plus élevée. Il relie toujours plus étroitement que tout opérateur de préfixe unaire ou que tout 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 deux chaînes de ses opérandes.
L'opérateur % a pour résultat le reste de son opérande de partie gauche modulo son opérande de partie droite.
Le résultat de tout opérateur binaire est une valeur numérique, sauf pour l'opérateur de concaténation || dont le résultat est une chaîne.
L'opérateur LIKE effectue une comparaison de correspondance avec un modèle.
L'opérande situé à droite de l'opérateur LIKE contient le modèle, et l'opérande de partie 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 suite de zéros ou à plusieurs caractères de la chaîne. Un caractère de soulignement (_) présent dans le modèle correspond à tout caractère unique dans la chaîne. Tous les autres caractères se correspondent à eux-mêmes ou à leur équivalent majuscule/minuscule. En d'autres termes, la correspondance ne respecte pas la casse. (Remarque : le moteur de base de données ne comprend que la casse majuscule/minuscule dans le cas des caractères latins 7 bits. Par conséquent, l'opérateur LIKE respecte la casse pour les caractères 8 bits iso8859 ou UTF-8. Par exemple, l'expression 'a' LIKE 'A' est TRUE mais 'æ' LIKE 'Æ' est FALSE). Le respect de la casse pour les caractères latins peut être modifié avec la propriété SQLConnection.caseSensitiveLike.
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 signe de pourcentage, d'un soulignement ou de lui-même correspond à un symbole littéral de pourcentage, de soulignement ou d'échappement dans la chaîne, respectivement.
L'opérateur GLOB est similaire à LIKE mais utilise la syntaxe globbing de fichier Unix pour ses caractères génériques. Contrairement à LIKE, GLOB respecte la casse.
L'opérateur IN calcule si son opérande de partie gauche est égale à l'une des valeurs de son opérande de partie droite (ensemble de valeurs entre parenthèses).
L'opérande de partie droite peut être un ensemble de valeurs littérales séparées par des virgules ou le résultat d'une instruction SELECT. Reportez-vous aux instructions SELECT dans les expressions pour obtenir une description et pour connaître les limites de l'utilisation d'une instruction SELECT en tant qu'opérande de partie droite de l'opérateur IN.
L'opérateur BETWEEN...AND revient à utiliser deux expressions avec les opérateurs >= et <=. Par exemple, l'expression x BETWEEN y AND z équivaut à x >= y AND x <= z.
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é).
Un paramètre spécifie dans l'expression un espace réservé pour une valeur littérale renseignée au moment de l'exécution par l'affectation d'une valeur au tableau associatif SQLStatement.parameters. Les paramètres peuvent prendre trois formes :
? |
Un point d'interrogation indique un paramètre indexé. Des valeurs d'index numériques (basées sur 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 pour un paramètre nommé portant le nom AAAA. Les paramètres nommés sont également numérotés en fonction de leur ordre d'apparition dans l'instruction SQL. Pour prévenir toute confusion, il est préférable d'éviter de combiner des paramètres numérotés et nommés. |
@AAAA |
Le "signe at" équivaut au caractère deux-points. |
Voici la liste des éléments SQL standard non pris en charge dans Adobe AIR :
FOREIGN KEY sont analysées mais ne sont pas imposées.FOR EACH STATEMENT ne sont pas pris en charge (tous les déclencheurs doivent être FOR EACH ROW). Les déclencheurs INSTEAD OF ne sont pas pris en charge sur les tables (les déclencheurs INSTEAD OF ne sont autorisés que sur les vues). Les déclencheurs récursifs — déclencheurs qui s'actionnent eux-mêmes — ne sont pas pris en charge.RENAME TABLE et ADD COLUMN de la commande ALTER TABLE sont prises en charge. Les autres types d'opérations ALTER TABLE telles que DROP COLUMN, ALTER COLUMN, ADD CONSTRAINT, etc., sont ignorés.RIGHT OUTER JOIN et FULL OUTER JOIN ne sont pas pris en charge.DELETE, INSERT ou UPDATE sur une vue. Un déclencheur INSTEAD OF qui s'actionne lors d'une tentative d'instruction DELETE, INSERT ou UPDATE sur une vue est pris en charge et peut être utilisé pour actualiser les tables de soutien dans le corps du déclencheur.GRANT et REVOKE fréquemment détectées sur les systèmes SGBDR clients/serveur ne sont pas implémentées.Les éléments SQL suivants et les fonctionnalités SQLite 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 l'intermédiaire des méthodes de la classe SQLConnection :
BEGIN, END, COMMIT, ROLLBACK) : cette fonctionnalité est disponible par l'intermédiaire des méthodes liées aux transactions de la classe SQLConnection : SQLConnection.begin(), SQLConnection.commit() et SQLConnection.rollback().ANALYZE: cette fonctionnalité est disponible par l'intermédiaire de la méthode SQLConnection.analyze().ATTACH: cette fonctionnalité est disponible par l'intermédiaire 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 l'intermédiaire de la méthode SQLConnection.detach().PRAGMA: cette instruction n'est pas prise en charge.VACUUM: cette fonctionnalité est disponible par l'intermédiaire de la méthode SQLConnection.compact().SQLConnection.loadSchema().SQLITE_VERSION() : la fonction sqlite_version() n'est pas disponible dans les instructions SQL.MATCH() et REGEX()) : ces fonctions ne sont pas disponibles dans les instructions SQL.La fonctionnalité suivante diffère entre les nombreuses implémentations SQLite et Adobe AIR :
Les types d'affinité de colonne suivants ne sont pas pris en charge par défaut dans SQLite, mais le sont dans Adobe AIR :
Les valeurs littérales suivantes ne sont pas prises en charge par défaut dans SQLite, mais le sont dans Adobe AIR :
true, avec les colonnes BOOLEAN.false, avec les colonnes BOOLEAN.Contrairement à la plupart des bases de données SQL, le moteur de base de données SQL d'Adobe AIR n'a pas besoin ou n'impose pas que les colonnes des tables contiennent des valeurs d'un certain type. Le moteur d'exécution utilise à la place deux concepts, les classes de stockage et l'affinité des colonnes, pour contrôler les types de données. Cette section décrit les classes de stockage et l'affinité des colonnes, ainsi que la résolution des différences de types de données selon les cas :
Les classes de stockage représentent les types de données réels utilisés pour stocker des valeurs dans une base de données. Les classes de stockage suivantes sont disponibles :
NULL.Toutes les valeurs, fournies à la base de données sous forme de valeurs littérales intégrées dans une instruction SQL ou de valeurs liées à l'aide de paramètres à une instruction SQL préparée, se voient affecter une classe de stockage avant l'exécution de l'instruction SQL.
Les valeurs littérales qui font partie d'une instruction SQL se voient affecter la classe de stockage TEXT si elles sont placées entre guillemets simples ou doubles, INTEGER si la valeur littérale est spécifiée en tant que nombre sans guillemet et sans décimale ou exposant, REAL si la valeur littérale est spécifiée en tant que nombre sans guillemet avec décimale ou exposant et NULL si la valeur est NULL. Les valeurs littérales avec classe de stockage BLOB sont spécifiées par la notation X'ABCD'. Pour plus d'informations, consultez la section Valeurs littérales dans les expressions.
Les valeurs fournies en tant que paramètres via le tableau associatif SQLStatement.parameters se voient affecter la classe de stockage la plus proche de la liaison native du type de données. Par exemple, les valeurs int sont liées en tant que classe de stockage INTEGER, les valeurs Number obtiennent la classe de stockage REAL, les valeurs String obtiennent la classe de stockage TEXT et les objets ByteArray obtiennent la classe de stockage BLOB.
L' affinité d'une colonne est le type recommandé pour les données stockées dans cette colonne. Lorsqu'une valeur est stockée dans une colonne (par une instruction INSERT ou UPDATE), le moteur d'exécution tente de convertir le type de données de cette valeur en l'affinité spécifiée. Par exemple, si une valeur Date (occurrence Date ActionScript ou JavaScript) est insérée dans une colonne dont l'affinité est TEXT, elle est convertie en représentation String (ce qui équivaut à appeler la méthode toString() de l'objet) avant d'être stockée dans la base de données. Si la valeur ne peut pas être convertie en l'affinité spécifiée, une erreur survient et l'opération n'est pas exécutée. Lorsqu'une valeur est récupérée dans la base de données par une instruction SELECT, elle est renvoyée sous forme d'occurrence de la classe correspondant à l'affinité, qu'elle ait ou non été convertie à partir d'un type de données différents lors de son stockage.
Si une colonne accepte des valeurs NULL, la valeur ActionScript ou JavaScript null peut être utilisée en tant que valeur de paramètre pour stocker NULL dans la colonne. Lorsqu'une valeur de classe de stockage NULL est récupérée dans une instruction SELECT, elle est toujours renvoyée en tant que valeur ActionScript ou JavaScript null, quelle que soit l'affinité de la colonne. Lorsqu'une colonne accepte les valeurs NULL, vérifiez toujours les valeurs récupérées dans cette colonne pour déterminer si elles sont null avant de tenter d'attribuer aux valeurs un type qui ne peut pas être null (par exemple Number ou Boolean).
L'une des affinités de type suivantes est affectée à chaque colonne de la base de données :
Une colonne d'affinité TEXT ou STRING stocke toutes les données à l'aide des classes de stockage NULL, TEXT ou BLOB. Si des données numériques sont insérées dans une colonne dont l'affinité est TEXT, elles sont converties au format texte avant d'être stockées.
Une colonne d'affinité NUMERIC contient des valeurs à l'aide des classes de stockage NULL, REAL ou INTEGER. Lorsque des données texte sont insérées dans une colonne NUMERIC, le système tente de les convertir en nombres entiers ou réels avant de les stocker. Si la conversion est réussie, la valeur est stockée à l'aide de la classe de stockage INTEGER ou REAL (par exemple, une valeur de '10.05' est convertie dans la classe de stockage REAL avant d'être stockée). Si la conversion est impossible, une erreur survient. Il n'y a pas de tentative de conversion en valeur NULL. Une valeur récupérée dans une colonne NUMERIC est renvoyée sous forme d'occurrence du type numérique le plus adapté à la valeur. En d'autres termes, si la valeur est un nombre entier positif ou 0, elle est renvoyée sous forme d'occurrence uint. S'il s'agit d'un nombre entier négatif, elle est renvoyée sous forme d'occurrence int. Enfin, s'il s'agit d'un composant à virgule flottante (ce n'est pas un nombre entier), elle est renvoyée sous forme d'occurrence Number.
Une colonne qui utilise l'affinité INTEGER se comporte de la même façon qu'une colonne dont l'affinité est NUMERIC, à une exception près. Si la valeur à stocker est une valeur réelle (par exemple une occurrence Number) sans composant à virgule flottante, ou si la valeur est une valeur de texte pouvant être convertie en valeur réelle sans composant à virgule flottante, elle est convertie en nombre entier et stockée avec la classe de stockage INTEGER. En cas de tentative de stockage d'une valeur réelle avec composant à virgule flottante, une erreur se produit.
Une colonne dont l'affinité est REAL ou NUMBER se comporte comme une colonne d'affinité NUMERIC, sauf qu'elle convertit les valeurs entières en représentation à virgule flottante. Les valeurs d'une colonne REAL sont toujours renvoyées à partir de la base de données sous forme d'occurrence Number.
Une colonne d'affinité BOOLEAN stocke des valeurs true ou false. Une colonne BOOLEAN accepte une valeur correspondant à une occurrence Boolean ActionScript ou JavaScript. Si le code tente de stocker une valeur String, une String dont la longueur est supérieure à zéro est considérée comme true et une String vide est false. Si le code tente de stocker des données numériques, toute valeur non nulle est stockée en tant que true et 0 est stocké en tant que false. Lorsqu'une valeur booléenne est récupérée par une instruction SELECT, elle est renvoyée en tant qu'occurrence Boolean. Les valeurs non NULL sont stockées avec la classe de stockage INTEGER (0 pour false et 1 pour true) et sont converties en objet Boolean lors de la récupération des données.
Une colonne d'affinité DATE stocke des valeurs de date et d'heure. Une colonne DATE est conçue pour accepter des valeurs qui sont des occurrences Date ActionScript ou JavaScript. En cas de tentative de stockage d'une valeur String dans une colonne DATE, le moteur d'exécution tente de la convertir en date julienne. Si la conversion échoue, une erreur survient. Si le code tente de stocker une valeur Number, int ou uint, il n'y a pas de tentative de validation des données et il est supposé qu'il s'agit d'une valeur de date julienne valide. Une valeur DATE récupérée par une instruction SELECT est automatiquement convertie en occurrence Date. Les valeurs DATE étant stockées en tant que valeurs de dates juliennes avec la classe de stockage REAL, les opérations de tri et de comparaison fonctionnent comme prévu.
Une colonne qui utilise une affinité XML ou XMLLIST stocke des structures XML. Lorsque le code tente de stocker des données dans une colonne XML en utilisant un paramètre SQLStatement, le moteur d'exécution tente de convertir et de valider la valeur à l'aide de la fonction ActionScript XML() ou XMLList(). Si la valeur ne peut pas être convertie en XML valide, une erreur survient. Si la tentative de stockage des données utilise une valeur de texte SQL littérale (par exemple INSERT INTO (col1) VALUES ('), la valeur n'est pas analysée ou validée — elle est supposée être bien formée. Si une valeur non valide est stockée, elle est renvoyée en tant qu'objet XML vide lorsqu'elle est récupérée. Les données XML et XMLLIST sont stockées avec la classe de stockage TEXT ou NULL.
Une colonne d'affinité OBJECT stocke des objets complexes ActionScript ou JavaScript, y compris les occurrences de la classe Object, les occurrences des sous-classes Object telles que les occurrences Array et même les occurrences des classes personnalisées. Les données de la colonne OBJECT sont sérialisées au format AMF3 et stockées avec la classe de stockage BLOB. Lorsqu'une valeur est récupérée, elle est désérialisée du format AMF3 et renvoyée sous forme d'occurrence de la classe telle qu'elle était stockée. Notez que certaines classes ActionScript, en particulier les objets d'affichage, ne peuvent pas être désérialisées en tant qu'occurrences de leur type de données d'origine. Avant de stocker une occurrence de classe personnalisée, vous devez enregistrer un alias pour la classe avec la méthode flash.net.registerClassAlias() (ou dans Flex, en ajoutant des métadonnées [RemoteObject] à la déclaration de la classe). De même, avant de récupérer les données, vous devez enregistrer le même alias pour la classe. Toutes les données qui ne peuvent pas être désérialisées correctement, que cela soit inhérent à la classe ou dû au fait qu'un alias de classe est manquant ou ne correspond pas, sont renvoyées sous forme d'objet anonyme (occurrence de la classe Object) avec des propriétés et des valeurs correspondants à l'occurrence d'origine.
Une colonne d'affinité NONE n'a pas de préférence en matière de classe de stockage. Elle ne tente pas de convertir les données avant leur insertion.
L'affinité du type d'une colonne est déterminée par le type déclaré de la colonne dans l'instruction CREATE TABLE. Lors de la détermination du type, les règles suivantes s'appliquent :
VARCHAR contient la chaîne "CHAR" et se voit affecter l'affinité TEXT.CREATE TABLE t AS SELECT..., aucun type de données n'est spécifié pour toutes les colonnes et celles-ci obtiennent l'affinité NONE.Les opérateurs de comparaison binaire suivants =, <, <=, >= et != sont pris en charge, de même qu'une opération permettant de tester l'appartenance, IN, et l'opérateur de comparaison ternaire BETWEEN. Pour plus d'informations sur ces opérateurs, consultez la section Opérateurs.
Le résultat d'une comparaison dépend des classes de stockage des deux valeurs comparées. Lors de la comparaison de deux valeurs, les règles suivantes s'appliquent :
Lors de comparaisons binaires entre des classes de stockage numérique et texte, la base de données tente au besoin de convertir les valeurs avant d'effectuer la comparaison. Lors de la comparaison de classes de stockage numérique et texte, les règles suivantes s'appliquent (Remarque : le terme expression utilisé dans les règles suivantes comprend toute expression scalaire SQL ou toute valeur littérale autre qu'une valeur de colonne. Par exemple, si X et Y.Z sont des noms de colonnes, +X et +Y.Z sont considérés comme des expressions) :
L'opérateur ternaire BETWEEN est toujours remanié en tant qu'expression binaire équivalente. Par exemple, a BETWEEN b AND c est transformé en a >= b AND a <= c, même si cela signifie que des affinités différentes sont appliquées à a dans chacune des comparaisons requises pour évaluer l'expression.
Les expressions de type a IN (SELECT b ....) sont gérées selon les trois règles énumérées précédemment pour les comparaisons binaires, c'est-à-dire de la même façon que a = b. Par exemple, si b est une valeur de colonnes et a une expression, l'affinité de b est appliquée à a avant toute comparaison. L'expression a IN (x, y, z) est transformée en a = +x OR a = +y OR a = +z. Les valeurs placées à droite de l'opérateur IN (les valeurs x, y et z dans cet exemple) sont considérées comme des expressions, même si ce sont en réalité des valeurs de colonne. Si la valeur située à gauche de l'opérateur IN est une colonne, l'affinité de cette colonne est utilisée. Si la valeur est une expression, aucune conversion n'est effectuée.
L'utilisation de la clause COLLATE peut également affecter la manière dont les comparaisons sont effectuées. Pour plus d'informations, voir COLLATE.
Pour chaque opérateur mathématique pris en charge, *, /, %, + et -, une affinité numérique est appliquée à chaque opérande avant l'évaluation de l'expression. Lorsqu'un opérande ne peut pas être converti vers la classe de stockage NUMERIC, l'expression renvoie NULL.
Lorsque l'opérateur de concaténation || est utilisé, chaque opérande est converti vers la classe de stockage TEXT avant l'évaluation de l'expression. Lorsqu'un opérande ne peut pas être converti vers la classe de stockage TEXT, le résultat de l'expression est NULL. L'impossibilité de convertir la valeur peut se produire dans deux cas : si la valeur de l'opérande est NULL, ou s'il s'agit d'une valeur BLOB contenant une classe de stockage non TEXT.
Lorsque des valeurs sont triées par une clause ORDER BY, celles dont la classe de stockage est NULL sont prioritaires. Elles sont suivies par les valeurs INTEGER et REAL organisées en ordre numérique, puis par les valeurs TEXT en ordre binaire ou selon le classement spécifié (BINARY ou NOCASE). Enfin, viennent les valeurs BLOB en ordre binaire. Aucune conversion de classe de stockage n'est effectuée avant le tri.
Lors du regroupement de valeurs avec la clause GROUP BY, les valeurs de classes de stockage différentes sont considérées comme distinctes, à l'exception des valeurs INTEGER et REAL, considérées comme égales si elles sont équivalentes du point de vue numérique. Aucune affinité n'est appliquée aux valeurs en résultat d'une clause GROUP BY.
Les opérateurs SELECT composés, UNION, INTERSECT et EXCEPT, effectuent des comparaisons implicites entre les valeurs. Avant que ces comparaisons ne soient effectuées, une affinité peut être appliquée à chaque valeur. La même infinité, le cas échéant, est appliquée à toutes les valeurs pouvant être renvoyées dans une seule colonne du jeu de résultats SELECT composé. L'affinité appliquée est celle de la colonne renvoyée par la première instruction SELECT composée possédant une valeur de colonne (et non un autre type d'expression) à cette position. Si, pour une colonne SELECT composée, aucune instruction SELECT de composant ne renvoie de valeur de colonne, aucune affinité n'est appliquée aux valeurs de cette colonne avant leur comparaison.
Les définitions des instructions de ce document utilisent les conventions suivantes :
UPPER CASE - les mots-clés SQL littéraux sont écrits en majusculeslower case - les noms de clause et les termes d'espaces réservés sont écrits en minuscules::= - indique une définition de clause ou d'instruction| - le caractère pipe est utilisé entre des options alternatives, et peut être lu comme "ou"[] - les éléments placés entre crochets sont des éléments facultatifs ; les crochets peuvent contenir un seul élément ou un ensemble d'éléments alternatifs() - les parenthèses qui entourent un ensemble d'alternatives (ensemble d'éléments séparés par des caractères pipe) désignent un groupe d'éléments obligatoires, c'est-à-dire un ensemble d'éléments correspondant aux valeurs possibles pour un seul élément requis+ - un caractère plus suivant un élément entre parenthèses indique que l'élément précédent peut survenir une ou plusieurs fois* - un caractère astérisque suivant un élément placé entre crochets indique que l'élément précédent (entre crochets) peut survenir 0 ou plusieurs fois* - un caractère astérisque utilisé dans un nom de colonne ou entre des parenthèses après un nom de fonction désigne un caractère astérisque littéral et non le quantificateur "0 ou plus". - un caractère point représente un point littéral, - un caractère virgule représente une virgule littérale() - une paire de parenthèses renfermant une seule clause ou un élément indique que les parenthèses sont des caractères littéraux obligatoires