jueves, 1 de enero de 2015

Preguntas Frecuentes y Ayuda


Tienes alguna duda o pregunta sobre este blog o tal vez quisieras algún tutorial que no encontraste en este foro; encuentra aqui lo que buscas y dejala como comentario en este post.

domingo, 16 de octubre de 2011

Infografias Tópicos V

Para el curso topicos V nos pidieron unas infografias sobre los temas siguientes:


PROBLEMAS



ISO 9001


FODA


OBJETIVOS


viernes, 23 de septiembre de 2011

La Web Semántica Social


Hoy Facebook siempre algo tecnólogos han estado esperando, desde hace más de 10 años: una razón para ir a la Web Semántica. El anuncio de Facebook de tipo Open Graph objetos y verbos personalizados va a ser un gran problema para todo el Internet, pero no por la razón que usted puede pensar.




¿Por qué lo digo en PC?
Tim Berners-Lee , inventor de la mayoría de las tecnologías que llamar a la Web, utiliza el término "Web Semántica" para el concepto de anotación de páginas web con información significativa a las computadoras, más que de contenido para los seres humanos. Tuvo la visión de lo que los autores de ciencia ficción han escrito por años: los agentes de inteligencia artificial que podría ayudar a los seres humanos con tareas más complejas que las búsquedas web simple.
Desde Berners-Lee planteó la Web Semántica, docenas de tecnologías han propuesto la forma de resolver el problema, pero ninguno tuvo éxito. ¿Por qué? Nadie podía pensar en un uso que impulsan el valor suficiente para poner en el costo y el esfuerzo.
El valor es social, no mecánica
Hoy en día, el mundo tiene una necesidad de la Web Semántica, y resulta que es la gente , después de todo.
Lo que Facebook nos ha dado hoy en día es una nueva manera de ofrecer actualizaciones de nuestros amigos y crear archivos ejecutables, archivos sentimental de cómo nos hemos movido y se ha movido por el mundo que nos rodea. Por ejemplo:
  • Puedo actualizar mi estado a "Horton Noé vio 'The Dark Knight".
Esta declaración es simple, y sin una Web Semántica, de alguna manera se sienta allí, como lo es.
Social es una reacción en cadena
Con la Web Semántica, mi actualización es mucho más. Se convierte en un catalizador de las reacciones, y por medio de esas reacciones, Warner Brothers se vuelve más valor a partir de mi relación.

Con la exclusión en el derecho de ponerse en contacto conmigo y todos los que vieron "The Dark Knight", Warner Brothers podría pueden alertar a mí a las nuevas versiones de la película, o incluso otras películas que creo que puede gustar. A continuación, puede añadir más información al nodo Open Graph, como el director de la película o quien escribió la partitura. Lo harán porque los servicios de otros consumirán esta información que me ayude y otros consumidores a tomar decisiones que en última instancia, hacer dinero Warner Brothers.
Puede ocurrir de esta manera:
  • Warner Brothers, añade los metadatos que "The Dark Knight" y "Inception", fueron dirigidas por Christopher Nolan .
  • Fandango utiliza mi actualización sobre "The Dark Knight" para inferir que podría al igual que otras películas de Christopher Nolan, y sugiere que comprar entradas para "Inception".
  • LinkedIn ve mi confirmación de asistencia a este evento, y sugiere que invite a un compañero de trabajo que también le gusta Christopher Nolan películas. (Don Beck, quiere coger la sesión de tarde?)
Esta cadena sigue, con mis interacciones alimentarias más y más información en la Web Semántica, ayudando a todos los negocios que compartir la información con la ayuda a vivir la vida mejor.
Porque la vida es más que semántica
Ha tomado 10 años para ver la Web Semántica realmente empezar a trabajar, y esto es un punto crucial. Lo que vemos hoy no es la Web Semántica, concebido por Tim Berners-Lee. Es algo mejor: la semántica social Web. Y con él, el circuito trazado emergentes de todas las reacciones de la cadena social que compartimos con otros todos los días.
Pero tengo algunas preguntas:
  • ¿Qué tan cómodo se la gente esté con todos estos servicios utilizando esta información para ayudar a hacer sugerencias? La gente abrazar las ventajas, o el miedo de las consecuencias?
  • Marcas abarcará el "El aumento de la marea levanta todos los barcos" la filosofía y abrazar estas tecnologías sabiendo que ayudará tanto a ellos como a sus competidores, o se resisten a las marcas? Si las marcas resisten, pueden los proveedores de servicios como el Fandango y la unidad de IMDB la visión hacia adelante?

lunes, 11 de julio de 2011

Conexion Java NetBeans con MySql


Una vez instalada la base de datos, MySQL en nuestro ejemplo, vamos a ver de forma rápida como podemos conectarnos con ella y ejecutar los comandos SQL básicos: SELECT, INSERT, UPDATE y DELETE.

También, por si acaso, crearemos desde Java la tabla de base de datos que vamos a usar y la borraremos.

El driver con la base de datos

Lo primero que necesitamos para conectarnos con una base de datos es un Driver (o Connector) con ella. Ese Driver es la clase que, de alguna forma, sabe cómo hablar con la base de datos. Desgraciadamente (y hasta cierto punto es lógico), java no viene con todos los Drivers de todas las posibles bases de datos del mercado. Debemos ir a internet y obtener el Driver, normalmente en la página de nuestra base de datos

Para el caso de MySQL, podemos descargarlo de http://dev.mysql.com/downloads/connector/j/5.0.html. Nos bajamos el mysql-connector-java-5.0.5.zip, lo desempaquetamos en algún sitio y nos quedamos con el mysql-connector-java-5.0.5-bin.jar que viene dentro. En ese jar está la clase Driver que nos interesa.

Tendremos que poner ese jar accesible en nuestro proyecto. Dependiendo de qué utilicemos para programar en java hay muchas opciones.

Guardarlo en la carpeta /jre/lib/ext. Si has hecho una instalación por defecto en Windows, estará en C:\Archivos de Programa\Java\jdk1.5.0_05\jre\lib\ext. Esta es la carpeta en la que java nos deja poner jar adicionales para que se encuentren por defecto. Es buena idea ponerlo aquí si vamos a hacer muchos programas con base de datos. Si solo vamos a hacer uno, es mejor no ponerlo aquí. Si decidimos usar esta carpeta, también debemos tener la precaución de ir retirando jars de versiones antiguas cuando pongamos las nuevas, o tendremos problemas.
Ponerlo en la variable de entorno CLASSPATH, siempre que nuestro IDE (eclipse, netbeans, etc) haga caso de esa variable. Si trabajas con una ventana de ms-dos (símbolo del sistema), puedes poner esto
C:\> set CLASSPATH=\mysql-connector-java-5.0.5-bin.jar

Añadirlo en nuestro IDE. En el ejemplo de eclipse, damos con el botón derecho del ratón sobre el proyecto, para sacar el menú y elegimos "properties"->"java build path"->"Libraries"->"Add external JARs..." y seleccionamos nuestro jar.
Conectarnos con la base de datos

Una vez que java tiene el jar accesible y sabe dónde encontrarlo, ya podemos empezar con el código. Lo primero es conectarse con la base de datos

El código puede ser como este

import java.sql.Connection;
import java.sql.DriverManager;
...
try
{
Class.forName("com.mysql.jdbc.Driver");
Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/agenda", "root", "LA_PASSWORD");
...

En primer lugar hemos hecho los import adecuados para poder obtener la conexión.

Luego hay que asegurarse de que se inicializa el Driver y se registra. Para ello hay dos opciones. Hacer un new de él o bien instanciarlo con Class.forName("nombre de clase"), que es como hacer el new, pero de una forma rara.

La ventaja de hacerlo con Class.forName() es que sólo necesitaremos el Driver de una base de datos si lo usamos. Me explico. Imagina que haces un programa que permite permite conectarse con varias bases de datos distintas: MySQL, PostGres, Oracle, etc. En algún sitio damos a elegir al usuario qué tipo de base de datos tiene.

Si hacemos new de los Driver, tendremos que hacer unos if para en función de la elegida, hacer new de uno o de otro. El problema es que en nuestro código estarán los import y los new de todos los Driver de todas las bases de datos necesaras, los vayamos a usar o no. El programa no compilará y no correrá si no tiene todos los Driver accesibles.

/* Todos estos import son necesarios para que compilen los news correspondientes */
import driver_de_mysql;
import driver_de_postgres;
import driver_de_oracle;
...
if (ha_elegido_mysql)
new driver_de_mysql();
if (ha_elegido_postgres)
new driver_de_postgres();
if (ha_elegido_oracle)
new driver_de_oracle();

Sin embargo, con Class.forName() no necesitamos el import. Haremos los mismos if de antes, pero usaremos simplemente String distintos para llamar a Class.forName(). No necesitamos los import y no necesitamos los jar con los Driver, salvo el jar con el Driver que realmente elija el usuario. Es cosa suya tener instalado SU driver de SU base de datos.

/* No hacen falta imports */
...
if (ha_elegido_mysql)
Class.forName("driver_de_mysql");
if (ha_elegido_postgres)
Class.forName("driver_de_postgres");
if (ha_elegido_oracle)
Class.forName("driver_de_oracle");

Una vez que nos hemos asegurado que java tiene el Driver cargado, simplemente pediremos conexión con la base de datos a la clase DriverManager.

Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/agenda", "root", "LA_PASSWORD");

DriverManager tiene muchos métodos getConnection() con parámetros variados. Todos son variantes de lo mismo y la información que suministramos es la misma. Aquí hemos utilizado uno con tres parámetros String, que vamos a explicar.

url: Es una cadena que nos permite localizar la base de datos. Para mysql, el formato es "jdbc:mysql://ordenador_donde_corre_la_base_de_datos/nombre_base_datos". Donde se pone el nombre o IP del ordenador en el que se encuentra nuestro servidor de base de datos y el nombre de la base de datos. En nuestro ejemplo, tenemos el servidor de base de datos corriendo en el mismo ordenador que el programa java, por lo que ponemos localhost. La base de datos la he llamado agenda. El comando SQL para crear la base de datos agenda sería
mysql> CREATE DATABASE agenda;

user: Un usuario válido para la base de datos.
password: La clave del usuario.
Si todo va bien, tendremos nuestra conexión a la base de datos. Si va mal, saltará una excepción. Por eso es importante (y obligatorio para que compile) meter todo esto en un try-catch.

Esta forma de obtener una conexión está bien para apliaciones sencillas, en el que únicamente se establece una conexión con la base de datos, no hay muchos hilos trabajando, etc. Si nuestra aplicación es algo más compleja/seria, en el que varios hilos pueden trabjar simultáneamente, en vez de obtner las conexiones directamente con DriverManager.getConnection(), es mejor obtenerlas a través de un Pool de Conexiones.

Creamos la tabla en Base de Datos ... y la borramos.

Para enviar comandos SQL a la base de datos, se usa la clase Statement de java. Esta clase se obtiene a partir de la conexión, de esta forma:

Statement st = conexion.createStatement();

por supuesto, dentro de un try-catch.

Statement tiene muchos métodos, pero hay dos interesentantes: executeUpdate() y executeQuery(). El primero se usa para sentencias SQL que impliquen modificaciones en la base de datos (INSERT, UPDATE, DELETE, etc). El segundo sólo para consultas (SELECT y similares).

Nuestra creación de tabla afecta a la base de datos, así que con executeUpdate().

st.executeUpdate("CREATE TABLE contacto (id INT AUTO_INCREMENT, PRIMARY KEY(id), nombre VARCHAR(20), apellidos VARCHAR(20), telefono VARCHAR(20))");

Esto crea una tabla contacto con cuatro campos: id, nombre, apellidos y telefono.

Para borrar la tablita esta, lo mismo, pero con DROP en vez de CREATE.

st.executeUpdate("DROP TABLE contacto");

Insertar datos en la base de datos

Vamos a hacer un esfuerzo de imaginación y supongamos que no hemos borrado la tabla contacto, que sigue existiendo en base de datos. Vamos a meterle datos.

String nombres[]={"Juan","Pedro","Antonio"};
String apellidos[]={"Gomez","Lopez","Alvarez"};
String telefonos[]={"123","456","789"};
...
for (int i=0;i st.executeUpdate("INSERT INTO contacto (nombre, apellidos, telefono) VALUES ('"+nombres[i]+"','"+apellidos[i]+"','"+telefonos[i]+"' )");

también en un try-catch.

He puesto los datos a insertar en unos arrays. Tú puedes recogerlos de un sitio con más sentido. Por ejemplo, si es una agenda de contactos, lo mejor es pedírselos al usuario. Yo, por simplicidad y porque para el ejemplo va que chuta, los pongo en un array y con un bucle los voy insertando.

Fíjate que la sentencia INSERT se va componiendo a base de sumar cadenas. Sería más eficiente con un StringBuffer, pero así se simplifica algo el ejemplo.

Fíjate que en el INSERT metemos comillas simples para los valores de cadenas, es decir, en nombre, apellidos y telefono. El INSERT sería, de verdad, así

INSERT INTO contacto (nombre, apellidos, telefono) VALUES ('Juan', 'Gomez', '123');

Ahí se ven más claras las comillas simples para los datos que definimos como VARCHAR en la creación de la tabla, es decir, Juan, Gomez y 123. Por eso en el código las hemos puesto

...VALUES ('"+nombres[i]+"','"...

Si fuesen datos numéricos no harían falta, son cosas de SQL, pero tenemos que tener cuidado de componerlas bien.

Consultar datos de la base de datos

Vamos a hacer ahora una consulta de los datos que acabamos de insertar en la base de datos. Las consultas se hacen con executeQuery() y nos devolverán un ResultSet.

El ResultSet de alguna forma representa una conexión hacia los datos. En el ResultSet NO están todavía los datos. Según se los vayamos pidiendo, los irá trayendo de base de datos. Esto quiere decir que si una consulta devuelve muchos resultados, no se nos va a llenar la memoria por el hecho de hacer la consulta.

Para traer el primer resultado, debemos llamar el método next() del ResulSet. Para el siguiente otro next() y así sucesivamente hasta que next() devuelva false, indicando que ya no quedaban datos. El código puede ser así

ResultSet rs = st.executeQuery("SELECT * FROM contacto");
while (rs.next())
{
System.out.println("nombre="+rs.getObject("nombre")+
", apellidos="+rs.getObject("apellidos")+
", telefono="+rs.getObject("telefono"));
}
rs.close();

Hemos hecho un SELECT para obtener los datos. Luego un bucle while(rs.next()), es decir, mientras next() vaya trayendo resultados.

Después de next(), el resultado recién traido está disponible en el ResulSet. La forma de recoger los campos es pedirlos con algún método get(). Si sabemos de qué tipo es el dato, podemos pedirlo con getInt(), getString(), etc. Si no lo sabemos o nos da igual (como en este caso), bastará con un getObject(), capaz de traer cualquier tipo de dato.

En estos métodos get() podemos pasar como parámetro un entero, empezando en 1, que es el número del campo en el SELECT. Es decir, si hacemos SELECT campo1, campo2, campo3 ..., si pedimos getObject(1) obtenemos el valor de campo1, para getObject(2) el de campo2, etc.

Otra opción que a mi me gusta más, es pasar el nombre del campo, como se muestra en el código. Así, en el ejemplo de antes, getObject("campo1") nos devuelve el valor del campo1.

Update en la base de datos

Para UPDATE usamos executeUpdate(). Vamos a cambiar el número de teléfono de Juan. Ya que en la tabla hemos puesto un campo id, vamos primero a obtener el id de Juan para luego usarlo en el UPDATE. Esto no tiene por qué ser así, es sólo el ejemplo.

Para obtener el id:

rs = st.executeQuery("SELECT id FROM contacto WHERE nombre='Juan'");
rs.next();
int id = rs.getInt("id");

Es un SELECT para obtener el campo id de Juan. Con rs.next() hacemos que venga el primer resultado de la consulta (y único en nuestro ejemplo). Como sabemos que es un INT, lo recogemos con getInt() y lo guardamos.

Para hacerlo bien, deberíamos ver si rs.next() devuelve o no resultado (quizás no haya nadie que se llame Juan en la base de datos) o si devuelve más de uno (más de un Juan en la base de datos), pero no vamos a complicarnos la vida en este ejemplo sencillo.

Ahora, sabiendo el id, podemos hacer el UPDATE.

st.executeUpdate("UPDATE contacto SET telefono='111' WHERE id="+id);

Esta vez, como el campo id es numérico, no hemos puesto las comillas simples.

Borrar datos de la base de datos

El borrado se hace con DELETE y executeUpdate(). Vamos a borrar a Pedro, que nos hemos peleado con él. Obtenemos primero su id, igual que antes.

rs = st.executeQuery("SELECT id FROM contacto WHERE nombre='Pedro'");
rs.next();
id = rs.getInt("id");

y ahora lo borramos

st.executeUpdate("DELETE FROM contacto WHERE id="+id);

Cerramos conexiones

Los Connection, Statement y ResultSet con conexiones abiertas con base de datos. Debemos cerrarlas.

ResultSet se cierra solo cuando hacemos otra llamada execute() al Statement del que obtuvimos este ResultSet o bien cuando el recolector de basura "recolecta" al ResultSet. No nos preocupa en principio que se quede abierto, porque se acabará cerrando solo.

Eso sí, no podemos hacer nada con el Statement hasta que hayamos terminado con el ResultSet o se nos cerrará. Si necesitamos realizar otra cosa con base de datos, debemos crear otro Statement distinto.

Cuando terminemos con el Statement, lo cerramos con st.close().

Cuando terminemos con la Connection, la cerramos con conexion.close().

Normalizacion en Base de Datos

Qué es la normalización?
La normalización es el proceso mediante el cual se transforman datos complejos a un conjunto de estructuras de datos más pequeñas, que además de ser más simples y más estables, son más fáciles de mantener. También se puede entender la normalización como una serie de reglas que sirven para ayudar a los diseñadores de bases de datos a desarrollar un esquema que minimice los problemas de lógica. Cada regla está basada en la que le antecede. La normalización se adoptó porque el viejo estilo de poner todos los datos en un solo lugar, como un archivo o una tabla de la base de datos, era ineficiente y conducía a errores de  lógica cuando se trataban de manipular los datos.

La normalización también hace las cosas fáciles de entender. Los seres humanos tenemos la tendencia de simplificar las cosas al máximo. Lo hacemos con casi todo, desde los animales hasta con los automóviles. Vemos una imagen de gran tamaño y la hacemos más simple agrupando cosas similares juntas. Las guías que la normalización provee crean el marco de referencia para simplificar una estructura de datos compleja.

Otra ventaja de la normalización de base de datos es el consumo de espacio. Una base de datos normalizada ocupa menos espacio en disco que una no normalizada. Hay menos repetición de datos, lo que tiene como consecuencia un mucho menor uso de espacio en disco. El proceso de normalización tiene un nombre y una serie de reglas para cada fase. Esto puede parecer un poco confuso al principio, pero poco a poco se va entendiendo el proceso, así como las razones para hacerlo de esta manera.

Grados de normalización

Existen básicamente tres niveles de normalización: Primera Forma Normal (1NF), Segunda Forma Normal (2NF) y Tercera Forma Normal (3NF). Cada una de estas formas tiene sus propias reglas. Cuando una base de datos se conforma a un nivel, se considera normalizada a esa forma de normalización. No siempre es una buena idea tener una base de datos conformada en el nivel más alto de normalización, puede llevar a un nivel de complejidad que pudiera ser evitado si estuviera en un nivel más bajo de normalización.

En la tabla siguiente se describe brevemente en que consiste cada una de las reglas, y posteriormente se explican con más detalle.


Primera Forma Normal

La regla de la Primera Forma Normal establece que las columnas repetidas deben eliminarse y colocarse en tablas separadas.

Poner la base de datos en la Primera Forma Normal resuelve el problema de los encabezados de columna múltiples. Muy a menudo, los diseñadores de bases de datos inexpertos harán algo similar a la tabla no normalizada. Una y otra vez, crearán columnas que representen los mismos datos. La normalización ayuda a clarificar la base de datos y a organizarla en partes más pequeñas y más fáciles de entender. En lugar de tener que entender una tabla gigantesca y monolítica que tiene muchos diferentes aspectos, sólo tenemos que entender los objetos pequeños y más tangibles, así como las relaciones que guardan con otros objetos también pequeños.


Segunda Forma Normal

La regla de la Segunda Forma Normal establece que todas las dependencias parciales se deben eliminar y separar dentro de sus propias tablas. Una dependencia parcial es un término que describe a aquellos datos que no dependen de la llave primaria de la tabla para identificarlos.

Una vez alcanzado el nivel de la Segunda Forma Normal, se controlan la mayoría de los problemas de lógica. Podemos insertar un registro sin un exceso de datos en la mayoría de las tablas.


Tercera Forma Normal

Una tabla está normalizada en esta forma si todas las columnas que no son llave son funcionalmente dependientes por completo de la llave primaria y no hay dependencias transitivas. Comentamos anteriormente que una dependencia transitiva es aquella en la cual existen columnas que no son llave que dependen de otras columnas que tampoco son llave.

Cuando las tablas están en la Tercera Forma Normal se previenen errores de lógica cuando se insertan o borran registros. Cada columna en una tabla está identificada de manera única por la llave primaria, y no deben haber datos repetidos. Esto provee un esquema limpio y elegante, que es fácil de trabajar y expandir.

Un dato sin normalizar no cumple con ninguna regla de normalización. Para explicar con un ejemplo en que consiste cada una de las reglas, vamos a considerar los datos de la siguiente tabla.


Al examinar estos registros, podemos darnos cuenta que contienen un grupo repetido para NUM_ITEM, DESC_ITEM, CANT y PRECIO. La 1FN prohibe los grupos repetidos, por lo tanto tenemos que convertir a la primera forma normal. Los pasos a seguir son:

» Tenemos que eliminar los grupos repetidos.
» Tenemos que crear una nueva tabla con la PK de la tabla base y el grupo repetido.

Los registros quedan ahora conformados en dos tablas que llamaemos ORDENES y ARTICULOS_ORDENES

- ORDENES


- ARTICULOS_ORDENES


Ahora procederemos a aplicar la segunda formal normal, es decir, tenemos que eliminar cualquier columna no llave que no dependa de la llave primaria de la tabla. Los pasos a seguir son:

» Determinar cuáles columnas que no son llave no dependen de la llave primaria de la tabla.
» Eliminar esas columnas de la tabla base.
» Crear una segunda tabla con esas columnas y la(s) columna(s) de la PK de la cual dependen.

La tabla ORDENES está en 2FN. Cualquier valor único de ID_ORDEN determina un sólo valor para cada columna. Por lo tanto, todas las columnas son dependientes de la llave primaria ID_ORDEN.

Por su parte, la tabla ARTICULOS_ORDENES no se encuentra en 2FN ya que las columnas PRECIO y DESC_ITEM son dependientes de NUM_ITEM, pero no son dependientes de ID_ORDEN. Lo que haremos a continuación es eliminar estas columnas de la tabla ARTICULOS_ORDENES y crear una tabla ARTICULOS con dichas columnas y la llave primaria de la que dependen.

Las tablas quedan ahora de la siguiente manera.

- ARTICULOS_ORDENES


- ARTICULOS


La tercera forma normal nos dice que tenemos que eliminar cualquier columna no llave que sea dependiente de otra columna no llave. Los pasos a seguir son:

» Determinar las columnas que son dependientes de otra columna no llave.
» Eliminar esas columnas de la tabla base.
» Crear una segunda tabla con esas columnas y con la columna no llave de la cual son dependientes.

Al observar las tablas que hemos creado, nos damos cuenta que tanto la tabla ARTICULOS, como la tabla ARTICULOS_ORDENES se encuentran en 3FN. Sin embargo la tabla ORDENES no lo está, ya que NOM_CLIENTE y ESTADO son dependientes de ID_CLIENTE, y esta columna no es la llave primaria.

Para normalizar esta tabla, moveremos las columnas no llave y la columna llave de la cual dependen dentro de una nueva tabla CLIENTES. Las nuevas tablas CLIENTES y ORDENES se muestran a continuación.

- ORDENES


- CLIENTES


¿Qué tan lejos debe llevar la normalización?

La siguiente decisión es ¿qué tan lejos debe llevar la normalización? La normalización es una ciencia subjetiva. Determinar las necesidades de simplificación depende de nosotros. Si nuestra base de datos va a proveer información a un solo usuario para un propósito simple y existen pocas posibilidades de expansión, normalizar los datos hasta la 3FN quizá sea algo exagerado. Las reglas de normalización existen como guías para crear tablas que sean fáciles de manejar, así como flexibles y eficientes. A veces puede ocurrir que normalizar los datos hasta el nivel más alto no tenga sentido.

¿Se están dividiendo tablas sólo para seguir las reglas o estas divisiones son en verdad prácticas?. Éstas son el tipo de cosas que nosotros como diseñadores de la base de datos, necesitamos decidir, y la experiencia y el sentido común nos pueden auxiliar para tomar la decisión correcta. La normalización no es una ciencia exacta, más bien subjetiva.

Existen seis niveles más de normalización que no se han discutido aquí. Ellos son Forma Normal BoyceCodd, Cuarta Forma Normal (4NF), Quinta Forma Normal (5NF) o Forma Normal de Proyección-Unión, Forma Normal de Proyección-Unión Fuerte, Forma Normal de Proyección-Unión Extra Fuerte y Forma Normal de Clave de Dominio. Estas formas de normalización pueden llevar las cosas más allá de lo que necesitamos. Éstas existen para hacer una base de datos realmente relacional. Tienen que ver principalmente con dependencias múltiples y claves relacionales.


En resumen

La normalización es una técnica que se utiliza para crear relaciones lógicas apropiadas entre tablas de una base de datos. Ayuda a prevenir errores lógicos en la manipulación de datos. La normalización facilita también agregar nuevas columnas sin romper el esquema actual ni las relaciones.

Existen varios niveles de normalización: Primera Forma Normal, Segunda Forma Normal, Tercera Forma Normal, Forma Normal Boyce-Codd, Cuarta Forma Normal, Quinta Forma Normal o Forma Normal de Proyección-Unión, Forma Normal de Proyección-Unión Fuerte, Forma Normal de Proyección-Unión Extra Fuerte y Forma Normal de Clave de Dominio. Cada nuevo nivel o forma nos acerca más a hacer una base de datos verdaderamente relacional.

Se discutieron las primeras tres formas. Éstas proveen suficiente nivel de normalización para cumplir con las necesidades de la mayoría de las bases de datos. Normalizar demasiado puede conducir a tener una base de datos ineficiente y hacer a su esquema demasiado complejo para trabajar. Un balance apropiado de sentido común y práctico puede ayudarnos a decidir cuándo normalizar.