public Object crearTabla(ZContenedor e)
{
if (!data.Exists(v => v is NodoCrearNombre) || !data.Exists(v => v is NodoColumns))
{
throw new SemanticError(" no se definio el atrbuto tipo o los parametros del objeto");
}
string nombre = (string)data.First(v => v is NodoCrearNombre).ejecutar(e);
NodoColumns nC = (NodoColumns)data.First(v => v is NodoColumns);
nC.definirTabla(nombre);
nC.ejecutar(e);
Tabla tab = Dbms.getBd().getTabla(nombre);
if (!data.Exists(v => v is NodoData))
{
throw new SemanticError("no existe este el atributo data");
}
NodoData nD = (NodoData)data.First(v => v is NodoData);
List <NodoFila> nodoFilas = nD.Filas;
foreach (NodoFila nodo in nodoFilas)
{
ZFila entorno = tab.crearFila();
nodo.ejecutar(entorno);
tab.addFila(entorno);
}
//-------------------------------------------------------------
return(null);
}
public override object ejecutarSinposicion(ZContenedor e)
{
bd = Dbms.BdSeleccionada;
if (!data.Exists(v => v is NodoObtenerTipo))
{
throw new SemanticError(" no se definio el atrbuto tipo");
}
var nTipo = data.First(v => v is NodoObtenerTipo);
string tipo = (string)nTipo.ejecutar(e);
if (tipo.Equals("object"))
{
return(crearObjeto(e));
}
if (tipo.Equals("table"))
{
return(crearTabla(e));
}
if (tipo.Equals("procedure"))
{
return(crearProc(e));
}
return(null);
}
public override object ejecutarSinposicion(ZContenedor e)
{
while (Utilidades.evaluarCondicion(exp, e).obtenerValor())
{
ZContenedor local = new ZContenedor(e, null);
local.enFuncion = e.enFuncion;
local.enProcedimiento = e.enProcedimiento;
var result = Utilidades.ejecutarSentencias(lInstrucciones, local);
if (result is NodoBreak)
{
return(null);
}
if (result is NodoContinue)
{
continue;
}
if (result is Retorno || result is RetornoProc)
{
return(result);
}
}
return(null);
}
public ZContenedor casteoExplicitoCadnea(ZContenedor valor)
{
if (valor is ZDate n1)
{
return(new ZCadena(n1.stringBonito()));
}
if (valor is ZTiempo n2)
{
return(new ZCadena(n2.stringBonito()));
}
if (valor is ZNumero n3)
{
return(new ZCadena(n3.obtenerValor() + ""));
}
if (valor is ZDecimal n4)
{
return(new ZCadena(n4.obtenerValor() + ""));
}
if (valor is ZCadena)
{
return(valor);
}
throw new SemanticError("se esta intentando castear un tipo a string no compatible");
}
public object crearProc(ZContenedor e)
{
if (!data.Exists(v => v is NodoCrearNombre) || !data.Exists(v => v is NodoParametro) ||
!data.Exists(v => v is NodoCrearInstruProc))
{
throw new SemanticError(" no se definio el atrbuto tipo o los parametros del procedimiento");
}
string nombre = (string)data.First(v => v is NodoCrearNombre).ejecutar(e);
List <NodoCrearParametro> list = (List <NodoCrearParametro>)data.First(v => v is NodoParametro).ejecutar(e);
List <NodoDeclararParametro> lEntrada = new List <NodoDeclararParametro>();
List <NodoDeclararParametro> lSalida = new List <NodoDeclararParametro>();
foreach (NodoCrearParametro nodo in list)
{
if (nodo.isIn())
{
lEntrada.Add((NodoDeclararParametro)nodo.ejecutar(e));
}
else
{
lSalida.Add((NodoDeclararParametro)nodo.ejecutar(e));
}
}
List <Instruccion> lis = (List <Instruccion>)data.First(v => v is NodoCrearInstruProc).ejecutar(e);
NodoDeclararProce nProc = new NodoDeclararProce(nombre, lEntrada, lSalida, lis);
return(nProc.ejecutar(e));
}
public void ejecutarAnalizador(string entrada)
{
AnalizadorChison analizador = new AnalizadorChison();
Parser parser = new Parser(analizador);
ParseTree arbol = parser.Parse(entrada);
ParseTreeNode raiz = arbol.Root;
if (raiz == null || arbol.ParserMessages.Count > 0 || arbol.HasErrors())
{
if (raiz == null || arbol.ParserMessages.Count > 0 || arbol.HasErrors())
{
//---------------------> Hay Errores
foreach (var item in arbol.ParserMessages)
{
MessageBox.Show("Error->" + item.Message + " Line:" + item.Location.Line);
}
return;
}
}
List <Instruccion> listIns = (List <Instruccion>)arbol.Root.AstNode;
ZContenedor global = new ZContenedor(null, null);
Dbms.cargarTedeUs();
EjecutarAnalizadorCQL.loadToday(global);
EjecutarAnalizadorCQL.loadNow(global);
Utilidades.ejecutarSenteciass(listIns, global);
BaseDeDatos bd = Dbms.BdSeleccionada;
Console.WriteLine("--- analizado chison ---");
}
public override object ejecutarSinposicion(ZContenedor e)
{
Tabla tab = Dbms.getBd().getTabla(nombreTabla);
tab.alterAdd(encabezados);
return(null);
}
public override object ejecutarSinposicion(ZContenedor e)
{
var sim = i1.ejecutar(e);
if (sim is Simbolo s1)
{
var val = Utilidades.desenvolver(s1);
if (val is ZNumero n1)
{
ZNumero novo = new ZNumero(n1.obtenerValor() - 1);
s1.definirValor(novo);
return(new ZNumero(n1.obtenerValor()));
}
if (val is ZDecimal n2)
{
ZDecimal novo = new ZDecimal(n2.obtenerValor() - 1);
s1.definirValor(novo);
return(new ZDecimal(n2.obtenerValor()));;
}
throw new SemanticError("error en exp--; tipos no compatbiles");
}
throw new SemanticError("el lado izquierdo no es un simbolo exp--");
}
public override object ejecutarSinposicion(ZContenedor e)
{
TeDeU tipo = e.getTeDeU("int");
tipo.isCount = true;
return(tipo);
}
public override object ejecutarSinposicion(ZContenedor e)
{
if (entrada == "")
{
return(new List <Instruccion>());
}
AnalizadorCQL an = new AnalizadorCQL();
Parser parser = new Parser(an);
ParseTree arbol = parser.Parse(entrada);
ParseTreeNode raiz = arbol.Root;
//verificar si el arbol no sta nulo
if (raiz == null || arbol.ParserMessages.Count > 0 || arbol.HasErrors())
{
if (raiz == null || arbol.ParserMessages.Count > 0 || arbol.HasErrors())
{
//---------------------> Hay Errores
foreach (var item in arbol.ParserMessages)
{
MessageBox.Show("Error->" + item.Message + " Line:" + item.Location.Line);
}
return(null);
}
}
List <Instruccion> listIns = (List <Instruccion>)arbol.Root.AstNode;
return(listIns ?? new List <Instruccion>());
}
public override object ejecutarSinposicion(ZContenedor e)
{
BaseDeDatos bd = Dbms.crearBDChison(nombre);
Dbms.seleccionarBaseDeDatos(nombre);
return(bd);
}
public virtual ZContenedor ejecutarFuncion(List <ZContenedor> argumentos)
{
ZContenedor ambitoFuncion = new ZContenedor(ambitoCapturado, null);
ambitoFuncion.enFuncion = true;
//los argumentos ya estan desembueltos
for (int i = 0; i < nodosDeclararParametro.Count; i++)
{
Simbolo sim = (Simbolo)nodosDeclararParametro[i].ejecutarSinposicion(ambitoFuncion);
sim.definirValor(argumentos[i]);
}
var result = Utilidades.ejecutarSentencias(listaInstrucciones, ambitoFuncion);
//las funciones siempre tienn que retornar algo
if (!(result is Retorno r))
{
throw new SemanticError("Error la funcion no devuelve nignun valor");
}
if (tipoRetorno == r.Tipo || r.Tipo == TiposPrimitivos.tipoNulo)
{
return(r.Valor); //valor es un Z o sea un z valor
}
throw new SemanticError("Error la funcion, no es del mismo tipo con el que se retorna");
}
public override object ejecutarSinposicion(ZContenedor e)
{
var algo1 = i1.ejecutar(e);
var algo2 = i2.ejecutar(e);
ZContenedor valor1 = Utilidades.desenvolver(algo1);
ZContenedor valor2 = Utilidades.desenvolver(algo2);
if (valor1 is ZNumero n1 && valor2 is ZNumero n2)
{
return(new ZNumero(n1.obtenerValor() % n2.obtenerValor()));
}
if (valor1 is ZDecimal n11 && valor2 is ZDecimal n12)
{
return(new ZDecimal(n11.obtenerValor() % n12.obtenerValor()));
}
if (valor1 is ZNumero n111 && valor2 is ZDecimal n122)
{
return(new ZDecimal(n111.obtenerValor() % n122.obtenerValor()));
}
if (valor1 is ZDecimal n11a && valor2 is ZNumero n12b)
{
return(new ZDecimal(n11a.obtenerValor() % n12b.obtenerValor()));
}
throw new SemanticError("Error; operacion % no compatible con tipos");
}
public static ZBool IgualIgual(ZContenedor valor1, ZContenedor valor2)
{
if (valor1 is ZBool b1 && valor2 is ZBool b2)
{
return(new ZBool(b1.obtenerValor() == b2.obtenerValor()));
}
if (valor1 is ZCadena c1 && valor2 is ZCadena c2)
{
return(new ZBool(c1.obtenerValor() == c2.obtenerValor()));
}
if (valor1 is ZDecimal d1 && valor2 is ZDecimal d2)
{
return(new ZBool(d1.obtenerValor() == d2.obtenerValor()));
}
if (valor1 is ZNumero n1 && valor2 is ZNumero n2)
{
return(new ZBool(n1.obtenerValor() == n2.obtenerValor()));
}
if (valor1 is ZNumero n3 && valor2 is ZDecimal d3)
{
return(new ZBool(n3.obtenerValor() == d3.obtenerValor()));
}
if (valor1 is ZDecimal d4 && valor2 is ZNumero n4)
{
return(new ZBool(d4.obtenerValor() == n4.obtenerValor()));
}
if (valor1 is ZDate d5 && valor2 is ZDate n5)
{
return(new ZBool(d5.obtenerValor().Equals(n5.obtenerValor())));
}
if (valor1 is ZTiempo d6 && valor2 is ZTiempo n6)
{
return(new ZBool(d6.obtenerValor().Equals(n6.obtenerValor())));
}
if ((valor1 is ZInstancia || valor1.Origen == TiposPrimitivos.tipoNulo) && (valor2 is ZInstancia || valor2.Origen == TiposPrimitivos.tipoNulo))
{
return(new ZBool(valor1 == valor2));
}
if (valor1 is ZCadena d9 && valor2 is ZNull)
{
return(new ZBool(d9.obtenerValor() == null));
}
if (valor1 is ZNull && valor2 is ZCadena d10)
{
return(new ZBool(d10.obtenerValor() == null));
}
return(null);
}
public void pruebaCqlFuncionesList()
{
var entrada = @"
list<int> ids = [];
log(ids);
ids.insert(1993);
ids.insert(93);
ids.insert(17);
log(ids);
log(ids.get(1));
ids.set(1, 993);
log(ids);
ids.remove(1);
log(ids);
log(ids.size());
log(ids.contains(17));
log(ids.contains(18));
ids.clear();
log(ids);
";
var an = new AnalizadorCQL();
var parser = new Parser(an);
var arbol = parser.Parse(entrada);
var mensajes = arbol
.ParserMessages
.Select(message => $"{message.Location} - {message.Message}")
;
var errores = string.Join("\n", mensajes);
Assert.IsFalse(arbol.HasErrors(), errores);
List <Instruccion> listIns = (List <Instruccion>)arbol.Root.AstNode;
ZContenedor global = new ZContenedor(null, null);
Dbms.cargarTedeUs();
Utilidades.cargarFuncionesNativas(global);
//funciones
// loadToday(global);
// loadNow(global);
Utilidades.ejecutarSentencias(listIns, global);
}
public RetornoProc enProcedimiento(ZContenedor e)
{
NodoCrearTupla aux = new NodoCrearTupla(listaExp);
ZTupla tupla = (ZTupla)aux.ejecutar(e);
RetornoProc ret = new RetornoProc(tupla);
return(ret);
}
public override object ejecutarSinposicion(ZContenedor e)
{
ZBool cond = Utilidades.evaluarCondicion(condicion, e);
return(cond.obtenerValor()
? Utilidades.desenvolver(valor1.ejecutar(e))
: Utilidades.desenvolver(valor2.ejecutar(e)));
}
public override object ejecutarSinposicion(ZContenedor e)
{
Object algo = exp.ejecutar(e);
ZContenedor zAlgo = Utilidades.desenvolver(algo);
Simbolo sim = acPunto(zAlgo, id);
return(sim);
}
public override object ejecutarSinposicion(ZContenedor e)
{
Tabla tab = Dbms.getBd().getTabla(id);
tab.truncate();
return(null);
}
public override object ejecutarSinposicion(ZContenedor e)
{
var algo = expresion.ejecutar(e);
ZContenedor valor = Utilidades.desenvolver(algo);
List <ZContenedor> argumentos = Utilidades.desnvolverArgumento(this.argumentos, e);
return(Utilidades.invocarFuncionPunto(valor, id, argumentos));
}
public override object ejecutarSinposicion(ZContenedor e)
{
Tabla tab = Dbms.getBd().getTabla(nombreTabla);
tab.alterDrop(listaId);
return(null);
}
public override object ejecutarSinposicion(ZContenedor e)
{
TeDeU ti = (TeDeU)tipo.ejecutar(e);
Funcion funcion = new Funcion(ti, parametros, lInsturcciones, e);
e.declararFuncion(id, funcion);
return(null);
}
public override object ejecutarSinposicion(ZContenedor e)
{
BaseDeDatos bd = (BaseDeDatos)this.bd.ejecutar(e);
Utilidades.ejecutarSenteciass(data, e);
return(null);
}
public Simbolo acPunto(ZContenedor Zalgo, string id)
{
if (Zalgo.exsiteVariableActual(id))
{
return(Zalgo.getVariableActual(id));
}
throw new SemanticError("no posee el valor " + id);
}
public void pruebaCqlFuncionesAgregacion()
{
var entrada = @"
create database prueba;
use prueba;
create table alumnos (peso int, edad int);
insert into alumnos values (50, 26);
insert into alumnos values (502, 36);
insert into alumnos values (93, 17);
int algo = count(<<select * from alumnos>>);
log(algo);
int sumaTotal = sum(<< select edad from alumnos >>);
log(sumaTotal);
int promedio = avg(<< select edad from alumnos >>);
log(promedio);
int maximo = max(<< select edad from alumnos >>);
int minimo = min(<< select edad from alumnos >>);
log(maximo);
log(minimo);
";
var an = new AnalizadorCQL();
var parser = new Parser(an);
var arbol = parser.Parse(entrada);
var mensajes = arbol
.ParserMessages
.Select(message => $"{message.Location} - {message.Message}")
;
var errores = string.Join("\n", mensajes);
Assert.IsFalse(arbol.HasErrors(), errores);
List <Instruccion> listIns = (List <Instruccion>)arbol.Root.AstNode;
ZContenedor global = new ZContenedor(null, null);
Dbms.cargarTedeUs();
Utilidades.cargarFuncionesNativas(global);
//funciones
// loadToday(global);
// loadNow(global);
Utilidades.ejecutarSentencias(listIns, global);
}
public void setValor(int indice, ZContenedor valor)
{
if (indice < 0 || indice >= this.Elementos.Count)
{
throw new SemanticError($"Accesso [{indice}] fuera de rango [0..{this.Elementos.Count}]");
}
this.Elementos[indice] = valor;
}
public Funcion(TeDeU tipoRetorno, List <NodoDeclararParametro> nodosDeclararParametro, List <Instruccion> listaInstrucciones, ZContenedor ambitoCapturado)
{
this.tipoRetorno = tipoRetorno;
this.nodosDeclararParametro = nodosDeclararParametro;
this.listaInstrucciones = listaInstrucciones;
this.ambitoCapturado = ambitoCapturado;
//se valida que el ambito capturado sea una funcion
}
public override object ejecutarSinposicion(ZContenedor e)
{
var tab = (Tabla)tabla.ejecutar(e);
var result = procesarFilas(tab.Filas);
imprimirTabla(result);
return(new ZResultadoQuery(result));
}
public static object ejecutarSenteciass(List <Instruccion> lista, ZContenedor f)
{
foreach (Instruccion ins in lista)
{
ins.ejecutar(f);
}
return(null);
}
public override object ejecutarSinposicion(ZContenedor e)
{
TeDeU nuevoTeDeU = new TeDeU(id);
nuevoTeDeU.definirListaDeclaraciones(listaAtributos);
e.setTeDeU(id, nuevoTeDeU);
//se declara el TeDeU
return(null);
}
