SQLite Operadores
¿Qué es un operador SQLite?
Un operador es una palabra reservada o un carácter, utilizado principalmente en la cláusula WHERE de las sentencias SQLite para realizar operaciones, como comparaciones y cálculos aritméticos.
Los operadores se utilizan para especificar condiciones en sentencias SQLite y para conectar múltiples condiciones en la sentencia.
Operadores aritméticos
Operadores de comparación
Operadores lógicos
Operadores de bits
Operadores aritméticos de SQLite
Supongamos que la variable a=10 y la variable b=20, entonces:
| Operador | Descripción | Ejemplo |
|---|---|---|
| + | Suma - Suma los valores a ambos lados del operador | a + b dará 30 |
| - | Resta - Resta el operando derecho del operando izquierdo | a - b dará -10 |
| * | Multiplicación - Multiplica los valores a ambos lados del operador | a * b dará 200 |
| / | División - Divide el operando izquierdo entre el operando derecho | b / a dará 2 |
| % | Módulo - El resto tras dividir el operando izquierdo entre el operando derecho | b % a dará 0 |
Ejemplo
A continuación se muestra un ejemplo sencillo de los operadores aritméticos de 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
Operadores de comparación de SQLite
Supongamos que la variable a=10 y la variable b=20, entonces:
| Operador | Descripción | Ejemplo |
|---|---|---|
| == | Comprueba si los valores de dos operandos son iguales; si son iguales, la condición es verdadera. | (a == b) no es verdadero. |
| = | Comprueba si los valores de dos operandos son iguales; si son iguales, la condición es verdadera. | (a = b) no es verdadero. |
| != | Comprueba si los valores de dos operandos son iguales; si no son iguales, la condición es verdadera. | (a != b) es verdadero. |
| <> | Comprueba si los valores de dos operandos son iguales; si no son iguales, la condición es verdadera. | (a <> b) es verdadero. |
| > | Comprueba si el valor del operando izquierdo es mayor que el valor del operando derecho; si es así, la condición es verdadera. | (a > b) no es verdadero. |
| < | Comprueba si el valor del operando izquierdo es menor que el valor del operando derecho; si es así, la condición es verdadera. | (a < b) es verdadero. |
| >= | Comprueba si el valor del operando izquierdo es mayor o igual que el valor del operando derecho; si es así, la condición es verdadera. | (a >= b) no es verdadero. |
| <= | Comprueba si el valor del operando izquierdo es menor o igual que el valor del operando derecho; si es así, la condición es verdadera. | (a <= b) es verdadero. |
| !< | Comprueba si el valor del operando izquierdo no es menor que el valor del operando derecho; si es así, la condición es verdadera. | (a !< b) es falso. |
| !> | Comprueba si el valor del operando izquierdo no es mayor que el valor del operando derecho; si es así, la condición es verdadera. | (a !> b) es verdadero. |
Ejemplo
Supongamos que la tabla COMPANY tiene los siguientes registros:
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
El siguiente ejemplo demuestra el uso de varios operadores de comparación de SQLite.
Aquí, usamosWHERE la cláusula, que se explicará en un capítulo separado más adelante, pero por ahora necesita entender que la cláusula WHERE se utiliza para establecer las condiciones de la sentencia SELECT.
La siguiente sentencia SELECT enumera todos los registros cuyo SALARY es mayor que 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
La siguiente sentencia SELECT enumera todos los registros cuyo SALARY es igual a 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
La siguiente sentencia SELECT enumera todos los registros cuyo SALARY no es igual a 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
La siguiente sentencia SELECT enumera todos los registros cuyo SALARY no es igual a 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
La siguiente sentencia SELECT enumera todos los registros cuyo SALARY es mayor o igual a 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
Operadores lógicos de SQLite
A continuación se muestra la lista de todos los operadores lógicos en SQLite.
| Operador | Descripción |
|---|---|
| AND | El operador AND permite la existencia de múltiples condiciones en la cláusula WHERE de una sentencia SQL. |
| BETWEEN | El operador BETWEEN se utiliza para buscar un valor dentro de una serie de valores en un rango dado entre un mínimo y un máximo. |
| EXISTS | El operador EXISTS se utiliza para buscar la existencia de filas en una tabla especificada que cumplan ciertas condiciones. |
| IN | El operador IN se utiliza para comparar un valor con una lista de valores especificados. |
| NOT IN | Lo opuesto al operador IN, se utiliza para comparar un valor con valores que no están en una lista especificada. |
| LIKE | El operador LIKE se utiliza para comparar un valor con valores similares utilizando operadores comodín. |
| GLOB | El operador GLOB se utiliza para comparar un valor con valores similares utilizando operadores comodín. GLOB se diferencia de LIKE en que distingue entre mayúsculas y minúsculas. |
| NOT | El operador NOT es lo opuesto del operador lógico utilizado. Por ejemplo, NOT EXISTS, NOT BETWEEN, NOT IN, etc.Es el operador de negación. |
| OR | El operador OR se utiliza para combinar múltiples condiciones en la cláusula WHERE de una sentencia SQL. |
| IS NULL | El operador NULL se utiliza para comparar un valor con el valor NULL. |
| IS | El operador IS es similar a =. |
| IS NOT | El operador IS NOT es similar a !=. |
| || | Concatena dos cadenas diferentes para obtener una nueva cadena. |
| UNIQUE | El operador UNIQUE busca cada fila en la tabla especificada para asegurar la unicidad (sin duplicados). |
Ejemplo
Supongamos que la tabla COMPANY tiene los siguientes registros:
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
El siguiente ejemplo demuestra el uso de los operadores lógicos de SQLite.
La siguiente sentencia SELECT enumera los registros donde AGE es mayor o igual a 25ademásy el salario es mayor o igual a 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
La siguiente sentencia SELECT enumera los registros donde AGE es mayor o igual a 25oy el salario es mayor o igual a 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
La siguiente sentencia SELECT enumera todos los registros donde AGE no es NULL. El resultado muestra todos los registros, lo que significa que ningún registro tiene AGE igual a 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
La siguiente sentencia SELECT enumera todos los registros cuyo NAME comienza con 'Ki', sin restricciones sobre los caracteres después de 'Ki':
sqlite> SELECT * FROM COMPANY WHERE NAME LIKE 'Ki%'; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 6 Kim 22 South-Hall 45000.0
La siguiente sentencia SELECT enumera todos los registros cuyo NAME comienza con 'Ki', sin restricciones sobre los caracteres después de 'Ki':
sqlite> SELECT * FROM COMPANY WHERE NAME GLOB 'Ki*'; ID NAME AGE ADDRESS SALARY ---------- ---------- ---------- ---------- ---------- 6 Kim 22 South-Hall 45000.0
La siguiente sentencia SELECT enumera todos los registros cuyo valor de AGE es 25 o 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
La siguiente sentencia SELECT enumera todos los registros cuyo valor de AGE no es 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
La siguiente sentencia SELECT enumera todos los registros cuyo valor de AGE está entre 25 y 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
La siguiente sentencia SELECT utiliza una subconsulta SQL. La subconsulta busca todos los registros con el campo AGE donde SALARY > 65000. Luego, la cláusula WHERE se usa junto con el operador EXISTS para enumerar todos los registros de la consulta externa cuyo AGE existe en los resultados devueltos por la subconsulta:
sqlite> SELECT AGE FROM COMPANY
WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
AGE
----------
32
25
23
25
27
22
24
La siguiente sentencia SELECT utiliza una subconsulta SQL. La subconsulta busca todos los registros con el campo AGE donde SALARY > 65000. Luego, la cláusula WHERE se usa junto con el operador > para enumerar todos los registros de la consulta externa cuyo AGE es mayor que las edades en los resultados devueltos por la subconsulta:
sqlite> SELECT * FROM COMPANY
WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
Operadores de bits de SQLite
Los operadores de bits actúan sobre bits y realizan operaciones bit a bit. La tabla de verdad para & y | es la siguiente:
| p | q | p & q | p | q |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 |
| 1 | 1 | 1 | 1 |
| 1 | 0 | 0 | 1 |
Supongamos que A = 60 y B = 13. Ahora, en formato binario, son los siguientes:
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
~A = 1100 0011
La siguiente tabla enumera los operadores de bits que admite el lenguaje SQLite. Supongamos que la variable A=60 y la variable B=13, entonces:
| Operador | Descripción | Ejemplo |
|---|---|---|
| & | El operador AND binario copia un bit al resultado si existe en ambos operandos. | (A & B) dará 12, es decir, 0000 1100 |
| | | El operador OR binario copia un bit al resultado si existe en cualquiera de los operandos. | (A | B) dará 61, es decir, 0011 1101 |
| ~ | El operador de complemento binario es un operador unario que tiene el efecto de "voltear" los bits, es decir, 0 se convierte en 1 y 1 se convierte en 0. | (~A) dará -61, es decir 1100 0011, la forma de complemento a dos de un número binario con signo. |
| << | Operador de desplazamiento a la izquierda binario. El valor del operando izquierdo se desplaza a la izquierda el número de bits especificado por el operando derecho. | A << 2 dará 240, es decir 1111 0000 |
| >> | Operador de desplazamiento a la derecha binario. El valor del operando izquierdo se desplaza a la derecha el número de bits especificado por el operando derecho. | A >> 2 dará 15, es decir 0000 1111 |
Ejemplo
El siguiente ejemplo demuestra el uso de los operadores de bits 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) = 15Otras extensiones