Exemple #1
0
        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);
        }
Exemple #2
0
        /// <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);
        }
Exemple #3
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);
        }
Exemple #4
0
 public int Insertar(InsertInto insercion)
 {
     return(insertarArbol(insercion.TableName.Trim(), insercion.Values, insercion.Columns));
 }