Los 10 mejores tips de SQL para principiantes
Si sos principiante, quizás estés teniendo algunos problemas usando SQL, vamos a hacer acá un pequeño tutorial sobre los errores más comunes que cometemos cuando programamos y tratar de aprender un poco más sobre este hermoso lenguaje llamado SQL.
1. Nunca te olvides de los punto y coma.
Al principio, en la mayoría de los intérpretes SQL, tu código va a funcionar sin ellos pero en stored procedures o consultas complejas, usar punto y coma es obligatorio.
Por ejemplo, digamos que necesitás obtener los usuarios de una tabla y sus direcciones y también necesitás contarlos.
Estas líneas van a funcionar en casi cualquier intérprete:
SELECT COUNT(*) FROM table_users
SELECT users, addresses FROM table_users
Fácil, ¿no? Pero ¿qué pasa si te digo que podrías haber hecho lo mismo con un solo bloque de consulta? (Y deberías acostumbrarte a hacerlo así porque cuando escribís stored procedures o cualquier otra cosa, no hay otra forma adecuada de hacerlo)
SELECT COUNT(*) FROM table_users;
SELECT users, addresses FROM table_users;
Esto te va a dar dos resultados (en la mayoría de los intérpretes SQL van a estar en pestañas separadas).
2. Usar espacios en la sentencia AS (y no comillas dobles)
En la mayoría de los intérpretes SQL, usar espacios en la sentencia AS generalmente va a llevar a un error, A MENOS QUE uses comillas dobles para definir tu sentencia AS.
Por ejemplo, esta línea estaría mal:
SELECT users AS active users FROM table_users where active=1;
Esto seguro no va a funcionar, una forma fácil de solucionarlo sería usando un _ entre las palabras active y users
SELECT users AS active_users FROM table_users where active=1;
Pero otra alternativa sería usar comillas dobles para nombrar el campo
SELECT users AS "active users" FROM table_users where active=1;
3. Usar comillas dobles cuando necesitás comillas simples
Las comillas dobles y las comillas simples sirven para cosas distintas en SQL, usar comillas simples sería para strings u otras variables SQL, y las comillas dobles, como dijimos antes, serían para sentencias AS con caracteres especiales.
SELECT 'Hello World' AS predefined_text
Como siempre, va a depender de tu intérprete SQL, pero esta línea va a mostrar una variable diciendo ‘Hello World’ en una columna llamada predefined_text.
Pero la siguiente línea va a mostrar una columna llamada Hello World con Hello world como único resultado.
SELECT "HELLO WORLD"
4. Usar la cláusula WHERE con funciones de agregación te puede salvar la vida
Usar la cláusula WHERE con funciones de agregación es una de las formas óptimas de recorrer una tabla, el problema acá es que si una base de datos es demasiado grande, va a tardar una eternidad en cargar tu consulta (si es que puede hacerlo siquiera). Así es como deberías recorrer tablas de bases de datos extensas:
Por ejemplo, si tenés una base de datos con todas las acciones de los usuarios separadas por fecha y necesitás las acciones del último día, tu consulta debería ser algo así:
SELECT * FROM user_actions WHERE date_action=(SELECT MAX(date_action) FROM user_actions)
5. Las funciones de agregación van de la mano con la cláusula GROUP BY
Las funciones de agregación van de la mano con la cláusula GROUP BY A MENOS QUE lo único que necesites sea el resultado de la función de agregación.
Esta consulta va a agrupar por username el promedio de puntos
SELECT username, AVG(points) FROM users_table GROUP BY 1
Estamos diciendo GROUP BY 1 porque username es el primer dato que necesitamos de la tabla, también podríamos usar GROUP BY username en este caso.
Esta consulta, en cambio, va a traer el promedio de puntos de todos los usuarios de la tabla:
SELECT AVG(points) FROM user_table
6. Cada intérprete SQL tiene sus particularidades
Cada intérprete SQL tiene sus particularidades, una consulta podría funcionar en un entorno SQL y no en otro.
Por ejemplo, la cláusula QUALIFY para filtrar resultados es específica de Teradata (muy útil, por cierto) pero para hacer la misma consulta en OracleDB deberías usar algo distinto:
# CONSULTA ESPECÍFICA DE TERADATA:
SELECT * FROM table_user_points_actions QUALIFY ROW_NUMBER OVER (PARTITION BY username ORDER BY POINTS)=1
# EQUIVALENTE EN ORACLE DB:
SELECT T.* FROM
(SELECT
RANK() OVER (PARTITION BY username ORDER BY POINTS) my_rank, A.* FROM table_user_points_actions A) T
WHERE T.my_rank=1
Profundicemos un poco en esto. Ambas consultas van a obtener todos los usernames y el momento en que hicieron más puntos, en Teradata vamos a usar QUALIFY para ordenar los valores y vamos a obtener el primero de ellos (que sería el =1)
En oracle, deberíamos hacer un RANK de cada valor por username y points y después obtener el primero de ellos.
7. CASE WHEN… ELSE… END – Un buen aliado
La cláusula CASE es un buen aliado para entender cuándo se cumple una condición en tu consulta.
SELECT username, CASE WHEN SUBSTRING(username,1,2)='A' THEN 'Username starts with A'
WHEN SUBSTRING(username,1,2)='B' THEN 'Username starts with B'
ELSE 'Username doesn't start with A or B' END as username_first_letter_a_or_b_or_else FROM user_tables
Esta consulta nos va a decir si el username empieza con A o B, caso contrario, nos va a decir que no empieza con ninguno de los dos.
8. Usar subconsultas SIEMPRE es una buena idea
Usar subconsultas SIEMPRE es una buena idea, no solo porque va a ejecutar tu código por partes, permitiéndote un trabajo de debugging más fácil, sino también porque a veces necesitás saber un resultado para poder obtener otro resultado (casi siempre cuando usás funciones de agregación).
SELECT T.username,
CASE WHEN T.sum_points > 100 THEN 'User have win' ELSE 'User didn't win' END as USER_WIN
FROM (SELECT Username, SUM(points) as sum_points FROM table_user_points_actions GROUP BY 1) T
Esto va a sumar cuántos puntos acumuló el usuario, si fueron más de 100, va a decir que el usuario ganó, caso contrario que el usuario no ganó.
9. No todas las sentencias join funcionan de la misma manera.
No todas las sentencias join funcionan de la misma manera.
Por ejemplo, un LEFT JOIN va a usar la primera tabla como tabla base y le va a agregar los datos de la segunda tabla (y repetir si se encuentra más de una vez). Sin embargo, un FULL JOIN va a juntar las dos tablas.
# Esta consulta va a hacer coincidir la primera tabla y la segunda tabla, pero no va a mostrar cuando hay un username en table_user_points_actions que no está en table_username
SELECT * FROM table_username A
LEFT JOIN table_user_points_actions B
ON A.username=B.username
# Esta consulta va a hacer coincidir la primera tabla y la segunda tabla, pero SÍ va a mostrar los registros "abandonados" por la primera tabla
SELECT * FROM table_username A
FULL JOIN table_user_points_actions B
ON A.username=B.username
10. Si tenés dudas, separá tu sentencia de consulta
Una buena forma de debuggear tu sentencia de consulta es separarla en sentencias más chicas.
SELECT A.*, SUM(POINTS) FROM table_username A GROUP BY 1,2,3,4,5,6; --No funciona
SELECT A.* FROM TABLE_USERNAME A GROUP BY 1,2,3,4,5,6; -- Tampoco funciona porque hay 5 valores en la tabla y estoy agrupando por 6
SELECT SUM(POINTS) FROM table_username A; -- Sí funciona
Consulta corregida:
SELECT A.*, SUM(POINTS) FROM table_username A GROUP BY 1,2,3,4,5,6; -- Sí funciona
Conclusión
SQL es un lenguaje de programación hermoso y especial que necesitás conocer para ser un buen analista de datos, ¡espero que estos tips te ayuden en el presente o en el futuro!