He creado esta publicación sobre los 7 trucos de SQL más importantes para principiantes con el propósito de que todos podamos escribir buen código eficiente y rápidamente. Si estas comenzando en el mundo de la programación, ya debes saber, que el tema se las bases de datos es sumamente importante. Principalmente porque casi todos los sistemas que desarrollamos tienen, como fuente de datos, una base de datos transaccional.

Antes de comenzar, asegúrate de ver mis publicaciones previas sobre SQL. Te ayudarán a resolver problemas comunes y a ser más eficiente escribiendo código en SQL:


¡​ENVÍO GRATIS!


¡CONSOLA ​RETRO CON 620 JUEGOS!

​Revive tu infancia con esta consola de video juegos retro. ​Lo mejor de todo es que contiene 620 juegos listo para comenzar a jugar.

¡Bueno, empecemos!

1. Usar nombres apropiados

Como desarrolladores que somos, debemos acostumbrarnos a nombrar correctamente cada variable, método, clase y, por supuesto, tablas y otros elementos de base de datos. En mi caso, me gusta siempre ponerle un prefijo a cada cosa que nombro dentro de la base de datos. Normalmente lo hago de esta manera:

  • tbl para tablas. Ejemplo, tblProductos.
  • vw para vistas. Ejemplo, vwProductos.
  • fn para funciones. Ejemplo, fnProductos.
  • sp para stored procedures. Ejemplo, spProductos.
  • ix para índices. Ejemplo, ixProductos.

Esto me ayuda a saber con qué estoy trabajando solo de ver el nombre, ahorrándome tiempo y esfuerzos. También, me gusta nombrar mis objetos utilizando el estilo «camel case» pero puedes utilizar otro estilo con el que te sientas más cómodo. El punto es establecer un estilo que te ayude a identificar objectos y poder programar más rápidamente.

2. Usar la función ISNULL

ISNULL es una función muy útil cuyo propósito es sustituir el valor de un campo cuando es nulo. Por ejemplo, supongamos que vamos a buscar en una tabla la información de los productos de una tienda en línea. El precio del producto siempre tiene que ser numérico. Pero ¿qué pasa cuando aún no se le ha asignado un valor al precio del producto? El valor que devolvería sería NULO. Si no tenemos código que esté preparado para recibir este tipo de dato provocará que nuestro sistema explote y genere excepciones. Para esto es útil la función ISNULL. Se usa de la siguiente manera:

select productoId, productoNombre, isnull(precio, 0) as precio
from tblProductos

Este query devolverá la información de los productos como de costumbre con la diferencia de que si hay un récord donde el precio sea NULO, lo sustituirá por un 0. ¿Útil verdad? Puede cambiar el 0 por cualquier otro valor que necesites.

Nota: Aunque ISNULL es una función de SQL Server (MSSQL), otras bases de datos tienen funciones similares. Por ejemplo, en MySQL se llama IFNULL.

3. Filtrar por resultado de funciones agregadas

Hay ocasiones donde necesitamos filtrar los resultados de un query por el resultado de una función agregada (count, sum, max, min, avg, etc). Para esto podemos usar la cláusula HAVING. Se usa de la siguiente manera, supongamos que tenemos esta tabla:

productoId  productoNombre                                     productoCategoria                                  precio                cantidad
----------- -------------------------------------------------- -------------------------------------------------- --------------------- --------
1           Camisa de Hombre - Pequeña                         Camisas                                            9.99                  12
2           Camisa de Mujer - Pequeña                          Camisas                                            9.99                  8
3           Camisa de Hombre - Mediana                         Camisas                                            9.99                  15
4           Camisa de Mujer - Mediana                          Camisas                                            9.99                  10
5           Camisa de Hombre - Grande                          Camisas                                            9.99                  5
6           Camisa de Mujer - Grande                           Camisas                                            9.99                  3
7           Pantalón de Hombre - Pequeño                       Pantalones                                         11.99                 18
8           Pantalón de Mujer - Pequeño                        Pantalones                                         11.99                 5
9           Pantalón de Hombre - Mediano                       Pantalones                                         11.99                 14
10          Pantalón de Mujer - Mediano                        Pantalones                                         11.99                 9
11          Pantalón de Hombre - Grande                        Pantalones                                         11.99                 2
12          Pantalón de Mujer - Grande                         Pantalones                                         11.99                 6
13          Zapatos de Hombre                                  Zapatos                                            19.99                 7

Utilizando esos datos, necesitamos hacer un query para buscar las categorías que tengan menos de 3 productos. Escribimos el query de la siguiente manera.

select productoCategoria, count(productoId) cantidad
from tblProductos
group by productoCategoria
having count(productoId) < 3

El resultado sería:

productoCategoria                                  cantidad
-------------------------------------------------- -----------
Zapatos                                            1

Es sencillo y útil. Piensalo como una extensión a la clausula where.

4. Usar count(1) en lugar de count(*)

Siempre que sea posible usa count(1) en lugar de count(*). En lugar de tomar en consideración todas las columnas de una tabla para hacer el cálculo, solo toma la primera columna. Esto hace que la base de datos utilice menos recursos y, por consecuencia, ejecute más rápido. En bases de datos pequeñas la diferencia no será notable, pero cuando trabajamos con bases de datos con miles o millones de récords la forma en que escribimos nuestros queries tienen un gran impacto en la rapidez con la que nos devuelve los resultados.

5. Evitar usar funciones en el where

Siguiendo la misma línea del punto anterior, debemos evitar a toda costa utilizar funciones en las condiciones del where. Usar funciones en el where disminuye grandemente el desempeño de la base de datos. El problema está en que la base de datos tiene que ejecutar esa función por cada récord de las tablas mencionadas en el from. Ejemplo, supongamos que tenemos la misma tabla de productos de los ejemplos anteriores pero esta vez la tabla contiene miles de récords. Ahora necesitamos buscar los productos que tengan un precio mayor a 20. Tenemos que tener en consideración que en esta tabla pueden existir productos con el precio en NULO. La solución fácil sería:

select *
from tblProductos
where isnull(precio, 0) > 20

Aunque este query está bien hecho y no causará ningún tipo de error, no es el mejor. Como mencioné anteriormente, la base de datos tiene que calcular la función por cada récord dentro de la tabla para saber si cumple con la condición del where.

Lo que deberíamos hacer en este caso es hacer un UPDATE a esta tabla para que a todo precio que este NULO le pongamos un 0.

update tblProductos set precio = 0
where precio is null

Una vez corramos este query, entonces podemos correr el query anterior, pero sin la función ISNULL.

select *
from tblProductos
where precio > 20

6. Case when…

La cláusula de case when se puede comparar con los if-then-else o los switch de otros lenguajes de programación. Es una de las formas de poner condicionales en los queries que escribimos. Utilizando nuevamente la tabla de productos de los ejemplos anteriores, vamos a seleccionar todos los productos y determinar si el inventario está alto, bajo o no hay. Lo hacemos de esta manera.

select productoId, productoNombre, cantidad, 
       case when cantidad >= 10 then 'Alto'
            when cantidad between 1 and 9 then 'Bajo'
            else 'No Hay' end nivelInventario
from tblProductos

Esto nos devolvería el siguiente resultado:

productoId  productoNombre                                     cantidad nivelInventario
----------- -------------------------------------------------- -------- ---------------
1           Camisa de Hombre - Pequeña                         12       Alto
2           Camisa de Mujer - Pequeña                          8        Bajo
3           Camisa de Hombre - Mediana                         15       Alto
4           Camisa de Mujer - Mediana                          10       Alto
5           Camisa de Hombre - Grande                          5        Bajo
6           Camisa de Mujer - Grande                           3        Bajo
7           Pantalón de Hombre - Pequeño                       18       Alto
8           Pantalón de Mujer - Pequeño                        5        Bajo
9           Pantalón de Hombre - Mediano                       14       Alto
10          Pantalón de Mujer - Mediano                        9        Bajo
11          Pantalón de Hombre - Grande                        2        Bajo
12          Pantalón de Mujer - Grande                         6        Bajo
13          Zapatos de Hombre                                  7        Bajo

¿Ves la última columna del resultado? Varía según la cantidad de inventario por producto. Lo bonito es que puedes usar AND y OR para crear varias condiciones dentro de un mismo case.

7. Tablas temporeras

SQL Server provee la manera de crear tablas temporeras dentro de la sesión del usuario. Estas tablas son útiles para almacenar información que será utilizadas en múltiples ocasiones.

Nota: Estas tablas están disponibles bajo la sesión del usuario que las cree y serán destruidas una vez esa sesión termine.

Puedes crear las tablas temporeras de la misma manera que creas una tabla regular (por código). Existen 2 maneras:

  1. Utilizando select into
    SELECT 
        listado_de_campos
    INTO 
        #nombre_de_tabla_temporera
    FROM 
        nombre_de_tabla
    
  2. Utilizando create table
    CREATE TABLE #nombre_de_tabla_temporera(
        campo1 VARCHAR(50),
        campo2 INT
    );
    

Si te fijas, es el mismo código utilizado para crear una tabla regular, con la excepción de que las tablas temporeras siempre tienen como prefijo el símbolo «#». De esa manera sabemos que toda tabla que estemos utilizando que comience con el símbolo «#», es temporera.

Conclusión

Estos son solo 7 trucos de SQL que consideré más importante para principiantes en SQL. ¿Conoces alguno que no mencioné? Déjamelo saber en los comentarios.

Espero que les sea útil y beneficioso.