¿Introducción a las capacidades Cliente-ServidoR?
Por Pablo Almunia Sanz

Visual FoxPro 3.0 es un gran salto en el desarrollo de aplicaciones xBase. Dentro de todas las novedades que trae esta nueva versión está la ampliación de sus capacidades en el desarrollo de aplicaciones Cliente-Servidor. Ahora es mucho más sencillo realizar conexiones a bases de datos remotas por medio de ODBC, pues Visual FoxPro nos va a permitir no sólo realizar llamadas explícitas a funciones de ODBC, sino crear vistas locales sobre tablas remotas, lo que supone que podemos trabajar con tablas de SQL-Server u Oracle práticamente como si fueran tablas del propio Visual FoxPro.

FoxPro 2.5/2.6 ya incorporaba la posibilidad de realizar aplicaciones con acceso a ficheros de otros formatos y bases de datos remotas por medio de ODBC, pero ahora esta posibilidad se potencia y simplifica, aportando nuevas y más fáciles formas de desarrollar en este entorno.

Cuando aparezca el producto definitivo, ahora en fase de betatest, las nuevas capacidades en el desarrollo Cliente-Servidor serán una de las mejoras más importantes del producto junto a la introducción de los diccionarios o bases de datos (DBC), la programación orientada a objeto y los nuevos diseñadores de pantallas.

ODBC

ODBC se ha convertido de hecho en un estándar en el acceso a datos, tanto locales en otros formatos, como remotos en servidores SQL. Visual FoxPro utiliza toda la potencia de ODBC 2.0 integrando en su versión estándar todas las funcionalidades para el acceso a estos drivers.

El producto definitivo incluirá un conjunto de drivers ODBC 2.0 para leer ficheros Access, dBase, Btrieve, Excel, Paradox y TXT, así como para conectarse a servidores SQL Server y Oracle. No son los más rápidos y mejores drivers que se pueden encontrar, existe un mercado con más de 150 fabricantes de drivers ODBC que ofrecen, en muchos casos, drivers más optimizados y que permiten el acceso a más de 50 tipos diferentes de formatos y servidores. Pero, al fin y al cabo Microsoft sólo nos regala unos pocos drivers para que empecemos a trabajar.

Integración de las capacidades Cliente-Servidor

Hasta ahora, si queríamos incluir capacidades de conexión con bases de datos remotas, debíamos adquirir FoxPro Versión Profesional, que incluye el Conectivity Kit, y cargar la librería FPSQL.FLL. Con esto obteníamos una serie de funciones para acceder por medio de ODBC a bases de datos de otros formatos y a bases de datos de servidores SQL.

Con Visual FoxPro 3.0 la posibilidad de interactuar con ODBC está implícita al producto en su Versión Estándar, es decir, se incorporan al lenguaje de Visual FoxPro todas las funciones necesarias de estos drivers, sin necesidad de adquirir o cargar ningún otro producto adicional.

Además se ha incluido toda una serie de diseñadores y asistentes para hacer más fácil e intuitivo el trabajo con Visual FoxPro y ODBC. Este conjunto de herramientas nos van a permitir de forma interactiva definir y realizar conexiones a servidores SQL sin necesidad de teclear largas listas de comandos.

Esta integración de las capacidades Cliente-Servidor en Visual FoxPro, facilitará, sin duda, la extensión del desarrollo de aplicaciones en modelo Cliente-Servidor a un mayor número de usuarios.

Funciones SQL : El SQL Pass-through

Con este término nos referimos a las funciones para la ejecución explícita de órdenes SQL por medio de los drivers ODBC, similares a las que obteníamos con el Connectivity Kit de la Versión Profesional de FoxPro. En Visual FoxPro estas funciones comienzan con las letras "SQL", a diferencia de la versión anterior que comenzaban con "DB", y son las que se señalan en el cuadro 1.

Con todas estas funciones somos capaces de realizar llamadas explícitas a los drivers de ODBC sin que estos drivers realicen la interpretación del SQL, dejando a los servidores de bases de datos realizar esta labor.

Para ejemplificar este sistema de trabajo vamos a ver un caso muy simple, pero no elemental : la obtención de los datos de tres tablas residentes en Oracle y la actualización de algunos de estos datos. Las sentencias SQL pueden ser mucho más sencillas o mucho más complejas, en esta ocasión hemos querido presentar un caso intermedio.

	****************************************
	* Programa de ejemplo                  *
	* con SQL pass-through                 *
	*                                      *
	* Conexión al servidor Oracle con un   *
	* Data Source de ODBC                  *
	****************************************
	nConexion = SQLCONNECT ;
	            ( "ORADESA", "PALMUN", "PASSWORD" )
	IF nConexion < 1
	  ERROR "Conexión no realizada."
	ENDIF
	****************************************
	* Ejecución de una consulta al servidor*
	****************************************
	IF 0 < SQLEXEC( nConexion, ; 
	                "SELECT USUARIOS.NOMBRE,"+;
	                  "USUARIOS.APELLIDOS,"+;
	                  "APLICACIONES.APLICACION,"+;
	                  "APLICACIONES.VERSION,"+; 
	                  "APLICACIONES.COMENTARIO "+; 
	                "FROM USUARIOS, APLICACIONES, ; 
	                  "USER_APLI "+; 
	                "WHERE ; 
	                  "USUARIOS.NOMBRE_CORTO = USER_APLI.NOMBRE_CORTO"+;
	                "AND USER_APLI.ORDEN = APLICACIONES.ORDEN",;
	                "user_apli" )
	  ERROR "Ejecución SQL incorrecta."
	ENDIF
	******************************************
	* Si se quiere, se pueden visualizar     *
	* en un Browse                           *
	******************************************
	BROWSE NOWAIT
	******************************************
	* Se modifican los datos en Oracle       *
	******************************************
	IF 0 < SQLEXEC( nConexion, ;
	                "UPDATE USUARIOS SET"+ ;
	                  "USUARIOS.NOMBRE = 'PEDRO'"+; 
	                "WHERE USUARIO.NOMBRE = 'JORGE '" )
	  ERROR "Ejecución SQL incorrecta."
	ENDIF
	***********************************
	* Desconexión del Servidor        *
	***********************************
	=SQLDISCONNECT( nConexion ) 
	***********
	* Fin     *
	*********** 

Como se puede ver, el esquema de desarrollo es simple, por lo menos existirá un conexión a una fuente de datos de ODBC por medio de SQLCONNECT, una o varias ejecuciones de sentencias SQL por medio de SQLEXEC y un cierre de la conexión con SQLDISCONNECT.

Este esquema se puede perfeccionar y completar definiendo el modo de realizar las transacciones, definiendo ejecuciones asíncronas o batch, etc.. Pero en definitiva el sistema es simple y las posibilidades son muchísimas.

Definición de conexiones: CREATE CONNECTION

Una de las posibilidades incorporadas a Visual FoxPro es la de utilización de los servicios de ODBC a través del entorno y no sólo por medio de comandos y funciones. Ejemplo de esto es la posibilidad de crear conexiones predefinidas por medio del Diseñador de Conexiones. Para ejecutarlo deberemos tener abierta una base de datos (DBC) y teclear CREATE CONNECTION.

Por medio de este diseñador podemos definir todas las características de una conexión a bases de datos por medio de ODBC de forma sencilla y sin necesidad de utilizar las funciones SQLSETPROP y SQLGETPROP para su configuración. Esta conexión se almacena dentro de la base de datos (.DBC) y está disponible siempre que abramos la base de datos en cuestión.

Creación de Vistas sobre tablas remotas: CREATE SQL VIEW

Otra posibilidad de trabajo diferente al uso de SQL pass-through es la utilización de Vistas Remotas. Las vistas están definidas en las bases de datos (.DBC), junto a las conexiones, tablas y procedimientos almacenados y pueden referirse tanto a datos locales (DBF) como a datos remotos (obtenidos por medio de ODBC).

Para definir una vista y sus propiedades podemos utilizar una serie de ordenes SQL o utilizar el entorno de desarrollo. La orden básica para crear vistas es CREATE SQL VIEW. Con ella podremos crear una vista sobre tablas remotas. El caso más sencillo es realizar la vista sobre todos las columnas de una tabla, para ello la sentencia es simplemente :

	CREATE SQL VIEW usuarios ;
	  REMOTE CONNECTION oradesa ; 
	  SHARE AS SELECT * FROM ;  
	  USUARIOS

En ese instante la vista queda incoporada en la base de datos (DBC) que tengamos abierta en ese momento. De esta forma podemos vincular una vista remota de Visual FoxPro con cada tabla del servidor SQL sin apenas complicación y haciendo totalmente transparente el uso de las mismas.

La vista no tiene por qué restringirse a una sóla tabla, es muy posible que deseemos ver como una vista de Visual FoxPro varias tablas remotas. Siguiendo con el ejemplo anterior podemos definir la vista sobre los datos de esas tres tablas como se muestra en este ejemplo.

	CREATE SQL VIEW User_apli REMOTE CONNECTION oradesa SHARE 
	    AS SELECT USUARIOS.NOMBRE,                        ;
	              USUARIOS.APELLIDOS,                     ;
	              APLICACIONES.APLICACION,                ;
	              APLICACIONES.VERSION,                   ;
	              APLICACIONES.COMENTARIO                 ;
	        FROM  USUARIOS, APLICACIONES, USER_APLI       ;
	        WHERE USUARIOS.NOMBRE_CORTO = USER_APLI.NOMBRE_CORTO ;
	              AND USER_APLI.ORDEN = APLICACIONES.ORDEN

De esta forma estamos definiendo una vista sobre algunos de los datos de tres tablas unidas por medio de una "Join". Podemos complicar la definición de la vista tanto como lo deseemos, sin apenas esfuerzo por nuestra parte.

Creación de Vistas sobre tablas remotas: DISEÑADOR DE VISTAS

La otra posibilidad es utilizar el Diseñador de Vistas. Para ello deberemos abrir un base de datos con la sentencia OPEN DATABASE y una vez abierta la modificaremos con MODIFY DATABASE, nos aparecerá el diseñador de bases de datos y seleccionaremos en el menú 'Database' la 'New Remote View' o pulsaremos el icono correspondiente de la barra de herramientas.

Se nos pedirá que seleccionemos conexión ODBC almacenada en la base de datos o alguna fuente de datos predefinida :

Una vez seleccionada la conexión ODBC se nos abrirá el Diseñador de Vistas, muy similar al generador de consultas. En este diseñador seleccionaremos las tablas remotas sobre las que deseamos hacer la vista. En este caso hemos seleccionado las tres tablas relacionadas que venimos utilizando, a fin de obtener la vista con datos de las tres. La definición puede llegar a ser muy sencilla -todos los datos de una sóla tabla- o muy compleja -pudiendo definir multitud de parámetros, selecciones, órdenes, agrupación, campos a visualizar y criterios de actualización.

Una vez cerrado el diseñador y dado un nombre a la vista, la definición de la misma será almacenada en la base de datos. Siempre que tengamos abierta esta base de datos, podremos hacer uso de la vista.

Trabajo sobre vistas remotas: Como tablas Fox

Pero, ¿cómo trabajamos con las vistas remotas? Cuando abrimos una bases de datos que tiene definida una vista podemos utilizarla como si se tratara de una tabla normal. Por ejemplo, podremos abrirla con USE, utilizar sus datos en programas, hacer modificaciones con APPEND y REPLACE o con SQL, realizar búsquedas, etc..

Para mostrar la transparencia en el uso de una vista he aquí el aspecto de una vista remota desde un BROWSE después de haber hecho un simple USE :

	OPEN DATABASE Data1
	USE user_list
	BROWSE

Todas las operaciones que realizamos sobre la vista, como añadir un registro, o modificar un dato, se corresponden a operaciones sobre las tablas originales, de este modo si realizamos una modificación en los datos de la vista, estamos modificando automáticamente los datos en las tablas remotas y si alguien realiza un cambio en un valor en la tabla remota, nosotros observaremos ese cambio en la vista.

Podemos no darnos cuenta de la importancia de este hecho, podemos trabajar con datos remotos como si fueran datos de Visual FoxPro, manteniendo una total integridad entre la vista remota que maneja Visual FoxPro y los datos del servidor SQL, sin que sea necesario por nuestra parte ningún código específico para ello, simplemente definiendo los datos como una vista remota.

Un ejemplo. Sobre la vista que hemos definido anteriormente vamos a modificar algunos valores y esta modificación será realizada automáticamente en las base de datos remota.

	********************************************
	*
	* Programa de ejemplo con vistas
	*
	*******************************************

	***************************
	* Abre la Base de Datos   *
	***************************
	OPEN DATABASE Data1

	*******************************************
	* Abre la vista sobre tablas de Oracle    *
	*******************************************
	USE User_apli

	*******************************************
	* Si se quiere, se pueden visualizar en   *
	* un Browse                               *
	*******************************************
	BROWSE NOWAIT

	******************************************
	* Se modifican los datos en Oracle       *
	******************************************
	REPLACE Nombre WITH "PEDRO" FOR Nombre == "JORGE          "

	***********
	* Fin     *
	***********

Las posibilidades son inmensas, podemos relacionar tablas locales con vistas remotas, realizar todo tipo de operaciones sobre los datos remotos, realizar búsquedas, modificaciones, etc. Es prácticamente indiferente trabajar sobre tablas locales que sobre vistas remotas, es decir, gracias a la capacidad de Visual FoxPro de definir vistas remotas podremos trabajar en un entorno Cliente-Servidor de forma transparente.

Asistente para Upsizing

Gracias a la enorme similitud en el trabajo con tablas locales y con vistas remotas, es posible realizar las labores de desarrollo sobre vistas o tablas locales y en un momento dado, cercano a la finalización del proyecto, realizar una migración de las estructuras de datos y relaciones a un Servidor SQL tipo SQL-Server u ORACLE. Esto nos permite desarrollar sin necesidad de disponer de un servidor SQL, siempre costoso.

Para ayudar en esta labor de migración desde las tablas y vistas locales a tablas en un servidor SQL existe el "Upsizing Wizard" (o asistente de 'upsizing'), que nos facilita el traslado del diseño de nuestra base de datos desde Visual FoxPro a un servidor de Bases de Datos.

Si bien es posible que en la versión definitiva de Visual FoxPro el asistente tenga algunas modificaciones sobre la versión beta actual, ésta es una de las pantallas del mismo :

Su uso es muy sencillo, siguiendo sus indicaciones seremos capaces de trasladar nuestro modelo de datos local a un modelo Cliente-Servidor. Es decir, una vez realizado este upsizing nuestra aplicación pasará a trabajar sobre un diseño Cliente-Servidor, en principio, sin más modificaciones, aun cuando debe de tenerse en cuenta algunos aspectos sobre el nuevo diseño y ajustar los parámetros de las vistas remotas a fin de que sea un sistema efectivo.

Conclusión : Una de las mejores herramientas para el modelo Cliente-Servidor

Visual FoxPro está llamado a convertirse en una de las mejores herramientas para el desarrollo de aplicaciones en entornos Cliente-Servidor. Conjuga un sistema de desarrollo muy optimizado por medio de "forms", un lenguaje xBase potente y extendido, una programación orientada a objeto sencilla y efectiva, una velocidad en el manejo de datos locales inmejorable y unas capacidades de acceso a datos remotos sorprendentemente fáciles.

Por lo tanto, la revolución que sin duda supone la aparición de Visual FoxPro nos acercará a todos un poco más al interesante mundo del desarrollo de aplicaciones en entornos Cliente-Servidor.