UNIVERSIDAD DE PANAMÁ

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

FACULTAD DE INFORMÁTICA, ELECTRÓNICA Y COMUNICACIÓN
LICENCIATURA EN INFORMÁTICA PARA LA GESTIÓN EDUCATIVA Y
EMPRESARIAL

“Laboratorio # 9”

“Mysql
Mysql”
Mysql

ESTUDIANTES:

BALLESTEROS DANIEL CED. 9-704-1031

CARRILLO ALBERTO CED. 9-725-389

PROFESOR:
DIEGO SANTIMATEO

SEMESTRE:
II SEMESTRE – II AÑO

FECHA DE ENTREGA:

13-DICIEMBRE-2007
 Índice
1- Describa qué es una base de datos y un motor (manejador) de base de
datos. ............................................................................................................................... 3
2- Describa una tabla y sus componentes. Haga ejemplos de varios registros.
Indique cómo están constituidos los registros. ......................................................... 3
3- ¿Qué es SQL? ¿Qué es MYSQL? ......................................................................... 4
4- Identifique la estructura de los comandos SQL en Mysql para insertar,
eliminar, actualizar y consultar registros de una tabla, así como para crear una
tabla. ¿Cuál es la utilidad de la cláusula WHERE? ................................................. 5
5- ¿Cuáles son los tipos de los campos y qué significa llave primaria o key? .... 7
7. Elabore un programa OO que lea el archivo de texto de las calificaciones de
los estudiantes del CRUV y cree una tabla de profesores, otra de estudiantes y
otra de asignatura. ¿Dedicó tiempo para diseñar sus tablas?¿Qué datos
pueden duplicarse y cuáles no?................................................................................ 17
8- Diseñe una clase que permita consultar a partir de la cédula, las
calificaciones identificadas con asignatura y docente. ......................................... 17
9- Compare la solución del punto #8 usando Base de datos vs. Archivos. ....... 34
1- Describa qué es una base de datos y un motor (manejador) de base de
datos.

Una base de datos es un conjunto de datos que pertenecen al mismo contexto

almacenados sistemáticamente para su posterior uso. En este sentido, una
biblioteca puede considerarse una base de datos compuesta en su mayoría por
documentos y textos impresos en papel e indexados para su consulta. En la
actualidad, y debido al desarrollo tecnológico de campos como la informática y
la electrónica, la mayoría de las bases de datos tienen formato electrónico, que
ofrece un amplio rango de soluciones al problema de almacenar datos.

Un motor de base de datos, es un programa que sirve para guardar y

administrar datos. Básicamente estos son llamados RDBMS (RELATIONAL
DATABASE MANAGENEMT SYSTEM) o Sistema Administrador de Base de
Datos Relacional. Las Bases de datos relacionales son aquellas donde los
datos están almacenados en tablas, las tablas están organizadas agrupando
información acerca del mismo tema y contiene columnas y filas de información.
Las tablas se relacionan entre sí, por medio del motor de base de datos cuando
se solicita.

En general, se puede decir que una base de datos es un conjunto de datos

relacionados. Una base de datos relacional la componen en tablas, y las tablas
están compuestas de filas y columnas.

Las filas son llamadas generalmente registros, y las columnas son llamadas
campos, básicamente los campos son las propiedades de un registro.

2- Describa una tabla y sus componentes. Haga ejemplos de varios

registros. Indique cómo están constituidos los registros.

Las tablas se componen de dos estructuras:

Campo: Corresponde al nombre de la columna. Debe ser único y además de

tener un tipo de dato asociado.
Registro: Corresponde a cada fila que compone la tabla. Allí se componen los
datos y los registros. Eventualmente pueden ser nulos en sus
almacenamientos.
En la definición de cada campo, debe existir un nombre único, con su tipo de
dato correspondiente. Esto es útil a la hora de manejar varios campos en la
tabla, ya que cada nombre de campo debe ser distinto entre sí.

A los campos se les puede asignar, además, propiedades especiales que

afectan a los registros insertados. El campo puede ser definido como índice o
autoincrementable, lo cual permite que los datos de ese campo cambien solos
o sean el principal indicar a la hora de ordenar los datos contenidos.

Cada tabla creada debe tener un nombre único en la cada Base de Datos,
haciéndola accesible mediante su nombre o su sinónimo (dependiendo del tipo
de base de datos elegida).
La estructura de las tablas viene dado por la forma de un archivo plano, los
cuales en un inicio se componían de un modo similar.

Un fichero o tabla es un conjunto de registros con la misma estructura por

ejemplo:

Cédula Nombre Apellidos Edad Dep Salario

9-704-1121 Luis Pérez 56 Cont 450.00
4-254-365 Angel López 43 Cont 1200.00
3-651-352 José Sánchez 36 Prod 700.00
6-325-325 Alberto Jerez 40 Prod 700.00

Cuando se tienen varias tablas o ficheros con algún campo en común,

entonces pueden relacionarse y constituyen una base de datos relacional.
En el ejemplo siguiente, podría extraerse la información relacionada en las dos
tablas, por medio del campo común Cédula; por ejemplo:

Cédula Nombre Apellido

9-721-374 Luis Perez
8-235-632 Jose Lopez
9-214-542 Miguel Zaa
Cédula Puesto Antigüedad
9-721-374 1235 10
6-245-632 1254 12
4-111-542 1242 24

Para hacer búsquedas rápidas deben definirse campos índice. Los campos
comunes por donde se conectan las tablas deben tener un índice definido.
Se conoce como gestor o motor de bases de datos al programa de ordenador
que sirve para definir, diseñar y utilizar los registros, ficheros y formularios de la
base de datos. Generadores de bases de datos muy conocidos son ORACLE,
SyBase, INFORMIX, MySQL, PARADOX, ACCESS, etc.

3- ¿Qué es SQL? ¿Qué es MYSQL?

SQL: es un lenguaje de base de datos normalizado, utilizado por el motor de

base de datos de Microsoft Jet. SQL ; SQL Server es el motor de base de
datos de Microsoft, y como ya hemos dicho una base da datos es una
colección de tablas con información relevante de un tema. Ej. Inventarios
(Contiene productos, movimientos de Entrada y salida, Ajustes, etc.). Pero
también existen otros manejadores de bases de datos tales como Oracle,
Sybase, Informix, MySql, Porgress, InterBase, Access, etc. Todos aunque de
diferentes empresas, tienen un mismo objetivo, manipular bases de datos.
El lenguaje de consulta estructurado SQL, está compuesto por comandos,
cláusulas, operadores y funciones de agregado. Estos elementos se combinan
en las instrucciones para crear, actualizar y manipular las bases de datos

MySQL: es la base de datos open source (fuente libre) más popular y,

posiblemente, mejor del mundo. Su continuo desarrollo y su creciente
popularidad está haciendo de MySQL un competidor cada vez más directo de
gigantes en la materia de las bases de datos como Oracle.
MySQL es un sistema de administración de bases de datos (Database
Management System, DBMS) para bases de datos relacionales. Así, MySQL
no es más que una aplicación que permite gestionar archivos llamados de
bases de datos.
Existen muchos tipos de bases de datos, desde un simple archivo hasta
sistemas relacionales orientados a objetos. MySQL, como base de datos
relacional, utiliza múltiples tablas para almacenar y organizar la información.
MySQL fue escrito en C y C++ y destaca por su gran adaptación a diferentes
entornos de desarrollo, permitiendo su interactuación con los lenguajes de
programación más utilizados como PHP, Perl y Java y su integración en
distintos sistemas operativos.
También es muy destacable, la condición de open source de MySQL, que hace
que su utilización sea gratuita e incluso se pueda modificar con total libertad,
pudiendo descargar su código fuente. Esto ha favorecido muy positivamente en
su desarrollo y continuas actualizaciones, para hacer de MySQL una de las
herramientas más utilizadas por los programadores orientados a Internet.

4- Identifique la estructura de los comandos SQL en Mysql para insertar,

eliminar, actualizar y consultar registros de una tabla, así como para crear
una tabla. ¿Cuál es la utilidad de la cláusula WHERE?

Los principales comandos SQL en Mysql que hemos utilizado son:

1- INSERT inserta nuevas filas en una tabla existente. Los formatos INSERT ...
VALUES e INSERT ... SET, insertas filas basándose en los valores
especificados explícitamente. El formato The INSERT ... SELECT inserta filas
seleccionadas de otra tabla o tablas. El formato INSERT ... VALUES con una
lista de múltiples valores está soportada por MySQL desde la versión 3.22.5. La
sintaxis INSERT ... SET está soportada por MySQL desde la versión 3.22.10.
mysql> INSERT INTO tbl_name () VALUES();

2- DELETE: elimina columnas desde "table_name" que satisfagan la condición

dada por la "where_definition", y devuelve el número de registros borrados.
Si se usa una sentencia DELETE sin cláusula WHERE, todas las filas serán
borradas. Una forma más rápida de hacer esto, cuando no se necesita conocer
el número de filas eliminadas, es usar TRUNCATE TABLE.
En MySQL 3.23, DELETE sin la cláusula WHERE retorna cero como número
de filas afectadas.
En esta versión, si realmente se quiere saber cuántas filas fueron eliminadas
cuando se borran todas, y se está dispuesto a sufrir una pérdida de velocidad,
se puede usar una sentencia DELETE con una cláusula WHERE que siempre
se cumpla. Por ejemplo:
mysql> DELETE FROM table_name WHERE 1>0;

3- UPDATE: actualiza columnas de filas existentes de una tabla con nuevos

valores. La cláusula SET indica las columnas a modificar y los valores que
deben tomar. La cláusula WHERE, si se da, especifica qué filas deben ser
actualizadas. Si no se especifica, serán actualizadas todas ellas. Si se
especifica la cláusula ORDER BY, las filas se modificarán en el orden
especificado. La cláusula LIMIT establece un límite al número de filas que se
pueden actualizar.
mysql> UPDATE persondata SET edad=edad+1;
4- SELECT: El proceso más importate que podemos llevar a cabo en una base
de datos es la consulta de los datos. De nada serviría una base de datos si no
pudiéramos consultarla. Es además la operación que efectuaremos con mayor
frecuencia.
Para consultar la información SQL pone a nuestra disposición la sentencia
SELECT.
Se usa para recuperar filas seleccionadas de una o más tablas. El soporte
para sentencias UNION y subconsultas está disponible a partir de MySQL 4.0 y
4.1, respectivamente.
Cada select_expr indica una columna que se quiere recuperar.
table_references indica la tabla o tablas de las que se recuperan filas. Su
sintaxis se describe en JOIN.
where_definition consiste de la palabra clave WHERE seguida por una
expresión que indica la condición o condiciones que las filas deben satisfacer
para ser seleccionadas.
SELECT puede usarse también para recuperar filas calculadas sin referencia a
ninguna tabla. Por ejemplo:
mysql> SELECT 1 + 1;
-> 2
Con INSERT ... SELECT, se pueden insertar rápidamente muchas filas en una
tabla desde otra u otras tablas.
Por ejemplo:
INSERT INTO tbl_temp2 (fld_id)
SELECT tbl_temp1.fld_order_id
FROM tbl_temp1 WHERE tbl_temp1.fld_order_id > 100;
Se puede usar REPLACE en lugar de INSERT para sobrescribir filas viejas.
REPLACE es el homólogo de INSERT IGNORE en el tratamiento de nuevas
filas que contengan valores de clave únicas que dupliquen filas existentes: Las
nuevas filas se usan para reemplazar a las antiguas más que para que sean
descartadas

5- CREATE TABLE: crea una tabla con el nombre dado. Se debe poseer el
privilegio CREATE para la tabla.
Por defecto, la tabla se crea en la base de datos actual. Se producirá un error si
la tabla ya existe, si no hay una base de datos actual o si la base de datos no
existe.
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
[(definición_create,...)]
[opciones_tabla] [sentencia_select]

6- WHERE: La cláusula WHERE es la instrucción que nos permite filtrar el

resultado de una sentencia SELECT. Habitualmente no deseamos obtener
toda la información existente en la tabla, sino que queremos obtener sólo la
información que nos resulte útil es ese momento. La cláusula WHERE filtra los
datos antes de ser devueltos por la consulta.

5- ¿Cuáles son los tipos de los campos y qué significa llave primaria o
key?

5.1 Tipos de Campos: Los tipos de los campos en forma general los
podríamos agrupar en tres que describimos a continuación:

1- Tipos numéricos:
Existen tipos de datos numéricos, que se pueden dividir en dos grandes
grupos, los que están en coma flotante (con decimales) y los que no.

TinyInt: es un número entero con o sin signo. Con signo el rango de valores
válidos va desde -128 a 127. Sin signo, el rango de valores es de 0 a 255

Bit ó Bool: un número entero que puede ser 0 ó 1

SmallInt: número entero con o sin signo. Con signo el rango de valores va
desde -32768 a 32767. Sin signo, el rango de valores es de 0 a 65535.

MediumInt: número entero con o sin signo. Con signo el rango de valores va
desde -8.388.608 a 8.388.607. Sin signo el rango va desde 0 a16777215.

Integer, Int: número entero con o sin signo. Con signo el rango de valores va
desde -2147483648 a 2147483647. Sin signo el rango va desde 0 a
429.4967.295

BigInt: número entero con o sin signo. Con signo el rango de valores va desde
-9.223.372.036.854.775.808 a 9.223.372.036.854.775.807. Sin signo el rango
va desde 0 a 18.446.744.073.709.551.615.

Float: número pequeño en coma flotante de precisión simple. Los valores

válidos van desde -3.402823466E+38 a -1.175494351E-38, 0 y desde
1.175494351E-38 a 3.402823466E+38.

xReal, Double: número en coma flotante de precisión doble. Los valores

permitidos van desde -1.7976931348623157E+308 a -2.2250738585072014E-
308, 0 y desde 2.2250738585072014E-308 a 1.7976931348623157E+308

Decimal, Dec, Numeric: Número en coma flotante desempaquetado. El

número se almacena como una cadena

2- Tipos fecha:
A la hora de almacenar fechas, hay que tener en cuenta que Mysql no
comprueba de una manera estricta si una fecha es válida o no. Simplemente
comprueba que el mes esta comprendido entre 0 y 12 y que el día esta
comprendido entre 0 y 31.
Date: tipo fecha, almacena una fecha. El rango de valores va desde el 1 de
enero del 1001 al 31 de diciembre de 9999. El formato de almacenamiento es
de año-mes-dia

DateTime: Combinación de fecha y hora. El rango de valores va desde el 1 de

enero del 1001 a las 0 horas, 0 minutos y 0 segundos al 31 de diciembre del
9999 a las 23 horas, 59 minutos y 59 segundos. El formato de almacenamiento
es de año-mes-dia horas:minutos:segundos

TimeStamp: Combinación de fecha y hora. El rango va desde el 1 de enero de

1970 al año 2037. El formato de almacenamiento depende del tamaño del
campo:

Time: almacena una hora. El rango de horas va desde -838 horas, 59 minutos
y 59 segundos a 838, 59 minutos y 59 segundos. El formato de
almacenamiento es de 'HH:MM:SS'

Year: almacena un año. El rango de valores permitidos va desde el año 1901 al

año 2155. El campo puede tener tamaño dos o tamaño 4 dependiendo de si
queremos almacenar el año con dos o cuatro dígitos.

3-Tipos de cadena:

Char(n): almacena una cadena de longitud fija. La cadena podrá contener

desde 0 a 255 caracteres.

VarChar(n): almacena una cadena de longitud variable. La cadena podrá

contener desde 0 a 255 caracteres.

Dentro de los tipos de cadena se pueden distinguir otros dos subtipos, los tipo
Test y los tipo BLOB (Binary large Object)
La diferencia entre un tipo y otro es el tratamiento que reciben a la hora de
realizar ordenamientos y comparaciones. Mientras que el tipo test se ordena
sin tener en cuenta las Mayúsculas y las minúsculas, el tipo BLOB se ordena
teniéndolas en cuenta.
Los tipos BLOB se utilizan para almacenar datos binarios como pueden ser
ficheros.
TinyText y TinyBlob: Columna con una longitud máxima de 255 caracteres.

Blob y Text: un texto con un máximo de 65535 caracteres.

MediumBlob y MediumText: un texto con un máximo de 16.777.215

caracteres.

LongBlob y LongText: un texto con un máximo de caracteres 4.294.967.295.

Hay que tener en cuenta que debido a los protocolos de comunicación los
paquetes pueden tener un máximo de 16 Mb.

Enum: campo que puede tener un único valor de una lista que se especifica. El
tipo Enum acepta hasta 65535 valores distintos

Set: un campo que puede contener ninguno, uno ó varios valores de una lista.
La lista puede tener un máximo de 64 valores.

5.2- La llave Primaria o key:

En una base de datos, la distinción de una entidad entre otra se debe a sus
atributos, lo cual lo hacen único. Una llave primaria es aquel atributo el cual
consideramos clave para la identificación de los demás atributos que describen
a la entidad. Por ejemplo, si consideramos la entidad ALUMNO dela
universidad de Panamá, podríamos tener los siguientes atributos: Nombre,
Cédula, Semestre, Carrera, Dirección, Teléfono, etc. de todos estos atributos el
que podremos designar como llave primaria es el número de la cédula, ya que
es diferente para cada alumno y este nos identifica en la institución.
Claro que puede haber más de un atributo que pueda identificarse como llave
primaria en este caso se selecciona la que consideremos más importante, los
demás atributos son denominados.
6- Pruebe cada uno de los comandos mencionados, utilizando como base
el ejemplo de la clase de la semana #12. Use el servidor SERFIEC de la
facultad.
prueba de comandos de SQL en el servidor SERFIEC

• Insertar un registro

Para insertar un registro a la base de datos utilizamos el comando INSERT

que permite insertar datos en una tabla, junto con la cláusula INTO que indica
la tabla y sus registros a la cual se va a añadir datos y la cláusula VALUES
indica los valores que han de insertarse en los registros de la tabla.

Ejemplo:

Estos son los datos de los registros contenidos en la tabla

”estu”:

Por medio de una aplicación añadimos un registro a la tabla que por la cual
indica los siguientes datos.

Cantidad de datos:
 • se pide que se inserte la cantidad de datos para insertar en la tabla

Insertar valores en los registros:

• se insertan valores de cada registro como el nombre, apellido y edad

Despliegue en consola de la tabla:

Como podemos observar se ha insertado un nuevo registro en la tabla estu de

la base de datos facultad.

El codigo en java y la sentencia SQL que utilizamos es la siguiente:

String ins = "INSERT INTO estu (nombre,apellido,edad) VALUES (

'"+var1+"','"+var2+"','"+var3+"')";
s.executeUpdate(ins);
• Eliminar un registro

Para borrar un registro utilizamos la instrucción DELETE junto con la clausula

FROM que especifica la tabla que contiene los registros. Para su debida
implementación, se debe especificar cual o cuales son los registros que
queremos borrar. Es por ello necesario establecer una selección que se llevara
a cabo mediante la cláusula WHERE.

Ejemplo:

Insertar el codigo del registro para eliminar:

• En el cuadro de dialogo se pise que se inserte el código de un registro

para ser eliminado, en este caso vamos a eliminar el registro que
contiene el código 50 que es el de pedro concepción.

Despliegue en consola de la tabla:

Como vemos el registro que contenía el código 50 de pedro concepción fue

eliminado de la tabla.
El código en java y la sentencia SQL que utilizamos es la siguiente:

String insd = "DELETE FROM estu WHERE codigo='"+var1+"'";

s.executeUpdate(insd);

• Actualizar un registro

UPDATE es el comando que nos sirve para modificar los registros de una tabla,
como para el caso de DELETE, necesitamos especificar por medio de WHERE
cuáles son los registros en los que queremos hacer efectivas nuestras
modificaciones. Además, tendremos que especificar cuáles son los nuevos
valores de los campos que deseamos actualizar.

Ejemplo:

Supongamos que hubo una variación en el registro con el codigo 18 de aleyda

huertas y se pide realizar una actualización con los datos:

- nombre: Guillermo
- apellido: Urriola
- codigo: 81
 • se pide que se inserte el código del registro actual para actualizarlo

Insertar datos actualizados:

• insertan los datos actualizados del registro

Despliegue en consola de la tabla:

Como se muestra en la consola, el registro que contenía los datos de aleyda

huerta, fueron actualizados por los de Guillermo Urriola.
El codigo en java y la sentencia SQL que utilizamos es la siguiente:

String upd = "UPDATE estu SET nombre='"+var1+"', apellido='"+var2+"',

codigo='"+var3+"' WHERE codigo='"+varB+"' ";

s.executeUpdate(upd);

• Consultar registros de una tabla

Para la consulta registros de una tabla, se utiliza la instrucción SELECT ya que

devuelve un conjunto de registros definido como un conjunto de resultados
(ResultSet). Para emplear sentencias de JDBC, JDBC devuelve un resultado
en un objeto ResultSet para contener dicho resultado, para establecer
expresiones en MYSQL , se utiliza la interfaz Statement ya que invoca a un
metodo que crea la interfaz provenida de un objeto que realiza la conexión con
MYSQL.

Ejemplo:

• En la consola se muestra una consulta de los registros que contiene la

tabla compuesto por el campo nombre, edad y código.
 • Crear una tabla

Para crear una tabla utilizamos el comando CREATE TABLE junto con el
nombre de la tabla que sirve como parámetro para establecer la función.

Al momento de crear una tabla, debemos especificar diversos datos: El nombre

que le queremos asignar, los nombres de los campos y sus características.
Además, puede ser necesario especificar cuáles de estos campos van a ser
índices y de qué tipo van a serlo.

Ejemplo:

Creación de la tabla estudiante, asignatura y profesor

Instruccion SQL para la creacion de la tabla estudiante con sus registros:

CREATE TABLE `estudiante` (`curso` MEDIUMINT (5) NOT NULL, `numero`

SMALLINT (3) NOT NULL, `cedula` VARCHAR (18) NOT NULL, `nota`
VARCHAR (3) NOT NULL );

Instruccion SQL para la creacion de la tabla asignatura con sus registros:

CREATE TABLE `asignatura` (`curso` MEDIUMINT (5) NOT NULL,

`datoasig` MEDIUMINT (5) NOT NULL);

Instrucción SQL para la creación de la tabla profesor con sus registros:

CREATE TABLE `profesor` (`curso` MEDIUMINT (5) NOT NULL, `datoprofe`

MEDIUMINT (5) NOT NULL);

Estas son las tablas que manipulamos en la base de datos facultad que por
consiguiente almacenan los datos indicados como por ejemplo la tabla
estudiante almacena el código de curso , el numero , la cedula y la nota del
estudiante, la tabla asignatura almacena el curso y los datos de la asignatura
como el código de asignatura, numero de profesor y el nombre de la asignatura
y la tabla profesor almacenara el código de curso y los datos del profesor como
el código de profesor y el nombre del profesor.

La aplicación que desarrollamos requiere de una clase que realice consultas de

las notas un estudiante relacionado con la asignatura y profesor indicando la
cedula correspondiente, debido a esto, las tablas deben estar relacionadas con
un campo identificador o campo clave que realice la relación con las otras
tablas, el campo que seleccionamos es el campo curso ya que cada
asignatura posee un código de curso distinto en orden ascendente lo que
facilita una mejor interacion en el proceso de consulta de los registros.
 7. Elabore un programa OO que lea el archivo de texto de las
calificaciones de los estudiantes del CRUV y cree una tabla de
profesores, otra de estudiantes y otra de asignatura. ¿Dedicó tiempo
para diseñar sus tablas?¿Qué datos pueden duplicarse y cuáles no?

8- Diseñe una clase que permita consultar a partir de la cédula, las

calificaciones identificadas con asignatura y docente.

código fuente de la aplicación OO incluyendo el punto 7 y 8

/***************************CLASE SisConsulta (principal)

********************************/
import javax.swing.*;
import java.text.*;

public class SisConsulta {

public static void main(String[] args) {

System.out.println(" UNIVERSIDAD DE PANAMA");

System.out.println(" CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS");
System.out.println(" SISTEMA DE CONSULTA DE CALIFICACIONES");
int o=0;
CaptDespDatos cap = new CaptDespDatos();
String ntab=" ";

do
{
Menu1 men = new Menu1();
o = men.opcion();

switch (o)
{
case 1:{
String ar = cap.getarch();//metodo que decuelve el archivo que contiene los datos del CRUV
TablasSQL ins = new TablasSQL(ar,1);//inicializa objeto de la clase TablasSQL
ins.insRegTabla();//metodo que inserta o añade registros a las tablas de la base de datos
break;
}

case 2:{
String c = cap.Getcedula();//metodo que devuelve la cedula
ConsultaRegistro co = new ConsultaRegistro(c,0);//inicializa objeto de la clase ConsultaRegistro
co.consultarDatos();//metodo que consulta los datos en registros a partir de una cedula
break;
}

case 3: {
 ntab = cap.getnomTabla(1);//metodo que devuelve el nombre de una tabla
TablasSQL eli = new TablasSQL(ntab,0);//inicializa objeto de la clase TablasSQL
eli.eliminaRegs();//metodo que elimina registros de una tabla
break;
}

case 4:{
ntab = cap.getnomTabla(2);//metodo que devuelve el nombre de una tabla
CaptDespDatos des = new CaptDespDatos(ntab,2);//inicializa objeto de la clase CaptDespDatos
des.DespDatosSQL();//metodo que graba los registros de una tabla en un archivo
break;
}

case 5:System.out.println("\n\nGRACIAS POR UTILIZAR EL SISTEMA");

break;

default:System.out.println("\nopcion incorrecta");

while (o<5);

/*******************************************************************************
******/

/******************************CLASE Menu1
******************************************/
import javax.swing.*;
import java.text.*;

class Menu1
{
public Menu1()
{

public int opcion()

{
String ops = JOptionPane.showInputDialog(null, "MENU DE OPCIONES\n\n 1. añadir
registros de un archivo\n 2. realizar consulta\n 3. eliminar registros en tabla\n 4. ver registros en
tabla\n 5. salir del sistema \n\n seleccione una opcion: ");
int op = Integer.parseInt(ops);
return(op);
}//fin del metodo opcion

}//fin de la clase Menu1

/*******************************************************************************
******/

/*********************CLASE DriversConnSQL (abstracta)

*********************************/
import java.sql.*;
import java.io.*;

/*clase abstracta que administra la conexion con MYSQL y el flujo de entrada/salida de archivos de texto*/

abstract class DriversConnSQL

{
public String userName;
public String password;
public String url;
public String ConxDriver;
Connection conn = null;
Statement s0,s1,s2;
public String operador;
public int ident;
FileReader arch1=null;
BufferedReader in = null;
FileWriter arch2=null;
BufferedWriter as=null;
PrintWriter arn=null;
ResultSet rs = null;

public DriversConnSQL()
{

public DriversConnSQL(String oper, int id)

{
this.operador=oper;
this.ident = id;

System.out.println ("\nConectar a base de datos...");

try
{
System.out.println ("Connection Database OKKK!");
userName = "user@localhost";
password = "";
url = "jdbc:mysql://localhost:3307/facultad";
ConxDriver = "com.mysql.jdbc.Driver";

Class.forName (ConxDriver).newInstance ();//instancia que carga los controladores jdbc necesarios para
conectar con mysql
conn = DriverManager.getConnection (url, userName, password);//obtiene la conexion remota con la
base de datos de mysql
s0 = conn.createStatement ();//crea la instancia de conexion con mysql para usarla en la 1 tabla
s1 = conn.createStatement ();//crea la instancia de conexion con mysql para usarla en la 2 tabla
s2 = conn.createStatement ();//crea la instancia de conexion con mysql para usarla en la 3 tabla
 if (ident==1)
{
arch1 = new FileReader(this.operador);//instancia de la clase que nos permite leer un archivo
in = new BufferedReader(arch1);//instancia de la clase que nos permite leer una cadena del archivo

}
else
if (ident==2)
{
arch2 = new FileWriter("ResTabla.txt"); //declaracion para escribir en el archivo
as = new BufferedWriter(arch2);//instancia de la clase que permite grabar en el archivo
arn = new PrintWriter(as);//instancia que nos permite grabar datos en el archivo
System.out.println ("Generando el archivo ResTabla.txt");
}
}
catch (Exception e)
{
System.err.println ("No puede conectarse al Servidor Mysql " + e );
}
}

abstract void insRegTabla();

}

/*******************************************************************************
******/

/********************************CLASE TablasSQL
************************************/
import java.sql.*;
import java.io.*;

/*subclase heredera de DriversConnSQL que inserta registros de un archivo de lectura y elimina registros
de una tabla*/

class TablasSQL extends DriversConnSQL

{
public TablasSQL(String opr,int id)
{
super(opr,id);
}

public void insRegTabla()

{
String s = new String();
try
{
System.out.println("insertando registros en las tablas, espere un momento...");
int cur=0;
String ins,codp=" ",curs=" ",as=" ",pro=" ",codp1=" ",ins1,ins2;

while( (s = in.readLine())!=null ) //lectura del archivo

{
 if ( (! s.equals(" UNIVERSIDAD DE PANAMA") ) && (! s.equals("
LISTADO DE CEDULAS Y SUS RESPECTIVAS CALIFICACIONES") ) && (! s.startsWith(" 31-
ENE-07") ) && (! s.startsWith(" SEDE") ) && (! s.startsWith(" Num") ) && (! s.startsWith(" ---
") ) )
{
//System.out.println(s);
if (s.startsWith(" CURSO") )
{
curs = s.substring(s.indexOf(':')+2,s.length() );//extrae el string que contiene el curso
cur = Integer.parseInt(curs);
}
else
if (s.startsWith(" ASIGNATURA:") )
{
as = s.substring(s.indexOf(':')+2,s.length() );//extrae el string que contiene los datos de la
asignatura
ins = "INSERT INTO asignatura (curso,datoasig) VALUES ('"+cur+"','"+as+"')";//string con
la sentencia sql que inserta el curso y los datos de asignatura
s0.executeUpdate(ins);//ejecuta y actualiza la sentencia sql insertando los datos en la
tabla asignatura

}
else
if (s.startsWith(" PROFESOR") )
{
pro = s.substring(s.indexOf(':')+2,s.length());//extrae el string que contiene los datos del
profesor
ins1 = "INSERT INTO profesor (curso,datoprofe) VALUES (
'"+cur+"','"+pro+"')";//string con la sentencia sql que inserta el curso y los datos del profesor
s1.executeUpdate(ins1);//ejecuta y actualiza la sentencia sql insertando los datos en
la tabla profesor
}
else
if ( s.length()==43 )
{
char pl = s.charAt(38);
if (pl==' ')
{
String nuc = s.substring(7,8);//extrae el numero
String cede = s.substring(15,31);//extrae la cedula
String not = s.substring (42,43);//extrae la nota
ins2 = "INSERT INTO estudiante (curso,numero,cedula,nota) VALUES (
'"+cur+"','"+nuc+"','"+cede+"','"+not+"')";//string con la sentencia sql que inserta el curso , numero, cedula
y nota en la tabla estudiante
s2.executeUpdate(ins2);//ejecuta y actualiza la sentencia sql insertando los
datos en la tabla estudiante
}
}
}//if

}//while
try
{
in.close();//cierra el archivo de lectura
}//try2
 catch ( IOException e )//captura una excepcion de entrada/salida con un mensaje
{
System.err.println( "El archivo no se pudo cerrar correctamente" );
System.exit( 1 );//sale de la ejecucion del sistema
}
s0.close();
s1.close();
s2.close();
System.out.println("los registros se han insertado satisfactoriamente...");
}//try conexion a la tabla
catch (Exception e)
{
System.err.println ("Problemas con acceso a la tabla"+e);
}
}

public void eliminaRegs()

{
try
{
if (this.operador.equals("asignatura") )
s0.executeUpdate("DELETE FROM asignatura");//ejecuta sentencia sql para eliminar la tabla
asignatura
else
if (this.operador.equals("profesor") )
s1.executeUpdate("DELETE FROM profesor");//ejecuta sentencia sql para eliminar la tabla profesor
else
if (this.operador.equals("estudiante") )
s2.executeUpdate("DELETE FROM estudiante");//ejecuta sentencia sql para eliminar la tabla
estudiante
else
throw new Exception ("la tabla no se encuentra en la base de datos o esta mal escrita");

System.out.println("los registros de la tabla "+ this.operador +" se han eliminado correctamente");

}
catch (Exception e)
{
System.err.println ("Problemas con acceso a la tabla "+ e);
}

}//fin de la clase TablasSQL

/*******************************************************************************
******/

/*******************************CLASE CaptDespDatos
**********************************/
import javax.swing.*;
import java.text.*;
import java.sql.*;
/*subclase CaptDespDatos heredera de DriverConnSQL que captura archivo de texto, cedula y realiza una
consulta de resgistros a una tabla y los graba en un archivo*/

class CaptDespDatos extends DriversConnSQL

{

public CaptDespDatos(String nt, int id)

{
super(nt,id);
}

public CaptDespDatos()
{

public void DespDatosSQL ()

{
try
{
String dats=" ", cu=" ";
boolean ag=false,pr=false,es=false;

if (this.operador.equals("asignatura") )
{
s0.executeQuery ("SELECT curso,datoasig FROM asignatura");//instancia que ejecuta una consulta de
campos en la tabla asignatura
rs = s0.getResultSet ();//instancia del metodo que devuelve un conjunto de resultado de la consulta
dats = "datoasig";
ag= true;
}
else
if (this.operador.equals("profesor") )
{
s1.executeQuery ("SELECT curso,datoprofe FROM profesor");//instancia que ejecuta una consulta de
campos en la tabla profesor
rs = s1.getResultSet ();//instancia del metodo que devuelve un conjunto de resultado de la consulta
dats = "datoprofe";
pr=true;
}
else
if (this.operador.equals("estudiante") )
{
s2.executeQuery ("SELECT curso,numero,cedula,nota FROM estudiante");//instancia que ejecuta
una consulta de campos a la tabla estudiante
rs = s2.getResultSet ();//instancia del metodo que devuelve un conjunto de resultado de la consulta
es=true;
}

int count = 0,curVal=0;

System.out.println ("insertando dato de la tabla "+ this.operador +" \n");
arn.println ("DATOS DE LA TABLA " + this.operador + " EJECUTANDOSE EN LA BASE DE
DATOS facultad");
arn.println ();
while (rs.next ())
 {
curVal = rs.getInt ("curso");//extrae el codigo de curso del campo curso en la tabla asignatura

if (ag)//condicion si es la tabla asignatura

{
String datVal = rs.getString (dats);//extrae los datos de la asignatura del campo datoasig en la tabla
asignatura
arn.println ("curso= "+curVal+" datos de la asignatura= "+datVal);
//arn.println (s);
}
else
if (pr)//condicion si es la tabla profesor
{
String datVal = rs.getString (dats);//extrae los datos del profesor del campo datoprofe en la
tabla profesor
arn.println ("curso= "+curVal+" datos del profesor= "+datVal);
}
else
if (es)//condicion si es la tabla estudiante
{
int numVal = rs.getInt ("numero");//extrae el numero de la tabla estudiante
String cedVal = rs.getString ("cedula");//extrae la cedula de la tabla estudiante
String noVal = rs.getString ("nota");//extrae la nota de la tabla estudiante
arn.println ("curso= "+curVal+" numero= "+numVal+" cedula= "+cedVal+" nota= " +
noVal);
}
++count;
}//while
rs.close ();
s0.close ();
s1.close ();
s2.close ();
System.out.println ("\n Registros recuperados...."+ count);
System.out.println ("se ha guardado la informacion de los registros en el archivo
ResTabla.txt");
}
catch (Exception e)
{
System.err.println ("Problemas con acceso a la tabla"+e);
}
finally
{
if (conn != null)
{
try
{
conn.close ();
System.out.println ("\n !!!!!Cerrada la coneccion a Mysql");
}
catch (Exception e) { /* sin mensajes de error */ }

}//if
}//finally
}//fin del metodo DespDatosSQL
 public void insRegTabla()
{/*no es necesario implementar el uso de este metodo en esta subclase*/ }

public String getarch()

{
String nomar = JOptionPane.showInputDialog(null, "ins. el archivo que contiene las calificaciones del
CRUV");
return (nomar);
}//fin del metodo getarch

public String Getcedula ()

{
String cedula = JOptionPane.showInputDialog(null, "inserte la cedula Ej. 9-724-389");

String [] cant = cedula.split("-");//se fracciona la cedula con las rayas en el split obteniendo la provincia,
el tomo y asiento
int f=cant.length;

String tomo = new String();//inicializa tomo

String asiento = new String();//inicializa el asiento

if ( cant[1].length()==3 )//si el tomo es igual a 3 caracteres se le concatena un cero

tomo="0";
else
if ( cant[1].length()==2 )//si el tomo es igual a 2 caracteres se le concatena dos ceros
tomo="00";

if (cant[2].length()==4)//si el asiento es igual a 4 caracteres se le concatena un cero

asiento="0";
else
if (cant[2].length()==3)//si el asiento es igual a 3 caracteres se le concatena dos ceros
asiento="00";
else
if (cant[2].length()==2)//si el asiento es igual a 2 caracteres se le concatena tres ceros
asiento="000";

String cedval =("0"+cant[0]+" "+"00"+" "+tomo+cant[1]+" "+asiento+cant[2]);//se contatena el

resultado de los if con los ceros del tomo y el asiento, con los datos de las posiciones del vector

return (cedval);

} //fin del metodo Getcedula

public String getnomTabla(int func)

{
String f=" ";

if (func==1)
f = "eliminar registros";
else
 if (func==2)
f="ver registros";

String nomtab = JOptionPane.showInputDialog(null, "inserte el nombre de la tabla para " + f + ": ");
return (nomtab);

}//fin del metodo getnomTabla

}//fin de la clase CaptDespDatos

/*******************************************************************************
******/

/****************************CLASE ConsultaRegistro
***********************************/
import java.sql.*;

/*subclase heredera de DriversConnSQL clase que consulta registros de calificaciones a partir de una
cedula*/

class ConsultaRegistro extends DriversConnSQL

{
public ConsultaRegistro(String c,int id)
{
super(c,id);
}

public void consultarDatos()

{
try
{
//string que contiene la sentencia SQL para realizar consultas en multiples tablas
String cons = "SELECT datoprofe,datoasig,numero,cedula,nota FROM profesor,asignatura,estudiante
WHERE estudiante.curso = profesor.curso AND profesor.curso = asignatura.curso AND asignatura.curso
= profesor.curso AND estudiante.cedula='"+this.operador+"' GROUP BY datoasig";

System.out.println ("CONSULTA DE LA CEDULA: \n"+this.operador);

s0.executeQuery (cons);
rs = s0.getResultSet();
int count = 0;
System.out.flush();

while (rs.next ())

{
int numVal = rs.getInt ("numero");//extrae el numero de cedula
//String cedVal = rs.getString ("cedula");
String noVal = rs.getString ("nota");//extrae la note
String proVal = rs.getString ("datoprofe");//extrae los datos del profesor
String asgVal = rs.getString ("datoasig");//extrae los datos de la asignatura
System.out.println ("\nnumero= "+numVal+"\nnota= "+noVal+"\ndatos del profesor=
"+proVal+"\ndatos de la asignatura= "+asgVal);
System.out.println ("*-----------------------------------------------------------------------------*");
++count;
 }//while

if (count==0)
throw new Exception ("error! la cedula no se encuentra en la base de datos!");

System.out.println ("\n Registros recuperados...."+ count);

rs.close ();//cierra la instancia del resultado para la consulta
s0.close ();//cierra la instancia que ejecuta la consulta
}
catch (Exception e)
{
System.err.println ("Problemas con acceso a la tabla: " + e);
}

}//fin del metodo ConsultarDatos

public void insRegTabla()

{/*no es necesario implementar el uso de este metodo en esta subclase*/ }

}//fin de la clase ConsultaRegistro

/*******************************************************************************
******/
 RESULTADOS Y EVIDENCIA DE EJECUCION

En este punto le mostraremos el programa corriendo sin errores ni excepciones, como

primer paso la aplicación mostrara un menú de opciones.

Cada opción se selecciona con un número del 1 al 5, como se muestra, las opciones
disponibles son: añadir registros de un archivo, realizar consulta, eliminar registros en
tabla, ver registros en tabla y salir del sistema.

1. añadir registros de un archivo

Para añadir registros de un archivo a las diferentes tablas que se están

manipulando las cuales son: asignatura, estudiante y profesor, se pide que
inserte un archivo de texto que contiene todos los datos importantes de las
tablas para la consulta de los mismos.

Como se ve en la imagen, se esta insertando un archivo de texto llamado datos1.txt.

Se realiza una verificación de conexión a la base de datos facultad y luego procesa los
la información requerida para añadirla a los registros de las tablas.

Luego de haber realizado la operación anterior, despliega en pantalla un

mensaje que indica que los registros se han insertado satisfactoriamente en las
tablas.

2. realizar consulta

Para la consulta se pide que se inserte una cedula con guiones y sin los ceros
adjuntos para facilitar la rapidez de inserción de datos.
En la imagen se detalla que se esta insertando una cedula solamente con los
guiones.

Después de haber insertado la cedula se verifica si existe en la base de datos y

de ser así despliega los registros con su información.
3. eliminar registros en tabla

Para eliminar los registros de una tabla se requiere que se inserte el nombre de
la tabla a la cual se desea eliminar toda la información que contiene.

En la imagen se presenta que se inserto la tabla asignatura para que sus

registros sean eliminados.

Luego de haber aceptado la eliminación de registros de la tabla asignatura, se

procede a eliminar todos sus registros.
4. ver registros en tabla

Esta opción despliega todos los registros de una tabla abriendo un archivo de
texto desde el explorador de Windows, insertándole el nombre de la tabla para
efectuar la operación.

Como aparece en la imagen se inserta la tabla profesor.

Luego de haber insertado el nombre de la tabla, se procere a realizar la

operación de grabar todos los datos que contienen los registro de la tabla
insertada en un archivo de texto llamado “ResTabla.txt”.
 El archivo ResTabla.txt va a contener todos datos de los registros de la tabla
profesor

5. salir del sistema

Para concluir el uso de la aplicación, se inserta la opción 5 para finalizar la

ejecución de la aplicación.
 9- Compare la solución del punto #8 usando Base de datos vs. Archivos.

COMPARACION DE ARCHIVOS VS BASE DE DATOS

Entre los archivos y las base de datos existe mucha sutileza en cuanto a la
redundancia de procesamiento y almacenamiento de información, según lo
analizado e investigado, entre las dos estructuras hay poca similitud entre el
acceso a la información y a la conexión. A continuación se mostrara una tabla
comparativa de las dos estructuras.

ARCHIVOS BASE DE DATOS

• un archivo es una estructura en donde • una base de datos es un conjunto

se almacena información de forma
masiva.
• Los archivos pueden ser secuenciales,
binarios y de acceso directo.
• Para implementar el uso del archivo se
necesita crear instancias de clases que
utilicen flujos de entrada o salida.
• Los archivos pueden ser locales o
remotos definiéndolo como una
referencia a un recurso web o local. Si
el archivo es remoto se tiene que
implementar la clase URL indicando
una dirección para efectuar diferentes
operaciones.
• Los archivos pueden manipularse para
lectura o escritura
estructurado organizado e integrado de
datos en la cual se identifican y
clasifican para su consulta,
actualización o cualquier tarea de
mantenimiento mediante aplicaciones
específicas.
• Una base de datos es relacional e
integral implementando sus tablas con
sus registros incorporando consultas y
actualizaciones.
• Para utilizar una base de datos, debe
cargar un controlador JDBC que
permite establecer una instancia con
mysql por medio de una dirección del
servidor y un puerto para acceder a una
base de datos.
• Las base de datos pueden ser locales o
remotas, si son locales se debe
implementar una dirección de servidor
local (localhost) ,un puerto del servidor
mysql local y la base de datos, si son
remotas se debe implementar una
dirección del servidor remoto, el puerto
de mysql remoto y el nombre de la base
de datos.

• La base de datos para manipular los

registros de las tablas, puede ser por
consulta o por actualización
especificando el tipo de campo de las
tablas, su longitud y su incidencia en un
índice o llave primaria.
Experiencia de Alberto Carrillo:

La experiencia y conocimientos que obtuve en la elaboración de este proyecto

fue verdaderamente interesante y de mucha utilidad, ya que me gusto mucho
aprender la implementación de base de datos en mysql para la creación de
tablas, realizar consultas y realizar actualizaciones en una aplicación en java,
pienso que no solamente en java podré usar los conocimientos de sql, sino que
en la programación de paginas web y en aplicaciones de Visual Basic según lo
investigado, mysql posee instrucciones y cláusulas que me permiten consultar
y actualizar los registros de las tablas de una manera organizada y eficiente en
el sentido de que facilita el rápido acceso y distribución de los datos. La parte
de la aplicación que mas me gusto fue la de cómo se realizaba la conexión de
la base de datos en mysql con java remotamente, veo que, radicalmente es
como mas aprovechable y recursivo acceder a los datos de la base de datos
por medio de la red y la parte mas difícil que me costo mucho realizar fue la de
consultar los datos a partir de la cedula, ya que en las tablas que contiene la
base de datos tienen un campo clave que las relaciona para acceder
consecutivamente a los distintos datos que poseen y por ende se me dificultaba
un poco realizar la consulta eficiente, pero investigue arduamente sobre
instrucciones y cláusulas que posee sql para la consulta de varias tablas y así
pude lograr la consulta en la aplicación usando poco código y de manera
eficiente. Este laboratorio me va a ayudar muchísimo para el desarrollo del
último proyecto.
Estudiante: Daniel Ballesteros.

1. ¿ Cómo fue la labor de los integrantes?

Ser parte de un equipo es complementar el trabajo realizado y pienso que en
este trabajo cada miembro fue parte importante en la solución del mismo.

2. ¿ Cuál fue la parte más difícil y por qué?

La parte más difícil fue visualizar que no solo estábamos utilizando los
comandos de Java sino también Mysql desde java y esto complico un poco mi
comprensión de lo que debía suceder en el programa

3. ¿Qué nuevos conocimientos se lograron?

Esto del manejo de base de datos a través de java utilizando Mysql me pareció
increíblemente útil, tecnológicamente avanzado y nos brindo una de las
experiencias profesionales más importantes de toda la carrera de LIEE, a mi criterio.

4. ¿Qué conocimientos previos fueron esenciales?

En programación orientada a objetos siempre los conocimientos previos tienen
mucha importancia en la solución de los siguientes laboratorios y proyectos y los
conceptos de abstracción, los flujos de datos, las conexiones remotas fueron de las
màs importantes para mi persona.

5. ¿Qué importancia tiene para su formación profesional?

Las bases de datos son el boom de la empleomanía en el área de la
informática y a mi parecer se nos ha abierto una puerta al éxito que necesitamos
seguir cultivando.

6. ¿Qué utilidad tiene el trabajo realizado?

El trabajo realizado tiene gran importancia porque nos permitió acceder a una base
de dato desde java que pudo haber estado en china y nosotros aca, me ha
impresionado mucho todo lo referente a java con Mysql y espero a pesar de que ya
culminamos el curso de Programación IV, poder seguir cultivando los conocimientos
que nos han sido proporcionados..