SELECT en SQLite: consultar filas, columnas y expresiones

SELECT: cómo leer filas de una tabla en SQLite

Toda consulta que le hagas a una base de datos SQLite empieza con SELECT. Lo que le estás diciendo es: dame estas columnas, de esta tabla, para las filas que cumplan estas condiciones. En este documento nos vamos a centrar en las dos primeras partes: las columnas y la tabla. El filtrado lo veremos en el siguiente.

La consulta SELECT más sencilla posible:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Cuaderno', 4.50, 120),
    ('Bolígrafo', 1.20, 500),
    ('Mochila', 39.99, 25),
    ('Goma de borrar', 0.80, 300);

SELECT * FROM products;

SELECT * significa "todas las columnas". FROM products indica la tabla. El resultado es una fila por cada registro, con las cuatro columnas. El punto y coma cierra la sentencia.

Esa es la forma básica de la sintaxis SELECT en SQLite: SELECT <columnas> FROM <tabla>;.

Seleccionar columnas específicas en SQLite

* viene bien cuando estás explorando los datos. Pero en código real casi siempre conviene nombrar exactamente las columnas que te interesan:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Cuaderno', 4.50, 120),
    ('Bolígrafo', 1.20, 500),
    ('Mochila', 39.99, 25);

SELECT name, price FROM products;

Recibes las dos columnas en el orden que pediste. El orden en la lista del SELECT define el orden del resultado: no tiene por qué coincidir con el orden de las columnas en la tabla.

¿Por qué conviene esto frente a un SELECT *? Por dos motivos. Primero, viaja menos información (o se lee menos del archivo), algo que se nota cuando las tablas tienen muchas columnas. Segundo, tu consulta se mantiene estable aunque alguien añada una columna nueva a la tabla el mes que viene. Con SELECT *, de repente empiezan a devolverse más columnas, y eso puede romper código de aplicación que desempaqueta las filas por posición.

SELECT no solo consulta: también calcula

Las columnas dentro de un SELECT no tienen por qué ser nombres de columnas tal cual. Pueden ser cualquier expresión: operaciones aritméticas, llamadas a funciones, concatenación de cadenas, constantes. SQLite evalúa la expresión para cada fila.

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Cuaderno', 4.50, 120),
    ('Bolígrafo', 1.20, 500),
    ('Mochila', 39.99, 25);

SELECT name, price, stock, price * stock FROM products;

La cuarta columna no existe en la tabla: SQLite la calcula fila por fila. Puedes hacer lo mismo con funciones de texto, fechas, expresiones condicionales o lo que se te ocurra. La lista de un SELECT es un sitio para moldear los datos, no solo para recuperarlos.

Es más, puedes usar SELECT sin la cláusula FROM y tratar a SQLite como si fuera una calculadora:

SELECT 2 + 2, upper('hola'), length('SQLite');

Una fila, tres columnas. Es útil para probar qué hace una expresión antes de meterla en una consulta de verdad.

Renombrar columnas con AS (alias en SQL)

Cuando calculas una columna, SQLite le asigna un nombre por defecto — muchas veces es la expresión tal cual, algo como price * stock. Eso queda feo y, además, no es estable. Ponle un nombre decente a la columna usando AS:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Cuaderno', 4.50, 120),
    ('Mochila', 39.99, 25);

SELECT
    name AS product,
    price * stock AS inventory_value
FROM products;

El alias es el nombre que tendrá la columna en el resultado. Esto importa para la legibilidad cuando estás revisando la salida, pero importa todavía más en el código de la aplicación que accede a los valores por nombre de columna (row["inventory_value"] en lugar de row[1]).

La palabra clave AS es opcional —price * stock inventory_value funciona igual—, pero conviene escribirla. La intención queda más clara y evitas confundir a quien lea el código, que podría interpretar una coma faltante como un alias.

Asignar un alias a la tabla

También puedes ponerle un alias corto a la propia tabla. Con una sola tabla no aporta gran cosa, pero es una costumbre que te salvará en cuanto empieces a hacer JOINs:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL
);

INSERT INTO products (name, price) VALUES ('Cuaderno', 4.50);

SELECT p.name, p.price FROM products AS p;

p ahora hace las veces de products. La forma con punto, p.name, deja claro de qué tabla viene cada columna. Con una sola tabla es ruido innecesario; con tres tablas unidas mediante JOIN, es lo único que mantiene la consulta legible.

Literales y constantes en el resultado

En un SELECT puedes combinar columnas reales con valores constantes. Resulta útil cuando quieres etiquetar filas o rellenar un valor de marcador:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL
);

INSERT INTO products (name, price) VALUES
    ('Cuaderno', 4.50),
    ('Bolígrafo', 1.20);

SELECT
    name,
    price,
    'USD' AS currency,
    1 AS active
FROM products;

Cada fila obtiene el mismo 'USD' y 1. Este patrón aparece cuando combinas resultados de varias consultas con UNION y necesitas una columna marcadora para distinguir el origen de cada una.

Una nota sobre NULL

Hay columnas que vienen vacías: o no se insertó ningún valor, o la columna no tiene valor por defecto. SQLite representa la "ausencia de valor" como NULL, y en los resultados de un SELECT ese NULL se muestra como un espacio en blanco o como la palabra literal NULL, según la herramienta que estés usando.

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL
);

INSERT INTO products (name, price) VALUES
    ('Cuaderno', 4.50),
    ('Artículo misterioso', NULL);

SELECT name, price, price * 2 AS doubled FROM products;

Fíjate en la segunda fila: price es NULL y price * 2 también es NULL. Cualquier operación aritmética que involucre un NULL devuelve NULL. Esta es una de las causas más habituales de resultados confusos en SQL, y le dedicaremos una página entera más adelante. Por ahora, quédate con la idea de que NULL se contagia a través de las expresiones.

Lo que debes recordar

• SELECT <columnas> FROM <tabla>; es la forma que tiene cualquier consulta SELECT en SQLite.
• En código real, lista las columnas de forma explícita; deja SELECT * para cuando estés explorando.
• La lista del SELECT admite cualquier expresión, no solo nombres de columna.
• Usa AS para ponerle un nombre decente a columnas calculadas y a alias de tablas.
• NULL se propaga en la aritmética: tenlo presente cuando un resultado te parezca raro.

Siguiente paso: filtrar con WHERE

Hasta ahora, cada consulta nos devuelve todas las filas de la tabla. La cláusula WHERE es la que te permite acotar el resultado: filtrar filas por precio, por nombre, por fecha o por cualquier expresión que se evalúe como verdadera o falsa. De eso trata el siguiente documento.