Hasta ahora, en todos los artículos de esta serie hemos visto como escribir un SELECT que nos devuelva las filas que necesitamos. Eso está muy bien y funciona perfectamente, pero tiene un problema, y es que si nuestro SELECT es muy complejo entonces se nos dificulta entender lo que hace. Para subsanar este inconveniente podemos utilizar dos (o más) comandos SELECT.
El primer SELECT hace gran parte del trabajo. El segundo SELECT completa el trabajo.
Veamos un ejemplo:
Captura 1. Enviando el SELECT a un cursor con nombre propio
En la Captura 1. el resultado del SELECT fue enviado a un cursor llamado MiCursor. Y como fue enviado a un cursor, nada vemos en la «Ventana de comandos» del Visual FoxPro. Para ver el contenido de ese cursor podemos escribir:
Captura 2. El contenido del cursor llamado MiCursor
Fíjate que lo único que escribimos es: SELECT * FROM MiCursor, tal y como te lo indica la flecha roja en la Captura 2. Lo interesante de esto es que hemos reemplazado un SELECT complejo como el mostrado en la Captura 1. por un SELECT extremadamente simple, como el que te muestra la flecha roja.
Pero además, y aquí viene lo realmente importante: podemos tratar a nuestro cursor como si de una tabla con todas esas columnas y todas esas filas se tratara. Por ejemplo, para ver todas las ventas cuyos totales sean superiores a 200 podríamos escribir:
Captura 3. Las ventas cuyos totales son mayores que 200
Desde luego que este mismo resultado podrías haber obtenido escribiendo una cláusula WHERE en la Captura 1. pero tu SELECT sería aún más complejo de lo que ya es. El SELECT de la Captura 3. es mucho más sencillo y por lo tanto mucho más fácil de entender.
Esta técnica de los dos cursores (o tres cursores, o cuatro cursores, los que necesites) nos permite obtener resultados de procesamientos muy complejos escribiendo poco y entendiendo mucho.
¿Cuándo debemos emplear la técnica de los dos cursores?
Cuando nuestro SELECT ya está muy largo y eso nos dificulta entender lo que hace. Y con mucha mayor razón si no estamos pudiendo obtener el resultado que queremos obtener. En tales casos, escribir dos (o más) cursores para dividir el problema en varias partes suele ser lo más inteligente que se puede hacer.
¿El SELECT ya está largo y te cuesta entender lo que hace y por qué no estás obteniendo el resultado que deseas obtener? Emplea la técnica de los dos cursores: divídelo en partes.
En el primer cursor pones todas las columnas que necesitarás procesar, incluyendo las subconsultas que deben estar en la lista de columnas del SELECT.
En el segundo cursor pones las cláusulas WHERE, GROUP BY, HAVING y quizás algunos JOIN que no pusiste en el primer cursor.
Si tu segundo cursor ya está largo y complejo y aún no consigues obtener el resultado que quieres, utiliza un tercer cursor. Y así sucesivamente.
Al final, el último cursor que utilices debe ser muy sencillo de entender, algo como lo que vemos en la Captura 3.
Con la técnica de los dos cursores ahorrarás mucho tiempo y quizás algún dolor de cabeza.
El defecto de esta técnica
Esta técnica no es perfecta, tiene un gran defecto.
¿Cuál es?
Que las filas se procesan más veces que las estrictamente necesarias. Por ejemplo, si la tabla tiene 1.000.000 de filas y se necesitaron 4 SELECT para obtener el resultado deseado eso significa que quizás se procesaron 4.000.000 de filas.
¿Cuál es la solución?
Una vez que se obtuvo el resultado deseado realizar el proceso inverso. Es decir lo que se agregó en el cuarto SELECT copiarlo en el tercer SELECT. Lo que se agregó en el cuarto SELECT más lo que se agregó en el tercer SELECT, agregarlo al segundo SELECT. Y lo que se agregó en el cuarto SELECT, en el tercer SELECT, y en el segundo SELECT, agregarlo al primer SELECT.
Se tendrá así un SELECT grande, feo, muy complejo, pero que funcionará perfectamente y que además será muy rápido porque procesará a todas esas filas una sola vez.
Conclusión:
Cuando el SELECT ya se está tornando muy complejo, es difícil de entender lo que hace, y no se está consiguiendo obtener el resultado deseado, lo más inteligente que se puede hacer es dividir el problema en partes.
O sea, no usar un solo SELECT sino dos o más SELECT.
Para ello, lo usual es que en el primer SELECT se escriban todas las columnas que se necesitan, esto suele implicar a la cláusula JOIN para traer a las columnas de otras tablas. El cursor así obtenido se utiliza en un segundo SELECT y es en este segundo SELECT donde se escriben las cláusulas WHERE, GROUP BY, y HAVING.
Si este segundo SELECT también se está tornando muy complejo y aún no se está consiguiendo obtener el resultado deseado, entonces se crea un cursor con nombre propio que será utilizado por un tercer SELECT. Y así sucesivamente.
El último SELECT que se escriba debe ser muy simple, muy sencillo, muy fácil de entender. Desde luego que eso de «muy fácil de entender» depende de cada quien, porque un SELECT que para una persona resulta «muy fácil de entender» para otra persona puede ser muy difícil de entender. Lo importante es que sea muy fácil de entender para la persona que escribe el SELECT.
Empleando la técnica de los dos cursores se puede muy rápidamente resolver problemas muy complicados. Trata de utilizarla en cada ocasión que se te dificulte obtener el resultado deseado.
Artículos relacionados:
De DBF a SQL (1). Introducción
De DBF a SQL (2). Reemplazando comandos
De DBF a SQL (3). Entendiendo a los cursores
De DBF a SQL (4). Ejemplos de usar SELECT con una sola tabla
De DBF a SQL (5). Las funciones agrupadas
De DBF a SQL (6). Agrupando filas
De DBF a SQL (7). Poniéndoles condiciones a los grupos
De DBF a SQL (8). Ordenando las filas
De DBF a SQL (9). Uniendo tablas
De DBF a SQL (10). Obteniendo las primeras filas de una tabla
De DBF a SQL (11). Relacionando una tabla con otra tabla
De DBF a SQL (12). Relacionando una tabla consigo misma
De DBF a SQL (13). Relacionando a varias tablas entre sí
De DBF a SQL (14). Más sobre el uso de DISTINCT
De DBF a SQL (15). Usando subconsultas
De DBF a SQL (16). Más sobre las subconsultas
De DBF a SQL (17). Ejemplos de subconsultas
De DBF a SQL (19). Hallando los porcentajes sobre un total
De DBF a SQL (20). Los operadores especiales de comparación
De DBF a SQL (22). Optimizando el uso del operador de comparación especial IN
De DBF a SQL (23). Usando la función CAST()
De DBF a SQL (24). Buscando texto
De DBF a SQL (25). Creando tablas y cursores
De DBF a SQL (26). INSERT, UPDATE, y DELETE, con subconsultas
De DBF a SQL (27). Entendiendo Cliente/Servidor
De DBF a SQL (28). Conectándose a un Servidor
De DBF a SQL (29). Las cadenas de conexión ODBC a los motores SQL más populares
De DBF a SQL (30). Conectándose mediante ADO a las bases de datos
De DBF a SQL (31). Optimizando la escritura de los SELECT
De DBF a SQL (32). Mejorando la estética de los SELECT
De DBF a SQL (33). Usando la función SQLEXEC()
De DBF a SQL (34). Enviándole parámetros a la función SQLEXEC()
El índice del blog VFPavanzado
Visual FoxPro. Técnicas avanzadas 
Mil gracias por el aporte Walter, nunca se deja de aprender algo. Saludos;
De nada Antonio.
Saludos.
Walter.