Hola compañeros usuarios de CSDN, hoy el contenido de Xiaoyalan son los operadores en la base de datos MySQL. ¡Ahora entremos al mundo de los operadores! ! !
operadores aritméticos
operador de comparación
Operadores logicos
Operadores de bits
precedencia del operador
Extensión: Consulta usando expresiones regulares
operadores aritméticos
Los operadores aritméticos se utilizan principalmente para operaciones matemáticas, pueden conectar dos valores o expresiones antes y después del operador, y sumar (+), restar (-), multiplicar (*), dividir (/) y tomar los valores. o expresiones Operación módulo (%).
Operadores de suma y resta
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)
De los resultados de la operación se pueden extraer las siguientes conclusiones:
- Un valor de tipo entero realiza operaciones de suma y resta en números enteros y el resultado sigue siendo un número entero;
- Un valor de tipo entero realiza operaciones de suma y resta en números de punto flotante y el resultado es un número de punto flotante;
- La prioridad de la suma y la resta es la misma, el resultado de sumar primero y luego restar es el mismo que el de restar primero y luego sumar.
- En Java, si hay cadenas en los lados izquierdo y derecho de +, significa concatenación de cadenas. Pero en MySQL + solo significa sumar valores. Si encuentra un tipo no numérico, intente convertirlo primero a un valor numérico. Si la conversión falla, se calculará como 0. (Suplemento: la concatenación de cadenas en MySQL debe implementarse utilizando la función de cadena CONCAT())
Operadores de multiplicación y división.
+-----+---------+-----------+-----------+---------+-----------------+---------+-------
----+
| 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)
#Calcular el salario básico anual de los empleados.
SELECCIONE empleado_id,salario,salario * 12 anual_sal
DE empleados;
De los resultados de la operación se pueden extraer las siguientes conclusiones:
- Cuando un número se multiplica por el número entero 1 y se divide por el número entero 1, aún se obtiene el número original;
- Un número multiplicado por un número de punto flotante 1 y dividido por un número de punto flotante 1 se convierte en un número de punto flotante y el valor es igual al número original;
- Después de dividir un número por un número entero, el resultado será un número de coma flotante independientemente de si se puede dividir por completo;
- Cuando un número se divide por otro número y no se puede dividir, el resultado es un número de coma flotante y se retiene con 4 decimales;
- La multiplicación y la división tienen la misma prioridad. La multiplicación primero y luego la división producirán el mismo resultado que la división primero y luego la multiplicación.
- En operaciones matemáticas, el 0 no se puede utilizar como divisor. En MySQL, un número dividido por 0 es NULL.
Operador de módulo (resto)
mysql> SELECT 12 % 3, 12 MOD 5 FROM dual;
+--------+----------+
| 12 % 3 | 12 MOD 5 |
+--------+----------+
| 0 | 2 |
+--------+----------+
1 row in set (0.00 sec)
#Filtrar empleados cuyo id_empleado sea un número par
SELECCIONAR * DE empleados
DONDE empleado_id MOD 2 = 0;
Como puede ver, el resultado de 100 módulo 3 es 3 y el resultado módulo 5 es 0.
operador de comparación
El operador de comparación se utiliza para comparar el operando en el lado izquierdo de la expresión con el operando en el lado derecho. Si el resultado de la comparación es verdadero, devuelve 1, si el resultado de la comparación es falso, devuelve 0 y en otros casos , devuelve NULO.
Los operadores de comparación se utilizan a menudo como condiciones en declaraciones de consulta SELECT para devolver registros de resultados que cumplen las condiciones.
operador de signo igual
El operador de signo igual (=) determina si los valores, cadenas o expresiones en ambos lados del signo igual son iguales. Si son iguales, devuelve 1, y si no son iguales, devuelve 0.
Cuando utilice el operador de signo igual, siga estas reglas:
- Si los valores, cadenas o expresiones en ambos lados del signo igual son cadenas, MySQL comparará según la cadena y la comparación es si la codificación ANSI de los caracteres en cada cadena es igual.
- Si los valores a ambos lados del signo igual son números enteros, MySQL comparará los dos valores como números enteros.
- Si uno de los valores a ambos lados del signo igual es un número entero y el otro es una cadena, MySQL convertirá la cadena en un número para comparar.
- Si uno de los valores, cadenas o expresiones a cada lado del signo igual es NULL, el resultado de la comparación es NULL.
Comparación: uso de símbolos de asignación 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)
#Consulta salario = 10000, tenga en cuenta que la comparación en Java es ==
SELECCIONE empleado_id, salario DE empleados DONDE salario = 10000;
Seguro es igual a operador
Cuando ambos operandos son NULL, el valor de retorno es 1
Cuando un operando es NULL, el valor de retorno es 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)
#Consulta Commission_pct es igual a 0,40
SELECCIONE empleado_id, comisión_pct DE empleados DONDE comisión_pct = 0,40;
SELECCIONE empleado_id, comisión_pct DE empleados DONDE comisión_pct 0,40;
# ¿Qué pasa si cambias 0,40 a NULL?
Se puede ver que cuando se utiliza el operador igual seguro, cuando los valores de ambos operandos son NULL, el resultado devuelto es 1 en lugar de NULL, y otros resultados devueltos son los mismos que los del operador igual.
no es igual al operador
Los operadores de desigualdad (<> y! =) se utilizan para determinar si los valores de números, cadenas o expresiones en ambos lados no son iguales. Si no son iguales, se devuelve 1 y 0 si lo son. igual. El operador de desigualdad no puede evaluar valores NULL. Si uno de los valores en ambos lados es NULL, o ambos lados son NULL, el resultado es NULL. Ejemplos de declaraciones SQL son los siguientes:
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)
Además, existen operadores de tipos no simbólicos:
operador nulo
El operador nulo (IS NULL o ISNULL) determina si un valor es NULL. Si es NULL, devuelve 1; de lo contrario, devuelve 0. Ejemplos de declaraciones SQL son los siguientes:
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)
#Consulta Commission_pct es igual a NULL. Compare las siguientes cuatro formas de escribir:
SELECCIONE empleado_id, comisión_pct DE empleados DONDE comisión_pct ES NULO;
SELECCIONE empleado_id, comisión_pct DE empleados DONDE comisión_pct NULL;
SELECCIONE empleado_id, comisión_pct DE los empleados DONDE ESTÁ ULL (commisión_pct);
SELECCIONE empleado_id, comisión_pct DE empleados DONDE comisión_pct = NULL;
SELECCIONE apellido, manager_id
DE empleados
DONDE manager_id ES NULO;
operador no nulo
El operador no nulo (NO ES NULL) determina si un valor no es NULL. Si no es NULL, devuelve 1; de lo contrario, devuelve 0. Ejemplos de declaraciones SQL son los siguientes:
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)
SELECCIONE empleado_id, comisión_pct DE empleados DONDE NO comisión_pct NULL;
SELECCIONE empleado_id, comisión_pct DE los empleados DONDE NO ES ULL (commisión_pct);
Operador mínimo
El formato de sintaxis es: MENOS(valor 1, valor 2,..., valor n). Entre ellos, "valor n" significa que hay n valores en la lista de parámetros. En el caso de dos o más argumentos, devuelve el valor mínimo.
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)
Como se puede ver en los resultados, cuando el parámetro es un número entero o de punto flotante, MENOS devolverá el valor más pequeño; cuando el parámetro es una cadena, devolverá el carácter más alto del alfabeto; cuando hay NULL en la comparación lista de valores, el tamaño no se puede determinar y el valor de retorno es NULL.
operador máximo
El formato de sintaxis es: MAYOR (valor 1, valor 2,..., valor n). Entre ellos, n significa que hay n valores en la lista de parámetros. Cuando hay dos o más parámetros, el valor de retorno es el valor máximo. Si algún argumento es NULL, el valor de retorno de GREATEST() es 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)
Como se puede ver en los resultados, cuando el parámetro es un número entero o de punto flotante, GREATEST devolverá el valor más grande; cuando el parámetro es una cadena, devolverá el último carácter del alfabeto; cuando hay NULL en la comparación lista de valores, el tamaño no se puede determinar y el valor de retorno es NULL.
ENTRE Y operador
El formato utilizado por el operador ENTRE suele ser SELECCIONAR D DE LA TABLA DONDE C ENTRE A Y B. En este momento, cuando C es mayor o igual que A y C es menor o igual que B, el resultado es 1, de lo contrario el resultado es 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)
SELECCIONE apellido, salario
DE empleados
DONDE salario ENTRE 2500 Y 3500;
operador EN
El operador IN se utiliza para determinar si el valor dado es un valor en la lista IN. Si es así, devuelve 1; de lo contrario, devuelve 0. Si el valor dado es NULL o NULL está presente en la lista IN, el resultado es 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)
NO EN operador
El operador NOT IN se utiliza para determinar si el valor dado no es un valor en la lista IN. Si no es un valor en la lista IN, devuelve 1, de lo contrario devuelve 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)
Me gusta operador
El operador LIKE se utiliza principalmente para hacer coincidir cadenas, generalmente para coincidencias difusas. Si se cumplen las condiciones, devuelve 1; de lo contrario, devuelve 0. Si el valor dado o la condición coincidente es NULL, el resultado devuelto es NULL.
El operador LIKE suele utilizar caracteres comodín como:
"%": coincide con 0 o más caracteres.
"_": sólo puede coincidir con un carácter.
Ejemplos de declaraciones SQL son los siguientes:
mysql> SELECT NULL LIKE 'abc', 'abc' LIKE NULL;
+-----------------+-----------------+
| NULL LIKE 'abc' | 'abc' LIKE NULL |
+-----------------+-----------------+
| NULL | NULL |
+-----------------+-----------------+
1 row in set (0.00 sec)
SELECCIONE nombre
DE empleados
DONDE nombre_nombre COMO 'S%';
SELECCIONE apellido
DE empleados
DONDE apellido COMO '_o%';
ESCAPAR
Para evitar símbolos especiales: utilice caracteres de escape. Por ejemplo: convierta [%] a [$%], [] a [$] y luego agregue [ESCAPE'$'].
SELECCIONE id_trabajo
DE trabajos
DONDE job_id COMO 'IT\_%';
Si usa \ para representar escape, omita ESCAPE. Si no es \, agregue ESCAPE.
SELECCIONE id_trabajo
DE trabajos
DONDE job_id COMO 'IT$_%' escape '$';
Operador REGEXP
El operador REGEXP se utiliza para hacer coincidir cadenas y el formato de sintaxis es: expr condición de coincidencia REGEXP.
- (1) '^' coincide con una cadena que comienza con el carácter que sigue a este carácter.
- (2) '$' coincide con una cadena que termina con el carácter que precede a este carácter.
- (3) '.' coincide con cualquier carácter.
- (4) "[...]" coincide con cualquier carácter entre corchetes. Por ejemplo, "[abc]" coincide con "a", "b" o "c". Para nombrar una variedad de caracteres, utilice un '-'. "[az]" coincide con cualquier letra, mientras que "[0-9]" coincide con cualquier número.
- (5) '*' coincide con cero o más caracteres que lo preceden. Por ejemplo, "x*" coincide con cualquier número de caracteres 'x', "[0-9]*" coincide con cualquier número de dígitos y "*" coincide con cualquier número de caracteres.
Ejemplos de declaraciones SQL son los siguientes:
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)
Operadores logicos
Los operadores lógicos se utilizan principalmente para determinar si una expresión es verdadera o falsa. En MySQL, el resultado de retorno de un operador lógico es 1, 0 o NULL.
MySQL admite 4 operadores lógicos de la siguiente manera:
operador lógico NOT
El operador lógico NOT (NOT o !) significa que cuando el valor dado es 0, devuelve 1; cuando el valor dado es distinto de cero, devuelve 0; cuando el valor dado es NULL, devuelve 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)
operador lógico Y
El operador lógico AND (AND o &&) devuelve 1 cuando todos los valores dados no son 0 y ninguno es NULL; devuelve 0 cuando uno o más de los valores dados son 0; en caso contrario, devuelve 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)
SELECCIONE empleado_id, apellido, trabajo_id, salario
DE empleados
DONDE salario>=10000
Y job_id COMO '%MAN%';
Operador lógico O
El operador lógico OR (OR o ||) devuelve 1 cuando ninguno de los valores dados es NULL y cualquier valor no es 0; de lo contrario, devuelve 0; cuando un valor es NULL y el otro valor es Cuando el valor es distinto de 0, se devuelve 1; de lo contrario, se devuelve NULL; cuando ambos valores son NULL, se devuelve NULL.
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)
#Consultar número de empleado y salario básico cuyo salario básico no esté entre 9000-12000
SELECCIONE empleado_id, salario DE empleados
DONDE NO (salario >= 9000 Y salario 12000);
SELECCIONE empleado_id, salario DE empleados
DONDE salario 9000 O salario > 12000;
SELECCIONE empleado_id, salario DE empleados
DONDE salario NO ENTRE 9000 Y 12000;
SELECCIONE empleado_id, apellido, trabajo_id, salario
DE empleados
DONDE salario >= 10000
O job_id COMO '%MAN%';
Nota: OR se puede usar junto con AND, pero debe prestar atención a la prioridad de los dos al usarlo. Dado que AND tiene una prioridad más alta que OR, los operandos en ambos lados de AND se operan primero y luego se combinan con el operandos en OR.
Operador XOR lógico
El operador lógico exclusivo OR (XOR) devuelve NULL cuando cualquiera de los valores dados es NULL; si los dos valores no NULL son ambos 0 o ninguno igual a 0, devuelve 0; si un valor es 0, y cuando el otro valor no es 0, se devuelve 1.
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)seleccione apellido, id_departamento, salario
de los empleados
donde id_departamento en (10,20) XOR salario > 8000;
Operadores de bits
Los operadores bit a bit son operadores que realizan cálculos con números binarios. Los operadores bit a bit primero convertirán el operando en un número binario, luego realizarán operaciones de bits y finalmente convertirán el resultado del cálculo de binario a decimal.
Los operadores bit a bit admitidos por MySQL son los siguientes:
operador AND bit a bit
El operador AND (&) bit a bit realiza una operación AND lógica bit a bit en el número binario correspondiente a un valor determinado. Cuando los bits binarios correspondientes al valor dado son todos 1, el bit devuelve 1; de lo contrario, devuelve 0.
mysql> SELECT 1 & 10, 20 & 30;
+--------+---------+
| 1 & 10 | 20 & 30 |
+--------+---------+
| 0 | 20 |
+--------+---------+
1 row in set (0.00 sec)
El número binario de 1 es 0001 y el número binario de 10 es 1010, por lo que el resultado de 1 y 10 es 0000 y el número decimal correspondiente es 0. El número binario de 20 es 10100 y el número binario de 30 es 11110, por lo que el resultado de 20 y 30 es 10100 y el número decimal correspondiente es 20.
Operador OR bit a bit
El operador OR bit a bit (|) realiza una operación OR lógica bit a bit en los números binarios correspondientes al valor dado. Cuando uno o dos de los bits binarios correspondientes a un valor dado son 1, el bit devuelve 1; de lo contrario, devuelve 0.
mysql> SELECT 1 | 10, 20 | 30;
+--------+---------+
| 1 | 10 | 20 | 30 |
+--------+---------+
| 11 | 30 |
+--------+---------+
1 row in set (0.00 sec)
El número binario de 1 es 0001 y el número binario de 10 es 1010, por lo que el resultado de 1 | 10 es 1011 y el número decimal correspondiente es 11. El número binario de 20 es 10100 y el número binario de 30 es 11110, por lo que el resultado de 20 | 30 es 11110 y el número decimal correspondiente es 30.
Operador XOR bit a bit
mysql> SELECT 1 ^ 10, 20 ^ 30;
+--------+---------+
| 1 ^ 10 | 20 ^ 30 |
+--------+---------+
| 11 | 10 |
+--------+---------+
1 row in set (0.00 sec)El número binario de 1 es 0001 y el número binario de 10 es 1010, por lo que el resultado de 1^10 es 1011 y el número decimal correspondiente es 11. El número binario de 20 es 10100 y el número binario de 30 es 11110, por lo que el resultado de 20^30 es 01010 y el número decimal correspondiente es 10.
Otro ejemplo:
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)
operador de negación bit a bit
El operador de negación bit a bit (~) invierte el número binario del valor dado bit a bit, es decir, 1 se cambia a 0 y 0 se cambia a 1.
mysql> SELECT 10 & ~1;
+---------+
| 10 & ~1 |
+---------+
| 10 |
+---------+
1 row in set (0.00 sec)
operador de desplazamiento a la derecha bit a bit
El operador de desplazamiento a la derecha bit a bit (>>) desplaza a la derecha todos los bits de un número binario de un valor determinado en el número de bits especificado. Después de desplazarse hacia la derecha el número de dígitos especificado, el valor de los bits de orden inferior de la derecha se desplaza y se descarta, y la posición vacante en los bits de orden superior de la izquierda se rellena con ceros.
mysql> SELECT 1 >> 2, 4 >> 2;
+--------+--------+
| 1 >> 2 | 4 >> 2 |
+--------+--------+
| 0 | 1 |
+--------+--------+
1 row in set (0.00 sec)
El número binario de 1 es 0000 0001, desplazado 2 dígitos hacia la derecha es 0000 0000 y el número decimal correspondiente es 0. El número binario de 4 es 0000 0100, desplazado 2 dígitos hacia la derecha es 0000 0001 y el número decimal correspondiente es 1.
Operador de desplazamiento a la izquierda bit a bit
El operador bit a bit de desplazamiento a la izquierda () desplaza todos los bits del número binario del valor dado hacia la izquierda en el número de bits especificado. Después de desplazarse hacia la izquierda el número de dígitos especificado, el valor en el bit alto de la izquierda se mueve hacia afuera y se descarta, y la posición vacante en el bit bajo de la derecha se llena con 0.
mysql> SELECT 1 << 2, 4 << 2;
+--------+--------+
| 1 << 2 | 4 << 2 |
+--------+--------+
| 4 | 16 |
+--------+--------+
1 row in set (0.00 sec)
El número binario de 1 es 0000 0001, desplazado dos lugares a la izquierda es 0000 0100 y el número decimal correspondiente es 4. El número binario de 4 es 0000 0100, desplazado dos lugares a la izquierda es 0001 0000 y el número decimal correspondiente El número es 16.
precedencia del operador
Cuanto mayor sea el número, mayor será la prioridad. Los operadores con mayor prioridad se calculan primero. Como puede ver, el operador de asignación tiene la prioridad más baja y la expresión encerrada entre "()" tiene la prioridad más alta.
Extensión: Consulta usando expresiones regulares
Las expresiones regulares se utilizan generalmente para recuperar o reemplazar contenido de texto que coincide con un determinado patrón y hacer coincidir cadenas especiales en el texto que cumplen con los requisitos de acuerdo con el patrón de coincidencia especificado. Por ejemplo, las expresiones regulares se pueden utilizar para extraer números de teléfono de un archivo de texto, buscar palabras repetidas en un artículo o reemplazar ciertas palabras confidenciales ingresadas por el usuario. Las expresiones regulares son potentes y flexibles y se pueden aplicar a consultas muy complejas.
La palabra clave REGEXP se utiliza en MySQL para especificar el patrón de coincidencia de caracteres de una expresión regular. La siguiente tabla muestra una lista de coincidencias de caracteres comúnmente utilizadas en el operador REGEXP.
Consultar registros que comiencen con un carácter o cadena específica
El carácter '^' coincide con el texto que comienza con un carácter o cadena específica.
En la tabla de frutas, consulte los registros cuyo campo f_name comience con la letra 'b', la declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name REGEXP '^b';
Consultar registros que terminen con un carácter o cadena específica
El carácter '$' coincide con el texto que termina con un carácter o cadena específica.
En la tabla de frutas, consulte los registros cuyo campo f_name termine con la letra 'y', la declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name REGEXP 'y$';
Utilice el símbolo "." para reemplazar cualquier carácter en la cadena
El carácter '.' coincide con cualquier carácter.
En la tabla de frutas, consulte los registros cuyo valor del campo f_name contiene las letras 'a' y 'g' con solo una letra entre las dos letras. La declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name REGEXP 'ag';
Utilice "*" y "+" para hacer coincidir varios caracteres
El asterisco '*' coincide con el carácter anterior cualquier número de veces, incluidas 0 veces. El signo más '+' coincide con el carácter anterior al menos una vez.
En la tabla de frutas, consulte los registros cuyo valor del campo f_name comienza con la letra 'b' y la letra 'a' aparece al menos una vez después de 'b'. La declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name REGEXP '^ba+';
Coincide con la cadena especificada
Las expresiones regulares pueden coincidir con una cadena especificada, siempre que la cadena esté en el texto de la consulta. Si desea hacer coincidir varias cadenas, utilice el separador '|' para separar varias cadenas.
En la tabla de frutas, consulte los registros cuyo valor del campo f_name contiene la cadena "on", la declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name REGEXP 'on';
En la tabla de frutas, consulte los registros cuyo valor del campo f_name contiene la cadena "on" o "ap", la declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name REGEXP 'on|ap';
Como se mencionó anteriormente, el operador LIKE también puede coincidir con la cadena especificada, pero a diferencia de REGEXP, si la cadena que coincide con LIKE aparece en el medio del texto, no se encontrará y no se devolverá la línea correspondiente. REGEXP coincide dentro del texto. Si la cadena coincidente aparece en el texto, REGEXP la encontrará y devolverá la línea correspondiente. Los resultados de la comparación se muestran a continuación.
En la tabla de frutas, use el operador LIKE para consultar los registros cuyo valor del campo f_name está "activado" y la declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name como 'on';
Conjunto vacío (0,00 seg)
Coincide con cualquiera de los caracteres especificados
Los corchetes "[]" especifican un conjunto de caracteres y solo uno de los caracteres coincide, que es el texto que se busca.
En la tabla de frutas, busque registros que contengan las letras 'o' o 't' en el campo f_name. La declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name REGEXP '[ot]';
En la tabla de frutas, consulte los registros que contienen 4, 5 o 6 en el campo s_id y la declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE s_id REGEXP '[456]';
Coincide con caracteres distintos de los caracteres especificados
"[^Conjunto de caracteres]" coincide con cualquier carácter que no esté en el conjunto especificado.
En la tabla de frutas, consulte los registros que contienen caracteres distintos de las letras a ~ e y los números 1 ~ 2 en el campo f_id. La declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_id REGEXP '[^a-e1-2]';
Utilice {n,} o {n,m} para especificar el número de apariciones consecutivas de una cadena
"Cadena {n,}" significa coincidir con el carácter anterior al menos n veces; "Cadena {n,m}" significa coincidir con la cadena de caracteres anterior no menos de n veces y no más de m veces. Por ejemplo, a{2, } significa que la letra a aparece al menos 2 veces seguidas, o más de 2 veces; a{2,4} significa que la letra a aparece al menos 2 veces seguidas, y no puede exceder 4 veces como máximo.
En la tabla de frutas, consulte los registros cuyo valor del campo f_name aparece con la letra 'x' al menos 2 veces. La declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name REGEXP 'x{2,}';
En la tabla de frutas, consulte los registros en los que la cadena "ba" aparece al menos una vez y como máximo tres veces en el valor del campo f_name, la declaración SQL es la siguiente:
mysql> SELECCIONAR * DE frutas DONDE f_name REGEXP 'ba{1,3}';
¡vamos! ! ! !
