Пример #1
0
        public override string Ejecutar(Entorno entorno)
        {
            System.Diagnostics.Debug.WriteLine("Ejecucion CURSOR");
            String        Cursor    = this.Hijos[0].Nombre.Replace(" (id2)", "");
            NodoAbstracto SELECCION = this.Hijos[1];
            String        BD        = entorno.Tabla();

            System.Diagnostics.Debug.WriteLine("Ejecucion CURSOR Nombre->" + Cursor);
            String id = "BRAY-CURSOR" + (entorno.CantidadDeCursores() + 1).ToString();

            System.Diagnostics.Debug.WriteLine("Ejecucion CURSOR id->" + id);
            //System.Diagnostics.Debug.WriteLine("Ejecucion CURSOR SELECTOR->" + SELECCION.ToString());
            if (entorno.ExisteCursor(Cursor) == false)
            {
                entorno.Agregarcursor(id, Cursor, "0", SELECCION);
            }
            else
            {
                return("#ERROR, YA EXISTE EL CURSOR");
            }
            //String valor1 = "";
            //SELECCION.Ejecutar(entorno);
            entorno.MostrarcURSORES();
            return("CURSOR");
        }
Пример #2
0
        public override string Ejecutar(Entorno entorno)
        {
            System.Diagnostics.Debug.WriteLine("Ejecucion funCIONES URUAIOAR------" + this.TipoDato + "x---");


            //LA FUCNION SE ENCONTRO
            //   this.TipoDato = "entero";
            //   System.Diagnostics.Debug.WriteLine("Ejecucion funCIONES URUAIOAR------" + this.TipoDato);

            if (this.AutoIncrmentable2 == 54)
            {
                String NombreFuncion = this.Hijos[0].Nombre;
                System.Diagnostics.Debug.WriteLine("NOMBRE FUNCION: 54" + NombreFuncion);
                NodoAbstracto Acciones = entorno.NodoSinParametros(NombreFuncion);
                String        Retorno  = "";
                System.Diagnostics.Debug.WriteLine("NOMBRE FUNCION: 54->" + Acciones.Hijos.Count);

                if (Acciones == null)
                {
                    return("#ERROR101 FUNCION NO EXISTENTE");
                }
                else
                {
                    String  valor1 = "";
                    Entorno x      = new Entorno();
                    entorno.NuevasFunciones(x);
                    entorno.NuevasVariables(x);
                    for (int i = 0; i < Acciones.Hijos.Count; i++)

                    {
                        System.Diagnostics.Debug.WriteLine("ESTAMOS DENTRO DEL if");
                        valor1 = Acciones.Hijos[i].Ejecutar(x);
                        if (valor1.Contains("#Error") == true)
                        {
                            System.Diagnostics.Debug.WriteLine("errroESTAMOS DENTRO DEL if");
                            return("#ERROR101 EN FUNCION");
                            //return "#Error";
                        }
                        if (valor1.Contains("RETORNO:") == true)
                        {
                            Retorno = valor1;
                            break;
                        }
                    }
                    x.AsignarNuevosValores(entorno);
                }

                System.Diagnostics.Debug.WriteLine("valor retorno: " + Retorno);

                string[] separadas;
                separadas = Retorno.Split(',');

                string[] separadas2;
                separadas2 = separadas[0].Split(':');

                string[] separadas3;
                separadas3 = separadas[1].Split(':');
                String TipoRetorno = separadas3[1];

                if (TipoRetorno.ToUpper().Contains("INT"))
                {
                    TipoRetorno = "entero";
                }
                else if (TipoRetorno.ToUpper().Contains("DOUBLE"))
                {
                    TipoRetorno = "decimal";
                }
                else if (TipoRetorno.ToUpper().Contains("STRING"))
                {
                    TipoRetorno = "cadena";
                }
                else if (TipoRetorno.ToUpper().Contains("BOOLEANO"))
                {
                    TipoRetorno = "Booleano";
                }
                else if (TipoRetorno.ToUpper().Contains("DATE"))
                {
                    TipoRetorno = "Fechas";
                }
                else if (TipoRetorno.ToUpper().Contains("TIME"))
                {
                    TipoRetorno = "hora";
                }



                this.TipoDato = TipoRetorno;
                return(separadas2[1]);
            }

            if (this.AutoIncrmentable2 == 345)
            {
                System.Diagnostics.Debug.WriteLine("VAMOS A BUSCAR LA FUNCION");
                String NombreFuncion = this.Hijos[0].Nombre;
                this.Hijos[0].TipoDato = this.TipoDato;
                System.Diagnostics.Debug.WriteLine("NOMBRE FUNCION Romeo: " + NombreFuncion);
                Boolean MismaCantidadDeParametros = entorno.ExisteListaConLaMismaCantidadDeParametros(NombreFuncion, this.ListaID1.Count);
                entorno.MostrarFunciones();
                List <String> Insulto = new List <String>();
                ///Empiezo
                ///
                System.Diagnostics.Debug.WriteLine("NOMBRE FUNCIONx:red2 " + NombreFuncion + "->" + MismaCantidadDeParametros + "->" + this.ListaID1.Count);
                if (MismaCantidadDeParametros == true)
                {
                    for (int i = 0; i < this.Parametros.Count; i++)
                    {
                        String valor1     = "";
                        String TipoDatoxd = "";
                        System.Diagnostics.Debug.WriteLine("NOMBRE FUNCION:-------------------------------> " + this.Parametros[i].Ejecutar(entorno) + "->" + i);
                        valor1     = this.Parametros[i].Ejecutar(entorno).Replace(" (numero)", "").Replace(" (numdecimal)", "");
                        TipoDatoxd = this.Parametros[i].TipoDato;
                        //System.Diagnostics.Debug.WriteLine("TIPO DATO:-" + TipoDatoxd);
                        if (TipoDatoxd == "entero")
                        {
                            valor1 = valor1 + " (numero)";
                        }
                        else if (TipoDatoxd == "decimal")
                        {
                            valor1 = valor1 + " (numdecimal)";
                        }
                        else if (TipoDatoxd == "cadena")
                        {
                            valor1 = valor1 + " (cadena)";
                        }
                        else if (TipoDatoxd == "Booleano")
                        {
                            valor1 = valor1 + " (Keyword)";
                        }
                        else if (TipoDatoxd.Contains("id2"))
                        {
                            String TipoDEId2 = entorno.ObtenerTipo(this.ListaID1[i].Replace(" (id2)", ""));

                            System.Diagnostics.Debug.WriteLine("TIPO DATO:--------------" + TipoDEId2);
                            if (TipoDEId2.ToUpper().Contains("INT") == true)
                            {
                                valor1 = valor1 + " (numero)";
                            }
                            else if (TipoDEId2.ToUpper().Contains("DOUBLE") == true)
                            {
                                valor1 = valor1 + " (numdecimal)";
                            }
                            else if (TipoDEId2.ToUpper().Contains("BOOL") == true)
                            {
                                valor1 = valor1 + " (Keyword)";
                            }
                            else if (TipoDEId2.ToUpper().Contains("STRING") == true)
                            {
                                valor1 = valor1 + " (cadena)";
                            }
                        }
                        else
                        {
                            valor1 = valor1 + this.Parametros[i].TipoDato;
                        }


                        Insulto.Add(valor1);
                    }
                    List <String> TiposParametros   = new List <String>();
                    List <String> ValoresParametros = new List <String>();
                    for (int i = 0; i < Insulto.Count; i++)
                    {
                        String TipoRetorno = Insulto[i];
                        System.Diagnostics.Debug.WriteLine("ROME PAR->" + TipoRetorno);


                        /// verificando el tipo de cada uno de los elementos y se agregará a una lista
                        if (TipoRetorno.ToUpper().Contains("NUMERO"))
                        {
                            ValoresParametros.Add(Insulto[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                            TipoRetorno = "int";
                        }
                        else if (TipoRetorno.ToUpper().Contains("DECIMAL"))
                        {
                            TipoRetorno = "double";
                            ValoresParametros.Add(Insulto[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("CADENA"))
                        {
                            TipoRetorno = "String";
                            ValoresParametros.Add(Insulto[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("(KEYWORD)") && (TipoRetorno.ToUpper().Contains("TRUE") || TipoRetorno.ToUpper().Contains("FALSE")))
                        {
                            TipoRetorno = "Booleano";
                            ValoresParametros.Add(Insulto[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("FECHAS"))
                        {
                            TipoRetorno = "Date";
                            ValoresParametros.Add(Insulto[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("HORA"))
                        {
                            TipoRetorno = "Time";
                            ValoresParametros.Add(Insulto[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("(ID2)"))
                        {
                            TipoRetorno = entorno.ObtenerTipo(TipoRetorno.Replace(" (id2)", ""));
                            ValoresParametros.Add(entorno.ObtenerValor(Insulto[i].Replace(" (id2)", "")));
                        }

                        TiposParametros.Add(TipoRetorno.Replace(" ", ""));
                    }
                    Boolean MismosParametros = entorno.MismosParametros2(NombreFuncion, TiposParametros);
                    System.Diagnostics.Debug.WriteLine("ROMEOLOG" + MismosParametros);
                    if (MismosParametros == true)
                    {
                        //LA FUCNION SE ENCONTRO
                        System.Diagnostics.Debug.WriteLine(NombreFuncion + "ENCONTADA..");
                        //LA FUCNION SE ENCONTRO
                        System.Diagnostics.Debug.WriteLine(NombreFuncion + "ENCONTADA..");
                        // Ahora vamos a Encontrar el tipo y nombre de los parametors junto con sus valores
                        List <String> Listaxx = new List <String>();
                        Listaxx = entorno.MismosParametros3(NombreFuncion, TiposParametros);
                        Entorno Xx = new Entorno();

                        //Xx = entorno;
                        for (int i = 0; i < Listaxx.Count; i++)
                        {
                            string[] separadasx;
                            separadasx = Listaxx[i].Split('*');
                            System.Diagnostics.Debug.WriteLine("Tipo: " + separadasx[0] + " Nombre: " + separadasx[1] + " Valor: " + ValoresParametros[i]);
                            Xx.Agregar(separadasx[1], separadasx[0], ValoresParametros[i]);
                        }
                        NodoAbstracto Nodo = entorno.ElNodoParametros(NombreFuncion, TiposParametros);

                        String valor1  = "";
                        String Retorno = "";
                        entorno.NuevasFunciones(Xx);
                        entorno.NuevasVariables(Xx);

                        for (int u = 0; u < Nodo.Hijos.Count; u++)

                        {
                            System.Diagnostics.Debug.WriteLine("ESTAMOS DENTRO DEL if de funretorno");
                            valor1 = Nodo.Hijos[u].Ejecutar(Xx);
                            if (valor1.Contains("#Error") == true)
                            {
                                System.Diagnostics.Debug.WriteLine("errroESTAMOS DENTRO DEL if");
                                return("#ERROR101 EN FUNCION");
                                //return "#Error";
                            }
                            if (valor1.Contains("RETORNO:") == true)
                            {
                                System.Diagnostics.Debug.WriteLine("cahiasdjfiassssssssssssssssssssss");
                                Retorno = valor1;
                                break;
                            }
                        }
                        System.Diagnostics.Debug.WriteLine("valor retorno: " + Retorno);

                        string[] separadas;
                        separadas = Retorno.Split(',');

                        string[] separadas2;
                        separadas2 = separadas[0].Split(':');

                        string[] separadas3;
                        separadas3 = separadas[1].Split(':');
                        String TipoRetorno  = separadas3[1];
                        String TipoRetornox = "";
                        if (TipoRetorno.ToUpper().Contains("INT"))
                        {
                            TipoRetornox = "entero";
                        }
                        else if (TipoRetorno.ToUpper().Contains("DOUBLE"))
                        {
                            TipoRetornox = "decimal";
                        }
                        else if (TipoRetorno.ToUpper().Contains("STRING"))
                        {
                            TipoRetornox = "cadena";
                        }
                        else if (TipoRetornox.ToUpper().Contains("BOOLEANO"))
                        {
                            TipoRetornox = "Booleano";
                        }
                        else if (TipoRetornox.ToUpper().Contains("DATE"))
                        {
                            TipoRetornox = "Fechas";
                        }
                        else if (TipoRetorno.ToUpper().Contains("TIME"))
                        {
                            TipoRetornox = "hora";
                        }


                        //this.Nombre == "EXP";
                        this.TipoDato = TipoRetornox;
                        //System.Diagnostics.Debug.WriteLine("Ejecucion funCIONES URUAIOAR------" + this.TipoDato);
                        Xx.AsignarNuevosValores(entorno);
                        return(separadas2[1]);
                    }
                    else
                    {
                        return("#ERROR103 LA FUNCION NO SE ENCONTRO");
                    }
                }
                else
                {
                    return("#ERROR103 LA FUNCIÓN A UTILIZAR NO EXISTE");
                }

                /*
                 * for (int i = 0; i < this.Parametros.Count; i++)
                 * {
                 *  System.Diagnostics.Debug.WriteLine("NOMBRE FUNCION: " + this.Parametros[i].Nombre +"->" + i);
                 *  String valor1 = "";
                 *  String Retorno = "";
                 *  String TipoDatoxd = "";
                 *
                 *  /*
                 * foreach (NodoAbstracto sentencia in this.Parametros[i].Hijos)
                 *
                 *  {
                 *
                 *      TipoDatoxd = sentencia.TipoDato;
                 *      valor1 = sentencia.Ejecutar(entorno);
                 *      if (valor1.Contains("#Error") == true)
                 *      {
                 *
                 *          return "#ERROR EN FUNCION";
                 *          //return "#Error";
                 *      }
                 *      if (valor1.Contains("RETORNO:") == true)
                 *      {
                 *          System.Diagnostics.Debug.WriteLine("cahiasdjfiassssssssssssssssssssss");
                 *          Retorno = valor1;
                 *          break;
                 *      }
                 *
                 *  }
                 *  System.Diagnostics.Debug.WriteLine("ESTAMOS DENTRO DEL if valor->" + valor1 + " Tipo->"+TipoDatoxd);
                 *  if(TipoDatoxd == "entero")
                 *  {
                 *      valor1 = valor1 + " (numero)";
                 *  }
                 *  else if (TipoDatoxd == "decimal")
                 *  {
                 *      valor1 = valor1 + " (numdecimal)";
                 *  }
                 *  else if (TipoDatoxd == "cadena")
                 *  {
                 *      valor1 = valor1 + " (cadena)";
                 *  }
                 *  else if (TipoDatoxd == "Booleano")
                 *  {
                 *      valor1 = valor1 + " (Keyword)";
                 *  }
                 *  else if (TipoDatoxd == "id2")
                 *  {
                 *      valor1 = valor1 + " (numero)";
                 *  }
                 *  else
                 *  {
                 *      valor1 = valor1 + " (" + TipoDatoxd + ")";
                 *  }
                 *
                 *  this.ListaID1.Add(valor1);
                 *
                 * }
                 *
                 *
                 * //termiano
                 *
                 * /*
                 *
                 * System.Diagnostics.Debug.WriteLine("NOMBRE FUNCION: saflog" + this.ListaID1.Count);
                 * if (MismaCantidadDeParametros == true)
                 * {
                 *  List<String> TiposParametros   = new List<String>();
                 *  List<String> ValoresParametros = new List<String>();
                 *  System.Diagnostics.Debug.WriteLine("MISMA CANTIDAD DE PARAMETROS EN FUNCION" + NombreFuncion);
                 *
                 *  for (int i = 0; i<this.ListaID1.Count; i++)
                 *  {
                 *      String TipoRetorno = this.ListaID1[i];
                 *      System.Diagnostics.Debug.WriteLine(this.ListaID1[i]);
                 *      /// verificando el tipo de cada uno de los elementos y se agregará a una lista
                 *      if (TipoRetorno.ToUpper().Contains("NUMERO"))
                 *      {
                 *          ValoresParametros.Add(this.ListaID1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)","").Replace(" (cadena)", ""));
                 *          TipoRetorno = "int";
                 *      }
                 *      else if (TipoRetorno.ToUpper().Contains("DECIMAL"))
                 *      {
                 *          TipoRetorno = "double";
                 *          ValoresParametros.Add(this.ListaID1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                 *
                 *      }
                 *      else if (TipoRetorno.ToUpper().Contains("CADENA"))
                 *      {
                 *          TipoRetorno = "String";
                 *          ValoresParametros.Add(this.ListaID1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                 *
                 *      }
                 *      else if (TipoRetorno.ToUpper().Contains("(KEYWORD)")&& (TipoRetorno.ToUpper().Contains("TRUE")|| TipoRetorno.ToUpper().Contains("FALSE")) )
                 *      {
                 *          TipoRetorno = "Booleano";
                 *          ValoresParametros.Add(this.ListaID1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                 *
                 *      }
                 *      else if (TipoRetorno.ToUpper().Contains("FECHAS"))
                 *      {
                 *          TipoRetorno = "Date";
                 *          ValoresParametros.Add(this.ListaID1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                 *
                 *      }
                 *      else if (TipoRetorno.ToUpper().Contains("HORA"))
                 *      {
                 *          TipoRetorno = "Time";
                 *          ValoresParametros.Add(this.ListaID1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)",""));
                 *
                 *      }
                 *      else if (TipoRetorno.ToUpper().Contains("(ID2)"))
                 *      {
                 *          TipoRetorno = entorno.ObtenerTipo(TipoRetorno.Replace(" (id2)", ""));
                 *          ValoresParametros.Add(entorno.ObtenerValor(this.ListaID1[i].Replace(" (id2)", "")));
                 *      }
                 *
                 *      TiposParametros.Add(TipoRetorno.Replace(" ",""));
                 *  }
                 *  Boolean MismosParametros = entorno.MismosParametros2(NombreFuncion, TiposParametros);
                 *  System.Diagnostics.Debug.WriteLine("ROMEOLOG" + MismosParametros);
                 *  if (MismosParametros == true)
                 *  {
                 *      //LA FUCNION SE ENCONTRO
                 *      System.Diagnostics.Debug.WriteLine(NombreFuncion + "ENCONTADA..");
                 *      // Ahora vamos a Encontrar el tipo y nombre de los parametors junto con sus valores
                 *      List<String> Listaxx = new List<String>();
                 *      Listaxx = entorno.MismosParametros3(NombreFuncion, TiposParametros);
                 *      Entorno Xx = new Entorno();
                 *
                 *      //Xx = entorno;
                 *      for(int i = 0; i < Listaxx.Count; i++)
                 *      {
                 *          string[] separadasx;
                 *          separadasx = Listaxx[i].Split('*');
                 *          System.Diagnostics.Debug.WriteLine("Tipo: " + separadasx[0] + " Nombre: " +separadasx[1] + " Valor: "+ValoresParametros[i]);
                 *          Xx.Agregar(separadasx[1], separadasx[0], ValoresParametros[i]);
                 *      }
                 *      NodoAbstracto Nodo = entorno.ElNodoParametros(NombreFuncion, TiposParametros);
                 *
                 *      String valor1 = "";
                 *      String Retorno = "";
                 *      entorno.NuevasFunciones(Xx);
                 *      foreach (NodoAbstracto sentencia in Nodo.Hijos)
                 *
                 *      {
                 *          System.Diagnostics.Debug.WriteLine("ESTAMOS DENTRO DEL if");
                 *          valor1 = sentencia.Ejecutar(Xx);
                 *          if (valor1.Contains("#Error") == true)
                 *          {
                 *              System.Diagnostics.Debug.WriteLine("errroESTAMOS DENTRO DEL if");
                 *              return "#ERROR EN FUNCION";
                 *              //return "#Error";
                 *          }
                 *          if (valor1.Contains("RETORNO:") == true)
                 *          {
                 *              System.Diagnostics.Debug.WriteLine("cahiasdjfiassssssssssssssssssssss");
                 *              Retorno = valor1;
                 *              break;
                 *          }
                 *
                 *      }
                 *
                 *      ///eliminar funciones
                 *
                 *      System.Diagnostics.Debug.WriteLine("valor retorno: " + Retorno);
                 *
                 *      string[] separadas;
                 *      separadas = Retorno.Split(',');
                 *
                 *      string[] separadas2;
                 *      separadas2 = separadas[0].Split(':');
                 *
                 *      string[] separadas3;
                 *      separadas3 = separadas[1].Split(':');
                 *      String TipoRetorno = separadas3[1];
                 *      String TipoRetornox = "";
                 *      if (TipoRetorno.ToUpper().Contains("INT"))
                 *      {
                 *          TipoRetornox = "entero";
                 *      }
                 *      else if (TipoRetorno.ToUpper().Contains("DOUBLE"))
                 *      {
                 *          TipoRetornox = "decimal";
                 *      }
                 *      else if (TipoRetorno.ToUpper().Contains("STRING"))
                 *      {
                 *          TipoRetornox = "cadena";
                 *      }
                 *      else if (TipoRetornox.ToUpper().Contains("BOOLEANO"))
                 *      {
                 *          TipoRetornox = "Booleano";
                 *      }
                 *      else if (TipoRetornox.ToUpper().Contains("DATE"))
                 *      {
                 *          TipoRetornox = "Fechas";
                 *      }
                 *      else if (TipoRetorno.ToUpper().Contains("TIME"))
                 *      {
                 *          TipoRetornox = "hora";
                 *
                 *      }
                 *
                 *
                 *      //this.Nombre == "EXP";
                 *      this.TipoDato = TipoRetornox;
                 *      //System.Diagnostics.Debug.WriteLine("Ejecucion funCIONES URUAIOAR------" + this.TipoDato);
                 *      return separadas2[1];
                 *
                 *  }
                 *  else
                 *  {
                 *      return "#ERROR TIPO DE PARAMETROS INCORRECTO";
                 *  }
                 *
                 *  ///Verificando Si el tipo de Parametros es igual
                 *
                 * }
                 * else
                 * {
                 *
                 *  return "#ERROR CANTIDAD DE PARAMETROS INCORRECTO";
                 * }
                 */
            }


            return("FuncionesPropias");
        }
Пример #3
0
        public override string Ejecutar(Entorno entorno)
        {
            System.Diagnostics.Debug.WriteLine("Ejecucion LLLAMADA CURSOR");
            String        Cursor    = this.Hijos[0].Nombre.Replace(" (id2)", "");
            NodoAbstracto Sentencia = this.Hijos[1];

            System.Diagnostics.Debug.WriteLine("Ejecucion LLLAMADA CURSOR -nombre->" + Cursor);
            String        ValorCursor = entorno.EstadoCursor(Cursor);
            List <String> Parametros  = new List <String>();

            if (ValorCursor == "1")
            {
                //leeemos el archivo en primer lugar
                string   text = System.IO.File.ReadAllText(@"C:\Users\Bayyron\Desktop\RoshiEIrack\" + Cursor + ".txt");
                string[] separadas;
                separadas = text.Split('\n');
                for (int x = 0; x < separadas.Length; x++)
                {
                    if (separadas[x].Contains("*"))
                    {
                        //System.Diagnostics.Debug.WriteLine("Ejecucion LLLAMADA CURSOR -archivi->" + separadas[x]);
                        string[] Comas;
                        Comas = separadas[x].Split(',');
                        List <String> ParametrostAbla = new List <String>();
                        for (int p = 0; p < Comas.Length - 1; p++)
                        {
                            ParametrostAbla.Add(Comas[p]);
                        }
                        for (int p = 0; p < ParametrostAbla.Count; p++)
                        {
                            //System.Diagnostics.Debug.WriteLine("Archivro->" + ParametrostAbla[p]);
                        }
                        if (ParametrostAbla.Count == this.ListaID1.Count)
                        {
                            //empezamos con los entornos
                            System.Diagnostics.Debug.WriteLine("Nuevo entorno->");
                            Entorno NuevoEntorno = new Entorno();
                            for (int p = 0; p < ParametrostAbla.Count; p++)
                            {
                                //System.Diagnostics.Debug.WriteLine("Archivro->" + ParametrostAbla[p] + " Lista->" + this.ListaID1[p]);
                                string[] AteriscoTabla;
                                AteriscoTabla = ParametrostAbla[p].Split('*');

                                string[] AteriscoLista;
                                AteriscoLista = this.ListaID1[p].Split('*');

                                if (AteriscoLista[0].ToUpper() == AteriscoTabla[1].ToUpper())
                                {
                                    if (NuevoEntorno.Agregar(AteriscoLista[1], AteriscoLista[0], AteriscoTabla[0]))
                                    {
                                        System.Diagnostics.Debug.WriteLine("Archivro Variable->" + AteriscoLista[1] + "->" + AteriscoLista[0] + "->" + AteriscoTabla[0]);
                                    }
                                    else
                                    {
                                        return("#ERROR, uno de los parametros ya fue declarado");
                                    }
                                }
                                else
                                {
                                    return("#ERROR, los parametros no coinciden de tipo con los resltados de la tabla");
                                }

                                //ejecuando sentencias.
                            }
                            for (int ix = 1; ix < this.Hijos.Count; ix++)
                            {
                                this.Hijos[ix].Ejecutar(NuevoEntorno);
                            }
                        }
                        else
                        {
                            return("#ERROR, LA CANTIDAD DE PARAMETROS NO SON IGUALES");
                        }
                    }
                }
            }
            else
            {
                return("#ERROR el cursos no ha sido activado");
            }

            /*
             * //System.Diagnostics.Debug.WriteLine("Ejecucion LLLAMADA CURSOR -seteca->" + Sentencia.ToString());
             * for (int i = 0; i < this.ListaID1.Count; i++)
             * {
             *  System.Diagnostics.Debug.WriteLine("Ejecucion LLLAMADA CURSOR -aratro->" + this.ListaID1[i]);
             * }
             * for(int i = 1; i < this.Hijos.Count; i++)
             * {
             *  this.Hijos[i].Ejecutar(entorno);
             * }
             */
            return("llamada cursor");
        }
Пример #4
0
        public override string Ejecutar(Entorno entorno)
        {
            System.Diagnostics.Debug.WriteLine("Se esta ejecutnado CALL");
            String NombreProcedimiento = this.Hijos[0].Nombre;


            System.Diagnostics.Debug.WriteLine("nombre proc-->" + NombreProcedimiento);
            System.Diagnostics.Debug.WriteLine("part proc-->" + this.ListaID1.Count);
            if (entorno.ExisteProcedimiento(NombreProcedimiento) == true)
            {
                //vamos a ver si existen las variables
                for (int i = 0; i < this.ListaID1.Count; i++)
                {
                    System.Diagnostics.Debug.WriteLine("nombre proc-->" + this.ListaID1[i]);
                    if (entorno.ExisteVariable(this.ListaID1[i]) == false)
                    {
                        return("#ERROR una de las variables del call no existe");
                    }
                }
                //procedimientos para ver si el procedimiento cumple con los parametros
                Boolean MismaCantidadDeParametros = entorno.ExisteListaConLaMismaCantidadDeParametrosEnProc(NombreProcedimiento, this.ListaR1.Count);
                //tIENE LA MISMA CANTIDAD DE PARAMETROS
                if (MismaCantidadDeParametros == true)
                {
                    List <String> TiposParametros   = new List <String>();
                    List <String> ValoresParametros = new List <String>();
                    System.Diagnostics.Debug.WriteLine("MISMA CANTIDAD DE PARAMETROS EN proc" + NombreProcedimiento);

                    for (int i = 0; i < this.ListaR1.Count; i++)
                    {
                        String TipoRetorno = this.ListaR1[i];
                        System.Diagnostics.Debug.WriteLine(this.ListaR1[i]);
                        /// verificando el tipo de cada uno de los elementos y se agregará a una lista
                        if (TipoRetorno.ToUpper().Contains("NUMERO"))
                        {
                            ValoresParametros.Add(this.ListaR1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                            TipoRetorno = "int";
                        }
                        else if (TipoRetorno.ToUpper().Contains("DECIMAL"))
                        {
                            TipoRetorno = "double";
                            ValoresParametros.Add(this.ListaR1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("CADENA"))
                        {
                            TipoRetorno = "String";
                            ValoresParametros.Add(this.ListaR1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("(KEYWORD)") && (TipoRetorno.ToUpper().Contains("TRUE") || TipoRetorno.ToUpper().Contains("FALSE")))
                        {
                            TipoRetorno = "Booleano";
                            ValoresParametros.Add(this.ListaR1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("FECHAS"))
                        {
                            TipoRetorno = "Date";
                            ValoresParametros.Add(this.ListaR1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("HORA"))
                        {
                            TipoRetorno = "Time";
                            ValoresParametros.Add(this.ListaR1[i].Replace(" (numero)", "").Replace(" (hora)", "").Replace(" (numdecimal)", "").Replace(" (fechas)", "").Replace(" (Keyword)", "").Replace(" (cadena)", ""));
                        }
                        else if (TipoRetorno.ToUpper().Contains("(ID2)"))
                        {
                            TipoRetorno = entorno.ObtenerTipo(TipoRetorno.Replace(" (id2)", ""));
                            ValoresParametros.Add(entorno.ObtenerValor(this.ListaR1[i].Replace(" (id2)", "")));
                        }

                        TiposParametros.Add(TipoRetorno.Replace(" ", ""));
                    }
                    Boolean MismosParametros = entorno.MismosParametros2Proc(NombreProcedimiento, TiposParametros);

                    if (MismosParametros == true)
                    {
                        List <String> Listaxx = new List <String>();
                        Listaxx = entorno.MismosParametros3Proc(NombreProcedimiento, TiposParametros);
                        Entorno Xx = new Entorno();

                        //Xx = entorno;
                        for (int i = 0; i < Listaxx.Count; i++)
                        {
                            string[] separadasx;
                            separadasx = Listaxx[i].Split('*');
                            System.Diagnostics.Debug.WriteLine("Tipo: " + separadasx[0] + " Nombre: " + separadasx[1] + " Valor: " + ValoresParametros[i]);
                            Xx.Agregar(separadasx[1], separadasx[0], ValoresParametros[i]);
                        }
                        NodoAbstracto Nodo = entorno.ElNodoParametrosProc(NombreProcedimiento, TiposParametros);
                        System.Diagnostics.Debug.WriteLine("ROMEOLOG" + Listaxx.Count);
                        String valor1  = "";
                        String Retorno = "";
                        entorno.NuevasFunciones(Xx);
                        entorno.NuevasVariables(Xx);
                        //foreach (NodoAbstracto sentencia in Nodo.Hijos)
                        for (int pu = 0; pu < Nodo.Hijos.Count; pu++)
                        {
                            ///Espacio para Agregar variables


                            valor1 = Nodo.Hijos[pu].Ejecutar(Xx);
                            if (valor1.Contains("#Error") == true)
                            {
                                System.Diagnostics.Debug.WriteLine("errroESTAMOS DENTRO DEL if");
                                return(valor1);
                                //return "#Error";
                            }
                            if (valor1.Contains("RETORNO:") == true)
                            {
                                System.Diagnostics.Debug.WriteLine("cahiasdjfiassssssssssssssssssssss");
                                Retorno = valor1;
                                break;
                            }
                        }

                        ///eliminar funciones

                        System.Diagnostics.Debug.WriteLine("valor retorno: " + Retorno);
                        Retorno = Retorno.TrimEnd('?').Replace("RETORNO:", "");
                        string[] separadasX;
                        separadasX = Retorno.Split('?');

                        if (separadasX.Length != this.ListaID1.Count)
                        {
                            System.Diagnostics.Debug.WriteLine("#ERROR EN PROC RETORNOS NO COINCIDEN EN CATIDAD");
                            return("#ERROR EN PROC123 " + NombreProcedimiento + "RETORNOS NO COINCIDEN EN CATIDAD");
                        }
                        else
                        {
                            for (int i = 0; i < separadasX.Length; i++)
                            {
                                string[] separadasXy;
                                separadasXy = separadasX[i].Split(',');
                                System.Diagnostics.Debug.WriteLine(this.ListaID1[i] + "#Retorno" + separadasXy[1]);
                                String eltipo = entorno.ObtenerTipo(this.ListaID1[i]);
                                if (eltipo.ToUpper().Contains(separadasXy[1].ToUpper()) == false)
                                {
                                    return("#ERROR EN PROC123 RETORNOS NO COINCIDEN EN tipo");
                                }
                            }
                            //codigo para asignar variables
                            System.Diagnostics.Debug.WriteLine("VAMOOOOOOOOOS ASIGNAR");
                            for (int i = 0; i < separadasX.Length; i++)
                            {
                                string[] separadasXy;
                                separadasXy = separadasX[i].Split(',');
                                System.Diagnostics.Debug.WriteLine(this.ListaID1[i] + "#Retorno" + separadasXy[0]);
                                String eltipo = entorno.ObtenerTipo(this.ListaID1[i]);

                                entorno.AsignarValor(this.ListaID1[i], separadasXy[0]);
                            }
                        }
                    }
                    else
                    {
                    }
                }
                else
                {
                    return("#ERROR111 NumberReturnsException: " + NombreProcedimiento + " la cantidad de variables de retorno no coincide con la cantidad de retornos ");
                }
            }
            else
            {
                return("#ERROR PROC123 " + NombreProcedimiento + " NO EXISTENTE");
            }
            return("CALL");
        }