private InsertInto TraerInformacion(string nombre)
{
StreamReader file = new StreamReader(path + "tablas\\" + nombre + ".tabla");
InsertInto info = new InsertInto();
string linea = file.ReadLine();
string[] elementos = linea.Split(',');
string[] datos;
info.TableName = nombre;
info.Columns.Add(elementos[0]);
info.Types.Add(tiposReservados[3]);
for (int i = 1; i < elementos.Length; i++)
{
datos = elementos[i].Split(' ');
info.Columns.Add(datos[0]);
info.Types.Add(datos[1]);
}
file.Close();
return(info);
}
/// <summary>
/// Verifica la sintaxis cuando se ejecuta el comando Insert Into.
/// </summary>
/// <param name="datos"></param>
/// <returns>Retorna el numero de error. (0 significa que no hay errores) </returns>
public int VerificarSintaxisInsertTo(List <string> datos)
{
int i = 0;
int aux = 0;
int aux2 = 0;
List <string> data = new List <string>();
List <string> valores = new List <string>();
if (!datos.Contains(palabrasReemplazo[7]))
{
//No contiene el comando values
return(14);
}
//Busca algun elemento 'VALUES' repetido
//tambien verifica que no se esten usando comandos que no corresponden a la funcion
for (i = 0; i < datos.Count; i++)
{
if (datos[i] == palabrasReemplazo[1] || datos[i] == palabrasReemplazo[3])
{
//Error de comandos que no corresponden a la funcion.
return(16);
}
else
{
if (aux > 1)
{
return(15);
}
else
{
if (datos[i] == palabrasReemplazo[7])
{
aux2 = i;
aux++;
}
}
}
}
//Se divide en 2 partes mi algoritmo
for (i = 0; i < aux2; i++)
{
data.Add(datos[i]);
}
for (i = aux2 + 1; i < datos.Count; i++)
{
valores.Add(datos[i]);
}
/* VERIFICACION EN LA PARTE DE DATA */
//Verificar la existencia de la llave de apertura.
if (data[1] != "(" && !data.Contains("("))
{
//Error de llave de apertura no encontrado
return(3);
}
//En caso que exista algo que no es el operador {
if (data[1] != "(")
{
//Error de espacios de los nombres de las variables
return(9);
}
//En caso el ultimo elemento no es la llave de cierre
if (data[data.Count - 1] != ")" && !data.Contains(")"))
{
return(4);
}
//En caso que exista la llave de cierre pero hay mas elementos despues de esto.
if (data[data.Count - 1] != ")")
{
return(1);
}
InsertInto nuevaInsercion = new InsertInto();
nuevaInsercion.TableName = data[0];
for (i = 2; i < data.Count - 1; i++)
{
//Empieza sin tomar en cuenta el nombre y la llave de apertura
nuevaInsercion.Columns.Add(data[i]);
}
/* VERIFICACIÓN DE LA PARTE VALUES */
//Verificar la existencia de la llave de apertura.
if (valores[0] != "(" && !valores.Contains(")"))
{
//Error de llave de apertura no encontrado
return(3);
}
//En caso que exista algo que no es el operador {
if (valores[0] != "(")
{
//Error de espacios de los nombres de las variables
return(9);
}
//En caso el ultimo elemento no es la llave de cierre
if (valores[valores.Count - 1] != ")" && !valores.Contains(")"))
{
return(4);
}
//En caso que exista la llave de cierre pero hay mas elementos despues de esto.
if (valores[valores.Count - 1] != ")")
{
return(1);
}
for (i = 1; i < valores.Count - 1; i++)
{
//Omite el operador de apertura y el de cierre
nuevaInsercion.Values.Add(valores[i]);
}
//En caso no concuerden la cantidad de columnas con los valores ingresados.
if (nuevaInsercion.Values.Count != nuevaInsercion.Columns.Count)
{
return(17);
}
if (!ExisteTabla(nuevaInsercion.TableName))
{
//La tabla que se busca no existe..
return(18);
}
InsertInto infoObtenidaTabla = TraerInformacion(nuevaInsercion.TableName);
//Verica que las columnas concuerden con el formato de tabla almacenado
for (i = 0; i < nuevaInsercion.Columns.Count; i++)
{
if (nuevaInsercion.Columns[i] != infoObtenidaTabla.Columns[i])
{
return(19);
}
}
for (i = 0; i < infoObtenidaTabla.Types.Count; i++)
{
if (infoObtenidaTabla.Types[i] == tiposReservados[1])
{
//Debe ser del tipo Varchar
if (!(nuevaInsercion.Values[i][0].ToString() == "'") && !(nuevaInsercion.Values[i][nuevaInsercion.Values[i].Length - 1].ToString() == "'"))
{
return(20);
}
//nuevaInsercion.Values[i] = nuevaInsercion.Values[i].Replace("'", string.Empty);
}
if (infoObtenidaTabla.Types[i] == tiposReservados[2])
{
//Cuando el tipo de dato es DATETIME
if (!(nuevaInsercion.Values[i][0].ToString() == "'") && !(nuevaInsercion.Values[i][nuevaInsercion.Values[i].Length - 1].ToString() == "'"))
{
return(21);
}
//nuevaInsercion.Values[i] = nuevaInsercion.Values[i].Replace("'", string.Empty);
//string[] probar = nuevaInsercion.Values[i].Split('/');
// string[] probar = nuevaInsercion.Values[i].Replace("'", String.Empty).Split('/');
string temp = nuevaInsercion.Values[i];
string[] probar = temp.Replace("'", string.Empty).Split('/');
if (probar.Length != 3 || nuevaInsercion.Values[i].Length != 12)
{
return(23);
}
aux = 0;
for (int x = 0; x < probar.Length; x++)
{
try
{
aux = int.Parse(probar[x]);
//Verifica el dia
if (x == 0)
{
if (aux > 31 || aux < 1)
{
return(24);
}
}
//Verifica el mes
if (x == 1)
{
if (aux > 12 || aux < 1)
{
return(25);
}
}
//Verifica el año
if (x == 2)
{
if (aux < 1)
{
return(26);
}
}
}
catch
{
return(22);
}
}
}
if (infoObtenidaTabla.Types[i] == tiposReservados[3])
{
try
{
//Cuando el tipo de dato es INT
if (infoObtenidaTabla.Columns[i] == "ID")
{
if (int.Parse(nuevaInsercion.Values[i]) < 1)
{
return(29);
}
}
int.Parse(nuevaInsercion.Values[i]);
}
catch
{
return(22);
}
}
}
insertar = nuevaInsercion;
return(0);
}
/// <summary>
/// Verifica la sintaxis cuando se ejecuta el comando Select.
/// </summary>
/// <param name="datos"></param>
/// <returns>Retorna el numero de error. (0 significa que no hay errores) </returns>
public int VerificiarSintaxisSelect(List <string> datos)
{
int i = 0;
int aux = 0;
int aux2 = 0;
int aux3 = 0;
int aux4 = 0;
Selection nuevaSeleccion = new Selection();
List <string> columnas = new List <string>();
List <string> filtro = new List <string>();
string nombreTabla = string.Empty;
if (!datos.Contains(palabrasReemplazo[1]))
{
//No contiene el comando from
return(30);
}
//Busca algun elemento 'WHERE O FROM' repetido
//tambien verifica que no se esten usando comandos que no corresponden a la funcion
for (i = 0; i < datos.Count; i++)
{
if (datos[i] == palabrasReemplazo[7])
{
//Error de comandos que no corresponden a la funcion.
return(16);
}
else
{
if (aux > 1 || aux2 > 1)
{
return(33);
}
else
{
if (datos[i] == palabrasReemplazo[1])
{
aux3 = i;
aux++;
}
if (datos[i] == palabrasReemplazo[3])
{
aux4 = i;
aux2++;
}
}
}
}
if (datos.Contains(palabrasReemplazo[3]))
{
/* ANALIZAR COMO SI EXISTIERA EL WHERE*/
for (i = 0; i < aux3; i++)
{
columnas.Add(datos[i]);
}
//Verifica que solo exista un campo despues del from
if (aux4 - aux3 != 2)
{
return(31);
}
//Obtiene el nombre de la tabla buscada
nombreTabla = datos[aux3 + 1];
//Obtiene el filtro
for (i = aux4 + 1; i < datos.Count; i++)
{
filtro.Add(datos[i]);
}
//Verifica la existencia de la tabla
if (!ExisteTabla(nombreTabla))
{
return(18);
}
//Analisis del filtro
if (filtro.Count > 3 || filtro.Count < 3)
{
return(38);
}
if (filtro[0] != "ID")
{
return(36);
}
if (filtro[1] != "=")
{
return(38);
}
try
{
if (int.Parse(filtro[2]) < 0)
{
return(39);
}
}
catch
{
return(39);
}
InsertInto infoObtenida = TraerInformacion(nombreTabla);
//Verificar si se necesita toda la informacion o no "*"
if (columnas.Count == 1 && columnas[0] == "*")
{
nuevaSeleccion.TableName = nombreTabla;
nuevaSeleccion.Columns = infoObtenida.Columns;
nuevaSeleccion.Filtro = string.Join("", filtro);
}
else
{
//Si se sobrepasa la cantidad de columnas que existen
if (columnas.Count > infoObtenida.Columns.Count)
{
return(35);
}
//Verica que las columnas concuerden con el formato de tabla almacenado
for (i = 0; i < columnas.Count; i++)
{
if (!infoObtenida.Columns.Contains(columnas[i]))
{
return(34);
}
}
nuevaSeleccion.TableName = nombreTabla;
nuevaSeleccion.Columns = columnas;
nuevaSeleccion.Filtro = string.Join("", filtro);
}
}
else
{
/* ANALIZAR SIN WHERE */
//Obtiene las columnas
for (i = 0; i < aux3; i++)
{
columnas.Add(datos[i]);
}
//Obtiene el nombre
if (datos[datos.Count - 2] != palabrasReemplazo[1])
{
return(31);
}
nombreTabla = datos[aux3 + 1];
//Verifica la existencia de la tabla.
if (!ExisteTabla(nombreTabla))
{
return(18);
}
InsertInto infoObtenida = TraerInformacion(nombreTabla);
//En caso se quiera toda la info...
if (columnas.Count == 1 && columnas[0] == "*")
{
nuevaSeleccion.TableName = infoObtenida.TableName;
nuevaSeleccion.Columns = infoObtenida.Columns;
}
else
{
if (columnas.Count > infoObtenida.Columns.Count)
{
return(35);
}
//Verica que las columnas concuerden con el formato de tabla almacenado
for (i = 0; i < columnas.Count; i++)
{
if (!infoObtenida.Columns.Contains(columnas[i]))
{
return(34);
}
}
nuevaSeleccion.TableName = nombreTabla;
nuevaSeleccion.Columns = columnas;
}
}
seleccion = nuevaSeleccion;
return(0);
}
public int Insertar(InsertInto insercion)
{
return(insertarArbol(insercion.TableName.Trim(), insercion.Values, insercion.Columns));
}
