/// <summary>
///Inserta una entidad
/// </summary>
/// <param name="nombre"></param>
public void escribeEntidad(string nombre)
{
Entidad nEntidad = new Entidad(nombre);
entidades.Add(nEntidad);
//ordena elementos
entidades.Sort((p, q) => string.Compare(p.Nombre, q.Nombre));
//escribe apuntadores
actualizaPtr();
}
/// <summary>
/// Escribe todo el bloque que compone una entidad
/// </summary>
/// <param name="ent">Onjeto de tipo entidad</param>
public void escribeEntidad(Entidad ent)
{
stream.Position = stream.Length;
writer.Write(ent.Nombre);
writer.Write(ent.ApuntaEnt);
writer.Write(ent.ApuntaAt);
writer.Write(ent.Dir);
writer.Write(ent.ApuntaDat);
}
public void llenaDataTabIndex(Entidad ent)
{
dataGridIndices.Rows.Clear();
//Obtiene la tabla de indices (Entidad Ent)
tablaIndices = indexada.getTablaIndices(ent);
foreach (Indice i in tablaIndices)
{
dataGridIndices.Rows.Add(i.Ind.ToString(), i.Direccion.ToString(), i.ApuntaSig.ToString(), i.ApuntaDat.ToString());
}
dataGridData.Rows.Clear();
}
/// <summary>
/// Funcion que es llamada desde la form para insertar un bloque
/// </summary>
/// <param name="ent"></param>
/// <param name="dats"></param>
/// <param name="diccionario"></param>
/// <returns></returns>
public bool insertaBloque(Entidad ent,List<string> dats,Diccionario diccionario)
{
bool res = false;
long dirBloqNuevo = 0;
//Primero escribe el bloque en el archivo
dirBloqNuevo = escribeBloqueMulti(ent, dats);
for (int i = 0; i < ent.Atributos.Count; i++)
//Inserta ordenado(atributo,dato,dirBloque)
insertaOrdenado(ent, ent.Atributos[i], dats[i], dirBloqNuevo, i, ent.Atributos[i].Tipo);
return res;
}
/// <summary>
/// Inserta un bloque en el archivo
/// </summary>
/// <param name="ent"></param>
/// <param name="nomDat"></param>
public void insertaBloqueDatos(Entidad ent,List<string> nomDat)
{
Bloque bloque;
long dirBloque = 0;
//toma la direccion que tendra el bloque
dirBloque = archivo.getLength();
bloque = new Bloque(dirBloque, (long)-1);
ent.ListBloq.Add(bloque);
//escribe en archivo el bloque
archivo.escribeBloque(bloque);
//escribe los atributos en archivo
for(int i=0;i<ent.Atributos.Count;i++)
{
insertaAtDato(ent.Atributos[i], nomDat[i]);
}
//Reescribe las direcciones de la lista
reescribeDirsDatos(ent);
}
/// <summary>
/// Sobrecarga de constructor para modificaciones
/// </summary>
/// <param name="atri"></param>
/// <param name="dato"></param>
/// <param name="mod"></param>
/// <param name="baseAc"></param>
/// <param name="ent"></param>
public GetDatos(List<Atributo> atri,List<string> dat,bool mod,Diccionario baseAc,Entidad ent)
{
InitializeComponent();
atributos = atri;
diccionario = baseAc;
noSecu = false;
viejos = dat;
modificando = mod;
dato = new List<string>();
cambioPrim = false;
entidad = ent;
dataGridView1.ColumnCount = ent.Atributos.Count - 6;
for (int i = 0; i < ent.Atributos.Count - 6; i++)
{
if (ent.Atributos[i].TClave == 2)
{
DataGridViewComboBoxColumn combo = new DataGridViewComboBoxColumn();
List<String> itemCodeList = llenaCombo(ent.Atributos[i].ApuntaPrim, diccionario);
if (itemCodeList.Count == 0)
{
MessageBox.Show("Error aun no existen datos para llenar la clave externa", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
dato.Add("error");
this.Close();
}
combo.DataSource = itemCodeList;
combo.HeaderText = ent.Atributos[i].Nombre + "(" + ent.Atributos[i].Tipo + ")";
combo.Name = ent.Atributos[i].Nombre + "(" + ent.Atributos[i].Tipo + ")";
combo.Width = 100;
dataGridView1.Columns.Insert(0, combo);
dataGridView1.ColumnCount--;
}
else
{
dataGridView1.Columns[i].Name = ent.Atributos[i].Nombre + "(" + ent.Atributos[i].Tipo + ")";
dataGridView1.Rows[0].Cells[i].Value = viejos[i];
}
}
}
private void eliminaOrdenado(Entidad ent, Atributo a, string dirBloq, int indice)
{
string datoLeido;
long dirNextBloq = a.ApuntaEntidad; ;
long dirActual = 0;
long dirAnt = 0;
while (dirNextBloq != -1)
{
archivo.setStreamPosition(dirNextBloq);
//Recorre los atributos
dirNextBloq=recorrePtrs(dirNextBloq, ent,indice);
dirActual = archivo.getLong();
archivo.getLong();
//Obtiene el dato a ordenar
datoLeido = getDatoByIndice(indice,Convert.ToInt64( dirBloq), ent);
if (dirActual==Convert.ToInt64(dirBloq))
{
//Si es el primer lugar
if (dirAnt == 0)
{
a.ApuntaEntidad = dirNextBloq;
archivo.escribePtrDatAtr(a.Direccion, dirNextBloq);
break;
}
//Si es un elemento intermedio
else
{
//reescribe el apuntador del bloque anterior
escribePtrNextBloq(dirAnt, indice, ent, dirNextBloq);
break;
}
}
dirAnt = dirActual;
}
}
private long recorrePtrs(long dirBloq,Entidad ent,int indice)
{
long ptrSig = 0;
for (int i = 0; i < ent.Atributos.Count; i++)
if (i == indice)
ptrSig = archivo.getLong();
else
archivo.getLong();
return ptrSig;
}
private string getDatoByIndice(int indice,long dirBloq,Entidad ent)
{
string result="";
//Recorre los atributos de acuerdo al tipo
for (int i = 0; i < ent.Atributos.Count; i++)
{
switch (ent.Atributos[i].Tipo)
{
case "int":
if (indice == i)
result = Convert.ToString(archivo.getInt());
else
archivo.getInt();
break;
case "float":
if (indice == i)
result = Convert.ToString(archivo.getDouble());
else
archivo.getDouble();
break;
case "char":
if (indice == i)
result = Convert.ToString(archivo.getChar());
else
archivo.getChar();
break;
case "string":
if (indice == i)
result = archivo.getString(ent.Atributos[i].Tam);
else
archivo.getString(ent.Atributos[i].Tam);
break;
}
}
return result;
}
/// <summary>
/// escribe el apuntador a siguiente bloque por indice
/// </summary>
/// <param name="dirBloq"></param>
/// <param name="indice"></param>
/// <param name="ent"></param>
/// <param name="dirNext"></param>
private void escribePtrNextBloq(long dirBloq, int indice, Entidad ent,long dirNext)
{
archivo.setStreamPosition(dirBloq);
for (int i = 0; i < ent.Atributos.Count; i++)
{
if (i == indice)
archivo.escribeLong(dirNext);
else
archivo.getLong();
}
}
/// <summary>
/// inserta ordenado de acuerdo al tipo de dato que es el atributo
/// </summary>
/// <param name="ent"></param>
/// <param name="a"></param>
/// <param name="dato"></param>
/// <param name="dirBloq"></param>
/// <param name="indice"></param>
/// <param name="tipo"></param>
/// <returns></returns>
private bool insertaOrdenado(Entidad ent,Atributo a,string dato,long dirBloq,int indice,string tipo)
{
bool esRepe = false;
string datoLeido;
long dirNextBloq = a.ApuntaEntidad; ;
long dirActual = 0;
long dirDats = a.ApuntaEntidad;
long dirAnt = 0;
bool inserto = false;
//Si no hay ningun dato inserta al inicio
if (dirDats == ent.Dir)
{
a.ApuntaEntidad = dirBloq;
archivo.escribePtrDatAtr(a.Direccion, dirBloq);
inserto = true;
}
else
{
while (dirNextBloq != -1)
{
archivo.setStreamPosition(dirNextBloq);
//Recorre los atributos
dirNextBloq=recorrePtrs(dirNextBloq, ent,indice);
dirActual = archivo.getLong();
archivo.getLong();
//Obtiene el dato a ordenar
datoLeido = getDatoByIndice(indice, dirBloq, ent);
if (comparaMayor(datoLeido, dato, tipo))
{
//Si es el primer lugar
if (dirAnt == 0)
{
a.ApuntaEntidad = dirBloq;
archivo.escribePtrDatAtr(a.Direccion, dirBloq);
//Nuevo apunta a las anteriores
//Escribe en el apuntador de acuerdo al indice
escribePtrNextBloq(dirBloq, indice, ent, dirActual);
inserto = true;
break;
}
//Si es un elemento intermedio
else
{
//reescribe el apuntador del bloque anterior
escribePtrNextBloq(dirAnt, indice, ent, dirBloq);
//escribe el apuntador a siguiente mio
escribePtrNextBloq(dirBloq, indice, ent, dirActual);
inserto = true;
break;
}
}
dirAnt = dirActual;
}
//Inserta al final
if (inserto == false)
{
//reescribe el apuntador del bloque anterior
escribePtrNextBloq(dirAnt, indice, ent, dirBloq);
//escribe el apuntador a siguiente mio
escribePtrNextBloq(dirBloq, indice, ent, (long)-1);
}
}
return esRepe;
}
private List<string> getDatosPrimariosIndex(Entidad ent)
{
List<string> auxList = new List<string>();
long dirDat = ent.ApuntaDat;
long apuntaDat=0;
while (dirDat != -1)
{
archivo.setStreamPosition(dirDat);
//lee indice
archivo.getLong();
//Lee direccion
archivo.getLong();
dirDat = archivo.getLong();
apuntaDat = archivo.getLong();
//Ciclo que recorre los datos en busca de atributos primarios
while (apuntaDat != -1)
{
archivo.setStreamPosition(apuntaDat);
//Lee la direccion
archivo.getLong();
apuntaDat = archivo.getLong();
foreach (Atributo i in ent.Atributos)
{
switch (i.Tipo)
{
case "int":
if (i.TClave == 1)
auxList.Add(archivo.getInt().ToString());
else
archivo.getInt();
break;
case "float":
if (i.TClave == 1)
auxList.Add(archivo.getDouble().ToString());
else
archivo.getDouble();
break;
case "char":
if (i.TClave == 1)
auxList.Add(archivo.getChar().ToString());
else
archivo.getChar();
break;
case "string":
if (i.TClave == 1)
auxList.Add(archivo.getString(i.Tam));
else
archivo.getString(i.Tam);
break;
}
}
}
}
return auxList;
}
public Entidad getBloqueEntidad(long direccion)
{
Entidad ent;
stream.Position = direccion;
string nombre = reader.ReadString();
long uno = reader.ReadInt64();
long dos = reader.ReadInt64();
long tres = reader.ReadInt64();
long cuatro = reader.ReadInt64();
ent = new Entidad(nombre);
return ent;
}
/// <summary>
/// Modifica datos a excepcion de la clave primaria
/// </summary>
/// <param name="dir"></param>
/// <param name="ent"></param>
/// <param name="datos"></param>
public void modificaBloque(long dir, Entidad ent,List<string> datos)
{
archivo.setStreamPosition(dir);
archivo.getLong();
archivo.getLong();
for (int a = 0; a < ent.Atributos.Count;a++)
{
switch (ent.Atributos[a].Tipo)
{
case "int":
if (ent.Atributos[a].TClave != 1)
archivo.escribeInt(Convert.ToInt32(datos[a]));
else
archivo.getInt();
break;
case "float":
if (ent.Atributos[a].TClave != 1)
archivo.escribeFloat(Convert.ToDouble(datos[a]));
else
archivo.getDouble();
break;
case "char":
if (ent.Atributos[a].TClave != 1)
archivo.escribeChar(Convert.ToChar(datos[a]));
else
archivo.getChar();
break;
case "string":
if (ent.Atributos[a].TClave != 1)
archivo.escribeString(datos[a], ent.Atributos[a].Tam);
else
archivo.setStreamPosition(archivo.Positon + ent.Atributos[a].Tam);
break;
}
}
}
private void reescribeDirsDatos(Entidad ent)
{
ent.ApuntaDat = ent.ListBloq[0].Direccion;
//escribe apuntador a datos de una entidad
archivo.escribePtrDatEnt(ent.Dir, ent.ListBloq[0].Direccion);
for (int i = 0; i < ent.ListBloq.Count; i++)
{
if (i <= (ent.ListBloq.Count - 2))
{
ent.ListBloq[i].ApuntaDato = ent.ListBloq[i + 1].Direccion;
//en archivo
archivo.escribePtrSigBloq(ent.ListBloq[i].Direccion, ent.ListBloq[i + 1].Direccion);
}
}
}
//Llena el datagrid
private void llenaData(Entidad ent)
{
dataGridData.Rows.Clear();
foreach(List<string> i in ent.ListaRegistros)
dataGridData.Rows.Add(i.ToArray());
}
public void eliminaBloque(string dirBloq,Entidad ent)
{
for (int i = 0; i < ent.Atributos.Count; i++)
//Elimina (atributo,dato,dirBloque)
eliminaOrdenado(ent, ent.Atributos[i], dirBloq, i);
}
private void desenlazaAtributos(Entidad ent)
{
foreach (Entidad i in entidades)
if (i.Dir != ent.Dir)
foreach (Atributo j in i.Atributos)
if (j.TClave == 2)
if (j.ApuntaPrim == ent.Nombre)
{
//Quita el enlace
j.ApuntaPrim = "";
//Cambia el tipo de clave
j.TClave = 3;
}
}
private long escribeBloqueMulti(Entidad ent,List<string> listDats)
{
long dirNBloque = 0;
//****Escribe el bloque en el archivo con sus apuntadores****
dirNBloque = archivo.getDir();
archivo.setStreamPosition(archivo.getDir());
//ciclo que escribe N veces los apuntadores necesarios
for (int i = 0; i < ent.Atributos.Count; i++)
archivo.escribeLong((long)-1);
archivo.escribeLong(dirNBloque);
archivo.escribeLong((long)-1);
//escribe los datos correspondientes al tipo de atributo
for (int i = 0; i < ent.Atributos.Count; i++)
escribeSegunTipo(listDats[i], ent.Atributos[i].Tipo, ent.Atributos[i].Tam);
return dirNBloque;
}
private List<List<string>> getBloqDats(long dirDats,Entidad ent,int indice)
{
long dirNextBloq = 0, dirActual = 0;
string auxCad = "";
List<List<string>> rowsData = new List<List<string>>();
List<string> auxRow = new List<string>();
dirNextBloq = dirDats;
while (dirNextBloq != -1)
{
auxRow = new List<string>();
multilistas.Archivo.setStreamPosition(dirNextBloq);
//Obtiene el bloque de apuntadores
for (int i = 0; i < ent.Atributos.Count; i++)
if (i == indice)
{
dirNextBloq = multilistas.Archivo.getLong();
auxCad = Convert.ToString(dirNextBloq);
auxRow.Add(auxCad);
}
else
auxRow.Add(Convert.ToString(multilistas.Archivo.getLong()));
//Obtiene direccion
dirActual = multilistas.Archivo.getLong();
auxRow.Add(Convert.ToString(dirActual));
multilistas.Archivo.getLong();
//Obtiene los datos de cada atributo
foreach (Atributo i in ent.Atributos)
//getByTipo(i.tipo)
auxRow.Add(multilistas.getByTipo(i.Tipo, i.Tam));
rowsData.Add(auxRow);
}
return rowsData;
}
