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:
- SQL Server: Generar números aleatoriamente
- SQL Server: Función Split para dividir un string
- Cómo usar regular expression en SQL Server
- Obtener solo la fecha de un campo datetime en SQL
- Cómo obtener el primer y último dia del mes en SQL Server
- Poner número de línea en SQL Server
¡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:
- Utilizando select into
SELECT listado_de_campos INTO #nombre_de_tabla_temporera FROM nombre_de_tabla - 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.
