Bonjour chers utilisateurs du CSDN, aujourd'hui, le contenu de Xiaoyalan est constitué des opérateurs de la base de données MySQL. Entrons maintenant dans le monde des opérateurs ! ! !
opérateurs arithmétiques
opérateur de comparaison
Opérateurs logiques
Opérateurs de bits
priorité des opérateurs
Extension : requête utilisant des expressions régulières
opérateurs arithmétiques
Les opérateurs arithmétiques sont principalement utilisés pour les opérations mathématiques. Ils peuvent relier deux valeurs ou expressions avant et après l'opérateur, et ajouter (+), soustraire (-), multiplier (*), diviser (/) et prendre les valeurs ou expressions.Opération Modulo (%).
Opérateurs d'addition et de soustraction
mysql> SELECT 100, 100 + 0, 100 - 0, 100 + 50, 100 + 50 -30, 100 + 35.5, 100 - 35.5
FROM dual;
+-----+---------+---------+----------+--------------+------------+------------+
| 100 | 100 + 0 | 100 - 0 | 100 + 50 | 100 + 50 -30 | 100 + 35.5 | 100 - 35.5 |
+-----+---------+---------+----------+--------------+------------+------------+
| 100 | 100 | 100 | 150 | 120 | 135.5 | 64.5 |
+-----+---------+---------+----------+--------------+------------+------------+
1 row in set (0.00 sec)
Les conclusions suivantes peuvent être tirées des résultats de l’opération :
- Une valeur de type entier effectue des opérations d'addition et de soustraction sur des entiers, et le résultat est toujours un entier ;
- Une valeur de type entier effectue des opérations d'addition et de soustraction sur des nombres à virgule flottante, et le résultat est un nombre à virgule flottante ;
- La priorité de l'addition et de la soustraction est la même.Le résultat de l'addition puis de la soustraction est le même que celui de la soustraction puis de l'addition.
- En Java, s’il y a des chaînes à gauche et à droite de +, cela signifie la concaténation de chaînes. Mais dans MySQL +, cela signifie uniquement ajouter des valeurs. Si un type non numérique est rencontré, essayez d'abord de le convertir en valeur numérique. Si la conversion échoue, il sera calculé comme 0. (Supplément : la concaténation de chaînes dans MySQL doit être implémentée à l'aide de la fonction de chaîne CONCAT())
Opérateurs de multiplication et de division
+-----+---------+-----------+-----------+---------+-----------------+---------+-------
----+
| 100 | 100 * 1 | 100 * 1.0 | 100 / 1.0 | 100 / 2 | 100 + 2 * 5 / 2 | 100 /3 | 100
DIV 0 |
+-----+---------+-----------+-----------+---------+-----------------+---------+-------
----+
| 100 | 100 | 100.0 | 100.0000 | 50.0000 | 105.0000 | 33.3333 |
NULL |
+-----+---------+-----------+-----------+---------+-----------------+---------+-------
----+
1 row in set (0.00 sec)
#Calculer le salaire de base annuel des salariés
SELECT employ_id,salaire,salaire * 12 annual_sal
DES employés ;
Les conclusions suivantes peuvent être tirées des résultats de l’opération :
- Lorsqu'un nombre est multiplié par l'entier 1 et divisé par l'entier 1, le nombre d'origine est toujours obtenu ;
- Un nombre multiplié par un nombre à virgule flottante 1 et divisé par un nombre à virgule flottante 1 devient un nombre à virgule flottante et la valeur est égale au nombre d'origine ;
- Une fois qu'un nombre est divisé par un entier, le résultat sera un nombre à virgule flottante, qu'il puisse ou non être divisé complètement ;
- Lorsqu'un nombre est divisé par un autre nombre et ne peut pas être divisé, le résultat est un nombre à virgule flottante et est conservé à 4 décimales ;
- La multiplication et la division ont la même priorité. La multiplication d'abord, puis la division produira le même résultat que la division d'abord, puis la multiplication.
- Dans les opérations mathématiques, 0 ne peut pas être utilisé comme diviseur. Dans MySQL, un nombre divisé par 0 est NULL.
Opérateur Modulo (reste)
mysql> SELECT 12 % 3, 12 MOD 5 FROM dual;
+--------+----------+
| 12 % 3 | 12 MOD 5 |
+--------+----------+
| 0 | 2 |
+--------+----------+
1 row in set (0.00 sec)
#Filtrer les employés dont l'employe_id est un nombre pair
SELECT * FROM employés
OÙ id_employé MOD 2 = 0 ;
Comme vous pouvez le voir, le résultat de 100 modulo 3 est 3 et le résultat modulo 5 est 0.
opérateur de comparaison
L'opérateur de comparaison est utilisé pour comparer l'opérande du côté gauche de l'expression avec l'opérande du côté droit. Si le résultat de la comparaison est vrai, il renvoie 1, si le résultat de la comparaison est faux, il renvoie 0 et dans les autres cas. , il renvoie NULL.
Les opérateurs de comparaison sont souvent utilisés comme conditions dans les instructions de requête SELECT pour renvoyer les enregistrements de résultats qui remplissent les conditions.
opérateur de signe égal
L'opérateur de signe égal (=) détermine si les valeurs, chaînes ou expressions des deux côtés du signe égal sont égales. Si elles sont égales, il renvoie 1, et si elles ne sont pas égales, il renvoie 0.
Lorsque vous utilisez l'opérateur de signe égal, suivez ces règles :
- Si les valeurs, chaînes ou expressions des deux côtés du signe égal sont des chaînes, MySQL comparera en fonction de la chaîne, et la comparaison déterminera si le codage ANSI des caractères de chaque chaîne est égal.
- Si les valeurs des deux côtés du signe égal sont des entiers, MySQL comparera les deux valeurs comme des entiers.
- Si l'une des valeurs des deux côtés du signe égal est un entier et l'autre est une chaîne, MySQL convertira la chaîne en nombre à des fins de comparaison.
- Si l’une des valeurs, chaînes ou expressions de chaque côté du signe égal est NULL, le résultat de la comparaison est NULL.
Comparaison : Utilisation de symboles d'affectation en SQL : =
mysql> SELECT 1 = 1, 1 = '1', 1 = 0, 'a' = 'a', (5 + 3) = (2 + 6), '' = NULL , NULL =
NULL;
+-------+---------+-------+-----------+-------------------+-----------+-------------+
| 1 = 1 | 1 = '1' | 1 = 0 | 'a' = 'a' | (5 + 3) = (2 + 6) | '' = NULL | NULL = NULL |
+-------+---------+-------+-----------+-------------------+-----------+-------------+
| 1 | 1 | 0 | 1 | 1 | NULL | NULL |
+-------+---------+-------+-----------+-------------------+-----------+-------------+
1 row in set (0.00 sec)
mysql> SELECT 1 = 2, 0 = 'abc', 1 = 'abc' FROM dual;
+-------+-----------+-----------+
| 1 = 2 | 0 = 'abc' | 1 = 'abc' |
+-------+-----------+-----------+
| 0 | 1 | 0 |
+-------+-----------+-----------+
1 row in set, 2 warnings (0.00 sec)
#Requête salaire=10000, notez que la comparaison en Java est ==
SELECT employ_id,salary FROM employes WHERE salaire = 10 000 ;
Coffre-fort égal à opérateur
Lorsque les deux opérandes sont NULL, la valeur de retour est 1
Lorsqu'un opérande est NULL, la valeur de retour est 0
mysql> SELECT 1 <=> '1', 1 <=> 0, 'a' <=> 'a', (5 + 3) <=> (2 + 6), '' <=> NULL,NULL
<=> NULL FROM dual;
+-----------+---------+-------------+---------------------+-------------+-------------
--+
| 1 <=> '1' | 1 <=> 0 | 'a' <=> 'a' | (5 + 3) <=> (2 + 6) | '' <=> NULL | NULL <=>
NULL |
+-----------+---------+-------------+---------------------+-------------+-------------
--+
| 1 | 0 | 1 | 1 | 0 |
1 |
+-----------+---------+-------------+---------------------+-------------+-------------
--+
1 row in set (0.00 sec)
#Query commission_pct est égal à 0,40
SELECT employe_id, commission_pct FROM employés WHERE commission_pct = 0,40 ;
SELECT employe_id, commission_pct FROM employés WHERE commission_pct 0,40 ;
#Et si vous changez 0,40 en NULL ?
On peut voir que lors de l'utilisation de l'opérateur égal sécurisé, lorsque les valeurs des deux opérandes sont NULL, le résultat renvoyé est 1 au lieu de NULL et les autres résultats renvoyés sont les mêmes que l'opérateur égal.
différent de l'opérateur
Les opérateurs d'inégalité (<> et !=) sont utilisés pour déterminer si les valeurs des nombres, des chaînes ou des expressions des deux côtés ne sont pas égales. Si elles ne sont pas égales, 1 est renvoyé et 0 est renvoyé si elles le sont. égal. L'opérateur d'inégalité ne peut pas évaluer les valeurs NULL. Si l'une des valeurs des deux côtés est NULL, ou si les deux côtés sont NULL, le résultat est NULL. Des exemples d'instructions SQL sont les suivants :
mysql> SELECT 1 <> 1, 1 != 2, 'a' != 'b', (3+4) <> (2+6), 'a' != NULL, NULL <> NULL;
+--------+--------+------------+----------------+-------------+--------------+
| 1 <> 1 | 1 != 2 | 'a' != 'b' | (3+4) <> (2+6) | 'a' != NULL | NULL <> NULL |
+--------+--------+------------+----------------+-------------+--------------+
| 0 | 1 | 1 | 1 | NULL | NULL |
+--------+--------+------------+----------------+-------------+--------------+
1 row in set (0.00 sec)
De plus, il existe des opérateurs de types non symboliques :
opérateur nul
L'opérateur null (IS NULL ou ISNULL) détermine si une valeur est NULL. Si elle est NULL, il renvoie 1, sinon il renvoie 0. Des exemples d'instructions SQL sont les suivants :
mysql> SELECT NULL IS NULL, ISNULL(NULL), ISNULL('a'), 1 IS NULL;
+--------------+--------------+-------------+-----------+
| NULL IS NULL | ISNULL(NULL) | ISNULL('a') | 1 IS NULL |
+--------------+--------------+-------------+-----------+
| 1 | 1 | 0 | 0 |
+--------------+--------------+-------------+-----------+
1 row in set (0.00 sec)
#Query commission_pct est égal à NULL. Comparez les quatre façons d’écrire suivantes :
SELECT employe_id, commission_pct FROM employés OÙ commission_pct EST NULL ;
SELECT employ_id, commission_pct FROM employes WHERE commission_pct NULL ;
SELECT employ_id, commission_pct FROM employes WHERE ISNULL(commission_pct);
SELECT employ_id, commission_pct FROM employes WHERE commission_pct = NULL ;
SELECT nom_famille, identifiant_gestionnaire
DES employés
OÙ manager_id EST NULL ;
opérateur non nul
L'opérateur non nul (IS NOT NULL) détermine si une valeur n'est pas NULL. Si elle n'est pas NULL, il renvoie 1, sinon il renvoie 0. Des exemples d'instructions SQL sont les suivants :
mysql> SELECT NULL IS NOT NULL, 'a' IS NOT NULL, 1 IS NOT NULL;
+------------------+-----------------+---------------+
| NULL IS NOT NULL | 'a' IS NOT NULL | 1 IS NOT NULL |
+------------------+-----------------+---------------+
| 0 | 1 | 1 |
+------------------+-----------------+---------------+
1 row in set (0.01 sec)
SELECT employe_id, commission_pct FROM employes WHERE NOT commission_pct NULL ;
SELECT employe_id,commission_pct FROM employes WHERE NOT ISNULL(commission_pct);
Opérateur minimum
Le format de syntaxe est : LEAST (valeur 1, valeur 2,..., valeur n). Parmi eux, « valeur n » signifie qu'il y a n valeurs dans la liste des paramètres. Dans le cas de deux arguments ou plus, renvoie la valeur minimale.
mysql> SELECT LEAST (1,0,2), LEAST('b','a','c'), LEAST(1,NULL,2);
+---------------+--------------------+-----------------+
| LEAST (1,0,2) | LEAST('b','a','c') | LEAST(1,NULL,2) |
+---------------+--------------------+-----------------+
| 0 | a | NULL |
+---------------+--------------------+-----------------+
1 row in set (0.00 sec)
Comme le montrent les résultats, lorsque le paramètre est un nombre entier ou à virgule flottante, LEAST renverra la plus petite valeur ; lorsque le paramètre est une chaîne, il renverra le caractère le plus élevé de l'alphabet ; lorsqu'il y a NULL dans la comparaison liste de valeurs, la taille ne peut pas être déterminée et la valeur de retour est NULL.
opérateur maximum
Le format de syntaxe est : GREATEST (valeur 1, valeur 2,..., valeur n). Parmi eux, n signifie qu'il y a n valeurs dans la liste des paramètres. Lorsqu'il y a deux paramètres ou plus, la valeur de retour est la valeur maximale. Si un argument est NULL, la valeur de retour de GREATEST() est NULL.
mysql> SELECT GREATEST(1,0,2), GREATEST('b','a','c'), GREATEST(1,NULL,2);
+-----------------+-----------------------+--------------------+
| GREATEST(1,0,2) | GREATEST('b','a','c') | GREATEST(1,NULL,2) |
+-----------------+-----------------------+--------------------+
| 2 | c | NULL |
+-----------------+-----------------------+--------------------+
1 row in set (0.00 sec)
Comme le montrent les résultats, lorsque le paramètre est un nombre entier ou à virgule flottante, GREATEST renverra la plus grande valeur ; lorsque le paramètre est une chaîne, il renverra le dernier caractère de l'alphabet ; lorsqu'il y a NULL dans la comparaison value list , la taille ne peut pas être déterminée et la valeur de retour est NULL.
ENTRE ET opérateur
Le format utilisé par l'opérateur BETWEEN est généralement SELECT D FROM TABLE WHERE C BETWEEN A AND B. À ce stade, lorsque C est supérieur ou égal à A et que C est inférieur ou égal à B, le résultat est 1, sinon le résultat est 0.
mysql> SELECT 1 BETWEEN 0 AND 1, 10 BETWEEN 11 AND 12, 'b' BETWEEN 'a' AND 'c';
+-------------------+----------------------+-------------------------+
| 1 BETWEEN 0 AND 1 | 10 BETWEEN 11 AND 12 | 'b' BETWEEN 'a' AND 'c' |
+-------------------+----------------------+-------------------------+
| 1 | 0 | 1 |
+-------------------+----------------------+-------------------------+
1 row in set (0.00 sec)
SELECT nom de famille, salaire
DES employés
OÙ salaire ENTRE 2500 ET 3500 ;
Opérateur IN
L'opérateur IN est utilisé pour déterminer si la valeur donnée est une valeur de la liste IN. Si c'est le cas, il renvoie 1, sinon il renvoie 0. Si la valeur donnée est NULL ou si NULL est présent dans la liste IN, le résultat est NULL.
mysql> SELECT 'a' IN ('a','b','c'), 1 IN (2,3), NULL IN ('a','b'), 'a' IN ('a', NULL);
+----------------------+------------+-------------------+--------------------+
| 'a' IN ('a','b','c') | 1 IN (2,3) | NULL IN ('a','b') | 'a' IN ('a', NULL) |
+----------------------+------------+-------------------+--------------------+
| 1 | 0 | NULL | 1 |
+----------------------+------------+-------------------+--------------------+
1 row in set (0.00 sec)
Opérateur PAS DANS
L'opérateur NOT IN est utilisé pour déterminer si la valeur donnée n'est pas une valeur dans la liste IN. Si ce n'est pas une valeur dans la liste IN, il renvoie 1, sinon il renvoie 0.
mysql> SELECT 'a' NOT IN ('a','b','c'), 1 NOT IN (2,3);
+--------------------------+----------------+
| 'a' NOT IN ('a','b','c') | 1 NOT IN (2,3) |
+--------------------------+----------------+
| 0 | 1 |
+--------------------------+----------------+
1 row in set (0.00 sec)
Opérateur LIKE
L'opérateur LIKE est principalement utilisé pour faire correspondre des chaînes, généralement pour une correspondance floue. Si les conditions sont remplies, il renvoie 1, sinon il renvoie 0. Si la valeur donnée ou la condition de correspondance est NULL, le résultat renvoyé est NULL.
L'opérateur LIKE utilise généralement des caractères génériques tels que :
"%" : correspond à 0 caractère ou plus.
"_" : ne peut correspondre qu'à un seul caractère.
Des exemples d'instructions SQL sont les suivants :
mysql> SELECT NULL LIKE 'abc', 'abc' LIKE NULL;
+-----------------+-----------------+
| NULL LIKE 'abc' | 'abc' LIKE NULL |
+-----------------+-----------------+
| NULL | NULL |
+-----------------+-----------------+
1 row in set (0.00 sec)
SELECT prénom
DES employés
OÙ prénom_nom LIKE 'S%';
SELECT nom_de_famille
DES employés
WHERE nom_LIKE '_o%';
S'ÉCHAPPER
Pour éviter les symboles spéciaux : utilisez des caractères d'échappement. Par exemple : convertissez [%] en [$%], [] en [$], puis ajoutez [ESCAPE'$'].
SELECT job_id
Emplois FROM
OÙ ID_travail LIKE 'IT\_%' ;
Si vous utilisez \ pour représenter l'échappement, omettez ESCAPE. Si ce n'est pas \, ajoutez ESCAPE.
SELECT job_id
Emplois FROM
OÙ job_id LIKE 'IT$_%' escape '$';
Opérateur REGEXP
L'opérateur REGEXP est utilisé pour faire correspondre des chaînes. Le format de syntaxe est : expr REGEXP matching condition.
- (1) '^' correspond à une chaîne commençant par le caractère suivant ce caractère.
- (2) '$' correspond à une chaîne se terminant par le caractère précédant ce caractère.
- (3) '.' correspond à n'importe quel caractère.
- (4) "[...]" correspond à tous les caractères entre crochets. Par exemple, « [abc] » correspond à « a », « b » ou « c ». Pour nommer une plage de caractères, utilisez un « - ». "[az]" correspond à n'importe quelle lettre, tandis que "[0-9]" correspond à n'importe quel nombre.
- (5) « * » correspond à zéro ou plusieurs caractères qui le précèdent. Par exemple, "x*" correspond à n'importe quel nombre de caractères "x", "[0-9]*" correspond à n'importe quel nombre de chiffres et "*" correspond à n'importe quel nombre de caractères.
Des exemples d'instructions SQL sont les suivants :
mysql> SELECT 'shkstart' REGEXP '^s', 'shkstart' REGEXP 't$', 'shkstart' REGEXP 'hk';
+------------------------+------------------------+-------------------------+
| 'shkstart' REGEXP '^s' | 'shkstart' REGEXP 't$' | 'shkstart' REGEXP 'hk' |
+------------------------+------------------------+-------------------------+
| 1 | 1 | 1 |
+------------------------+------------------------+-------------------------+
1 row in set (0.01 sec)
mysql> SELECT 'atguigu' REGEXP 'gu.gu', 'atguigu' REGEXP '[ab]';
+--------------------------+-------------------------+
| 'atguigu' REGEXP 'gu.gu' | 'atguigu' REGEXP '[ab]' |
+--------------------------+-------------------------+
| 1 | 1 |
+--------------------------+-------------------------+
1 row in set (0.00 sec)
Opérateurs logiques
Les opérateurs logiques sont principalement utilisés pour déterminer si une expression est vraie ou fausse. Dans MySQL, le résultat de retour d'un opérateur logique est 1, 0 ou NULL.
MySQL prend en charge 4 opérateurs logiques comme suit :
opérateur NON logique
L'opérateur logique NOT (NOT ou !) signifie que lorsque la valeur donnée est 0, il renvoie 1 ; lorsque la valeur donnée est différente de zéro, il renvoie 0 ; lorsque la valeur donnée est NULL, il renvoie NULL.
mysql> SELECT NOT 1, NOT 0, NOT(1+1), NOT !1, NOT NULL;
+-------+-------+----------+--------+----------+
| NOT 1 | NOT 0 | NOT(1+1) | NOT !1 | NOT NULL |
+-------+-------+----------+--------+----------+
| 0 | 1 | 0 | 1 | NULL |
+-------+-------+----------+--------+----------+
1 row in set, 1 warning (0.00 sec)
opérateur ET logique
L'opérateur logique AND (AND ou &&) renvoie 1 lorsque toutes les valeurs données sont différentes de 0 et aucune n'est NULL ; renvoie 0 lorsqu'une ou plusieurs des valeurs données sont 0 ; sinon, renvoie NULL.
mysql> SELECT 1 AND -1, 0 AND 1, 0 AND NULL, 1 AND NULL;
+----------+---------+------------+------------+
| 1 AND -1 | 0 AND 1 | 0 AND NULL | 1 AND NULL |
+----------+---------+------------+------------+
| 1 | 0 | 0 | NULL |
+----------+---------+------------+------------+
1 row in set (0.00 sec)
SELECT employ_id, last_name, job_id, salaire
DES employés
OÙ salaire >=10000
ET job_id LIKE '%MAN%';
Opérateur OU logique
L'opérateur logique OU (OR ou ||) renvoie 1 lorsqu'aucune des valeurs données n'est NULL et qu'une valeur est non-0, sinon il renvoie 0 ; lorsqu'une valeur est NULL et l'autre valeur est Lorsque la valeur est non-0, 1 est renvoyé, sinon NULL est renvoyé ; lorsque les deux valeurs sont NULL, NULL est renvoyé.
mysql> SELECT 1 OR -1, 1 OR 0, 1 OR NULL, 0 || NULL, NULL || NULL;
+---------+--------+-----------+-----------+--------------+
| 1 OR -1 | 1 OR 0 | 1 OR NULL | 0 || NULL | NULL || NULL |
+---------+--------+-----------+-----------+--------------+
| 1 | 1 | 1 | NULL | NULL |
+---------+--------+-----------+-----------+--------------+
1 row in set, 2 warnings (0.00 sec)
#Requérez le numéro d'employé et le salaire de base dont le salaire de base n'est pas compris entre 9 000 et 12 000
SELECT employ_id, salaire des employés
OÙ PAS (salaire >= 9000 ET salaire 12000) ;
SELECT employ_id, salaire des employés
OÙ salaire 9 000 OU salaire > 12 000 ;
SELECT employ_id, salaire des employés
OÙ salaire NON ENTRE 9000 ET 12000 ;
SELECT employ_id, last_name, job_id, salaire
DES employés
OÙ salaire >= 10000
OU job_id LIKE '%MAN%';
Remarque : OR peut être utilisé avec AND, mais vous devez faire attention à la priorité des deux lors de son utilisation. Puisque AND a une priorité plus élevée que OR, les opérandes des deux côtés de AND sont d'abord exploités, puis combinés avec le opérandes dans OR.
Opérateur XOR logique
L'opérateur logique OU exclusif (XOR) renvoie NULL lorsque l'une des valeurs données est NULL ; si les deux valeurs non NULL sont toutes deux 0 ou aucune n'est égale à 0, il renvoie 0 ; si une valeur est 0, et lorsque l'autre valeur n'est pas 0, 1 est renvoyé.
mysql> SELECT 1 XOR -1, 1 XOR 0, 0 XOR 0, 1 XOR NULL, 1 XOR 1 XOR 1, 0 XOR 0 XOR 0;
+----------+---------+---------+------------+---------------+---------------+
| 1 XOR -1 | 1 XOR 0 | 0 XOR 0 | 1 XOR NULL | 1 XOR 1 XOR 1 | 0 XOR 0 XOR 0 |
+----------+---------+---------+------------+---------------+---------------+
| 0 | 1 | 0 | NULL | 1 | 0 |
+----------+---------+---------+------------+---------------+---------------+
1 row in set (0.00 sec)sélectionnez last_name,department_id,salary
des employés
où Department_id dans (10,20) salaire XOR > 8 000 ;
Opérateurs de bits
Les opérateurs au niveau du bit sont des opérateurs qui effectuent des calculs sur des nombres binaires. Les opérateurs au niveau du bit convertiront d'abord l'opérande en un nombre binaire, puis effectueront des opérations sur les bits et enfin reconvertiront le résultat du calcul du binaire en nombre décimal.
Les opérateurs au niveau du bit pris en charge par MySQL sont les suivants :
opérateur ET au niveau du bit
L'opérateur ET (&) au niveau du bit effectue une opération ET logique bit par bit sur le nombre binaire correspondant à une valeur donnée. Lorsque les bits binaires correspondant à la valeur donnée sont tous à 1, le bit renvoie 1, sinon il renvoie 0.
mysql> SELECT 1 & 10, 20 & 30;
+--------+---------+
| 1 & 10 | 20 & 30 |
+--------+---------+
| 0 | 20 |
+--------+---------+
1 row in set (0.00 sec)
Le nombre binaire de 1 est 0001 et le nombre binaire de 10 est 1010, donc le résultat de 1 et 10 est 0000 et le nombre décimal correspondant est 0. Le nombre binaire de 20 est 10100 et le nombre binaire de 30 est 11110, donc le résultat de 20 et 30 est 10100 et le nombre décimal correspondant est 20.
Opérateur OU au niveau du bit
L'opérateur bit à bit OU (|) effectue une opération OU logique bit par bit sur les nombres binaires correspondant à la valeur donnée. Lorsqu'un ou deux des bits binaires correspondant à une valeur donnée sont à 1, le bit renvoie 1, sinon il renvoie 0.
mysql> SELECT 1 | 10, 20 | 30;
+--------+---------+
| 1 | 10 | 20 | 30 |
+--------+---------+
| 11 | 30 |
+--------+---------+
1 row in set (0.00 sec)
Le nombre binaire de 1 est 0001 et le nombre binaire de 10 est 1010, donc le résultat de 1 | 10 est 1011 et le nombre décimal correspondant est 11. Le nombre binaire de 20 est 10100 et le nombre binaire de 30 est 11110, donc le résultat de 20 | 30 est 11110 et le nombre décimal correspondant est 30.
Opérateur XOR au niveau du bit
mysql> SELECT 1 ^ 10, 20 ^ 30;
+--------+---------+
| 1 ^ 10 | 20 ^ 30 |
+--------+---------+
| 11 | 10 |
+--------+---------+
1 row in set (0.00 sec)Le nombre binaire de 1 est 0001 et le nombre binaire de 10 est 1010, donc le résultat de 1^10 est 1011 et le nombre décimal correspondant est 11. Le nombre binaire de 20 est 10100 et le nombre binaire de 30 est 11110, donc le résultat de 20^30 est 01010 et le nombre décimal correspondant est 10.
Un autre exemple:
mysql> SELECT 12 & 5, 12 | 5,12 ^ 5 FROM DUAL;
+--------+--------+--------+
| 12 & 5 | 12 | 5 | 12 ^ 5 |
+--------+--------+--------+
| 4 | 13 | 9 |
+--------+--------+--------+
1 row in set (0.00 sec)
opérateur de négation au niveau du bit
L'opérateur de négation au niveau du bit (~) inverse bit par bit le nombre binaire de la valeur donnée, c'est-à-dire que 1 est remplacé par 0 et 0 est remplacé par 1.
mysql> SELECT 10 & ~1;
+---------+
| 10 & ~1 |
+---------+
| 10 |
+---------+
1 row in set (0.00 sec)
opérateur de décalage à droite au niveau du bit
L'opérateur de décalage à droite au niveau du bit (>>) décale vers la droite tous les bits du nombre binaire d'une valeur donnée du nombre de bits spécifié. Après un décalage vers la droite du nombre de chiffres spécifié, la valeur dans les bits de poids faible à droite est déplacée et supprimée, et la position vacante dans les bits de poids fort à gauche est remplie de 0.
mysql> SELECT 1 >> 2, 4 >> 2;
+--------+--------+
| 1 >> 2 | 4 >> 2 |
+--------+--------+
| 0 | 1 |
+--------+--------+
1 row in set (0.00 sec)
Le nombre binaire de 1 est 0000 0001, décalé de 2 chiffres vers la droite est 0000 0000 et le nombre décimal correspondant est 0. Le nombre binaire de 4 est 0000 0100, décalé de 2 chiffres vers la droite est 0000 0001 et le nombre décimal correspondant est 0000 0001. 1.
Opérateur de décalage vers la gauche au niveau du bit
L'opérateur bitwise left shift() décale tous les bits du nombre binaire de la valeur donnée vers la gauche du nombre de bits spécifié. Après un décalage vers la gauche du nombre de chiffres spécifié, la valeur du bit haut de gauche est déplacée et supprimée, et la position vacante dans le bit bas de droite est remplie par 0.
mysql> SELECT 1 << 2, 4 << 2;
+--------+--------+
| 1 << 2 | 4 << 2 |
+--------+--------+
| 4 | 16 |
+--------+--------+
1 row in set (0.00 sec)
Le nombre binaire de 1 est 0000 0001, décalé de deux places vers la gauche est 0000 0100 et le nombre décimal correspondant est 4. Le nombre binaire de 4 est 0000 0100, décalé de deux places vers la gauche est 0001 0000 et le nombre décimal correspondant est 0000 0001. le numéro est 16.
priorité des opérateurs
Plus le nombre est grand, plus la priorité est élevée. Les opérateurs ayant une priorité plus élevée sont calculés en premier. Comme vous pouvez le constater, l'opérateur d'affectation a la priorité la plus basse et l'expression entourée de "()" a la priorité la plus élevée.
Extension : requête utilisant des expressions régulières
Les expressions régulières sont généralement utilisées pour récupérer ou remplacer le contenu du texte qui correspond à un certain modèle et pour faire correspondre des chaînes spéciales dans le texte qui répondent aux exigences en fonction du modèle de correspondance spécifié. Par exemple, les expressions régulières peuvent être utilisées pour extraire des numéros de téléphone d'un fichier texte, rechercher des mots répétés dans un article ou remplacer certains mots sensibles saisis par l'utilisateur. Les expressions régulières sont puissantes et flexibles et peuvent être appliquées à des requêtes très complexes.
Le mot-clé REGEXP est utilisé dans MySQL pour spécifier le modèle de correspondance de caractères d'une expression régulière. Le tableau suivant répertorie une liste des correspondances de caractères couramment utilisées dans l'opérateur REGEXP.
Interroger les enregistrements commençant par un caractère ou une chaîne spécifique
Le caractère « ^ » correspond au texte commençant par un caractère ou une chaîne spécifique.
Dans la table fruits, interrogez les enregistrements dont le champ f_name commence par la lettre « b ». L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE nom_f REGEXP '^b';
Interroger les enregistrements se terminant par un caractère ou une chaîne spécifique
Le caractère « $ » correspond au texte se terminant par un caractère ou une chaîne spécifique.
Dans la table fruits, interrogez les enregistrements dont le champ f_name se termine par la lettre "y". L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE nom_f REGEXP 'y$';
Utilisez le symbole "." pour remplacer n'importe quel caractère dans la chaîne
Le caractère '.' correspond à n'importe quel caractère.
Dans la table fruits, interrogez les enregistrements dont la valeur du champ f_name contient les lettres « a » et « g » avec une seule lettre entre les deux lettres. L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE nom_f REGEXP 'ag';
Utilisez "*" et "+" pour faire correspondre plusieurs caractères
L'astérisque « * » correspond au caractère précédent un certain nombre de fois, y compris 0 fois. Le signe plus « + » correspond au caractère précédent au moins une fois.
Dans la table fruits, interrogez les enregistrements dont la valeur du champ f_name commence par la lettre « b » et la lettre « a » apparaît au moins une fois après « b ». L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE nom_f REGEXP '^ba+';
Correspond à la chaîne spécifiée
Les expressions régulières peuvent correspondre à une chaîne spécifiée, à condition que la chaîne figure dans le texte de la requête. Si vous souhaitez faire correspondre plusieurs chaînes, utilisez le séparateur « | » pour séparer plusieurs chaînes.
Dans la table fruits, interrogez les enregistrements dont la valeur du champ f_name contient la chaîne "on". L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE nom_f REGEXP 'on';
Dans la table fruits, interrogez les enregistrements dont la valeur du champ f_name contient la chaîne "on" ou "ap". L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE nom_f REGEXP 'on|ap';
Comme introduit précédemment, l'opérateur LIKE peut également correspondre à la chaîne spécifiée, mais contrairement à REGEXP, si la chaîne correspondant à LIKE apparaît au milieu du texte, elle ne sera pas trouvée et la ligne correspondante ne sera pas renvoyée. REGEXP correspond à l'intérieur du texte. Si la chaîne correspondante apparaît dans le texte, REGEXP la trouvera et la ligne correspondante sera renvoyée. Les résultats de la comparaison sont présentés ci-dessous.
Dans la table fruits, utilisez l'opérateur LIKE pour interroger les enregistrements dont la valeur du champ f_name est "on". L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE nom_f comme 'on' ;
Ensemble vide (0,00 sec)
Correspond à l'un des caractères spécifiés
Les crochets "[]" spécifient un ensemble de caractères, et un seul des caractères correspond, à savoir le texte recherché.
Dans la table fruits, recherchez les enregistrements contenant les lettres « o » ou « t » dans le champ f_name. L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE nom_f REGEXP '[ot]';
Dans la table fruits, interrogez les enregistrements contenant 4, 5 ou 6 dans le champ s_id. L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE s_id REGEXP '[456]';
Correspond à des caractères autres que les caractères spécifiés
"[^Jeu de caractères]" correspond à tout caractère qui ne figure pas dans le jeu spécifié.
Dans la table fruits, interrogez les enregistrements contenant des caractères autres que les lettres a~e et les chiffres 1~2 dans le champ f_id. L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE f_id REGEXP '[^a-e1-2]';
Utilisez {n,} ou {n,m} pour spécifier le nombre d'occurrences consécutives d'une chaîne
"String {n,}" signifie faire correspondre le caractère précédent au moins n fois ; "String {n,m}" signifie faire correspondre la chaîne de caractères précédente au moins n fois et pas plus de m fois. Par exemple, a{2, } signifie que la lettre a apparaît au moins 2 fois de suite, ou plus de 2 fois ; a{2,4} signifie que la lettre a apparaît au moins 2 fois de suite, et ne peut excéder 4 fois au maximum.
Dans la table fruits, interrogez les enregistrements dont la valeur du champ f_name apparaît avec la lettre « x » au moins 2 fois. L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE nom_f REGEXP 'x{2,}';
Dans la table fruits, interrogez les enregistrements dans lesquels la chaîne "ba" apparaît au moins une fois et au maximum trois fois dans la valeur du champ f_name. L'instruction SQL est la suivante :
mysql> SELECT * FROM fruits WHERE f_name REGEXP 'ba{1,3}';
allez! ! ! !
