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

“Programación IV Inf._212”

“Proyecto # 2”

“Laboratorio
Laboratorio 9 - Mysql”
Mysql”

ESTUDIANTE:

FLORES, MALQUIS CED. 9-722-2066

ORTEGA, AMANDA CED. 9-723-367

PROFESOR:

DIEGO SANTIMATEO

SEMESTRE:

II SEMESTRE – II AÑO

FECHA DE ENTREGA:

DICIEMBRE -2007
 LABORATORIO # 9

1. Describa qué es una base de datos y un motor (manejador) de base de datos.

Base de Datos: es un conjunto de información almacenada entre los que existen relaciones lógicas
y ha sido diseñada para satisfacer los requerimientos de información.
Motor (Manejador) de base de datos: programa que permite crear, editar, ordenar tablas,
capturar formas, realizar consultas y generar reportes.

2. Describa una tabla y sus componentes. Haga ejemplos de varios registros. Indique cómo están
constituidos los registros.
Las tablas son grandes contenedores que guardan la información en un modelo de bases de datos
relacionados.

Componentes de una tabla:

• 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 su almacenamientos.

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

SQL: es el lenguaje estándar utilizado para manejar las bases de datos.

MYSQL: es un software creado por MySQL AB y es un software multiusuario, multihilos y un

servidor SQL

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?

• Insertar:
INSERT INTO: Esta sentencia nos permite insertar registro a la tabla.
s.executeUpdate ("INSERT INTO estu (nombre, apellido, edad)
VALUES('amanda', 'ortega','1025')");
• Eliminar:
DELETE FROM: Esta sentencia nos permite hace el contenido de la tabla se borre en su
totalidad.
s.executeUpdate ("DELETE FROM estu WHERE edad=0");

• Actualizar:
UPDATE : nos permite modificar o cambiar los datos de la tabla.
Ejemplo: s.executeUpdate ("UPDATE estu SET
nombre='amanda'where nombre='fatima'");
 • Consultar:
SELECT: nos permite consultar los datos almacenados en una tabla de la
base de datos.
s.executeQuery ("SELECT nombre,apellido,edad FROM estu where
nombre='hernan'");
Utilidad de la cláusula WHERE: es la instrucción que nos permite filtrar el resultado de una
sentencia SELECT. Esta cláusula nos permite ver solo los datos que nos sean útiles. 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?

CHAR/CHAR(): Las columnas de tipo char o char() almacenan un carácter o una cadena
de caracteres de 0 hasta 255 respectivamente (Si lo recuerdan, este fue el tipo de datos que
le asignamos a todas nuestras columnas en la tabla UNO)

VARCHAR: Estas columnas almacenan una cadena de caracteres variables de 0 a 255.

TINYINT(): Almacena un valor entero pequeño de 0 a 255 o de -128 a 127

BIT, BOOL, BOOLEAN: Todos estos tipos son sinónimos de TINYINT(1).

SMALLINT: Almacena un entero corto (digamos que, no tan pequeño), entre -32768 y
32767 o, en caso de no tener un signo de 0 a 65535.

MEDIUMINT: Almacena un entero de tamaño medio entre -83888608 y 8388607 y entre 0

y 16777215 sin signo.

INT/INTEGER: Contiene un entero de tamaño normal (este normal es para nosotros en

realidad un tamañote) entre -2147483648 y 2147483647 o entre 0 y 4294967295.

BIGINT: Como podrán imaginarse contiene un entero grande (o lo que es lo mismo un

enterote) entre -9223372036854775808 a 922337203685477807 con signo o de 0 a
18446744073709551615 sin signo.

FLOAT/FLOAT(): Guarda un número de coma flotante. Opcionalmente puede

acompañarse (al tipo flota sin los paréntesis) de la palabra precision que le indica la
precisión decimal que se desea, que puede llegar hasta 24 para precisión sencilla y de 25 a
53 para una precisión doble. Para flota(), los valores permitidos van desde -
3402823466E+38 y -1.175494351E-38, 0, y entre 1.175494351E+38 y 3.402823466E+38.
En caso de espcificarse el modificador UNSIGNED los valores negativos no son permitidos.

DOUBLE: Contiene un número de coma flotante de precisión normal. Sus valores van desde
-1.7976931348623157E+308 y -2.2250738585072014E-308, 0, y entre
2.2250738585072014E-308 y 1.7976931348623157E+308. Una vez más, si se define
UNSIGNED, los valores negativos no son permitidos.

DOUBLE PRECISION
REAL : Son sinónimos de DOUBLE

DECIMAL: Guarda un número de coma flotante sin empaquetar. Esto de sin empaquetar
implica que se guarda como una cadena (véase CHAR), usando un carácter para dígito del
valor.

DEC, NUMERIC, FIXED : Son todos sinónimos de DECIMAL

DATE: Almacena un valor de fecha, los rangos permitidos son desde ‘1000-01-01’ y ‘9999-
12-31’ (Fecha en la que podría que nosotros ya no estemos vivos). El formato de fecha
presentado es, como ya lo habrán imaginado ‘AAAA-MM-DD’
 DATETIME: Contiene un “MIX” (para demostrar que sabemos de terminología moderna),
es decir una mezcla de fecha y hora. El rango que MySQL soporta es desde ‘1000-01-01
00:00:00’ hasta ‘9999-12-31 23:59:59’. El formato es del tipo ‘AAAA-MM-DD HH:MM:SS’

TIMESTAMP: Es un valor de tiempo que puede estar desde -1970-01-01 00:00:00’ hasta
un momento en el año 2037 (lo cual suena como a un libro de ciencia ficción o algo así, ¿no
les parece?)

TIME: Es una hora que permite los valores ‘-838:59:59’ a ‘838:59:59’. Los valores se
muestran en formato HH:MM:SS

YEAR: Guarda un año en formato de 2 o 4 dígitos, siendo el valor por defecto 4. Los valores
permitidos son desde 1901 a 2155 y 0000 en el formato de 4 dígitos y desde 1970 a 2069
en el formato de 2 dígitos (70-69).

Los siguientes tipos son para datos sin tipo o grandes cantidades de datos.

TINYBLOB, TINYTEXT: Almacena una columna BLOB o TEXT con una longitud de hasta
255 caracteres (28-1)

BLOX, TEXT: Almacena una columna BLOB o TEXT con una longitud de hasta 65535
caracteres (216-1)

MEDIUMBLOB, MEDIUMTEXT: Almacena una columna BLOB o TEXT con una longitud de
hasta 16777215 caracteres (224-1)

LONGBLOB, LONGTEXT: Almacena una columna BLOB o TEXT con una longitud de hasta
4294967298 caracteres (232-1)

Los siguientes son los tipos enumerados y los conjuntos:

ENUM: Almacena un enumerado, el cual es un objeto cadena que pueden un valor de entre
una lista, el valor NULL o el valor de error “”. Este valor puede tener un máximo de 65535
valores diferentes.

SET: Almacena un conjunto. Es una cadena que puede tener 0 ó más valores. Todos esos
valores debe estar entre una lista de valores. El máximo de miembros de un conjunto puede
ser 64.

- SIGNIFICADO DE LLAVE PRIMARIA:

Una palabra sobre diferenciación. Es necesario asegurarnos de que las entradas en una base
de datos puedan ser diferenciadas de otras.

La forma de lograr esto, es a través de lo que suele llamarse una LLAVE PRIMARIA. Lo
que una de estas llaves primarias es, es simplemente una distinción (usualmente un
número) que nos ayude a distinguir el contenido de una fila de otra, incluso si el contenido
de una columna es idéntico a otro.

Podemos crear una llave primaria en el momento de crear la tabla o incluso

crearla luego por medio de la sentencia ALTER.

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.
• Insertar:
INSERT INTO:
s.executeUpdate ("INSERT INTO estu (nombre, apellido, edad)
VALUES('amanda', 'ortega','1025')");
 El comando INSERT INTO, nos
permite insertar un registro dentro de
la tabla.

Eliminar:
DELETE FROM: Esta sentencia nos permite hace el contenido de la tabla se borre en su
totalidad.

Aquí se muestran los

ultimos registros de la
tabla, para eliminar el
último campo usamos las
sentencias:
s.executeUpdate
("DELETE FROM estu
WHERE edad=0");

Actualizar:
UPDATE : nos permite modificar o cambiar los datos de la tabla.
Ejemplo: s.executeUpdate ("UPDATE estu SET
nombre='pedro'where nombre='amanda'");

Se eliminó el registro que

contenia el código 0.

Ejecutamos el programa con el comando UPDATE para actualizar el nombre pedro por amanda.
 Se modificó el nombre de amanda a
Pedro, mediante la utilización del
comando UPDATE

Consultar:
Utilizamos el comando SELECT para consultar los datos almacenados en una tabla de la base
de datos.

s.executeQuery ("SELECT nombre,apellido,edad FROM estu where

nombre='hernan'");

Mediante el comando
SELECT verificamos
los datos de la tabla
estu...

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?
 Códigos Fuentes-
Fuentes- Crear Tablas
********************************************************************************************************************
//Crea las Tablas de Estudiantes, Profesores y asignatura

import java.sql.*;
public class PruebaRemotaMysql
{
public static void main (String[] args) Breve Explicación del
{
Código.
Connection conn = null;

try
{ En el Código que se
String userName = "FIEC-01";
presenta, creamos las
String password = "";
// se indica el servidor, puerto y la base de datos facultad de mysql tablas necesarias para
String url = "jdbc:mysql://serfiec:3306/facultad"; realizar el punto # 8 del
laboratorio.
/* se hace efectiva la comunicación con la base de datos
mediante el método 'forName' de la clase Class*/
Class.forName ("com.mysql.jdbc.Driver").newInstance (); Primero hacemos
efectiva la conexión con
/*En esta sección utilizamos la clase DriverManager para la base de datos
obtener un objeto de tipo Connection*/
mediante el método
conn = DriverManager.getConnection (url, userName, password); forName de la Clase
System.out.println ("Coneccion Database OKKK!!!"); Class, se obtiene un
try objeto de tipo
{
connection.
//En este segmento de código se crean las tablas en la BD.
Statement s = conn.createStatement ();
s.executeUpdate ("CREATE TABLE asigFiec6 (codAsig VARCHAR(6), Las tablas se realizaron
NombreMateria VARCHAR(100))"); mediante la creación de
s.executeUpdate ("CREATE TABLE profeFiec6 (codProf VARCHAR(6),
una sentencia ejecutable
NombreProfesor VARCHAR(40))");
s.executeUpdate ("CREATE TABLE estuFiec6 (cedula VARCHAR(30), (Statements) para la
Calificacion VARCHAR(5),CodAsignatura VARCHAR(6),codigoProfesor generación de un objeto
VARCHAR(6) )"); tipo Connection.
System.out.println ("Datos de la Tabla \n");
s.close ();
// System.out.println ("\n Registros recuperados...."+ count); Podemos observar que
} fueron creadas utilizando
catch (Exception e) el comando o sentencia
{
System.err.println ("Problemas con acceso a la tabla"+e);
SQL “CREATE TABLE”,
} asignándole el nombre
}// cierra try de la tabla, los campos y
catch (Exception e) los nombres de los
{
campos.
System.err.println ("No puede conectarse al Servidor Mysql");
}
finally Para los nombres de los
{ campos utilizamos el tipo
if (conn != null)
VARCHAR: Estas
{
try columnas almacenan
{ una cadena de
conn.close (); caracteres variables de 0
System.out.println ("\n !!!!!Cerrada la coneccion a Mysql");
a 255.
}
catch (Exception e) { /* sin mensajes de error */ }
}
}
}
}
Códigos Fuentes-
Fuentes- CreateTablas
********************************************************************************************************************

/* Clase que lee el archivo de texto de las calificaciones de los estudiantes del CRUV extrae los datos
necesarios y crea una tabla de profesores, otra de estudiantes y otra de asignatura. */
//*****************************************************************

import java.io.*;
import javax.swing.*;
import java.text.*;
import java.lang.String.*;
import java.sql.*; Breve Explicación del
Código.
public class CreateTablas
{
Mediante esta clase
// VARIABLE DE INSTANCIA ejecutamos el método
//*********************************************************** Crear(), el cual nos
private String originalFile; permite insertar datos a
las tablas previamente
creadas.
// CONSTRUCTOR DE LA CLASE Para llevar a cabo esta
//*********************************************************** tarea indicamos el
public CreateTablas(String princ)
{ servidor, puerto, y la
this.originalFile=princ; comunicación con la
} base de datos.
Luego se establecen
// METODOS - Crear
//Extrae los datos de un archivo a otro específico distintas condiciones que
//*********************************************************** permiten insertar la
información necesaria,
public void Crear() sin duplicar datos,
{
específicamente en las
Connection conn = null; tablas ProfesFiec y
AsignFiec, ya que no se
try deberían repetir registros
{
String userName = "FIEC-03"; iguales.
String password = ""; Para no repetir los datos
realizamos un SELECT
// se indica el servidor, puerto y la base de datos facultad de mysql en la tabla
String url = "jdbc:mysql://serfiec:3306/facultad";
correspondiente y
/* se hace efectiva la comunicación con la base de datos comparamos si el
mediante el método 'forName' de la clase Class*/ código de la asignatura
Class.forName ("com.mysql.jdbc.Driver").newInstance (); capturada del archivo se
/*En esta sección utilizamos la clase DriverManager para encuentra en la tabla, de
obtener un objeto de tipo Connection*/ ser así no se introduce el
conn = DriverManager.getConnection (url, userName, password); dato, en caso contrario
System.out.println ("Coneccion Database OKKK!!!"); se procede a introducir
/* Con el objeto de tipo Connecion se crea la sentencia (statements) el registro, esta lógica se
ejecutables, con objetos de tipo resultSet*/ repite al introducir la
Statement s = conn.createStatement (); tabla ProfesFiec.
//aqui abrimos el archivo para leer por linea
String viejo=originalFile; Para introducir datos en
FileReader arch1 = new FileReader(viejo); la tabla EstudFiec, se
BufferedReader in = new BufferedReader(arch1); aplica el método split a
String s1; la línea leída y luego se
/* Variables utilizadas en el programa para almacenar los datos compara si la primera
en cada campo de las tablas estudiantes, profesores y asignaturas*/ posición es un número
boolean op =false; para proceder entonces
String cont = ("[ ]+"); a introducir los datos a
String coAsig=" ";
String coProf=" "; la tabla..
String noProf=" ";
String cedula=" ";
 String noAsig=" ";
int count = 0;
/* Ciclo que recorre el archivo e introduce los datos en los campos de las
tres tablas almacenadas en la base de datos*/
while ((s1 = in.readLine())!= null)
{

/*mediante esta condición se extraen, del archivo, los datos

específicos y necesarios para crear la tabla asignatura
(nombreMateria, codAsignatura)*/
if ((s1.indexOf("ASIGNATURA"))!=-1)
{
String[] asig = s1.split(cont);
coAsig= asig[2];
s.executeQuery("SELECT codAsig FROM asignFiec WHERE codAsig ='"+coAsig+"'");
ResultSet rs = s.getResultSet ();
while (rs.next ()) {++count;}
if (count==0){
for (int i=4; i<asig.length;i++){
noAsig+=asig[i]+" ";}
s.executeUpdate ("INSERT INTO asignFiec (codAsig, NombreMateria)"+
"VALUES('"+coAsig+"','"+noAsig+"')");
noAsig=" ";
}// fin del if
count=0;rs.close ();
}//fin del if

/*mediante esta condición se extraen, del archivo, los datos

específicos y necesarios para crear la tabla profesor
(Nombre del Profesor, codProfesor)*/
if ((s1.indexOf("PROFESOR"))!=-1){
String[] prof = s1.split(cont);
coProf= prof[3];
s.executeQuery("SELECT codProf FROM profesFiec WHERE codProf ='"+coProf+"'");
ResultSet rs = s.getResultSet ();
while (rs.next ()) {++count;}
if (count==0){
System.out.println(coProf);
noProf=prof[4]+" "+prof[5];
s.executeUpdate ("INSERT INTO profesFiec (codProf, NombreProfesor)"+
"VALUES('"+coProf+"','"+noProf+"')");
noProf=" ";
}// fin del if
count=0;rs.close ();
}// fin if

/*En este segmento de código se capturan los datos del estudiante

(cédula, Calificación, CodAsigna)*/
String[] cedu = s1.split(cont);
try{
Integer.parseInt (cedu[1]);
for (int i=2; i<6;i++)
cedula+=cedu[i]+" ";
s.executeUpdate ("INSERT INTO estudFiec (cedula, Calificacion,CodAsignatura, codigoProfesor)"+
"VALUES('"+cedula+"','"+cedu[6]+"','"+coAsig+"','"+coProf+"')");
cedula=" "; }
catch (Exception e){}
}// finaliza el while

s.close ();//
//Excepciones de entrada salida
try {
in.close();
}
catch ( IOException e )
{
System.err.println( "El archivo no se pudo cerrar correctamente" );
}
}//try
catch (Exception e)
{
System.err.println("***Error al leer o abrir el archivo...\n" +e);
}
}//Fin del método
}//fin de la clase
 8.Diseñe una clase que permita consultar a partir de la cédula, las calificaciones identificadas
con asignatura y docente.

Códigos Fuentes-
Fuentes- BuscarCedula
********************************************************************************************************************
/*Esta clase nos permite consultar a partir de la cédula, las calificaciones identificadas con asignatura y
docente */

import java.io.*;
import javax.swing.*;
import java.text.*;
import java.lang.String.*;
import java.sql.*;
Breve Explicación del
Código.
public class BusquedaCedula
{ Para consultar a partir de
una cédula las
// VARIABLE DE INSTANCIA calificaciones
//********************************************************* identificadas con
private String cedula; asignatura y profesor,
procedimos a realizar
// CONSTRUCTOR DE LA CLASE dos métodos, contenidos
//********************************************************** dentro de esta clase, el
public BusquedaCedula(String ced) primero:
{
this.cedula=ced;
} ConsultarDatos():
Hacemos uso del
comando SELECT, para
// METODOS - Crear
//Busca los datos del estudiante - calificación por estudiante
realizar la búsqueda del
//********************************************************** archivo en que se
encuentra la cédula
public void ConsultarDatos() especificada. Al
{
Connection conn = null;
encontrar la cédula este
try nos despliega la cédula
{ del estudiante, y todas
String userName = "FIEC-03"; sus calificaciones al igual
String password = "";
// se indica el servidor, puerto y la base de datos facultad de
que el código de la
mysql materia y el código del
String url = "jdbc:mysql://serfiec:3306/facultad"; profesor que dicto esa
materia.
Class.forName ("com.mysql.jdbc.Driver").newInstance ();
conn = DriverManager.getConnection (url, userName, password);
ConsultarProfAsig():
Este método utiliza el
comando SELECT para
Statement s = conn.createStatement ();
s.executeQuery ("SELECT cedula, Calificacion,CodAsignatura,
identificar el Nombre del
codigoProfesor FROM estudFiec WHERE cedula='"+cedula+"' "); profesor y el nombre de
ResultSet rs = s.getResultSet (); la materia utilizando los
System.out.println ("\n\t\t\tDATOS DE LA CONSULTA "); códigos obtenidos en el
System.out.println (" -----------------------------------------------------------\n");
método
/*ciclo que nos permite capturar las calificaciones, código de ConsultarDatos(); es
asignatura y código de profesor, del estudiante según la cédula decir, accedemos de una
introducida */ tabla a otra mediante el
while (rs.next ())
{
código de asignatura y
String nombreVal = rs.getString ("cedula"); profesor.
String cal = rs.getString ("Calificacion");
String asig = rs.getString ("CodAsignatura");
String prof = rs.getString ("CodigoProfesor");
System.out.println ("\n cedula = " + nombreVal
+ "\n calificacion = " + cal);
ConsultarProfAsig(asig,prof);
}
rs.close ();
 s.close ();
}// fin del try

catch (Exception e)
{
System.err.println ("No puede conectarse al Servidor Mysql");
}

}//Fin del método

// METODOS - ConsultarProfAsig
//Busca los datos del estudiante - calificación por estudiante
//*******************************************************************

public void ConsultarProfAsig(String asig, String profe)

{

Connection conn = null;

try
{
String userName = "FIEC-03";
String password = "";
String url = "jdbc:mysql://serfiec:3306/facultad";

/* se hace efectiva la comunicación con la base de datos

mediante el método 'forName' de la clase Class*/
Class.forName ("com.mysql.jdbc.Driver").newInstance ();

/*En esta sección utilizamos la clase DriverManager para

obtener un objeto de tipo Connection*/
conn = DriverManager.getConnection (url, userName, password);

/* Con el objeto de tipo Connecion se crea la sentencia (statements)

ejecutables, con objetos de tipo resultSet*/
Statement s = conn.createStatement ();
Statement s1= conn.createStatement ();

s.executeQuery ("SELECT NombreMateria FROM AsignFiec WHERE CodAsig='"+asig+"' ");

s1.executeQuery("SELECT NombreProfesor FROM profesFiec WHERE CodProf='"+profe+"' ");

ResultSet rs = s.getResultSet ();

ResultSet rs1 = s1.getResultSet ();

/*ciclo que nos permite capturar las el nombre de la materia

según la cedula introducida*/
while (rs.next ())
{
String noMateria = rs.getString ("NombreMateria");
System.out.println (" nombre Materia = " + noMateria);
}
rs.close ();
s.close ();

/*ciclo que nos permite capturar las el nombre del profesor

según la cedula introducida*/
while (rs1.next ())
{
String poMateria = rs1.getString ("NombreProfesor");
System.out.println (" nombre Profesor = " + poMateria);
System.out.println (" -----------------------------------------------------------\n");
}
rs1.close ();
s1.close ();

}// fin del try

catch (Exception e)
{
System.err.println ("No puede conectarse al Servidor Mysql");
}

}//Fin del método

}//fin de la clase
Códigos Fuentes-
Fuentes- PrincClass
********************************************************************************************************************

/*Clase principal se encarga de inicializar los objetos las clases CreateTablas y

BusquedaCedula realizadas para dar funcionalidad a la aplicación Java, ..*/

import java.io.*;
import javax.swing.*;
import java.text.*;
import java.lang.String.*;

class PrincClass{

public static void main(String[] args) {

CreateTablas acces2=new CreateTablas("derecho.txt");

acces2.Crear(); // método crear tablas

String dat =JOptionPane.showInputDialog(null, "Introduzca la Cédula a buscar");

BusquedaCedula acces3 = new BusquedaCedula (" "+dat);

acces3.ConsultarDatos(); // método buscar cedulas

}
}
9. Compare la solución del punto #8 usando Base de datos vs. Archivos.
Base de Datos
En una Base de datos, es simple
realizar una búsqueda debido a que
cuenta con comandos especiales como
SELECT, y cláusulas específicas como:
WHERE, donde encontramos los datos
que necesitemos con solo especificar el
campo.
Es mucho más fácil e interesante
utilizar la base de datos ya que la
información está más detallada por
trabajar con tablas las cuales contienen
los datos precisos de la entidad a la
cual pertenecen.
Archivo
Si realizo la Búsqueda de la cédula
desde un archivo, hubiese sido un
poco más complicado debido a que
tendría que recorrer todo el archivo e
identificar, mediante métodos para
trabajar con cadenas, la línea en que se
encuentra la cédula introducida, luego
ubicar las calificaciones identificadas
con asignatura y profesor.
Evidencias de la ejecución -- 1era evidencia

Se introduce la
cédula del
estudiante

Datos de la
Consulta.
Equivale a todas
las calificaciones
del estudiante
Evidencias d e la ejecución -- 2da evidencia

Se introduce la
cédula del
estudiante

Datos de la
Consulta.
Equivale a todas
las calificaciones
del estudiante
Evidencias d e la ejecución -- 3da evidencia

Se introduce la
cédula del
estudiante

Datos de la
Consulta.
Equivale a todas
las calificaciones
del estudiante