# Qué es SQL y por qué hay cuatro URL canónica: https://missyera.com/guias/sql-desde-cero/que-es-sql/ Última actualización: 2026-11-14 Autora: Gera Flores (Miss Yera) > **Respuesta corta** > > SQL es el lenguaje con el que le pides datos a una base, y en lo esencial es uno solo: el SELECT, el WHERE, el GROUP BY y los JOIN se escriben igual en PostgreSQL, MySQL, SQL Server y SQLite. Lo que cambia es el borde, y es siempre el mismo borde: cómo limitas filas, cómo pegas texto, las funciones de fecha y los tipos de dato. Ese borde es el que te muerde el primer día de trabajo, y por eso yo lo comparo en cada capítulo. Capítulo 1 de 23 del libro [SQL desde cero](https://missyera.com/guias/sql-desde-cero.md). ## Hola! Empecemos por la confusión más común Vas a buscar "cómo aprender SQL" y en dos minutos aparecen cuatro nombres: MySQL, SQL Server, PostgreSQL y SQLite. Y la pregunta obvia: **¿cuál aprendo?** 😅 Te doy la respuesta de una y después la explico: **aprendes SQL, no un motor**. El 80% de lo que vas a escribir en tu vida es idéntico en los cuatro. Lo que cambia es un 20% que se puede tener en una tabla al lado, y en este libro lo vas a tener en cada capítulo 💜 Y antes de arrancar, contéstate una: **¿alguna vez copiaste una consulta de internet y no te corrió?** Casi seguro no era tu culpa ni de la consulta. Era que estaba escrita para otro motor, y al terminar este capítulo vas a saber reconocerlo de un vistazo 🕵️ ## Qué es SQL, sin rodeos SQL es un **lenguaje de consulta**, y de ahí viene el nombre: Structured Query Language, lenguaje de consulta estructurado. Cuando alguien dice "el lenguaje SQL" está hablando de esto 🐣 SQL es el lenguaje para pedirle datos a una base de datos. Se lee casi como una frase en inglés: ``` SELECT nombre, ciudad FROM clientes WHERE ciudad = 'Lima'; ``` "Selecciona el nombre y la ciudad, de la tabla clientes, donde la ciudad sea Lima". Ya está, eso es SQL. Y aquí está lo que lo hace especial: **tú dices QUÉ quieres, no CÓMO buscarlo**. No le explicas que recorra las filas ni por dónde empezar. El motor decide eso solo, y suele decidirlo mejor que tú. Por eso SQL lleva cincuenta años en pie mientras aparecen y desaparecen lenguajes: lo que se pide no cambia aunque cambie la forma de guardarlo. ## Motor, base de datos y SQL, que no son lo mismo Esta confusión la tiene todo el mundo al empezar, así que la aclaro con una imagen que a mí me sirvió. - 📖 **SQL** es el idioma. - ⚙️ **El motor** (PostgreSQL, MySQL, SQL Server, SQLite) es el programa que lo entiende y guarda los datos. Se le dice también gestor o DBMS. - 🗃️ **La base de datos** es tu conjunto de tablas concreto: la de ventas de tu empresa. Es como decir que el español es el idioma, la persona que lo habla es el motor, y lo que te está contando es la base. Cuatro personas pueden hablar español con acentos distintos y entenderse perfecto 🌸 ## Los cuatro, y dónde te los vas a encontrar | Motor | Dónde aparece | Qué conviene saber | |---|---|---| | **PostgreSQL** | Startups, fintech, analítica, casi todo lo nuevo | El más completo y el más estricto. Si aprendes aquí, el resto te resulta fácil | | **MySQL** | Web, ecommerce, WordPress, sistemas heredados | El más extendido del mundo. MariaDB es su gemelo y va casi igual | | **SQL Server** | Empresas grandes, banca, retail, todo lo Microsoft | Su dialecto se llama T-SQL y es el que más se aparta. Muy común en Perú | | **SQLite** | Celulares, apps de escritorio, un archivo suelto | No tiene servidor: la base es un archivo. Es con el que vamos a practicar | Si trabajas en una empresa grande peruana, lo más probable es **SQL Server**. Si es una startup o algo montado en los últimos años, **PostgreSQL**. Si es una tienda online o algo con WordPress detrás, **MySQL** 📊 Y hay un quinto grupo que conviene nombrar: los de la nube, como BigQuery de Google, Snowflake o Redshift de Amazon. Son otra cosa por dentro, pero el SQL que escribes ahí se parece muchísimo al de PostgreSQL, así que lo de este libro te sirve igual. ## Qué es igual en los cuatro Esto es lo que quiero que te lleves del capítulo, porque quita el miedo: **casi todo**. Existe un estándar, el ANSI SQL, que los cuatro respetan en lo fundamental. Lo que se escribe igual en todos: - ✅ `SELECT`, `FROM`, `WHERE` - ✅ `GROUP BY` y `HAVING` - ✅ Los cuatro `JOIN` - ✅ `ORDER BY` - ✅ `COUNT`, `SUM`, `AVG`, `MIN`, `MAX` - ✅ `INSERT`, `UPDATE`, `DELETE` - ✅ Las subconsultas, los `CTE` con `WITH` y las funciones de ventana O sea: los capítulos 3 al 9 de este libro, que son el corazón, valen tal cual en los cuatro motores 🌟 ## Y qué cambia El 20% restante. Te lo adelanto entero aquí para que lo veas junto una vez, y después cada capítulo lo retoma en su momento. Traer solo las primeras 10 filas | PostgreSQL | `SELECT * FROM clientes LIMIT 10;` | |---|---| | MySQL | `SELECT * FROM clientes LIMIT 10;` | | SQL Server | `SELECT TOP 10 * FROM clientes;` | | SQLite | `SELECT * FROM clientes LIMIT 10;` | Tres usan LIMIT y SQL Server usa TOP, que además va antes de las columnas. Es la primera diferencia con la que se choca todo el mundo. Juntar dos textos | PostgreSQL | `SELECT nombre \|\| ' - ' \|\| ciudad FROM clientes;` | |---|---| | MySQL | `SELECT CONCAT(nombre, ' - ', ciudad) FROM clientes;` | | SQL Server | `SELECT nombre + ' - ' + ciudad FROM clientes;` | | SQLite | `SELECT nombre \|\| ' - ' \|\| ciudad FROM clientes;` | Tres formas distintas para lo mismo. El CONCAT de MySQL también funciona en PostgreSQL y en SQL Server, así que si quieres escribir algo que corra en los tres, usa CONCAT. La fecha y hora de ahora | PostgreSQL | `SELECT NOW();` | |---|---| | MySQL | `SELECT NOW();` | | SQL Server | `SELECT GETDATE();` | | SQLite | `SELECT datetime('now');` | Y ojo: CURRENT_TIMESTAMP funciona en los cuatro. Cuando exista una forma estándar, esa es la que conviene usar. Si viene nulo, ponme otro valor | PostgreSQL | `SELECT COALESCE(monto, 0) FROM pedidos;` | |---|---| | MySQL | `SELECT IFNULL(monto, 0) FROM pedidos;` | | SQL Server | `SELECT ISNULL(monto, 0) FROM pedidos;` | | SQLite | `SELECT IFNULL(monto, 0) FROM pedidos;` | COALESCE funciona en los cuatro y además acepta varios valores de repuesto. Es la que yo uso siempre. ¿Ves el patrón? **Casi siempre hay una forma que funciona en los cuatro**, y las diferencias están en los atajos que cada motor inventó por su cuenta. Si te acostumbras a la forma estándar, tu SQL viaja 💜 Las otras diferencias que vas a encontrar, y que veremos cada una en su capítulo: - 🔤 **Las comillas.** El texto va entre comillas simples en los cuatro. Los nombres de tabla y columna con espacios van entre comillas dobles en PostgreSQL y SQLite, entre acentos graves en MySQL y entre corchetes en SQL Server. - 🔢 **Los tipos de dato.** Capítulo 5. - 🆔 **El id que se autoincrementa.** Capítulo 11, y ahí los cuatro se escriben distinto. - 📅 **Las funciones de fecha.** Capítulo 6, y es donde más se pelean. - 🔠 **Las mayúsculas.** En MySQL sobre Windows, `'lima'` y `'Lima'` suelen ser lo mismo. En PostgreSQL no. Esa te puede cambiar un conteo sin que te enteres. ## Con cuál practicamos, y por qué Con **SQLite**, y no porque sea el más fácil sino por tres cosas muy concretas: - 💾 **No hay que instalar un servidor.** La base entera es un archivo. Lo descargas y ya. - 🐍 **Python lo trae de fábrica.** Cero configuración. - 📱 **Lo usas todos los días sin saberlo.** Tu celular tiene decenas de bases SQLite dentro: WhatsApp, el navegador, la galería. Y lo importante: **lo que aprendas aquí se escribe igual en los otros tres**, salvo lo que este libro te va marcando en su tabla. Cuando quieras probar los demás, sin instalar nada: - 🐘 [DB Fiddle](https://www.db-fiddle.com/) para PostgreSQL y MySQL en el navegador. - 🪟 [dbfiddle.uk](https://dbfiddle.uk/), que además tiene SQL Server. ![Tres tablas enganchadas: clientes con la clave primaria id_cliente, pedidos que la repite como clave foránea y añade la suya, y detalle que a su vez apunta a pedidos. Un cliente tiene muchos pedidos y un pedido muchas líneas.](https://missyera.com/static/diagramas/webp/guia-sql-04-modelo.webp) *La clave foránea es todo el modelo relacional: la tabla de pedidos no guarda el nombre del cliente, guarda su id. Ese enganche es justo lo que un JOIN recorre, y por eso vale la pena entenderlo antes de llegar a los JOINs y no durante.* ## La base de este libro Todo corre sobre `tienda.db`, una distribuidora con cinco tablas y relaciones de verdad. Vamos a mirarla: ``` SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name; ``` ```text name ----------- clientes detalle direcciones pedidos productos ``` Esa consulta es de SQLite y no funciona igual en los otros. Es un buen ejemplo de algo que *parece* SQL normal y es específico del motor: Listar las tablas que hay | PostgreSQL | `\dt (o consultar information_schema.tables)` | |---|---| | MySQL | `SHOW TABLES;` | | SQL Server | `SELECT name FROM sys.tables;` | | SQLite | `SELECT name FROM sqlite_master WHERE type = 'table';` | Los cuatro guardan su catálogo en un sitio distinto. PostgreSQL, MySQL y SQL Server sí tienen information_schema.tables, que es lo estándar y lo que conviene usar si quieres una sola consulta para los tres. Y cuántas filas tiene cada una: ``` SELECT 'clientes' AS tabla, COUNT(*) AS filas FROM clientes UNION ALL SELECT 'direcciones', COUNT(*) FROM direcciones UNION ALL SELECT 'productos', COUNT(*) FROM productos UNION ALL SELECT 'pedidos', COUNT(*) FROM pedidos UNION ALL SELECT 'detalle', COUNT(*) FROM detalle; ``` ```text tabla filas ----------- ----- clientes 120 direcciones 164 productos 40 pedidos 900 detalle 2682 ``` Esa sí es SQL estándar y corre igual en los cuatro motores 🌟 Fíjate en la forma de las tablas, que dice mucho: 120 clientes hicieron 900 pedidos, y esos 900 pedidos tienen 2.682 líneas de detalle. O sea que cada cliente compró varias veces y cada compra tenía varios productos. Eso es una base relacional de verdad y por eso los JOIN del capítulo 7 van a tener sentido. ## Tu primera consulta ``` SELECT nombre, ciudad, segmento FROM clientes WHERE ciudad = 'Lima' ORDER BY nombre LIMIT 5; ``` ```text nombre ciudad segmento ---------------------- ------ ---------- Almacenes Vega 010 Lima Minimarket Almacenes Vega 039 Lima Mayorista Almacenes Vega 072 Lima Horeca Autoservicio Norte 091 Lima Bodega Bodega La Esquina 005 Lima Mayorista ``` Eso ya es una consulta completa: qué columnas quieres, de dónde, con qué filtro, en qué orden y cuántas 💜 Y salvo el `LIMIT`, esa consulta corre tal cual en los cuatro motores. En SQL Server sería `SELECT TOP 5 nombre, ciudad, segmento` y el resto igual. ## Le dices qué quieres, no cómo conseguirlo Esta es la idea que hace que SQL se aprenda rápido, y la que más cuesta si vienes de otro lenguaje 🧠 En Python, para sacar las ventas de más de mil soles ordenadas de mayor a menor, escribes **los pasos**: recorre la lista, compara cada elemento, guarda los que pasen, ordena el resultado. Le explicas a la máquina cómo hacerlo. En SQL escribes **qué quieres**: ```sql SELECT id, monto FROM pedidos WHERE monto > 1000 ORDER BY monto DESC LIMIT 3; ``` ```text id monto --- ------- 25 1399.98 674 1372.34 373 1341.15 ``` Ahí no hay ningún bucle. No dijiste por dónde empezar a recorrer, ni con qué algoritmo ordenar, ni si conviene mirar primero el filtro o el orden 🤷‍♀️ Eso lo decide el motor, y lo decide **cada vez**, mirando cuántas filas hay y qué índices existen. La misma consulta puede resolverse de dos maneras distintas hoy y dentro de un mes, y las dos te dan el mismo resultado. Se llama lenguaje declarativo, y tiene tres consecuencias prácticas: - 🚀 **Escribes mucho menos.** Cinco líneas contra quince. - 🧩 **No puedes optimizar a mano como en un bucle.** Lo que sí puedes es darle mejores herramientas, y de eso va el capítulo 14. - 🕵️ **Cuando algo va lento, la pregunta no es "qué hice mal" sino "qué plan eligió el motor"**. Y eso se puede consultar. Si vienes de Excel, el salto es más corto de lo que parece: una tabla dinámica también es declarativa. Arrastras un campo a filas y otro a valores, y no le explicas a Excel cómo agrupar 📊 ## Saber en qué motor estás, en un segundo Te sientas en una máquina que no es la tuya, abres un cliente que no conoces y no tienes ni idea de qué hay detrás. Antes de escribir nada, esto 🔍 ```sql SELECT sqlite_version() AS version; ``` ```text version ------- 3.45.1 ``` Y en cada motor se pregunta distinto, que ya es la primera lección del libro en acción: En qué motor y en qué versión estoy | PostgreSQL | `SELECT version();` | |---|---| | MySQL | `SELECT VERSION();` | | SQL Server | `SELECT @@VERSION;` | | SQLite | `SELECT sqlite_version();` | Cuatro formas de preguntar lo mismo, y ninguna se parece a las otras. Es el resumen del libro en una tabla. Parece un detalle de curiosidad y no lo es: **la versión decide qué puedes escribir**. Las funciones de ventana, que son media carrera de analista, llegaron a MySQL en la 8.0 y a SQLite en la 3.25. Si la máquina tiene una anterior, el capítulo 9 entero no te va a funcionar, y el error que te sale no dice "tu versión es vieja": dice que hay un problema de sintaxis 🙃 Por eso esta consulta es lo primero que escribo en una máquina nueva. Cuesta dos segundos y te ahorra media hora de buscar por qué algo que sabes que funciona no funciona. ## Lo que este libro no te va a enseñar Y lo digo aquí, al principio, para que no lo descubras a mitad del libro 🌸 **Administrar el servidor.** Copias de seguridad, usuarios, permisos, replicación. Eso es trabajo de administración de bases de datos, es una carrera entera y no es esta. Aquí vas a saber consultar y modificar datos, que es lo que hace alguien de datos. **Diseñar el modelo desde cero.** Vas a ver cómo se crean tablas y qué son las claves, lo suficiente para entender la base con la que trabajas y para montarte una propia. Pero decidir la estructura de un sistema entero, con sus formas normales, es otro tema y da para otro libro. **Los extras de cada motor.** PostgreSQL tiene tipos JSON y búsqueda de texto completo, SQL Server tiene su lenguaje de procedimientos, y cada uno tiene sus juguetes. Aquí está el 80% que es igual en los cuatro, más las diferencias que aparecen el primer día. Los juguetes se aprenden después, y se aprenden mejor sabiendo lo de aquí. Lo que sí te llevas: entrar a una base que no conociste nunca, entender qué hay dentro, sacar el número que te pidieron, y saber cuándo el número que sacaste está mal 💜 ## Ejercicios **1. Cuántos clientes hay** Cuenta cuántos clientes tiene la tabla. ``` SELECT COUNT(*) AS clientes FROM clientes; ``` ```text clientes -------- 120 ``` `COUNT(*)` es estándar y funciona igual en los cuatro motores. **2. Las ciudades sin repetir** Lista las ciudades distintas que hay, ordenadas. ``` SELECT DISTINCT ciudad FROM clientes ORDER BY ciudad; ``` ```text ciudad -------- Arequipa Chiclayo Cusco Lima Piura Trujillo ``` **3. Los cinco productos más caros** Trae nombre y precio de los cinco productos con el precio más alto. ``` SELECT nombre, precio FROM productos ORDER BY precio DESC LIMIT 5; ``` ```text nombre precio ----------- ------ Producto 27 89.35 Producto 37 86.1 Producto 16 83.42 Producto 36 82.97 Producto 12 81.85 ``` En SQL Server esto sería `SELECT TOP 5 nombre, precio FROM productos ORDER BY precio DESC;`. Todo lo demás igual. **4. Escríbelo para los cuatro motores** Sin ejecutar nada: escribe "los 3 pedidos más caros" en los cuatro dialectos. ``` -- PostgreSQL, MySQL y SQLite SELECT id, monto FROM pedidos ORDER BY monto DESC LIMIT 3; -- SQL Server SELECT TOP 3 id, monto FROM pedidos ORDER BY monto DESC; -- Y el estándar ANSI, que funciona en PostgreSQL y en SQL Server modernos SELECT id, monto FROM pedidos ORDER BY monto DESC FETCH FIRST 3 ROWS ONLY; ``` Esa tercera forma, `FETCH FIRST`, es la del estándar. Es más larga y casi nadie la usa, pero saber que existe te salva el día que veas una consulta escrita así y no entiendas de dónde salió 🙂 **5. El filtro con texto** Trae los clientes del segmento Mayorista que sean de Arequipa. ``` SELECT nombre, ciudad, segmento FROM clientes WHERE segmento = 'Mayorista' AND ciudad = 'Arequipa'; ``` ```text nombre ciudad segmento --------------------- -------- --------- Cafe del Puerto 060 Arequipa Mayorista Bodega San Martin 103 Arequipa Mayorista Minimarket El Sol 109 Arequipa Mayorista ``` Las comillas simples para el texto son estándar. Si usas comillas dobles, PostgreSQL va a creer que le hablas de una columna llamada Mayorista y te va a dar un error raro. **6. La consulta que falla** Pide una columna que no existe y lee el error. ``` SELECT nombre, telefono FROM clientes LIMIT 3; ``` ``` OperationalError: no such column: telefono ``` Los cuatro motores dicen lo mismo con otras palabras: PostgreSQL dice `column "telefono" does not exist`, MySQL `Unknown column 'telefono'` y SQL Server `Invalid column name 'telefono'`. Distinto texto, mismo problema 🙃 ## La división que se come el medio Antes de cerrar, una de las pocas cosas de SQL que se parecen a español y no lo son. Mírala ahora, porque la vas a escribir sin pensar 🧮 La trampa Sacas el ticket medio de los pedidos dividiendo la suma entre el número de pedidos. Es una división, no hay forma de equivocarse. ``` SELECT 7/2; -- 3 ``` **Qué está mal** Tres 😳 SQL divide enteros entre enteros y devuelve un entero, igual que hacía Python 2 y que todavía hace Java. No redondea: **corta**. El 0,5 no se pierde por poco, se tira entero. Y esto no avisa nunca, porque 3 es un número perfectamente razonable. En un reporte de unidades por pedido, o de días de entrega, o de cualquier cosa que sea "algo entre algo", te va a dar un número que se ve bien y que está bajo. Se arregla haciendo que un lado sea decimal: `7 * 1.0 / 2`, o `CAST(7 AS REAL) / 2`. Yo escribo el `1.0` por costumbre en cuanto veo una división, y no me he arrepentido nunca. Comprueba que lo tienes Aprendiste con SQLite y en tu primer trabajo hay SQL Server. Escribes SELECT * FROM ventas LIMIT 10 y te sale un error de sintaxis. ¿Qué pasó? - LIMIT no existe en SQL Server, ahí se escribe SELECT TOP 10 - La tabla ventas no existe en esa base - Falta un punto y coma al final - SQL Server no deja usar el asterisco ## Lo que te llevas - 🗣️ SQL es el idioma; el motor es quien lo habla. Aprendes el idioma. - 🤝 El 80% se escribe igual en PostgreSQL, MySQL, SQL Server y SQLite. - ⚠️ El 20% que cambia aparece el primer día: limitar filas, juntar textos, fechas y nulos. - 🧭 Cuando exista una forma estándar (`COALESCE`, `CONCAT`, `CURRENT_TIMESTAMP`), esa es la que conviene. - 💾 Practicamos con SQLite porque es un archivo, y lo aprendido viaja. Y si de todo el capítulo te llevas una sola frase, que sea esta: Aprendes SQL, no un motor. Lo que cambia entre los cuatro cabe en una tabla al lado. Y si todavía estás decidiendo si este camino es para ti, te dejo lo que hace de verdad una analista de datos en el día a día: [ser analista de datos](https://missyera.com/blog/ser-analista-de-datos/) 💛 En el capítulo 2 instalamos lo que haga falta y conectamos con la base, que es donde se atasca la gente antes de escribir su primer SELECT. Que tengas un hermoso día! 🌟 ## Preguntas frecuentes ### ¿Qué es SQL? El idioma para pedirle datos a una base. Se le dice qué quieres, no cómo buscarlo, y de eso se encarga la base. ### ¿Para qué sirve SQL? Para consultar, filtrar, cruzar y resumir datos que están guardados en tablas. Es lo que hay debajo de casi todo tablero y de casi todo reporte de empresa. ### ¿SQL es un lenguaje de programación? Es un lenguaje, y no se parece a Python ni a Java: no tiene bucles ni condicionales al uso. Se declara lo que quieres y punto. ### ¿Cuál es la diferencia entre SQL y MySQL? SQL es el idioma; MySQL es uno de los motores que lo hablan, como PostgreSQL, SQL Server y SQLite. El 80% del idioma es igual en los cuatro, y el 20% que cambia es el que te encuentras el primer día de trabajo. ### ¿Cuánto se tarda en aprender SQL? Para escribir consultas útiles, unas semanas. Lo que toma más es saber si el número que devolvió está bien, y eso es la mitad de este libro. ## Seguir leyendo - Siguiente: [Conectarte y mirar lo que hay dentro](https://missyera.com/guias/sql-desde-cero/conectar-y-explorar.md) ## Contacto - Diagnóstico de 30 minutos con Miss Yera: https://calendly.com/soymissyera/reunion-con-yera - Correo: hola@missyera.com - Esta página en HTML: https://missyera.com/guias/sql-desde-cero/que-es-sql/ - Índice de todas las páginas en texto: https://missyera.com/llms-index.txt