Operadores de PostgreSQL

Un operador es un símbolo que le indica al compilador realizar operaciones matemáticas o lógicas específicas.

Un operador de PostgreSQL es una palabra clave reservada o un carácter que generalmente se usa en la sentencia WHERE como condición de filtro.

Los operadores comunes son:

Operadores aritméticos
Operadores de comparación
Operadores lógicos
Operadores bit a bit

Operadores aritméticos

Suponiendo que la variable a es 2 y la variable b es 3, entonces:

Operador	Descripción	Ejemplo
+	Suma	a + b da como resultado 5
-	Resta	a - b da como resultado -1
*	Multiplicación	a * b da como resultado 6
/	División	b / a da como resultado 1
%	Módulo (resto)	b % a da como resultado 1
^	Exponenciación	a ^ b da como resultado 8
\|/	Raíz cuadrada	\|/ 25.0 da como resultado 5
\|\|/	Raíz cúbica	\|\|/ 27.0 da como resultado 3
!	Factorial	5 ! da como resultado 120
!!	Factorial (operador prefijo)	!! 5 da como resultado 120

Ejemplo

ejemplodb=# select 2+3;
 ?column?
----------
        5
(1 row)


ejemplodb=# select 2*3;
 ?column?
----------
        6
(1 row)


ejemplodb=# select 10/5;
 ?column?
----------
        2
(1 row)


ejemplodb=# select 12%5;
 ?column?
----------
        2
(1 row)


ejemplodb=# select 2^3;
 ?column?
----------
        8
(1 row)


ejemplodb=# select |/ 25.0;
 ?column?
----------
        5
(1 row)


ejemplodb=# select ||/ 27.0;
 ?column?
----------
        3
(1 row)


ejemplodb=# select 5 !;
 ?column?
----------
      120
(1 row)


ejemplodb=# select !!5;
 ?column?
----------
      120
(1 row)

Operadores de comparación

Suponiendo que la variable a es 10 y la variable b es 20, entonces:

Operador	Descripción	Ejemplo
=	Igual a	(a = b) es false.
!=	No igual a	(a != b) es true.
<>	No igual a	(a <> b) es true.
>	Mayor que	(a > b) es false.
<	Menor que	(a < b) es true.
>=	Mayor o igual que	(a >= b) es false.
<=	Menor o igual que	(a <= b) es true.

Ejemplo

Crear la tabla COMPANY (Descargar el archivo SQL de COMPANY), con el siguiente contenido de datos:

ejemplodb=# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Leer los datos donde el campo SALARY sea mayor que 50000:

ejemplodb=# SELECT * FROM COMPANY WHERE SALARY > 50000;
 id | name  | age |address    | salary
----+-------+-----+-----------+--------
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
(2 rows)

Leer los datos donde el campo SALARY sea igual a 20000:

ejemplodb=#  SELECT * FROM COMPANY WHERE SALARY = 20000;
 id | name  | age |  address    | salary
 ----+-------+-----+-------------+--------
   1 | Paul  |  32 | California  |  20000
   3 | Teddy |  23 | Norway      |  20000
(2 rows)

Leer los datos donde el campo SALARY no sea igual a 20000:

ejemplodb=#  SELECT * FROM COMPANY WHERE SALARY != 20000;
 id | name  | age |  address    | salary
----+-------+-----+-------------+--------
  2 | Allen |  25 | Texas       |  15000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
(5 rows)

ejemplodb=# SELECT * FROM COMPANY WHERE SALARY <> 20000;
 id | name  | age | address    | salary
----+-------+-----+------------+--------
  2 | Allen |  25 | Texas      |  15000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
(5 rows)

Leer los datos donde el campo SALARY sea mayor o igual a 65000:

ejemplodb=# SELECT * FROM COMPANY WHERE SALARY >= 65000;
 id | name  | age |  address  | salary
----+-------+-----+-----------+--------
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
(2 rows)

Operadores lógicos

Los operadores lógicos de PostgreSQL son los siguientes:

N.º	Operador y descripción
1	AND Operador AND lógico. Si ambos operandos son distintos de cero, la condición es verdadera. En PostgreSQL, la sentencia WHERE puede incluir múltiples condiciones de filtro usando AND.
2	NOT Operador NOT lógico. Se usa para invertir el estado lógico del operando. Si la condición es verdadera, el operador NOT lógico la hará falsa. PostgreSQL tiene operadores como NOT EXISTS, NOT BETWEEN, NOT IN, etc.
3	OR Operador OR lógico. Si cualquiera de los dos operandos es distinto de cero, la condición es verdadera. En PostgreSQL, la sentencia WHERE puede incluir múltiples condiciones de filtro usando OR.

N.º

Operador y descripción

AND

Operador AND lógico. Si ambos operandos son distintos de cero, la condición es verdadera.

En PostgreSQL, la sentencia WHERE puede incluir múltiples condiciones de filtro usando AND.

NOT

Operador NOT lógico. Se usa para invertir el estado lógico del operando. Si la condición es verdadera, el operador NOT lógico la hará falsa.

PostgreSQL tiene operadores como NOT EXISTS, NOT BETWEEN, NOT IN, etc.

Operador OR lógico. Si cualquiera de los dos operandos es distinto de cero, la condición es verdadera.

En PostgreSQL, la sentencia WHERE puede incluir múltiples condiciones de filtro usando OR.

SQL usa un sistema lógico de tres valores, que incluye true, false y null; null significa "desconocido".

`a`	`b`	`a` AND `b`	`a` OR `b`
TRUE	TRUE	TRUE	TRUE
TRUE	FALSE	FALSE	TRUE
TRUE	NULL	NULL	TRUE
FALSE	FALSE	FALSE	FALSE
FALSE	NULL	FALSE	NULL
NULL	NULL	NULL	NULL

`a`	NOT `a`
TRUE	FALSE
FALSE	TRUE
NULL	NULL

Ejemplo

Crear la tabla COMPANY (Descargar el archivo SQL de COMPANY), con el siguiente contenido de datos:

ejemplodb=# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Leer los datos donde el campo AGE sea mayor o igual a 25 y el campo SALARY sea mayor o igual a 6500:

ejemplodb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 6500;
 id | name  | age |                      address                  | salary
----+-------+-----+-----------------------------------------------+--------
  1 | Paul  |  32 | California                                    |  20000
  2 | Allen |  25 | Texas                                         |  15000
  4 | Mark  |  25 | Rich-Mond                                     |  65000
  5 | David |  27 | Texas                                         |  85000
(4 rows)

Leer los datos donde el campo AGE sea mayor o igual a 25 o el campo SALARY sea mayor que 6500:

ejemplodb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 6500;
 id | name  | age |  address    | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
  8 | Paul  |  24 | Houston     |  20000
  9 | James |  44 | Norway      |   5000
 10 | James |  45 | Texas       |   5000
(10 rows)

Leer los datos donde el campo SALARY no sea NULL:

ejemplodb=#  SELECT * FROM COMPANY WHERE SALARY IS NOT NULL;
 id | name  | age |  address    | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
  8 | Paul  |  24 | Houston     |  20000
  9 | James |  44 | Norway      |   5000
 10 | James |  45 | Texas       |   5000
(10 rows)

Operadores de bits

Los operadores de bits actúan sobre los bits y realizan las operaciones bit a bit. Las tablas de verdad de &, | y ^ son las siguientes:

p	q	p & q	p \| q
0	0	0	0
0	1	0	1
1	1	1	1
1	0	0	1

Suponiendo que A = 60 y B = 13, ahora representados en formato binario, son los siguientes:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

La siguiente tabla muestra los operadores de bits admitidos por PostgreSQL. Suponiendo que la variableAtiene el valor 60 y la variableBtiene el valor 13, entonces:

Operador	Descripción	Ejemplo
&	Operación Y bit a bit. Realiza la operación "Y" sobre los bits binarios. Regla de la operación: 0&0=0; 0&1=0; 1&0=0; 1&1=1;	(A & B) dará como resultado 12, es decir, 0000 1100
\|	Operador O bit a bit. Realiza la operación "O" sobre los bits binarios. Regla de la operación: 0\|0=0; 0\|1=1; 1\|0=1; 1\|1=1;	(A \| B) dará como resultado 61, es decir, 0011 1101
#	Operador XOR bit a bit. Realiza la operación "XOR" sobre los bits binarios. Regla de la operación: 0#0=0; 0#1=1; 1#0=1; 1#1=0;	(A # B) dará como resultado 49, es decir, 0011 0001
~	Operador de complemento. Realiza la operación "complemento" sobre los bits binarios. Regla de la operación: ~1=0; ~0=1;	(~A) dará como resultado -61, es decir, 1100 0011, que es la forma de complemento a dos de un número binario con signo.
<<	Operador de desplazamiento binario a la izquierda. Desplaza todos los bits de un operando hacia la izquierda un cierto número de posiciones (los bits de la izquierda se descartan y a la derecha se rellenan con 0).	A << 2 dará como resultado 240, es decir, 1111 0000
>>	Operador de desplazamiento binario a la derecha. Desplaza todos los bits de un número hacia la derecha un cierto número de posiciones; para números positivos se rellena con 0 a la izquierda, para números negativos con 1, y los bits de la derecha se descartan.	A >> 2 dará como resultado 15, es decir, 0000 1111

Ejemplo

ejemplodb=# select 60 | 13;
 ?column?
----------
       61
(1 row)


ejemplodb=# select 60 & 13;
 ?column?
----------
       12
(1 row)


ejemplodb=#  select  (~60);
 ?column?
----------
      -61
(1 row)


ejemplodb=# select  (60 << 2);
 ?column?
----------
      240
(1 row)


ejemplodb=# select  (60 >> 2);
 ?column?
----------
       15
(1 row)


ejemplodb=#  select 60 # 13;
 ?column?
----------
       49
(1 row)

Otras extensiones

PostgreSQL Avanzado

Operadores de PostgreSQL

Operadores aritméticos

Ejemplo

Operadores de comparación

Ejemplo

Operadores lógicos

Ejemplo

Operadores de bits

Ejemplo