public void addDependiente(Atributo attr = null,bool enlazar = false)
{
if (!this.determina.Contains(attr)) {
if (enlazar) attr.addDeterminante(this);
this.determina.Add(attr);
}
}
public void addDeterminante(Atributo attr)
{
if (!this.depende.Contains(attr)) {
attr.addDependiente(this);
this.depende.Add(attr);
}
}
private void nuevoToolStripMenuItem_Click(object sender, EventArgs e)
{
mapaAtributos.Clear();
clavePrimaria = null;
fmas.Clear();
normal.Clear();
listaDependencias.Items.Clear();
listaRelaciones.Items.Clear();
clavesCandidatas.Clear();
tf_entrada.Clear();
cb_tipo.SelectedIndex = 0;
cb_accion.SelectedIndex = 0;
cb_tipo.Enabled = false;
cb_accion.Enabled = false;
btn_ejecutar.Enabled = false;
etiqueta_estado.Text = "Esperando relacion...";
}
private bool estaEnTablas(List<Tabla> tablas,Atributo attr)
{
foreach (Tabla tabla in tablas) {
//if (xSubY(attr, tabla.getClavePrimaria())) return true;
if (tabla.getColumnas().Contains(attr)) return true;
}
return false;
}
private bool estaEnTabla3FN(Atributo attr)
{
return estaEnTablas(TERCERAFN, attr);
}
private bool estaEnTabla2FN(Atributo attr)
{
return estaEnTablas(SEGUNDAFN, attr);
}
private List<Atributo> determinatesPorTransitividad(Atributo attr)
{
return determinatesPorTransitividad(attr, new List<Atributo>());
}
public bool contains(Atributo attr)
{
return this.columnas.Contains(attr);
}
/* cumple3FN
* Todo atributo que dependa transitivamente de la ClavePrimaria
* No cumple la 3FN
*/
private bool cumple3FN(Atributo attr, Tabla tabla)
{
/* Si existe algun Atributo X que determine a Y, que no pertenezca a la clavePrimaria
* Decimos que Y depende transitivamente de la clavePrimaria.
*/
foreach (Atributo at in attr.getDeterminantes()) {
if (tabla.contains(at)) return false;
}
return true;
}
//=========================================================================
/* cumple2FN
* 1. Todo atributo no primo de la relacion debe depender de la clave primaria
* 2. Todo atributo que dependa parcialmente de la clavePrimaria no cumple 2FN
*/
private bool cumple2FN(Atributo attr, Atributo pk)
{
/*Si algun Atributo X que Determine a Y, es Subconjunto de la ClavePrimaria
* Decimos que Y depende parcialmente de la Clave Primaria
* entonces no cumple la 2FN
*/
foreach (Atributo at in attr.getDeterminantes()) {
if (xSubY(at, pk)) return false;
}
return true;
}
private void crearConjuntos()
{
int cantidadOriginales = mapaAtributos.Count;
List<KString> unitarios = new List<KString>();
/*TODOS*/
String nuevo = "";
foreach (var key in mapaAtributos.Keys) {
Atributo attr = mapaAtributos[key];
if (!attr.esConjunto() && !attr.esMultivaluado()) {
nuevo += (nuevo == "") ? attr.getValor().value() : "," + attr.getValor();
unitarios.Add(attr.getValor());
}
}
Atributo atributoConj = new Atributo(nuevo);
if (!mapaAtributos.ContainsKey(atributoConj.getValor())) {
mapaAtributos.Add(atributoConj.getValor(), atributoConj);
System.Diagnostics.Debug.WriteLine("Agregado: " + nuevo);
}
/*Subconjuntos pequeños*/
KString TODOS = new KString(nuevo);
for (int i = 2; i < cantidadOriginales - 1; i++) {
List<KString> nuevos = combinacion(unitarios, i);
foreach (KString nuevoCon in nuevos) {
if (!mapaAtributos.ContainsKey(nuevoCon)) {
mapaAtributos.Add(nuevoCon, new Atributo(nuevoCon));
}
}
}
/*
List<String> nuevos = new List<String>();
foreach (var atributoAQuitar in mapaAtributos.Keys) {
nuevo = "";
foreach (var key in mapaAtributos.Keys) {
if (atributoAQuitar == key) continue;
Atributo attr = mapaAtributos[key];
if (!attr.esConjunto() && !attr.esMultivaluado()) {
nuevo += (nuevo == "") ? attr.getValor().value() : "," + attr.getValor();
}
}
nuevos.Add(nuevo);
}
foreach (String val in nuevos) {
Atributo atributoSubConj = new Atributo(val);
if (!mapaAtributos.ContainsKey(atributoSubConj.getValor())) {
mapaAtributos.Add(atributoSubConj.getValor(), atributoSubConj);
System.Diagnostics.Debug.WriteLine("Agregado: " + val);
}
}*/
}
private Atributo calculaSubPK(Atributo attr, Atributo pk)
{
foreach (Atributo at in attr.getDeterminantes()) {
if (xSubY(at, pk)) return at;
}
return null;
}
private Atributo calcularFK(Atributo attr, Tabla tabla)
{
foreach (Atributo at in attr.getDeterminantes()) {
if (tabla.contains(at)) return at;
}
return null;
}
private void button1_Click_1(object sender, EventArgs e)
{
String entrada = tf_entrada.Text.ToUpper();
switch (cb_tipo.SelectedIndex) {
//Agregar Relacion
case 0: {
if (relacionValida(entrada)) {
listaRelaciones.Items.Add(entrada);
String[] elementos = entrada.Split(',');
confPB(elementos.Length);
foreach (String elem in elementos) {
Atributo attr = new Atributo(elem);
mapaAtributos.Add(attr.getValor(), attr);
barra_progreso.PerformStep();
}
crearConjuntos();
barra_progreso.Value = 0;
cb_tipo.SelectedIndex = 1;
tf_entrada.Text = "";
etiqueta_estado.Text = "Esperando Dependencia...";
} else {
MessageBox.Show("Datos invalidos, porfavor revise: "+entrada+"\nFormato válido: X,Y<m>,Z,W<m>");
}
break;
}
//Agregar Dependencia
case 1: {
if (dependenciaValida(entrada)) {
String[] deps = entrada.Split('/');
foreach (String entradaD in deps) {
listaDependencias.Items.Add(entradaD);
String[] partes = entradaD.Split('>');
KString determinantes = new KString(partes[0]);
KString dependientes = new KString(partes[1]);
Atributo attrDeterminate;
Atributo attrDependiente;
if (mapaAtributos.ContainsKey(determinantes)) {
attrDeterminate = mapaAtributos[determinantes];
} else {
attrDeterminate = new Atributo(determinantes);
mapaAtributos.Add(determinantes, attrDeterminate);
}
if (mapaAtributos.ContainsKey(dependientes)) {
attrDependiente = mapaAtributos[dependientes];
} else {
attrDependiente = new Atributo(dependientes);
mapaAtributos.Add(dependientes, attrDependiente);
}
/*al agregar un determinante a un atributo internamente
se agrega al atributo como dependiente.
*/
attrDependiente.addDeterminante(attrDeterminate);
}
tf_entrada.Text = "";
etiqueta_estado.Text = "Listo";
btn_ejecutar.Enabled = true;
} else {
MessageBox.Show("Datos invalidos, porfavor revise: " + entrada + "\nFormato válido: X,Y>W,Z[/Q,P>R,S]");
}
break;
}
}//FIn Switch
}
public void setClavePrimaria(Atributo PK)
{
this.clavePrimaria = PK;
}
private Tabla tabla3FNConPK(Atributo pk)
{
foreach (Tabla tabla in TERCERAFN) {
if (tabla.getClavePrimaria() == pk) return tabla;
}
return null;
}
/*Determina si x es subconjunto de y
*
*/
private bool xSubY(Atributo x, Atributo y)
{
KString[] conjX = x.getAtributosDelConjunto();
KString[] conjY = y.getAtributosDelConjunto();
//Si |x| >= |y|, x no puede ser subconjunto de y
if (conjX.Count() >= conjY.Count()) return false;
//Si Y no contiene alguno de los elementos de X, X no es subconjunto de Y
foreach (KString elem in conjX) {
if (!conjY.Contains(elem)) return false;
}
return true;
}
private void determinarClavePrimaria()
{
if (clavesCandidatas.Count <= 0) {
MessageBox.Show("No se han encontrado Claves Candidatas ni clave primaria!\nNo se puede normalizar!");
return;
}
cb_accion.Enabled = true;
cb_accion.SelectedIndex = 1;
int menor = clavesCandidatas.First().Value.getPeso();
KString kmenor = clavesCandidatas.First().Key;
if (menor > 1) {
foreach(var key in clavesCandidatas.Keys){
Atributo kcand = clavesCandidatas[key];
if (kcand.getPeso() < menor) {
menor = kcand.getPeso();
kmenor = (KString)key;
}
}
}
clavePrimaria = clavesCandidatas[kmenor];
fmas.Text += "Clave Primaria: " + clavePrimaria.getValor() + " \n";
}
/* determinatesPorTransitividad(Atributo attr)
* attr: Atributo del cual se quiren conseguir los Atributos que lo determinan
* retorna todos los Atributos que determinan a 'attr'
* *Es Recursivo, tomando la dependencia A>B>C>D, el metodo va 'escalando' desde D hasta A
* Tomando cada uno de sus determinantes.
*/
private List<Atributo> determinatesPorTransitividad(Atributo attr,List<Atributo> attrAnalizados)
{
List<Atributo> todos = new List<Atributo>();
todos = todos.Concat(attr.getDeterminantes()).ToList();
attrAnalizados.Add(attr);
foreach (Atributo det in attr.getDeterminantes()) {
if (attrAnalizados.Contains(det)) continue;
todos = todos.Concat(determinatesPorTransitividad(det, attrAnalizados)).ToList();
}
return todos;
}
public void addColumna(Atributo attr)
{
columnas.Add(attr);
}
