Académique Documents
Professionnel Documents
Culture Documents
“Programación IV Inf._212”
“Proyecto # 2”
“Laboratorio
Laboratorio 9 - Mysql”
Mysql”
ESTUDIANTE:
PROFESOR:
DIEGO SANTIMATEO
SEMESTRE:
II SEMESTRE – II AÑO
FECHA DE ENTREGA:
DICIEMBRE -2007
LABORATORIO # 9
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.
• 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.
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)
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.
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.
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)
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.
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.
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.
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.
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)
{
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");
}
// METODOS - ConsultarProfAsig
//Busca los datos del estudiante - calificación por estudiante
//*******************************************************************
import java.io.*;
import javax.swing.*;
import java.text.*;
import java.lang.String.*;
class PrincClass{
}
}
9. Compare la solución del punto #8 usando Base de datos vs. Archivos.
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