Professional Documents
Culture Documents
1.- INTRODUCCION
2.- MODELOS DE ALMACENAMIENTO DE DATOS
3.- TABLAS
4.- TABLAS CONTINUACION
5.- DATABASE DESKTOP
6.- APLICACIONES O PROGRAMAS CON TABLAS
7.- APLICACIONES POR RENGLON
8.- APLICACION POR TABLA
9.- PROCESOS BASICOS
10.- BUSQUEDAS
11.- FILTROS
12.- GRAFICOS O IMAGENES
13.- IMPRESION O REPORTES
14.- IMPRESION DE TODA LA TABLA
15.- MODELO RELACIONAL DE DATOS
16.- TIPOS DE RELACIONES
17.- MODELO RELACIONAL Y DATABASE DESKTOP
18.- APLICACIONES CON TABLAS DE RELACION
V UNIDAD C++BUILDER COMPONENTES
1.- INTRODUCCION
2.- COMPONENTES, CLASES Y OBJETOS
3.- INSTALACION Y MANTENIMIENTO DE COMPONENTES VISUALES
4.- INSTALACION PRACTICA DE COMPONENTES
5.- CREACION E INSTALACION DE COMPONENTES VISUALES
Tabla Empleado:
* Clave Empleado * Nombre Empleado * Direccin Empleado * Edad Empleado *
Telfono Empleado * etc. Empleado
Tabla Proveedor:
* Clave Proveedor * Nombre Proveedor * Empresa Proveedor * Telfono Proveedor *
Fax Proveedor * Celular Proveedor * etc. Proveedor
Tabla Autos:
* Numero de Serie * Modelo * Marca * Tipo * Color * Capacidad * etc.
Observar que cada tabla, empieza con una clave generalmente detipo numrica.
Todos los elementos de la tabla, solo hacen referencia hacia el mismo ente o sujeto de
informacin.
Cada elemento solo representa o debe contener un solo dato de informacin.
No se respetan o siguen al pie de la letra estos tres postulados y empiezan los problemas
al tiempo de programacin.
Existe una segunda forma o manera de representar las tablas, ejemplo:
Tabla: Camisas
NumCamisa Marca Estilo Medida Color Material
1 Jeans Manga Corta Grande Azul Algodn
2 Volis Camiseta Mediana Negra Poliester
3 Genrica Manga Larga Chica Morado Rayn
etc. etc. etc. etc. etc. etc.
Tabla: Clientes
NumCliente NomCliente DirCliente TelCliente
1 Juan Prez Av. aba 121212
2 Luis Prez calle zeta 898989
3 Jos Prez cjon sss 000000
etc. etc. etc. etc.
El trabajo correcto con bases de datos relacinales, se divide en dos grandes pasos o
etapas bien diferenciadas entre si:
En la primera etapa se disea la tabla , con sus campos, llaves y condiciones especiales,
luego se usa un paquete o programa de software especializado en la construccin,
mantenimiento y administracin de la base de datos, este software se usa para convertir
la tabla o tablas ya bien diseadas en un archivo en disco.
b) Crear una nueva con file, new, table, DD pregunta cual formato de tabla se va a usar;
Tomar nota de las dos reas del editor, la primera de ellas es el field roster y la segunda
rea es la de propiedades de la tabla.
d) Se usa ahora la primera rea, para escribir los campos o atributos de la tabla, la
segunda columna es el tipo de dato del atributo, para asignar un tipo de dato a un
atributo, pulsar dos veces la barra espaciadora en el teclado para que salga la siguiente
lista de tipos de datos:
Como se observa existen muchos e interesantes tipos de datos, de momento solo usar
los mas comunes, enteros, short, numricos, y alpha para el caso de strings.
Todas y cada una de las propiedades, se definen abajo en la parte de propiedades del
editor de tablas, es decir la propiedad validity check tiene como elementos:
y ya se puede empezar a
Recordar que todos los cambios hechos a una, aadir, insertar, eliminar, modificar, etc.
quedan grabados automticamente en disco, este hecho es la razn por lo que no existe
una opcin de grabar un rengln o registro cualesquiera.
Ahora si, ya creada, declarada o definida la tabla, es tiempo ahora de construir la
aplicacin, para esto se usara nuevamente el C++Builder .
6.- APLICACIONES O PROGRAMAS CON TABLAS C++BUILDER
y todos ellos haba que construirlos programarlos a mano, era terrible la situacin de los
programadores de antao.
En el modelo relacional-visual de datos, mucho de este trabajo no existe, solo se
construye una forma, y se pegan unos cuantos componentes para que aparezcan las
propias tablas y componentes para que se procesen los datos que contendrn la tablas.
Recordar tambin que la aplicacin ya no deber preocuparse, donde se almacenan los
datos, de validar las condiciones y restricciones impuestas en ellos, etc., todo este
trabajo ahora es responsabilidad del miniDBMS que usado, el DataBase Desktop.
Existen dos maneras sencillas de construir aplicaciones, la primera de ellas es
presentarle al usuario un solo rengln de informacin para su proceso y manipulacin y
la segunda es presentarle toda la tabla a la vez, tambin para su manipulacin y proceso.
7.- APLICACIONES POR RENGLON C++BUILDER
Este Componente acta como el enlace fsico entre el Componente Table y el resto de
componentes que procesan los datos de la tabla, es decir el componente Table apunta a
Button Significado
Recordar poner unos cuantos componentes Label arriba de los botones del navegador
para su aclaracin, uso y manejo al usuario.
Sus dos propiedades mas importantes son:
Propiedad DataSource = Click a un lado y seleccionar el DataSource al que se quiere
enlazar, por ejemplo DataSource1.
Propiedad +VisibleButtons = Click en el signo +, para activar(True) o desactivar(False)
los botones de proceso de renglones de la tabla, que se quieran mostrar u ocultar al
usuario.
Con estos cuatro componentes ya se construye una aplicacin, ejemplo;
Pantalla de Diseo:
Pantalla de ejecucin:
En este tipo de aplicacin, al usuario se le presenta toda la tabla completa a la vez para
su procesamiento y manipulacin.
Para construir esta tipo de aplicacin, solo se ocupan tres componentes y dos de ellos ya
son conocidos, estos componentes son:
Componente Table ( Data Access)
* propiedad DataBaseName = c:\datos
* propiedad TableName = Clientes.db
* propiedad Active = True
Componente DataSource ( Data Access)
* propiedad Dataset = Table1
Componente DBGrid ( Data Controls)
* DataSource = Click a un lado de la propiedad, para seleccionar el DataSource
respectivo a enlazar, por ejemplo DataSource1.
Una caracterstica interesante, es que este componente DBGrid, trae asociado un editor
de columnas, solo poner el componente DBGrid en la forma, enlazarlo al DataSource y
luego doble click dentro del DBGrid y aparece el siguiente editor:
Primero usar el botn Add All Fields para cargar todos los campos columnas a la
primera ventana y de esta ventana ir seleccionando el campo o columna a procesar,
observar que se pueden agregar nuevas columnas, o eliminar columnas existentes y para
cada columna que se vaya seleccionando ya funciona la segunda parte del editor.
Componente DBNavigator( Data Access)
* propiedad DataSource = DataSource1
* propiedad +VisibleButtons = activar o desactivar los botones apropiados
Aunque este componente no se ocupa en este tipo de aplicacin, puesto que el usuario
puede realizar todos los procesos bsicos directamente dentro de la tabla, es conveniente
poner un navegador para darle una segunda opcin o manera de realizar los procesos
bsicos.
Un ejemplo de aplicacin con esta estructura es:
Pantalla de Diseo
Pantalla de ejecucin:
Analizaremos ahora algunos procesos tambin bsicos que pueden realizarse con los
dos tipos de aplicaciones y que adems no estn contemplados en algunos de los
botones del navegador.
OPERACIONES CON CAMPOS
Para el caso de aplicaciones construidas con componentes DBEdit, recordar que
comparte muchas propiedades y mtodos con el componente edit, as que es valido por
ejemplo en una aplicacin donde la tabla productos tiene el campo
costounitario(DBEdit3) y el campo o columna utilidad(DBEdit6), poner un componente
edit1 para el precio de venta y realizar la siguiente operacin en el onclick de un botn
apropiado.
//----------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender)
{
Edit1->Text=DBEdit3->Text.ToDouble()+DBEdit6 Text.ToDouble();
}
Un filtro es una condicin que permite desplegar solo determinada informacin de una
tabla.
Es decir, en ocasiones solo se quiere desplegar informacin condicionada al usuario, por
ejemplo de la tabla de clientes solo desplegar aquellos que sean de la ciudad de Tijuana,
de la tabla de autos, solo desplegar aquellos de modelo 1990 en adelante.
Como se observa, filtrar una tabla, es condicionar uno o mas campos o columnas.
Formar condiciones simples o compuestas ya no debe ser problema, el real problema es
que la librera de VCL que contiene los componentes visuales, fue portada a C+
+Builder por parte de la Compaa Borland usando la librera VCL de Delphi( y este
Delphi es Pascal), en otras palabras los filtros o condiciones se tendrn que programar
tomando en cuenta a como Pascal maneja las constantes strings, los operadores
relacinales y los operadores lgicos.
Existen dos maneras de poner filtros o condiciones para una tabla, ellas son:
2.- En aplicaciones por renglones , no usar un DBEdit para este campo, sino usar un
componente DBImage (Data Controls)
7.- Para cargar o capturar una imagen directamente desde un archivo en disco de
extensin .BMP (u otros similares) solo usar un componente DBImage ya sea en
aplicaciones por rengln o por tabla, un componente Button de ordenes y el siguiente
cdigo;
OnClickButton1()
{ DBImagePictureLoadFromFile(C:\datos\mifoto.bmp); }
Ya debe estar en el directorio o folder datos dicho archivo .BMP y adems otra vez
recordar, que aunque la imagen ya esta en la pantalla, todava no se manda a la tabla a
disco si no se ejecuta un avance de rengln o un Next, etc.
8.- La propiedad Stretch en DBImage, la amplia, otro mtodo es ponerlas en Clipboard
o archivo ya con el tamao apropiado.
TAREAS PROGRAMACION C++BUILDER
1.- UNA TABLA DE MAMIFEROS COMPLETA INCLUYENDO IMAGENES
2.- UNA TABLA DE PRODUCTOS O MERCANCIAS INCLUYENDO SU FOTO
Imprimir tablas o construir reportes sobre las mismas, es tambin una tarea comn en
los sistemas de informacin basados en bases de datos.
Lo bueno es que se tiene un folder o pestaa llamada QReport cargada de componentes
visuales especializados en la impresin de reportes, esta librera de componentes, no es
hecha por Borland, es hecha por una compaa llamada QSOFT™
QReport
Practica para construir un reporte que contiene la cdula de un y solamente un cliente de
la tabla de clientes.
Los componentes y propiedades a usar son:
1.- Table1
* DataBaseName = c:\datos * TableName = Clientes.db * Active = true * Filter =
ClaveCliente = 2 (observar que aqu es donde se determina
cual cliente se imprime)
* Filtered = true
2.- QuickRep1, se encuentra en pestaa QReport.
Es el componente principal para impresin.
Toma la forma y tamao de una hoja de impresora dentro de Form1.
Sus propiedades a usar son:
* Dataset = Table1 * Zoom = 50
3.- QRShape1
Se usara para crear un rectngulo para encabezados de la cdula de un cliente.
Son varios tipos o formas las que existen de QRShape, rectngulos, lneas, crculos, etc.,
rectngulo es default, y la propiedad para cambiar de forma es Shape.
Acomodarlo y expanderlo en la parte superior de la hoja de impresin (QickRep1).
Componente para desplegar cada dato de una celda o campo o columna de una tabla, es
similar a DBEdit pero es esttico, es decir solo despliega.
Se debern poner tantos componentes QRDBText en esta banda o seccin de detalle,
como columnas de datos existan o se quieran desplegar de la tabla.
Propiedades:
* Dataset = Table1 * DataField = seleccionar columna apropiada * Font = color,
tamao, etc. que se quieran
10 .-QRDBImage
Componente para desplegar e imprimir campos de tipo Graphics ( BMP, ICO, WFW).
Propiedades:
* Dataset = Table1 * DataField = Seleccionar una columna de tipo Graphics * Stretch =
true
Notas:
1.- El componente QuickRep, tiene la propiedad +Frame, para que tambin pueda
desplegar e imprimir un marco apropiado.
2.- Para ir desplegando un Preview de impresin al tiempo del diseo del reporte, solo
dobleclick dentro de la hoja de impresin (QuickRep) para que aparezca una ventana de
Preview de impresin.
3.- La CIA Qsoft, ya tiene a la venta QReport V3.0 que ya trae incorporado
WYSWYNG.
4.- Para Preview o impresin en tiempo de ejecucin, solo aadir un botn de ordenes
OK, y usar solo una de las siguientes instrucciones:
OnClickButton1() {
QuickRep1Preview();
o QuickRep1Print();
b)Programa:
Todo los renglones de la tabla, ocuparan muchas hojas de impresora para desplegarse,
incluyendo un encabezado para todas las columnas que estn en la hoja, repito
necesitamos un encabezado para columnas y que aparezca en todas las paginas.
Probablemente, en la hoja final, seria conveniente aadir algunos contadores y
acumuladores, por ejemplo la cantidad de renglones, algn acumulado de alguna
columna numrica en especial, etc.
QReport, usa este modelo de bandas para la construccin de reportes, es decir, en la
practica anterior se uso un componente QRShape, para dividir el reporte en dos partes,
secciones o bandas, pero QReport trae incorporado un componente llamado QRBand
que permite dividir en partes, secciones o bandas todo el reporte.
Este componente QRBand, en su propiedad BandType, permite construir los siguientes
seis tipos importantes de banda.
BANDA NOTAS
Lo mas importante a tomar en cuenta es cada componente QRBand que se ponga dentro
de un reporte, se deber definir usando su propiedad BandType, como una cualquiera de
los seis tipos de bandas, es decir,
En general el procedimiento completo es:
1.-Poner un componente Table en la forma y nadamas cargarle sus tres propiedades
bsicas( no usar filtros).
2.-Poner un Componente QuickRep( es la hoja de impresin) y cargarle las propiedades
ya descritas en procedimiento de impresin anterior.
3.- Colocar y expandir un primer componente QRBand dentro del componente
QuickRep y primero asociarle el tipo de banda que representa, por ejemplo de
encabezado o de titulo, recordar que un reporte no necesariamente tiene que llevar las
seis bandas.
A este componente QRBand, cambiarle propiedades de font, frame, color, etc.
4.- Colocar dentro del componente QRBand1, los componentes necesarios y apropiados
como se indico en el cuadro anterior de bandas y significados, por ejemplo QRLabel,
etc.
5.-Colocar otro componente QRBand en la hoja de impresin, expanderlo y definirlo
como banda de titulo o banda de encabezado de columnas, etc.
6.-Repetir los pasos anteriores, hasta completar todas las bandas.
7.- Colocar un botn de ordenes OK, y asociarle el cdigo de Preview o de impresin.
TAREAS PROGRAMACION C++BUILDER
1.- Desplegar la tabla de Productos, y agregar un botn de impresin de tabla ( son dos
formas una con la tabla y su navegador y la segunda es la forma de reporte) no olvidar
Include File Unit.
15.- MODELO RELACIONAL DE DATOS C++BUILDER
Entre dos tablas bsicas o tablas simples cualesquiera, se debe y puede buscar,
identificar y establecer una o varias relaciones entre ellas, ejemplo;
tabla Clientes tabla Productos
tabla Autos tabla TALLERES MECANICOS
R1= El auto ingresa al taller
R2= El auto es diagnosticado en el taller
R3= El auto es reparado en el taller
R4= El auto sale del taller
Una relacin simple es la unin o combinacin de dos tablas bsicas mediante una y
solo una accin, hecho o conducta especifica.
Entindase de otra manera, como una frase que relaciona las dos tablas y un y solo un
verbo que las une.
Si se analizan detenidamente las relaciones de los ejemplo, es tambin posible deducir
que un conjunto de relaciones forman o constituyen un proceso administrativo,
contable, fiscal, o de otro tipo cualesquiera, en el primer ejemplo el proceso es el ventas,
en el segundo es el proceso de reparacin de un auto.
Debe ser obvio que un proceso cualesquiera no se podr describir completamente, con
tres o cuatro relaciones simples nadamas.
Aun mas, en un sistema de informacin cualesquiera cada una de las relaciones genera
una tabla especial llamada de relacin, pero tambin genera en muchos casos un
documento especifico, por ejemplo el cliente compra al contado productos genera la
tabla de relacin y el documento llamado Factura, en la relacin el auto ingresa al
taller se genera la tabla de relacin y/o documento llamado ORDEN DE ENTRADA,
en la relacin el cliente aparta productos se genera la tabla de relacin y/o documento
llamado NOTA O RECIBO DE APARTADO, etc.
Existirn casos o relaciones donde ser casi imposible identificar o nombrar el
documento o relacin existente, para resolver este problema, existen dos soluciones
bsicas, la primera de ellas es crear por nuestra cuenta el documento, es decir si en un
modelo practico no existe un documento para esta parte del proceso lo mas sencillo es
crearlo en la empresa, documentarlo y pedir a la empresa que lo ponga en practica, en
algunos casos es tambin posible no crear documento alguno, solo llamar a esta relacin
con el nombre de las dos tablas, por ejemplo rel perros/gatos, rel clientes/productos, etc.
( aunque no es recomendable o muy explicativo).
Igualmente es muy recomendable,, al describir un proceso cualquiera y su conjunto de
relaciones, no usar o buscar relaciones muy abstractas, porque ser casi imposible
pasarlas a un modelo de informacin implementado en computadora, por ejemplo la
relacin al cliente le gustan los autos, por ejemplo los perros corretean gatos, etctera.
En resumen las relaciones y en general el proceso deben de ser simples, y documentales.
Para terminar de complicar las cosas un modelo completo de informacin, no se
construye con dos tablas bsicas, un par de procesos y una cuantas relaciones o
documentos, el modelo completo incluye un montn de tablas bsicas, otro montn de
procesos diferentes entre ellas, y cada proceso contiene un conjunto amplio de
relaciones.
Por ejemplo en una Empresa de AUTOREFACCIONES, fcilmente se encuentran las
tablas bsicas, de clientes, mecnicos, proveedores, partes, proceso de ventas al publico,
proceso de compras a proveedores, etctera y cada proceso con su propio conjunto de
relaciones y o documentos.
TAREAS PROGRAMACION C++BUILDER
1.- PARA UNA EMPRESA DE VIDEO, IDENTIFICAR SUS TRES TABLAS MAS
BASICAS , SUS DOS PROCESOS MAS IMPORTANTES Y CUANDO MENOS
CINCO RELACIONES EN CADA PROCESO.
2.- CONSTRUIR UN MODELO DE TRES TABLAS BASICAS, DOS PROCESOS Y
CUATRO RELACIONES PARA UNA CASA DE EMPEO.
3.- UN EMPRESARIO DE EXITO, TIENE VARIOS LOTES PARA LA VENTA DE
AUTOS, VARIOS TALLERES MECANICOS PARA SU REPARACION, VENDE
LOS AUTOS A CREDITO Y AL CONTADO, CONSTRUIR UN MODELO SIMPLE
DE BASE DE DATOS RELACINALES PARA SU IMPLEMENTACION.
16.- TIPOS DE RELACIONES C++BUILDER
Analizando a fondo, la mayora de las relaciones y sus documentos son del tipo llamado
1:M ( uno a muchos), es decir cada tabla de relacin o documento contiene un rengln
de la primera tabla y muchos renglones de la segunda tabla, por ejemplo en una factura
solo hay o se encuentra, un cliente y muchos productos, en una receta por ejemplo solo
hay un paciente pero hay muchas medicinas, en una orden de compra o de pedido hay
un solo proveedor pero hay muchos productos y as sucesivamente.
En general existen los siguientes tipos de relaciones:
Repitiendo el caso mas comn de relaciones, son las de 1:M, en este caso, solamente la
tabla de relacin no permite resolver el problema de informacin, en casos de relaciones
1:M se ocupara una segunda tabla llamada detalle-relacin.
El modelo completo de tablas para una y solamente una relacin de tipo 1:M es;
tabla de 1(uno) tabla de M(muchos)
- Clave de uno - Clave de muchos
- otros campos - otros campos
tabla de R(relacin) tabla detallerelacion
- Clave de relacin - Clave de relacin
- Clave de uno - Clave de muchos
- otros campos - otros campos
Este es el modelo principal de una base de datos relacional y se deber siempre aplicar
cuando se tenga que construir una base de datos que tenga una relacin 1:M.
Ejemplo;
Clientes(1) Productos (M)
Facturas(relacin) DetalleFactura (detallerelacin)
Clave Factura Clave Factura
Clave Cliente Clave Producto
Fecha Factura Cantidad Producto
etctera Factura Etctera
ejemplo;
Pacientes (1) Medicinas (muchos)
Recetas (relacin) DetalleReceta
Como se observa en los dos ejemplos, las tres claves ( la de uno, la de muchos y la de
relacin) solo se repiten una sola vez en otra tabla.
De nuevo un problema o sistema de informacin, que descansa en una base de datos de
tipo relacional, y solo contiene una relacin de tipo 1:M ocupa cuatro tablas ( la de uno,
la de muchos, la de relacin y la de detalle-relacion).
Si el problema incluye una segunda relacin 1:M por ejemplo NotaDeVentaque se
deriva de las mismas dos tablas bsicas, entonces el modelo completo se resuelve con
seis tablas ( las dos bsicas, las dos de relacin y las dos de detalle) y as sucesivamente.
E)Solo seleccionar el campo o atributo a indexar y luego click en flecha negra ADD
para que pase a la segunda ventana, luego click en OK.
F)DD pregunta ahora por el nombre del ndice mediante la siguiente ventana:
5.- En la primera ventana estn todos los campos de la tabla a enlazar (factura) solo
doble click en el campo de enlace (Clave Cliente) y observar que se pase a la ventana
chica.
6.- En la segunda ventana estn todas las tablas del directorio, solo doble click en la
tabla a enlazar (clientes), con eso el campo de enlace (Clave Cliente) de dicha tabla
tambin pasa a la ventanilla izquierda, como se observa en la grfica anterior.
7.- En resumen la integridad referencial permite el enlace entre las dos tablas, su efecto
practico, como ya se indic es que tablas unidas de esta manera no permiten altas o
captura de un rengln, si dicho rengln de informacin, no existe en la tabla enlazada.
8.- Para terminar este proceso solo click en el botn OK.
9.- DD pregunta ahora por el nombre que tendr, esta integridad referencial o enlace
usando la siguiente ventana:
5.- Abrir e ir cargando las tablas tambin en orden (1,M,R,D) para capturarles unos
cuantos renglones de pruebas.
TAREAS PROGRAMACION C++BUILDER
1.- CONSTRUIR Y CARGAR EN DATABASE DESKTOP LA RELACION
RECETA(SON CUATRO TABLAS).
2.- CONSTRUIR Y CARGAR EN DATABASE DESKTOP LA RELACION ORDEN
DE COMPRA.
3.- CONSTRUIR EN DATABASE DESKTOP LA RELACION DE LA NOTA DE
RENTA DE PELICULA.
4.- CONSTRUIR EN DATABASE DESKTOP LA RELACION RECIBO DE RENTA(
AQUI SOLO SON TRES TABLAS Y EXISTE TAMBIEN UNA IR O ENLACE DE
RECIBO A DEPARTAMENTOS).
18.- APLICACIONES CON TABLA DE RELACION C++BUILDER
Es tiempo ahora de construir la aplicacin final con las tablas construidas con el modelo
relacional de bases de datos.
Recordar primero que en general, el usuario solo tendr acceso y podr manipular tres
de ellas, la tabla de uno, la tabla de muchos y la tabla de relacin, las dos primeras de
ellas son construidas usando aplicaciones normales por rengln y por tabla, como se
realizo en los primeros temas del capitulo, es recomendacin y sugerencia que la tabla
de uno se construya usando el formato de rengln y la tabla de muchos se construya
usando el formato de tabla(DBGrid).
En cuanto a la aplicacin a construir con la tabla de relacin, tambin dentro de C+
+Builder se debe construir los enlaces con las tablas ya descritas, con los siguientes
considerandos ;
T1-->TR ; TM-->TDET ; TDET-->TREL
Ej. 1) CTE-->FACTURA ; PROD-->DETFAC ; DETFACT-->FACT
ej. 2) PAC-->RECETA ; MED-->DETREC ; DETREC-->RECETA
Recordar ademas, que es en la primera tabla de cada uno de estos tres tipos de enlaces.
donde se establece la relacin de enlace o donde se manipula la propiedad
correspondiente.
Para construir una aplicacin para la tabla de relacin:
1.- Aunque es solo la tabla de relacion, la que est aparentemente a la vista del usuario,
la forma debera contener los cuatro componentes Table, puesto que esta relacin,
descansa y ocupa las cuatro tablas.
2.- Estos cuatro componentes Table se colocaran y usaran en el siquiente orden para el
ejercicio de aplicacin:
Table1 Tabla de uno (ej. clientes)
Table2 Tabla de muchos (ej. productos)
Table3 Tabla de relacin (ej. facturas)
Table4 Tabla de detalle (ej. detallefactura)
3) Igualmente se ocupan cuatro componentes DataSource en el mismo orden, es decir
DataSource1 apunta a Table1, DS2 a T2, y as sucesivamente.
4.- La Forma que contiene la tabla de relacin se organiza usando tres componentes
Panel para su mejor distribucin, estos componentes Panel, se construyen y contienen:
Panel de uno
Cve Cte Nom Cte Dir Cte etc.Cte NVO Cte
DBEdit DBEdit DBEdit DBEdit Buttonl
(DS3) (DS1) (DS1) (DS1)
Panel de detalle
NUM Prod. Nom Prod. etc. Prod.
DBEdit DBEdit DBEdit
(DS4) (DS2) (DS2)
DDBNav2(DS4)
Notas:
1.- Es muy importante que se respete el tipo de componente que va dentro de cada panel
y mas importante an que dichos componentes apunten a el DataSource indicado entre
parntesis.
2.- Igualmente es muy importante, el siguiente cdigo que se deber poner en el evento
OnExit del ultimo DBEdit que se tenga en pantalla y que se cargue o capture por parte
del usuario de la tabla de relacin y su DataSource3 correspondiente, generalmente es la
clave relacin o fecha, en particular seria el ultimo componente que se tenga apuntado a
DS3, es en este componente, donde se debe usar:
OnExitDBEdit#() { Table3Refresh();}
Esta instruccin actualiza los datos o rengln de la tabla de relacin, antes que la tabla
de detalle, haga una bsqueda, dentro de la tabla de relacin.
3.- El cdigo de los tres botones de ordenes, es el siguiente:
OnClickButton1(){
//ocultar la pantalla de factura y desplegar o llamar la pantalla de
clientes
}
OnClickButton2(){
Table4->Insert();
// para insertar un nuevo rengln en tabla de detalle
}
OnClickButton3(){
// primero operaciones pertinentes si es que existen y
// al final cerrar con la instruccin
Table4->Refresh();
// para cargar en disco el ultimo rengln de la tabla
// de detalle
}
\
4.- Como se observa los mtodos Insert() y Refresh(), usados se derivan y se pueden
sustituir con DDBnavegadores y sus botones visibles correspondientes, pero se debe
buscar que el usuario los presione en el momento indicado.
5.- Este esquema se puede aplicar a cualquier tabla relacional(recetas, ordenes de
compra, solicitudes de servicios, etc.) solo realizar los ajustes correspondientes.
PROCEDIMIENTO PARA CONSTRUCCION DE TABLA RELACIONAL
1.- CARGAR C++Builder.
2.- PONER LOS CUATRO COMPONENTES TABLE EN LA FORMA, Y
CARGARLES SUS TRES PROPIEDADES BASICAS(DATABASENAME,
TableName, Active),RESPETANDO EL ORDEN SUGERIDO (Table1Tabla de uno,
Table2Tabla de muchos, Table3Tabla de relacin, Table4Tabla de detalle).
3.- PONER LOS CUATRO COMPONENTES DataSource QUE SE OCUPAN Y
APUNTARLOS A SU TABLA CORRESPONDIENTE EN ORDEN, ES DECIR
DS1TABLE1, DS2Table2, DS3Table3, DS4Table4, USANDO LA
PROPIEDAD DATASET DEL COMPONENTE DataSource.
4.- ARMAR Y CARGAR LOS TRES ENLACES ENTRE TABLAS YA SUGERIDOS,
ESTO ES T1TR, 2) TM TDET, 3) TDETTREL, USANDO LAS
PROPIEDADES MASTERSOURCE Y MASTERFIELD EN LA PRIMERA DE LAS
DOS TABLAS EN CADA RELACION, COMO SE DEMUESTRA CON EL
SIGUIENTE EJEMPLO DE LA PRIMERA RELACION ES DECIR, T1TR.
1. SELECCIONAR LA TABLA DE CLIENTES ( LA DE UNO)
2. CLICK A UN LADO DE LA PROPIEDAD MASTERSOURCE Y SELECCIONAR
DATASOURCE3( QUE ES LA DE RELACION O FACTURA) CLICK A UN LADO
EN LA PROPIEDAD MASTERFIELD (DONDE ESTAN LOS TRES PUNTILLOS) Y
SALE EL SIGUIENTE EDITOR DE CAMPOS DE ENLACE:
3.
6.
7. LUEGO CLICK EN BOTON OK PARA FINALIZAR EL PROCESO
5.- EL PROCEDIMIENTO ANTERIOR 4.1) A 4.6) SE DEBERA REPETIR PARA
LOS DOS CASOS RESTANTES(TMTDET, TDETTREL).
6.- PONER LOS TRES COMPONENTES PANEL EN LA FORMA Y DENTRO DE
CADA PANEL, PONER Y APUNTAR LOS COMPONENTES YA DESCRITOS EN
EL MODELO ANTERIOR.
7.- RECORDAR PONER LOS TRES COMPONENTES BUTTON Y CARGARLOS
CON EL CODIGO QUE TAMBIEN YA SE INDICO.
EJEMPLO:
1. PANTALLA DE DISEO
1. CODIGO
//--------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender)
{ // En esta parte se oculta la ventana de factura
// y se llama la ventana de cliente
}
//-------------------------------------------------void __fastcall TForm1::DBEdit3Exit(TObject *Sender)
{ Table3->Refresh();
}
//--------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender)
{
Table4->Insert();
}
//--------------------------------------------------void __fastcall TForm1::Button3Click(TObject *Sender)
{
// operaciones y terminar con:
Table4->Refresh();
}
//---------------------------------------------------
PANTALLA DE EJECUCION
* Observar que todo clase no visual, se deriva de TComponent, con esto se asegura un
mnimo visual de propiedades, incluyendo un icono de default, para la barra de
componentes y un par de eventos, los mtodos de la clase es lo que se va a construir y
programar.
3.- File Save As, frmulas, Save
4.- A la vista queda el editor con formulas.cpp , en la parte de arriba donde dice
#include <formulas.h>, poner cursor encima y click derecho para el popupmenu,
seleccionar la primera opcin, de open source/header file, y con esto ya se tendrn a la
vista los dos archivos que se ocupan para construir la clase, ellos son formulas.cpp y
formulas.h
En estos dos archivos se construye la clase, la parte declarativa de la clase queda en el
archivo formulas.h y la parte de implementacion o los mtodos quedan en el archivo
formulas.cpp, como observacin en PASCAL solo se ocupa el archivo llamado unit.pas
y ah quedan juntos pero en su rea apropiada las dos partes de una clase, su declaracin
y su implementacin.
Observar el cdigo ya generado por C++Builder de formulas.h;
//---------------------------------------------------------#ifndef formulasH
#define formulasH
//---------------------------------------------------------#include <vcl\SysUtils.hpp>
#include <vcl\Controls.hpp>
#include <vcl\Classes.hpp>
#include <vcl\Forms.hpp>
//---------------------------------------------------------class frmulas : public TComponent
{
prvate:
protected:
public:
__fastcall frmulas(TComponent* Owner);
__published:
};
//----------------------------------------------------------
#endif
protected:
public:
__fastcall frmulas(TComponent* Owner);
int areatriangulo( int base, int altura);
float pesosdolares (int pesos, float tipocambio);
double promedio(int calif1, int calif2);
__published:
};
//---------------------------------------------------------------#endif
6.- La parte de implementacion, se escribe al final del archivo .cpp, como se muestra en
el siguiente ejemplo.
//---------------------------------------------------------------#include <vcl\vcl.h>
#pragma hdrstop
#include "formulas.h"
//---------------------------------------------------------------static inline frmulas *ValidCtrCheck()
{
return new frmulas(NULL);
}
//---------------------------------------------------------------__fastcall formulas::formulas(TComponent* Owner):TComponent(Owner)
{
}
//---------------------------------------------------------------namespace Frmulas
{
void __fastcall Register()
{
* Solo se escriben los ltimos renglones y en la posicin indicada, es decir al final del
archivo .cpp
7.- Files, Save All
8.- File, Close All
9.- Component, Install, Add, Browse, formulas.cpp, Open, Ok hasta
que Done=Make, entonces OK
* Observar el nuevo icono de frmulas
Ejemplo de aplicacin:
1. Pantalla de Diseo:
en la barra de componentes.
b) Cdigo
//---------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender)
{
Edit3->Text=formulas1->promedio(Edit1->Text.ToInt(),
Edit2->Text.ToInt() );
}
//----------------------------------------------------------------
3. Pantalla de corrida
implementacin de los mtodos que contenga la clase proceso1, tal como se analizo en
la
UNIDAD de componentes.
5.- El Cdigo de proceso1.h es;
//---------------------------------------------------------#ifndef proceso1H
#define proceso1H
//---------------------------------------------------------#include <vcl\Classes.hpp>
//---------------------------------------------------------class proceso1 : public TThread
{
prvate:
protected:
void __fastcall Execute();
public:
__fastcall proceso1(bool CreateSuspended);
};
//---------------------------------------------------------#endif
//---------------------------------------------------------#include <vcl\vcl.h>
#pragma hdrstop
#include "proceso1.h"
//---------------------------------------------------------// Important: Methods and properties of objects in VCL can
// only be used in a method called using Synchronize, for // //
example:
//
// Synchronize(UpdateCaption);
//
// where UpdateCaption could look like:
//
// void __fastcall proceso1::UpdateCaption()
// {
// Form1->Caption = "Updated in a thread";
// }
//---------------------------------------------------------__fastcall proceso1::proceso1(bool CreateSuspended)
: TThread(CreateSuspended)
{
}
//---------------------------------------------------------void __fastcall proceso1::Execute()
{
//---- Place thread code here ---}
//---------------------------------------------------------
* No hay muchas sorpresas, solo la implementacin de los dos mtodos que contiene la
clase:
prvate:
protected:
void __fastcall UpdateCaption();
void __fastcall Execute();
public:
__fastcall proceso1(bool CreateSuspended);
};
//---------------------------------------------------------#endif
: TThread(CreateSuspended)
{ }
//---------------------------------------------------------void __fastcall proceso1::Execute()
{
//---- Place thread code here ---Synchronize(UpdateCaption);
}
//---------------------------------------------------------void __fastcall proceso1::UpdateCaption()
{
Form1->Caption = "Updated in a thread";
}
* Observar que Execute(), en este caso solo llama a un segundo mtodo(), usando su
mtodo especial.
* El segundo mtodo, es un caso normal, se declaro en el archivo proceso1.h y se
construyo o implemento al final del archivo proceso1.cpp
* Grabar los dos archivos con File, Save All o CTRL S con cada uno, ya grabados en
folder tarea1, usar File, Close All
La preguntas son:
1.- Como se incorpora este objeto concurrente a una aplicacin
2.- Como se activa o se continua la ejecucin del proceso concurrente.
R.- esperar a la tercera edicin del libro :>)
Procedimiento:
1.- Crear y almacenar el objeto thread, llamado proceso1 con el procedimiento anterior,
asegurarse de que ya todo este CLOSE All y los archivos en folder tarea1.
2.- File, New Aplication
3.- File, Save Project as, y asegurarse que se grabe dentro del folder tarea1
4.- Poner un BUTTON OK y solo se escriben los siguientes tres renglones de cdigo:
#include "proceso1.cpp"
proceso1 *pro1;
pro1 = new proceso1(false);
Se construye ahora, una aplicacin con dos objetos concurrentes, el primero despliega
los nmeros del uno al mil, y el segundo lo mismo pero de dos en dos.
Procedimiento:
1.- File, Close All
2.- Crear el Thread Object, llamarlo y grabarlo como proceso1 con el procedimiento
anteriormente descrito, no olvidar al final File, Close All
2.1.-Codigo de proceso1.h
//---------------------------------------------------------
#ifndef proceso1H
#define proceso1H
//---------------------------------------------------------#include <vcl\Classes.hpp>
//---------------------------------------------------------class proceso1 : public TThread
{
prvate:
protected:
int alfa;
void __fastcall Editar();
void __fastcall Execute();
public:
__fastcall proceso1(bool CreateSuspended);
};
//---------------------------------------------------------#endif
2.2.-Codigo de proceso1.cpp
//---------------------------------------------------------#include <vcl\vcl.h>
#pragma hdrstop
#include "proceso1.h"
//---------------------------------------------------------__fastcall proceso1::proceso1(bool CreateSuspended)
: TThread(CreateSuspended)
{
}
//---------------------------------------------------------void __fastcall proceso1::Execute()
{ //---- Place thread code here ----
for(alfa=1;alfa<=1000;alfa++)
{ Synchronize(Editar); };
}
//--------------------------------------------------------void __fastcall proceso1::Editar()
{ Form1->Edit1->Text=alfa;
}
3.- Crear otro Thread Object, llamarlo y grabarlo como proceso2 con el procedimiento
ya descrito, no olvidar al final File, Close All
3.1- Cdigo de proceso2.h
//---------------------------------------------------------#ifndef proceso2H
#define proceso2H
//--------------------------------------------------------#include <vcl\Classes.hpp>
//---------------------------------------------------------class proceso2 : public TThread
{
prvate:
protected:
int beta;
void __fastcall Editar();
void __fastcall Execute();
public:
__fastcall proceso2(bool CreateSuspended);
};
//---------------------------------------------------------#endif
4.- File, New Aplication y no olvidar File, Save Project As dentro del folder tarea1.
5.- Colocar dos edits y dos buttons, en la aplicacin, el
cdigo de Unit1.cpp, es;
//---------------------------------------------------------#include <vcl\vcl.h>
#pragma hdrstop
#include "Unit1.h"
//----------------------------------------------------------
No parece impresionante, pero las dos cajas Edits, se estn cargando al mismo tiempo,
es decir concurrentemente.