SQLite Opérateurs
Qu'est-ce qu'un opérateur SQLite ?
Un opérateur est un mot réservé ou un caractère principalement utilisé dans la clause WHERE d'une instruction SQLite pour effectuer des opérations, telles que des comparaisons et des opérations arithmétiques.
Les opérateurs sont utilisés pour spécifier des conditions dans une instruction SQLite et pour combiner plusieurs conditions dans l'instruction.
Opérateurs arithmétiques
Opérateurs de comparaison
Opérateurs logiques
Opérateurs bit à bit
Opérateurs arithmétiques SQLite
Supposons que la variable a=10 et la variable b=20, alors :
| Operator | Description | Exemple |
|---|---|---|
| + | Addition - Ajoute les valeurs de chaque côté de l'opérateur | a + b donnera 30 |
| - | Soustraction - Soustrait l'opérande droit de l'opérande gauche | a - b donnera -10 |
| * | Multiplication - Multiplie les valeurs de chaque côté de l'opérateur | a * b donnera 200 |
| / | Division - Divise l'opérande gauche par l'opérande droit | b / a donnera 2 |
| % | Modulo - Donne le reste après division de l'opérande gauche par l'opérande droit | b % a donnera 0 |
Exemples
Voici un exemple simple d'opérateurs arithmétiques SQLite :
sqlite> .mode line sqlite> select 10 + 20; 10 + 20 = 30 sqlite> select 10 - 20; 10 - 20 = -10 sqlite> select 10 * 20; 10 * 20 = 200 sqlite> select 10 / 5; 10 / 5 = 2 sqlite> select 12 % 5; 12 % 5 = 2
Opérateurs de comparaison SQLite
Supposons que la variable a=10 et la variable b=20, alors :
| Operator | Description | Exemple |
|---|---|---|
| == | Vérifie si les valeurs de deux opérandes sont égales ; si oui, la condition devient vraie. | (a == b) n'est pas vrai. |
| = | Vérifie si les valeurs de deux opérandes sont égales ; si oui, la condition devient vraie. | (a = b) n'est pas vrai. |
| != | Vérifie si les valeurs de deux opérandes sont égales ; si non, la condition devient vraie. | (a != b) est vrai. |
| <> | Vérifie si les valeurs de deux opérandes sont égales ; si non, la condition devient vraie. | (a <> b) est vrai. |
| > | Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit ; si oui, la condition devient vraie. | (a > b) n'est pas vrai. |
| < | Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit ; si oui, la condition devient vraie. | (a < b) est vrai. |
| >= | Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit ; si oui, la condition devient vraie. | (a >= b) n'est pas vrai. |
| <= | Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit ; si oui, la condition devient vraie. | (a <= b) est vrai. |
| !< | Vérifie si la valeur de l'opérande gauche n'est pas inférieure à la valeur de l'opérande droit ; si oui, la condition devient vraie. | (a !< b) est faux. |
| !> | Vérifie si la valeur de l'opérande gauche n'est pas supérieure à la valeur de l'opérande droit ; si oui, la condition devient vraie. | (a !> b) est vrai. |
Exemples
Supposons que la table COMPANY contient les enregistrements suivants :
ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 2 Allen 25 Texas 15000.0 3 Teddy 23 Norway 20000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
Les exemples suivants démontrent l'utilisation de divers opérateurs de comparaison SQLite.
Ici, nous utilisons la clauseWHERE , qui sera expliquée dans un chapitre séparé plus tard, mais pour l'instant vous devez comprendre que la clause WHERE est utilisée pour définir des conditions dans une instruction SELECT.
L'instruction SELECT suivante répertorie tous les enregistrements où SALARY est supérieur à 50,000.00 :
sqlite> SELECT * FROM COMPANY WHERE SALARY > 50000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
L'instruction SELECT suivante répertorie tous les enregistrements où SALARY est égal à 20,000.00 :
sqlite> SELECT * FROM COMPANY WHERE SALARY = 20000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 3 Teddy 23 Norway 20000.0
L'instruction SELECT suivante répertorie tous les enregistrements où SALARY n'est pas égal à 20,000.00 :
sqlite> SELECT * FROM COMPANY WHERE SALARY != 20000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
L'instruction SELECT suivante répertorie tous les enregistrements où SALARY n'est pas égal à 20,000.00 :
sqlite> SELECT * FROM COMPANY WHERE SALARY <> 20000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
L'instruction SELECT suivante répertorie tous les enregistrements où SALARY est supérieur ou égal à 65,000.00 :
sqlite> SELECT * FROM COMPANY WHERE SALARY >= 65000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
Opérateurs logiques SQLite
Voici une liste de tous les opérateurs logiques dans SQLite.
| Operator | Description |
|---|---|
| ET | L'opérateur AND permet l'existence de plusieurs conditions dans la clause WHERE d'une instruction SQL. |
| ENTRE | L'opérateur BETWEEN est utilisé pour rechercher des valeurs dans une plage de valeurs, étant donné une valeur minimale et une valeur maximale. |
| EXISTS | L'opérateur EXISTS est utilisé pour rechercher l'existence d'une ligne dans une table spécifiée qui répond à certains critères. |
| IN | L'opérateur IN est utilisé pour comparer une valeur à une liste de valeurs spécifiées. |
| NOT IN | L'opposé de l'opérateur IN, utilisé pour comparer une valeur à des valeurs qui ne figurent pas dans une liste spécifiée. |
| LIKE | L'opérateur LIKE est utilisé pour comparer une valeur à des valeurs similaires à l'aide d'opérateurs de caractères génériques. |
| GLOB | L'opérateur GLOB est utilisé pour comparer une valeur à des valeurs similaires à l'aide d'opérateurs de caractères génériques. GLOB diffère de LIKE en ce qu'il est sensible à la casse. |
| NON | L'opérateur NOT est l'opposé de l'opérateur logique utilisé. Par exemple, NOT EXISTS, NOT BETWEEN, NOT IN, etc.Il s'agit d'un opérateur de négation. |
| OR | L'opérateur OR est utilisé pour combiner plusieurs conditions dans la clause WHERE d'une instruction SQL. |
| IS NULL | L'opérateur NULL est utilisé pour comparer une valeur avec une valeur NULL. |
| IS | L'opérateur IS est similaire à =. |
| IS NOT | L'opérateur IS NOT est similaire à !=. |
| || | Concatène deux chaînes de caractères différentes pour obtenir une nouvelle chaîne de caractères. |
| UNIQUE | L'opérateur UNIQUE parcourt chaque ligne d'une table spécifiée pour garantir l'unicité (aucun doublon). |
Exemples
Supposons que la table COMPANY contient les enregistrements suivants :
ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 2 Allen 25 Texas 15000.0 3 Teddy 23 Norway 20000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
Les exemples suivants illustrent l'utilisation des opérateurs logiques SQLite.
L'instruction SELECT suivante répertorie tous les enregistrements où AGE est supérieur ou égal à 25etet SALARY est supérieur ou égal à 65000.00 :
sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
L'instruction SELECT suivante répertorie tous les enregistrements où AGE est supérieur ou égal à 25orand SALARY est supérieur ou égal à 65000.00 :
sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
L'instruction SELECT suivante liste tous les enregistrements où AGE n'est pas NULL, le résultat montre tous les enregistrements, ce qui signifie qu'aucun enregistrement n'a AGE égal à NULL :
sqlite> SELECT * FROM COMPANY WHERE AGE IS NOT NULL; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 2 Allen 25 Texas 15000.0 3 Teddy 23 Norway 20000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
L'instruction SELECT suivante liste tous les enregistrements où NAME commence par 'Ki', sans restriction sur les caractères après 'Ki' :
sqlite> SELECT * FROM COMPANY WHERE NAME LIKE 'Ki%'; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 6 Kim 22 South-Hall 45000.0
L'instruction SELECT suivante liste tous les enregistrements où NAME commence par 'Ki', sans restriction sur les caractères après 'Ki' :
sqlite> SELECT * FROM COMPANY WHERE NAME GLOB 'Ki*'; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 6 Kim 22 South-Hall 45000.0
L'instruction SELECT suivante liste tous les enregistrements où AGE est 25 ou 27 :
sqlite> SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 ); ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
L'instruction SELECT suivante liste tous les enregistrements où AGE n'est ni 25 ni 27 :
sqlite> SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 ); ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 1 Paul 32 California 20000.0 3 Teddy 23 Norway 20000.0 6 Kim 22 South-Hall 45000.0 7 James 24 Houston 10000.0
L'instruction SELECT suivante liste tous les enregistrements où AGE est compris entre 25 et 27 :
sqlite> SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 2 Allen 25 Texas 15000.0 4 Mark 25 Rich-Mond 65000.0 5 David 27 Texas 85000.0
L'instruction SELECT suivante utilise une sous-requête SQL, qui trouve tous les enregistrements avec des champs AGE où SALARY > 65000. La clause WHERE suivante, utilisée avec l'opérateur EXISTS, liste tous les enregistrements de la requête externe où AGE existe dans les résultats renvoyés par la sous-requête :
sqlite> SELECT AGE FROM COMPANY
WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
AGE
----------
32
25
23
25
27
22
24
L'instruction SELECT suivante utilise une sous-requête SQL, qui trouve tous les enregistrements avec des champs AGE où SALARY > 65000. La clause WHERE suivante, utilisée avec l'opérateur >, liste tous les enregistrements de la requête externe où AGE est supérieur aux âges dans les résultats renvoyés par la sous-requête :
sqlite> SELECT * FROM COMPANY
WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
Opérateurs bit à bit SQLite
Les opérateurs bit à bit agissent sur les bits et effectuent des opérations bit par bit. Les tables de vérité pour & et | sont les suivantes :
| p | q | p & q | p | q |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 |
| 1 | 1 | 1 | 1 |
| 1 | 0 | 0 | 1 |
Supposons que A = 60 et B = 13 ; en format binaire, ils sont les suivants :
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
~A = 1100 0011
Le tableau suivant répertorie les opérateurs bit à bit pris en charge par le langage SQLite. Supposons que la variable A=60 et la variable B=13, alors :
| Operator | Description | Exemple |
|---|---|---|
| & | L'opérateur AND binaire copie un bit dans le résultat s'il existe dans les deux opérandes. | (A & B) donnera 12, soit 0000 1100 |
| | | L'opérateur OR binaire copie un bit dans le résultat s'il existe dans l'un ou l'autre des opérandes. | (A | B) donnera 61, soit 0011 1101 |
| ~ | L'opérateur de complément binaire est un opérateur unaire qui a pour effet de « retourner » les bits, c'est-à-dire que 0 devient 1 et 1 devient 0. | (~A ) donnera -61, soit 1100 0011, la forme en complément à deux d'un nombre binaire signé. |
| << | Opérateur de décalage binaire vers la gauche. La valeur de l'opérande gauche est décalée vers la gauche du nombre de bits spécifié par l'opérande droit. | A << 2 donnera 240, soit 1111 0000 |
| >> | Opérateur de décalage binaire à droite. La valeur de l'opérande de gauche est décalée vers la droite du nombre de bits spécifié par l'opérande de droite. | A >> 2 donnera 15, soit 0000 1111 |
Exemples
L'exemple suivant montre l'utilisation des opérateurs bit à bit de SQLite :
sqlite> .mode line sqlite> select 60 | 13; 60 | 13 = 61 sqlite> select 60 & 13; 60 & 13 = 12 sqlite> select (~60); (~60) = -61 sqlite> select (60 << 2); (60 << 2) = 240 sqlite> select (60 >> 2); (60 >> 2) = 15Autres extensions