Tutorial Básico de PowerBuilder

Tutorial Básico de PowerBuilder
Arphean
Se permite copia y distribución siempre que se cite la fuente de procedencia y el autor.
© Arphean Nih – Alls rights reserved
anih@ozu.es
http://arphean.mirrorz.com
Nota: Algunas partes de este manual están realizadas con la ayuda, información y soporte de
varios programadores. Agradezco a todos ellos su esmero y trabajo sin los cuales tutoriales
como el presente serían mucho mas difícil de llevar a cabo.
Se ha creado el archivo .pdf sin contraseña ni protecciones con la única intención de
facilitarte su lectura y futuros tratamientos, así como de que pueda ser abierto por cualquier
versión del reader de pdf. Por ello, ten en consideración nuestro trabajo y no lo modifiques ni
alteres sin consentimiento previo, y, si lo distribuyes, cita siempre su procedencia. Obra
altruistamente tal como nosotros te lo ofrecemos también altruistamente.
Gracias.
Índice
Presentación
Crear tu base de datos.
Creación de vínculos ODBC
Creación de tablas.
Introducción de valores en tablas
PowerBuilder
Creación de ventanas
Creación y enlace de BBDD desde PowerBuilder
DataWindow
Generar aplicaciones con PowerBuilder
ANEXOS
Anexo 1: PowerScript: fundamentos del lenguaje
Anexo 2: SQL
Presentación
Existen muy pocos libros e información en español sobre PowerBuilder, por lo que la
información sobre esta materia es realmente escasa. Por ello, he decidido comenzar
a trabajar sobre un tutorial que presente esta RAD de una forma sencilla, para todos
aquéllos que ya poseen algún conocimiento de programación.
Para que le saques el mayor provecho a este tutorial, es necesario que poseas un
conocimiento de los menús y de los conceptos de PowerBuilder, ya que este punto
solo voy a tocarlo por alto. Ello es bien facil, puesto que por Internet existen varios
documentos y artículos sobre los menús y sus funciones en PowerBuilder.
Comenzaré diciendo que PowerBuilder es una herramienta muy potente (de las mas
potentes que existen en la actualidad para esta tarea, sino la que mas) para
desarrollar bases de datos. Por lo tanto, PowerBuilder está orientado, sobre todo y
ante todo, a bases de datos.
En el presente tutorial desarrollaremos, valiéndonos de un ejemplo (que es como
mejor se aprende) una pequeña aplicación que nos servirá para trabajar con una
base de datos, acceder a ella, y realizar ciertos trabajos con sus datos.
Trabajaremos con PowerBuilder en su versión 10.5, si bien, aunque tu versión sea
algo más atrasada no importa, siempre y cuando no sea inferior a la 8.0 los cambios
son mas que nada estéticos.
El tutorial está profusamente ilustrado, de manera que resulte mas fácil y rápido el
aprendizaje.
1
Personalmente las versiones de PowerBuilder que considero mejores son las 5.0 y
6.0, creo que son las mas rápidas y las más estables. No obstante, los tiempos
actuales ponen sus modas y esto ha hecho que PowerBuilder haya cambiado y
empeorado, en algunos aspectos, bajo mi punto de vista.
Aún así, continúa siendo la mejor herramienta para aplicaciones de bases de datos.
Crear tu base de datos.
En casi todas partes inician su trabajo presentandote a PowerBuilder y su ambiente
de trabajo, y creando mas tarde las bases de datos. Creo que es un error, ya que
mezclan conceptos y, didácticamente, es mas enrevesado de entender. PowerBuilder
es una RAD, es decir, una aplicación de desarrollo. Las bases de datos son otra cosa,
y no deberían mezclarse, ya que podemos con trabajar con bases de datos ya
creadas, del cliente, o que nosotros vayamos a crear después. Y tal cosa a
PowerBuilder no le importa en absoluto, porque es algo externo a él.
Nosotros vamos a crear la base de datos con Sybase Central, una herramienta que
se incorpora en la suite de PowerBuilder. Podemos crear las bases de datos de forma
independiente, esto es totalmente flexible. Sin embargo, para un conocimiento más
profundo de lo que estamos haciendo, creo que es la mejor forma de empezar.
Sigamos la ruta siguiente para abrir Sybase Central: programas/sybase/SQL
Anywhere 9/Sybase Central.
Nos aparecerá una pantalla como esta:
Vamos a empezar a construir la base de datos:
2
Hacemos clic en el tree view de la izquierda, seleccionamos “adaptative server
anywhere 9” (aquí estamos eligiendo un tipo de servidor virtual), y seleccionamos la
pestaña de la parte derecha que lleva por nombre Utilities.
Si trabajas con una versión anterior de Sybase Central, puede ser que las opciones
no estén como aquí las ves, pero sí que están, y son las mismas. En versiones
anteriores, por ejemplo, las Utilities las tienes en el propio Tree View, pero es lo
mismo y cumplen la misma función.
Elegiremos, con doble click, el campo “Create Database”. Aparece el siguiente
cuadro de creación de base de datos:
A continuación, introduce los datos tal como siguen:
3
Nos informa que se va a proceder a la creación de la base de datos localmente (en la
computadora), por lo que un servidor local, como hemos dicho antes, será iniciado
automáticamente.
Caso de que deseemos crear la base de datos en un servidor (si estuviéramos
conectado al mismo), nos aparecería en el listado inferior.
Ahora nos pregunta dónde vamos a guardar la base de datos, junto con el nombre
del archivo, físico, que esta va a recibir. Pon el mismo nombre que ves en la imagen:
4
Le damos a Next y aparece la siguiente pantalla:
5
Aquí no hay nada que añadir, la explicación es suficientemente clarificante. Sigamos:
Le damos a Next en la siguiente pantalla, y seguimos dándole a Next hasta que
aparezca:
Nos pide que confirmemos instalación para acceso a base de datos con profiles Java
(JDBC driver), en caso de que no lo tengamos instalado. Como estos accesos Java
suelen ser bastante lentos y, por el momento, conflictivos y arcaicos, lo mejor es
que no instalemos nada, por lo que desmarcamos la casilla y pulsamos en Next.
Deje los campos como en la imagen, y pulse Next:
6
Sigamos dándole a Next, para dejar todas las opciones por defecto (que no deberían
modificarse a no ser que lo deseemos expresamente por alguna razón), hasta que
nos encontremos con la siguiente pantalla:
Llegados a este punto cabe destacar que es conveniente que anotemos, bien en un
papel o en aplicaciones independiente, como RakEdit, todos los datos con los que
estamos configurando nuestro acceso a base de datos y nuestra propia base de
datos. Esto es primordial para modificaciones futuras, o para facilitarnos los trabajos
de reestructuración o remodelación que puede que tengamos que llevar.
Le damos al botón Finish para concluir la creación de la base de datos.
Ahora Sybase Central procederá a crear la base de datos propiamente dicha, a
guardarla en disco, y a iniciarla. Si todo ha ido bien, nos tendrá que aparecer un
mensaje como este:
7
Ya podemos ver la base de datos creada y conectada desde Sybase:
Creación de vínculos ODBC
Ahora vamos a crear el vínculo ODBC que servirá de enlace con nuestra base de
datos, aunque hay que mencionar que esto también puede ser llevado a cabo desde
PowerBuilder. Aquí explicaremos un procedimiento, pasando, una vez estemos en el
entorno de PowerBuilder, a explicar el otro, para que así sepas los pasos de todos.
Para ello, volvemos a pinchar en Adaptative Server Anywhere, pestaña (o tab, para
los puritanos) “Utilities”, y seleccionamos, en lugar de “Create Database”, como
hemos hecho antes, la última opción de la List, que es Open ODBC Administrador:
8
Le damos doble clic y nos aparece una ventana como la siguiente:
Bien, no nos asustemos, aquí nos aparecen muchas cosas (y algunas que son basura
de mi propio ordenador, tranquilos).
Esta es la gestión de todas las bases de datos, desde aquí podremos eliminarlas y
gestionar sus accesos. Nosotros le damos al botón “Agregar” del tab “DSN de
usuario” (el primer tab):
9
Seleccionamos Adaptative Server Anywhere 9.0 (u la versión del ASA con que
estemos trabajando), y le damos al botón Finalizar.
Nos aparece una ventana con muchas cosas, así que tranquilidad, que aún ni hemos
abierto PowerBuilder ni siquiera hemos enlazado el ODBC con él, de modo que
paciencia, que el mundo no se hizo en dos dias:
“Data source name” es un nombre para los datos, y Description es eso, solamente
una pequeña descripción de la base de datos. Rellene los campos tal como ve aquí:
10
En la siguiente pestaña nos solicitará un login y un password. Esto es muy
importante, y son los datos de acceso que usaremos después con PowerBuilder, de
modo que recuerde anotarlo todo:
Nosotros pondremos como en la figura, es decir, en UID (user ID) DBA, y en
Password, SQL.
Vayamos a la siguiente pestaña. Aquí nos pide que introduzcamos el archivo bd
(base data) que hemos creado antes con Sybase, o que ya tengamos en disco
previamente. Lo localizamos y se lo introducimos. En Database name le vamos a
poner basedatos2, como hicimos al crearla.
Las demás son opciones que no necesitamos, por lo que le damos al botón Aceptar
para finalizar el enlace ODBC.
Nos aparecerá nuestra nueva base de datos en la DSN de usuario:
11
Cabe señalar que, en algunos casos, deberemos también incluir la base de datos en
el DSN de sistema. Si es así, solamente tenemos que seguir los pasos ya explicados,
pero en la segunda pestaña.
Si nos hemos equivocado en algo, o queremos modificar algo, solamente tendremos
que elegir la base de datos por su nombre, y seleccionar el botón “configurar”.
Creación de tablas.
Como es de suponer, una base de datos no sirve de nada si dentro no posee
información almacenada. Por ello, vamos a crear dos sencillas y simples tablas en
donde añadiremos datos.
Como aún tenemos Sybase Central abierto (y si lo has cerrado, tendrás que abrirlo
de nuevo y conectarte a la base de datos de nombre basedatos2 desde la ruta
file/connect… , teniendo, previamente, seleccionada en el tree view el “Adaptative
Server Anywhere 9”).
Antes de crear las tablas, refresquemos la memoria sobre lo que son y cómo se
organiza la información en ellas.
La tabla de una base de datos es una colección de información homogénea
(relacionada entre si). Los elementos de esta información se denominan registros,
cada registro esta conformado por idéntico número y tipo de campos. Cada campo
tiene asociado un nombre; por el que se identifica, y un tipo de dato, que especifica
la información que podrá almacenar dicho campo.
Una Tabla puede tener 0 o más registros y la definición de un registro deberá contar
con al menos un campo.
Clave Primaria
La clave primaria ('Primary Key') es el(los) campo(s) que permiten identificar a un
registro.
Clave Foránea
12
La clave foránea (‘Foreign Key’) es un(os) campo(s), cuyo valor(es) deben estar
presente en otra Tabla y los campos de esta segunda Tabla deben ser (o formar
parte) de la Clave primaria. Esto último permite definir una relación de integridad
entre los datos; la existencia de el dato en la primera Tabla esta condicionado a la
existencia de el(los) mismo(s) dato(s) en la segunda Tabla.
Indices
Los índices ('Index') se definen para mejorar la búsqueda y selección por parte del
motor de Base de Datos. Una Tabla puede tener varios índices definidos, o tener
ninguno. Cada índice se crea para uno o más campos, estos últimos se llaman
"Indices compuestos".
Toda esta gestión la llevaba muy fluidamente a cabo PowerBuilder hasta su versión
8.0, aproximadamente. A partir de ahí la configuración y definición es bastante mas
compleja y es muy facil perderse.
Nosotros vamos a crear tres tablas. La primera almacenará una serie de usuarios y,
dependiendo de esos usuarios, aparecerán unos datos u otros. La segunda
almacenará unos niveles por los que esos usuarios tendrán privilegios o no.
Es decir, en la tabla Usuarios incorporaremos:
usu_nivel
usu_login
usu_pass
usu_activo
usu_num
En la tabla Privilegios incorporaremos:
priv_nivel
priv_descripcion
Este es un ejemplo bastante común de acceso por niveles, y se suele usar en
diferentes tratamientos de bases de datos.
Para crear la tabla, vayamos a Sybase Central, seleccionamos nuestra base de datos
(basedatos2), después la carpeta “Tables”, y pulsamos el icono “new table”, o
también podemos hacer lo mismo con clic derecho sobre el campo Tables de la
derecha. En cualquiera de estas formas, nos aparecerá lo siguiente:
13
El nombre de la tabla, y le seguimos dando a Next, dejando todos los valores sin
modificar nada, hasta que tengamos los campos de la tabla listos para editar. Por
defecto, el primer campo será una clave primaria, por lo que no podrá estar
repetido. Esto, por supuesto, es opcional, pero a nosotros nos viene de perlas.
Introduce los campos tal como están a continuación:
Para ingresar nuevas columnas, pulsa con el botón derecho del ratón sobre la tabla:
Al final de la introducción de los datos, deberás guardar los cambios pulsando sobre
“guardar tabla”:
14
Ahora procedamos a crear la tabla de Privilegios. Aunque en la figura no aparezca,
señalemos como clave Primary Key (PKey) el campo “priv_nivel”:
Introducción de valores en tablas
Tras ello, vamos a rellenar los registros, introduciendo una serie de datos. Para ello,
podemos editar las tablas desde el último tab (Data), y pulsando sobre el botón + o
con clic derecho sobre el campo vacío:
En la tabla Privilegios introduciremos:
En la tabla Usuarios introduciremos:
Bien, ya tenemos nuestras tablas creadas y podemos empezar a trabajar con ellas
sobre PowerBuilder.
15
PowerBuilder
Lo primero que tendremos que hacer es crear un espacio de trabajo (workspace).
Clic en archivo/nuevo y seleccionamos Workspace (el primer tab). Nos pedirá un
nombre, lo guardaremos como ws_bd2.
Una vez creado nos aparecerá en el tree view:
Creamos ahora la aplicación propiamente dicha, sobre el workspace. Nuevo y
seleccionamos el segundo tab (target), y el icono Application:
Rellene los campos de la ventana de la aplicación tal como aquí aparecen:
Podemos desplegar el TreeView, donde nos aparecen todos los archivos y
complementos de la aplicación, junto con todo lo que esta incorpora:
16
Podemos acceder al nombre de todos sus eventos y propiedades que contenga,
desplegando las carpetas bajo el nombre de la propia aplicación (aunque esto no
siempre funciona, esperemos que en futuras versiones corrigan ciertos bugs del
IDE).
Creación de ventanas
Insertemos ahora una ventana, donde iniciaremos los parámetros de nuestra
aplicación de acceso a bases de datos. Para ello, vayamos a New, pestaña PB Object
(Power Builder Object) y seleccionamos Window.
En Propiedades (a la derecha), pongamos de nombre “Ventana Inicio”. Pulsando el
botón “Guardar” (arriba, a la izquierda), le ponemos de nombre a la ventana
w_inicio:
Procedamos ahora al diseño de la ventana de acceso tal como sigue:
17
El primer Single Line Edit lo llamaremos sle_login, el siguiente (el del Password), lo
llamaremos sle_pass. En properties (propiedades), clickearemos el box “mask” para
activarlo, de modo que cuando introduzcamos el password las letras no se visualicen
como tales.
El botón Aceptar lo llamaremos cb_aceptar, y el Cancelar, cb_cancelar.
Al botón Aceptar le activaremos el check “default”.
Ahora crearemos otra ventana, y la llamaremos w_principal. Será una de las
ventanas principales de nuestro programa.
Para ello, procedamos como en la ocasión anterior, desde el botón “new”.
Una vez la tengamos creada, volvamos a la ventana anterior, de inicio, y
seleccionamos el botón “Aceptar”. Clic sobre él y seleccionamos el ítem “script”:
Se nos abre el editor de PowerScript con el evento clicked() (que saltará al ser
pulsado el botón) seleccionado. Escribamos en él el código que viene a continuación:
18
Aquí le estamos diciendo que acceda a la base de datos y compruebe si el login y el
password, almacenados en los registros de ella, son correctos. En caso de que los
datos sean correctos, nos abrirá una ventana para gestionar la tabla de Usuarios
(ventana que haremos mas adelante).
Creación y enlace de BBDD desde PB
En DSN le decimos el nombre de nuestra base de datos. Caso de haberla nombrado
“basedatos2”, o “base2”, etc., deberemos escribirlo ahí.
DBA es el user, y SQL, el password para bases de datos en ASA 9.
Pero antes de llevar la tarea a cabo, vamos a enlazar la base de datos con
PowerBuilder:
En la barra de herramientas, seleccionamos “DB profile” (perfil de base de datos).
En el cuadro que nos aparece, seleccionamos ODB ODBC profile, y le damos al botón
“New…”:
19
Rellenamos los campos tal como aparecen aquí, teniendo cuidado en que el nombre
y el password sea el que nosotros le hayamos puesto. Dado que le hemos puesto
antes DBA de user, y SQL de password, es lo que deberemos incluir (no como está
en la imagen):
En la pestaña Preview nos aparecen los datos de la conexión, con la posibilidad de
copiarlos para que los podamos usar en nuestras aplicaciones:
20
Podemos realizar un test de conexión, para ello, pulsamos el botón “Test
Connection” y seleccionamos la base de datos a la que queremos conectarnos:
21
Si la conexión se ha realizado con éxito, aparecerá el siguiente mensaje:
Seleccionamos ahora el icono DataBase, para enlazar la base de datos con
PowerBuilder:
Seleccionamos nuestra base de datos:
22
Y le damos al botón conectar (previamente deberemos desconectarnos de la base de
datos en el Sybase Central, así como cerrar el programa para trabajar mejor):
Con el botón derecho del ratón sobre la base de datos, tendremos los mismos datos
que desde el DB Profile.
Cabe mencionar aquí que en estas últimas versiones de PowerBuilder el trabajo
desde el Database es bastante frágil, quedando fácilmente bloqueadas o “colgadas”,
cosa que no ocurría en las anteriores versiones del programa. Prueba de ello es que
mensajes como este te resultarán familiares, algo impensable hace solo algunos
años en esta herramienta:
DataWindow
Vamos a añadir ahora un objeto Data Window, que es el que nos proveerá de acceso
a los datos propiamente dichos.
Ello lo podemos realizar desde new/data window:
23
Ahora deberemos seleccionar un tipo. Para el ejemplo elegiremos Grid.
La manera de búsqueda de datos elegiremos Quick Select, que es el más rápido y
sencillo:
Ahora nos pedirá que seleccionemos la tabla, o tablas, de la base de datos, junto con
una serie de opciones simplemente visuales. Al final, se abrirá una ventana como la
que sigue:
24
Esta ventana está construida a partir de componentes XML, lo cual es una novedad
de las últimas versiones. Esta clase de presentación, aún a pesar de ser muy vistosa,
deja bastante que desear desde el punto de vista práctico.
Se pueden mover, redimensionar y desplazar todos los elementos visualmente,
tecleando con el ratón y moviendo sus cuadros, dando una presentación de tal como
quedará en tiempo de ejecución.
Se nos activará también la barra de herramientas para facilitarnos ciertos cambios
de inserción, movimiento y demás en el objeto de bbdd:
Ahora vamos a proceder a la creación de la ventana w_principal, que nos presentará
los datos de la tabla Usuarios.
El aspecto será el siguiente:
25
Incorporaremos tres botones, el primero llamado “insertar registro” será cb_insertar;
el segundo, “borrar registro”, será cb_borrarreg; y el tercero, “borrar fila”, será
cb_borrarfila.
También incorporaremos un control Data Window, que llevará por nombre dw_1.
El control Data Window es el mas importante en PowerBuilder, y establece una
conexión visual de datos entre nuestra base de datos (objeto DataWindow) y nuestra
aplicación (Control DataWindow).
El control Data Window está en la paleta de controles, solamente tendrás que
elegirlo y redimensionarlo en la ventana:
Ahora, tendremos que decirle con qué objeto Data Window trabajará el control, para
ello, nos vamos a la paleta de propiedades, teniendo seleccionado el control
DataWindow, y de la ventana que aparece elegimos dw_1 (el único que debe
aparecernos).
Fijarse en este punto que, aunque le hemos llamado por el mismo nombre (dw_1) a
ambos, son cosas diferentes.
26
Fijémonos también que el control DataWindow posee varias opciones que podemos
activar en su paleta de propiedades, activemos por tanto los checks HScrollBar y
VScrollBar, para que se visualicen las barras de desplazamiento.
Ya podemos ejecutar la aplicación. Pero antes, vamos a depurarla y compilarla
pulsando sobre el icono:
También podemos previsualizar las ventanas desde el modo diseño pulsando sobre:
Esta forma de previsualización de los modos de diseño es una de las mejores
cualidades que siempre ha tenido PowerBuilder.
Ya podemos ejecutar la aplicación clickeando sobre el icono de Run:
Si todo ha ido bien, tras poner nuestro nombre de usuario y contraseña (nombre y
pass que deben haber sido añadidas previamente a la tabla de la base de datos,
como es obvio) nos aparecerá la ventana w_principal.
Pero… ¿los datos no se visualizan en el control DataWindow, verdad? Por supuesto.
Para que esto ocurra, debemos indicárselo expresamente al control.
Volvamos al programa y eliminemos, o pongamos como comentario, las siguientes
líneas de código del botón Aceptar en la ventana w_inicio:
27
Ahora realiza un doble clic sobre la Aplicación basedatos2 (o el nombre que tú le
hayas puesto), y escribe lo siguiente en su evento Open:
Como le hemos quitado la llamada a la base de datos en el evento Clic del botón, se
la hemos puesto aquí, y con esto le decimos que se conecte mediante SQLCA
haciendo una llamada al objeto Transacción. Este objeto controla en todo momento
los accesos a la base de datos, y recoge los posibles errores. Para ello, hemos usado
también un messagebox.
SQLCA es el acrónimo de “SQL Communications Area”, y es el objeto de transacción
que utiliza por defecto PowerBuilder.
Tal como hemos añadido la conexión a la base de datos al abrir la aplicación,
deberemos desconectarnos de ella al salir, por lo que, sin salir del editor, y en el
evento Close escribimos:
Ahora vayamos al código de la ventana w_principal. Lo primero que deberemos
hacer es conectar el DataWindow a la base de datos. Para ello, en el evento Open de
la ventana, escribimos:
28
Mediante la función settransobject, le decimos al DataWindow qué objeto de
transacción usamos. Con retrieve obtenemos los datos y los visualizamos.
Prueba ahora el programa y verás como ya se visualiza la tabla de la base de datos.
Como ejercicio práctico, cambia ahora el nombre del DataWindow control a dwc_1,
de esta forma mas adelante ya no lo confundirás con el Objeto. Presta atención a
que también deberás cambiar el nombre en todas las llamadas al código que le
mencionen, por lo que tal ejercicio te vendrá bien para que cojas un poco de soltura
con el RAD de PowerBuilder.
Vamos a darle un aspecto un poco más “profesional” a la aplicación, haciendo que,
mediante una variable global, se personalice el título de la ventana principal.
Para ello, retiramos del código de la ventana w_inicio la variable usuario, y la
ponemos en la zona de declaración de variables globales de la aplicación:
Ahora tenemos que retocar el código del botón “Aceptar” en el w_inicio, añadiendo,
tras la llamada a la apertura de la ventana w_principal ( que es, como se recordará,
open(w_principal) ), el siguiente código:
w_principal.title=usuario + " Principal"
Si despliegas la carpeta de “Functions” del control DataWindow en el treeview,
podrás ver un listado con todas las funciones que dicho control incorpora, incluida
retrieve():
29
Esto lo podrás hacer en todos los demás controles u objetos que tengas en tu
aplicación.
Vamos ahora con el código de los botones que hemos incorporado. En el evento
“Clicked” del botón “insertar registro”, escribiremos:
Esta instrucción insertará un registro en la primera fila. Va acompañada del número
de la fila en la cual insertarse, siendo 1 un registro en la primera fila, y 0 un registro
al final.
En el botón de “borrar registro”, por su parte, escribiremos:
Por supuesto, como antes, en el evento Clicked. El nombre del botón lo tienes en la
imagen, en la parte superior (cb_borrareg, en este caso), y así como el evento, en el
list de la derecha del mismo (clicked(), en la imagen).
Ese codigo borrará el registro que esté seleccionado. Si lo que deseas es borrar una
fila en particular (obteniéndola a partir de un SingleLineControl o cualquier cuadro de
petición), deberás incluir el número de la fila a eliminar, por ejemplo, para eliminar
la fila 2:
30
dwc_1.deleterow(2)
Para el botón “borrar fila” realizaremos una pequeña modificación, de forma que
podamos manejar, aunque resulte algo engorroso (pero a efectos didácticos, muy
útil), los datos que el usuario nos introduzca.
Crearemos una variable global tal como aquí se ve, en la sección correspondiente,
como aparece en la imagen, sin movernos de la ventana w_principal:
Ahora, junto al botón “borrar fila”, incorporaremos un SingleLineEdit, tal como
aparece en la imagen, y un botón aceptar. A ambos le desactivaremos la propiedad
Enabled. Al sle le llamaremos sle_borrafila, y al botón, cb_borrafilaa, que será el
encargado de realizar la acción sobre la tabla:
En el código del botón “borra fila” incorporaremos:
Mientras que, en el del cb_borrafilaa, haremos:
31
Como se puede ver, el código es muy fácil. Solamente cabe mencionar que llamamos
a la función de PB “IsNumber”, que comprueba si lo escrito en el sle es un número.
Por supuesto, esto es muy básico, y lo lógico sería implementar un código que
comprobara que el número es factible, etc.
Ahora nos queda la parte mas importante del trabajo con las bases de datos, que es
la actualización y guardado de sus datos. Para ello, PowerBuilder nos ofrece algunas
funciones dentro de su control DataWindow.
Insertaremos un botón, al que llamaremos “Guardar”, y con nombre cb_guardar. En
su código de evento Clicked introduciremos:
Commit actualiza la base de datos en caso de que no hubiera ningún error, si se
produce algún error, se llama al método Rollback, de modo que los cambios no
surtan efecto.
Hecho esto, probemos la aplicación. Si no hay ningún error, la base de datos se
actualizará. Ahora probemos a introducir una fila con datos corrompidos, por
ejemplo, todo números, y dejemos campos clave sin rellenar. Nos aparecerá un error
parecido al siguiente:
32
Podemos personalizar los errores a nuestro gusto desde el DataWindow. Para ello,
selecciona el control DataWindow de w_principal, y escribe en su evento dberror el
siguiente código:
Esto hará aparecer un mensaje con el título “error”, y el testo con el error producido.
“Return 1” se utiliza para que el mensaje por defecto no se visualice.
Introduzcamos ahora un botón en la ventana principal al que llamaremos “Buscar
Usuario”, y le pondremos por nombre cb_busca. A su lado, ponemos un sle con el
nombre sle_busca, de una manera parecida a esta:
33
En el evento Clicked del botón introduciremos el siguiente código:
Explicaremos a continuación su significado: introducimos dos variables, una de tipo
long y otra string. En la de string, mediante la función Trim, que retirará espacios en
blanco del sle, si los hubiera, introducimos el valor del texto que escriba el usuario.
La variable cadena_bus es interesante, en ella introduciremos un número, que
corresponderá al de celda, usando el método Find del DataWindow, diciéndole que
busque en la columna “Usu_login”, pasándole como parámetro la variable que
contendrá la cadena a buscar, y, diciéndole que comience la búsqueda por la primera
celda, es decir, por la 1.
Lo demás es solamente una sentencia condicional para tratar los errores que puedan
producirse y el resultado.
Cabe mencionar aquí que el método Find devolverá la primera coincidencia que
encuentre, caso de estar repetida, la ignorará. Para tratar varias coincidencias
podremos crear bucles o diferentes bifurcaciones que las almacenen, o mediante un
contador, ir incrementando la celda de 1 en uno, hasta llegar al final, de una forma
que podría darnos una idea el siguiente código:
34
DO WHILE var_cont > 0
dwc_1.Find("Usu_login = '" + par_busca + "'" , var_cont, dwc_1.RowCount())
var_cont++
LOOP
Vamos a introducir al lado un botón, al que llamaremos “cb_buscart”, y le
pondremos de texto: “Buscar por SQL”. De esta forma haremos un ejemplo
parecido, pero usando solamente SQL.
En el Clicked del botón escribiremos:
Explicaremos brevemente el código: declaramos una variable de tipo string a la que
llamamos cadena_bus, a la cual, tras hacer una llamada a la columna usu_login de
la tabla usuarios, le introducimos su valor, teniendo como regla que cumplir la
condición de que sea igual a lo contenido en el texto del sle_busca.
Tras ello codificamos un condicional, que, en caso de encontrarse, nos informará de
su existencia, y, si no existe, nos lo dirá también.
Hasta aquí la parte de programación esencial de bases de datos con PowerBuilder.
Ahora mencionaremos la compilación y distribución de aplicaciones.
Generar aplicaciones con PowerBuilder
PowerBuilder es parecido a Java en el sentido de que usa bitecode, y de que posee
varios modos de distribuir aplicaciones (mediante dlls, usando objetos COM o
bitecode). Todo ello es demasiado extenso y dista bastante de lo que es un manual
básico, por lo que no lo trataremos.
Sin embargo, tocaremos el tema de la distribución de aplicaciones a través de la
generación de ejecutables para sistemas operativos Windows.
Lo primero que hay que realizar, es incluir en un archivo de distribución genérica
(.msi) las librerías y recursos con los que PowerBuilder trabaja. Estos son variados, y
dependerán siempre de nuestra aplicación. Por lo tanto, vamos a generar el
ejecutable de la aplicación que realizamos en este tutorial de ejemplo, y
empaquetaremos también los archivos de recursos de PowerBuilder. Comencemos
por esto último.
Lo primero, tenemos que abrir la utilidad “PowerBuilder Runtime Packager”, que está
dentro de la ruta de PowerBuilder.
35
Nos aparecerá una ventana como la siguiente:
En ella tendremos que elegir las interfaces de bases de datos que queramos cargar,
así como otros componentes web y de soporte. También elegiremos la ruta donde
queremos general el archivo .msi.
Para el ejemplo, elegiremos la misma ruta donde tenemos el archivo .pbw de
nuestra aplicación, sobre la que crearemos una carpeta llamada “distribución”, y allí
será donde meteremos el archivo .msi.
También desactivaremos los checks XML Support, EJB Client, y Rich Text Support,
que no necesitamos. Y desactivaremos las interfaces de JDB Interface, Informix y
Oracle, que tampoco necesitamos.
Una vez hecho esto, pulsaremos el botón Create. Tras unos segundos nos habrá
creado el archivo en el directorio especificado:
36
Ahora vayamos a PowerBuilder, abramos el WorkSpace de nuestro proyecto
(File/Open Workspace) y cerremos todas las ventanas y editores de código que
tengamos abiertos, de modo que solo tengamos visible el TreeView con los archivos
de nuestro proyecto.
Antes de crear el ejecutable, debemos crear un archivo .pbr. El archivo PBR es un
archivo de recursos. No es mas que un archivo ASCII en el que deberemos incluir
todos los recursos de imágenes de nuestra aplicación (iconos, etc), así como los
objetos DataWindow que hayamos incluido en esta.
Podemos incluir imágenes .bmp, .cur, .ico, .wmf, y la forma de hacerlo es la
siguiente:
icono1.ico
imagen_campo.bmp
etc., todo ello correlativo. En nuestra aplicación no vamos a incluir imagen alguna, ni
tan siquiera icono, puesto que no lo hemos hecho en tiempo de diseño tampoco, y
pienso que es lo suficientemente fácil el hacerlo como para no extendernos mas en
el particular.
Lo que sí debemos incluir es el DataWindow, ya que de otro modo nuestra aplicación
de ejemplo apenas haría nada.
Para ello debemos generar un archivo .pbr en ASCII, sin introducir caracteres
extraños ni cortes de líneas. Para ello debes usar una herramienta que trabaje
siempre directamente en ASCII, como RakEdit, y escribir lo siguiente:
El archivo .pbl es el archivo de proyecto de nuestra aplicación (puedes verlo en el
treeview de PB), entre paréntesis debemos poner el objeto DataWindow que
usamos, en este caso, nombrado como dw_1.
Esto debemos hacerlo si vamos a poner el archivo PBR dentro del directorio donde
estén los demás archivos de proyecto de nuestra aplicación, ya que, en caso
contrario, deberemos incluir la ruta completa, por ejemplo esta:
c:\aplicaciones\basedatos2.pbl(dw_1)
Ahora guardaremos el archivo con extensión .pbr en el directorio donde tengamos el
resto de archivos de nuestra aplicación.
37
En este punto vamos a crear el archivo .pbd, para ello vamos a New y seleccionamos
el pintor de librería (Library Painter) del tab Tool.
Esta librería .pbd (PowerBuilder dynamic library) será llamada en la activación del
archivo ejecutable y en la ejecución de la aplicación.
Al pulsar sobre OK, nos abrirá el listado de nuestro arbol de directorios. Tendremos
que ir donde tengamos el archivo .pbl de nuestra aplicación (basedatos2.pbl) y, con
el botón derecho, seleccionamos tal como aparece en la imagen:
Nos aparece la siguiente ventana:
38
Seleccionamos en “Browse” el archivo .pbr que hemos creado, y le damos a OK. Ya
tenemos generado el pbd.
Cerramos las ventanas del Library Painter y procederemos a crear el ejecutable
propiamente dicho. Para ello vamos a New y en el tab “Project” elegimos
“Application”:
Nos aparecerá la siguiente ventana:
39
En ella elegimos un nombre para nuestro archivo ejecutable, después, dándole al
botón (…), seleccionamos el archivo PBR que hemos creado antes. Asimismo,
activamos la casilla PBD y volvemos a seleccionar el archivo pbr.
Como se puede ver, esta es otra forma de generar el PBD, ya que nos lo habrá
creado al activar la casilla PBD en caso de que no lo tuviéramos o/y lo
necesitáramos.
Para generar el ejecutable seleccionaremos de la barra de herramientas el botón
“Deploy”. Podemos darle un nombre y guardar el proyecto también desde ahí.
Ahora nos habrá creado un archivo exe en el directorio donde tengamos los demás
archivos de la aplicación que hemos diseñado:
Si efectuamos doble clic sobre el archivo, nos aparecerá el programa listo para ser
usado:
40
Hasta aquí el ejemplo básico de este tutorial sobre PowerBuilder. Confía en haberte
ayudado a entender y a trabajar sobre esta potente herramienta de creación de
aplicaciones para bases de datos.
A lo largo de sus capítulos hemos visto desde cómo crear bases de datos, incluidas
sus tablas e introducir datos en las mismas, hasta enlazarlas con los drivers ODBC,
bien desde Sybase Central o desde PowerBuilder.
También hemos diseñado una aplicación, que conecta a la base de datos, comprueba
datos de acceso y lee y actualiza sobre una tabla de ejemplo. Asimismo, hemos visto
como realizar una sencilla búsqueda y como, finalmente, distribuir y crear el
ejecutable.
Para todo ello hemos usado en total cuatro aplicaciones, como son el propio
PowerBuilder para el diseño y trabajo principal, Sybase Central para la base de
datos, el PowerBuilder Runtime Packager para los archivos de soporte en
PowerBuilder, y el RakEdit para la creación de un archivo PBR en ASCII.
ANEXOS
Anexo 1: PowerScript: fundamentos del lenguaje.
Comentarios:
// comentario de una línea
/* comentarios
de varias líneas */
Palabras reservadas:
41
Arrays:
integer arr_b[4]
(arr_b[1], arr_b[2], arr_b[3] y arr_b[4] se inicializan a cero)
Estructuras:
Ejemplo:
persona yo
yo.nombre= "Alvaro"
yo.apellido="Suarez"
yo.edad= 10
if yo.edad<= 13 then yo.descrip= "Niño"
elseif yo.edad<= 18 then yo.descrip= "Adulto"
else
yo.descrip="Anciano"
end if
Tipos de datos estándar:
Boolean Contiene solo Verdadero o Falso. (TRUE o FALSE)
Char Almacena un único carácter ASCII.
Date Incluye una fecha, en formato americano (yy[yy],mm, dd) Año (1000- 3000),
mes (01- 12) y días. (01- 31)
DateTime Contiene la Fecha y la Hora en un único tipo de dato, usado solo para
lectura o escritura de valores ‘DateTime’ definidos en una Base de Datos. Para
convertir un valor ‘DataTime’ en un tipo de dato que pueda ser usado en
PowerBuilder (date, time), use:
-Date(DateTime), para convertir un valor ‘DateTime’ en un valor Date.
-Time(DateTime), para convertir un valor ‘DateTime’ en un valor Time.
42
-DateTime(Date, Time), para convertir un ‘Date’ y un ‘Time’ en un valor DateTime
Dec Soporta números decimales con sobre 18 dígitos. Ej. 123456,000001
Double Números con punto flotante, con 15 dígitos de precisión y un rango desde
2.2E308 a 1.7E+308.
Int Un entero de 16 bits, con rango de -32768 a +32767.
Long Un entero largo de 32 bits, con rango de -2,147,483,648 a +2,147,483,647.
Real Un numero con punto flotante, con 6 dígitos de precisión y un rango desde 1.17
E -38 a 3.4 E +38.
String Cualquier carácter ASCII con un largo variable. (0 a 60,000)
Time Hora en formato 24 horas, incluye la hora (00-23), minutos (00- 59) segundos
(00- 59) y fracción de segundos (sobre 6 dígitos). Con un rango desde 00:00:00 a
23:59:59.999999
Definición de variables:
Ej.:
string nombre
O:
string nombre = "Alvaro"
Definición de constantes:
constant real LR_PI = 3.14159265
Ámbito de las variables:
Global
Es aquella variable/constante que podrá ser utilizada en toda la aplicación, es decir;
podrá hacerse referencia a ella desde cualquier modulo del programa.
Globales solo al Objeto (Instance)
Las variables que sean declaradas como Globales solo al Objeto, podrán ser
utilizadas en cualquier código fuente, pero solo del objeto donde se declaro
(ventana, menú, objetos del usuario), es decir, donde se defina la(s) variable(s).
También podrán ser utilizadas por todos los objetos que estén inmersos en el (ej.
botón en una ventana)
Recordantes (Shared)
Las variables declaradas de este tipo igual que las del tipo anterior (Instance) solo
pueden ser reconocidas dentro del objeto especifico donde se declaro (ventana,
menú, objeto del usuario) , pero estas últimas tienen la particularidad de conservar
el valor almacenado en esta al momento de cerrar y abrir nuevamente el objeto en
cuestión.
Locales (al Modulo)
Estas variables son declaradas en el mismo código del modulo en cuestión, y solo
tienen vida en este, no pueden ser compartida por otros módulos del mismo objeto
inclusive.
Operadores:
Los operadores matemáticos son los siguientes:
Suma +
Resta Multiplicación *
División /
Los operadores relaciónales son los siguientes:
O inclusivo OR
y inclusivo AND
Negación NOT
Igualdad =
43
Desigualdad <>
Menor <
Menor o igual <=
Mayor >
Mayor o igual >=
Valores booleanos:
Verdadero True
Falso False
Sentencias de control de flujo o bifurcaciones:
Condicional IF
Se refiere a que el flujo de control es bifurcado desde una sentencia, o conjunto de
estas, a otra, o conjunto de estas. Existen 2 clase de Flujos de control condicionales
IF..THEN..ELSE..END IF
IF..THEN..ELSEIF..THEN..ELSE..END IF
CHOOSE
Permite bifurcar la ejecución del código entre múltiples caminos posibles;
dependiendo de la veracidad o no de una expresión condicional, principalmente una
variable.
CHOOSE..CASE IS..ELSE..EN CHOOSE
Ej.
Choose case cuota
Case Is< 13: nombre='Ramiro'
Case 16 To 48:nombre= 'Roberto'
Else
nombre='Francisco'
End Choose
Cada Case <expresión> puede tener los siguientes valores:
· Un valor
· Una lista de valores separados por coma. (ej. 2, 4, 6, 8)
· Una cláusula TO, desde hasta. (ej. 1 TO 30)
· Una cláusula IS seguida por un operador relacional y un valor a comparar. (ej.
IS>5)
· Cualquier combinación de lo anterior, implícitamente indica un OR. (ej.1, 3, 5, 7, 9,
27 TO 33, IS >42)
Bucles:
For:
for i= 1 to 23
j= i + ( j * 1.2 )
next
Do:
Ej.
integer A = 1, B = 1 //Emite un pito por los parlantes hasta que la variable
DO UNTIL A > 15 // A sea mayor que 15.
Beep(A)
A = (A + 1) * B
LOOP
integer A = 1, B = 1 //Emite un pito por los parlantes mientras la variable
DO WHILE A <= 15 // A sea menor o igual a 15.
Beep(A)
A = (A + 1) * B
LOOP
44
En ambos tipos de iteraciones se puede terminar la ejecución del bloque utilizando la
sentencia ‘Exit’.
Ej.
FOR contador = 1 to 10
IF vector1[Contador] = 0 THEN EXIT
NEXT
En ambos tipos de iteraciones se puede continuar la ejecución del bloque, desde el
principio y no ejecutando las demás instrucciones del bloque.
Ej.
integer A=1, B=1
DO WHILE A < 100
A = A+1
B = B+1
IF B > 3 THEN CONTINUE
MessageBox("Hola", "B es = " + String(B) )
LOOP
Sentencias referentes al ámbito en que nos encontremos:
This
Indica el objeto en el cual se esta codificando. Ej. this. Text = "hola"
Parent
Indica el objeto que contiene uno particular donde se esta codificando Close( parent
)
Anexo 2: SQL
Alter Table: Permite añadir una o mas columnas a una tabla existente. Las columnas
nuevas de los registros que ya existían se rellenarán con valores nulos.
Sintaxis:
ALTER TABLE nombre_tabla
ADD nombre_columna tipo_dato
ALTER TABLE nombre_tabla (ADD nombre_columna tipo_dato [, ADD
nombre_columna tipo_dato, ..]);
Ej.:
ALTER TABLE usuarios ADD (edad INT);
Create Index: Crea un índice en una o mas columnas de una tabla, mediante las
palabras reservadas ASC y DESC se especifica si la columna se va a indexar de
forma ascendente o descendente. Si se usa la palabra UNIQUE se esta pidiendo que
en caso de alguna coincidencia de un valor en la tabla se genere un error.
Sintaxis:
CREATE [UNIQUE] INDEX indice
ON nombre_tabla (nombre_columna [ASC | DESC] [,nombre_columna [ASC | des],
…]);
Create Table: Crea una tabla.
Sintaxis:
CREATE TABLE nombre_tabla (elemento_columna [,elemento_columna,...]);
El elemento_columna puede ser una definición de una columna o una definición de
restricción de tabla:
nombre_columna tipo_dato [DEFAULT expresión] [retricción_columna [,
restricción_columna, … ] UNIQUE (nombre_columna [, nombre_columna, …]) |
PRIMARY KEY (nombre_columna [, nombre_columna, … ]) | CHECK
(condicion_busqueda) | FOREIGN KEY (Lista_de_columnas_a_referenciar)
REFERENCES tabla_referida (Lista_de_columnas_de_referencia) REFERENCES
tabla_referida (lista_de_columnas_referidas);
45
DEFAULT especifica el valor por defecto que se introducirá en la columna.
Las restricciones de columnas podrán constar de una de las siguientes palabras:
-NOT FULL: especifica que la columna no puede contener valores nulos
-UNIQUE: dos filas no podrán tener el mismo valor en esa columna
-PRIMARY KEY: la columna representa la clave primaria para la tabla
-REFERENCES tabla_referida (lista_de_columnas_referidas): Clave externa. Nos
permite un mecanismo que enlaza dos tablas
-CHECK condicion_de_busqueda: restringue los valores que se insertan en la
columna.
Ej.:
CREATE TABLE usuarios (id_numero INTEGER PRIMARY KEY, nombre
CHARACTER(20), apellidos CHARACTER(40) telefono INTEGER DEFAULT -1);
Delete: Borra las filas de una tabla que no cumplan una cierta condición. Si no se
especifica la condición, se borran todos los registros.
Sintaxis:
DELETE FROM nombre_tabla [WHERE condicion_busqueda];
Drop Index: Elimina un índice.
Sintaxis:
DROP INDEX nombre_indice ON nombre_tabla
Drop Table : Elimina una tabla.
Sintaxis:
DROP TABLE nombre_tabla
Insert: Inserta una fila en la tabla. Si introducimos los valores de cada columna en
orden, no será necesario especificar los nombres de las columnas.
Sintaxis:
INSERT INTO nombre_tabla [(nombre_columna1[,nombre_columna2, … ])]
VALUES (expresión_columna1[,expresión_columna2,…]);
Select: Todas las consultas sobre tablas en una base de datos se llevan a cabo con la
setencia select.
Sintaxis:
SELECT [ALL|DISTINCT] lista_de_selección
FROM tablas
[WHERE condicion[subconsultas] ]
[GROUP BY nombre_columna [HAVING condicion]
[UNION | UNION ALL | INTERSECT | MINUS] seleccion]
[ORDEN BY columna [ASC | DESC]];
Selección hace referencia a otra sentencia SELECT; ASC en orden ascendente y
DESC, descendente.
La palabra clave ALL es el valor por defecto y permite que se devuelvan todas las
filas del resultado obtenido mediante la sentencia SELECT. DISTINCT, por su parte,
eliminará todas las filas que se encuentren repetidas en la tabla. Mediante la
cláusula WHERE establecemos una condición de búsqueda; ésta podrá encadenarse
mediante AND u OR.
Ej.:
SELECT DISTINCT nombre
FROM lista
WHERE apellido LIKE ‘E%’ OR apellido LIKE “_A%”;
Este ejemplo devolverá todos los nombres que pertenezcan a una lista cuyos
apellidos empiezan por “E” o por “A”.
La condición de búsqueda podrá estar formada por:
46
expresión operador expresión | expresión LIKE patron | nombre_columna IS [NOT]
NULL
LIKE permite especificar un patrón, los posibles son:
“%”: que significa ninguno o mas caracteres.
“_”: que significa que hay un solo carácter
Si establecemos IS NULL se devolverán aquellas filas que estén o no vacías. Si es IS
NOT NULL se excluirán aquellas filas que estén vacías.
La condición de búsqueda de una forma más compleja podrá estar compuesta
también de la siguiente forma:
expresión BETWEEN expresión AND expresión | EXISTS {subconsulta} | expresión
[NOT] IN {subconsulta} | expresión operador {ALL | ANY} subconsulta
BETWEEN nos permitirá especificar valores que se encuentran en un intervalo.
Mediante EXISTS se seleccionará la tupla de la consulta principal si la subconsulta
devuelve algún valor. Con EXISTS es frecuente usar subconsultas anidadas
correlacionadas entre sí.
El tipo IN se usa para seleccionar todas las filas para las que el valor de una columna
se encuentre (o no ) en el resultado de la subconsulta.
Mediante ALL se seleccionarán todas las tuplas que cumplan el comparador para
todos los valores del conjunto asociado a la cláusula ALL (la subconsulta).
Con ANY se seleccionará la tupla si se cumple el comparador para alguno de los
valores del conjunto asociado a la cláusula ANY (la subconsulta).
Un ejemplo de consulta SELECT que retornará los datos de todos los usuarios,
ordenador por el campo nombre, que se llamen Javier o que tengan como primer
apellido Suarez es:
SELECT * FROM usuarios WHERE nombre=’Javier’ OR apellido=’Suarez’ ORDEN BY
nombre.
Update: Actualiza las columnas de una tabla.
Sintaxis:
UPDATE nombre_tabla SET nombre_columna={expresión | null} [,
nombre_columna={expresión | null} WHERE condicion
Nota:
Corchetes [] : indican que lo que hay dentro de éstos es opcional
Barra vertical | : indica que se debe elegir una entre las opciones o parámetros que
se presentan
Puntos suspensivos … : indica la posibilidad de repetir los elementos o las
sentencias.
Arphean.
47