/*
* Constructor de la clase
* @id nombre de la tabla
* @l linea del id
* @c columna del id
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
string user = ambito.usuario;
string baseD = ambito.baseD;
LinkedList <string> mensajes = ambito.mensajes;
if (user.Equals("admin"))
{
Usuario usuario = TablaBaseDeDatos.getUsuario(id);
if (usuario == null)
{
usuario = new Usuario(id, password, new LinkedList <string>());
TablaBaseDeDatos.listaUsuario.AddLast(usuario);
mensajes.AddLast(mensa.message("El usuario: " + id + " se creo exitosamente"));
return("");
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("useralreadyexists", "El usuario: " + id + " ya existe"));
mensajes.AddLast(mensa.error("El usuario: " + id + " ya existe", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("Solo un admin puede crear usuarios, el usuario: " + user + " no es admin", l, c, "Semantico"));
}
return(null);
}
private LinkedList <Attrs> newLista(LinkedList <Attrs> oldList, LinkedList <string> mensajes, BaseDeDatos db)
{
LinkedList <Attrs> newL = new LinkedList <Attrs>();
foreach (Attrs a in oldList)
{
if (a.type.Equals("string") || a.type.Equals("int") || a.type.Equals("double") || a.type.Equals("boolean") || a.type.Equals("map") ||
a.type.Equals("date") || a.type.Equals("time"))
{
newL.AddLast(a);
}
else if (a.type.ToLower().Contains("list") || a.type.ToLower().Contains("map") || a.type.ToLower().Contains("set"))
{
newL.AddLast(a);
}
else if (TablaBaseDeDatos.getUserType(a.type.ToLower(), db) || a.type.ToLower().Equals(id))
{
newL.AddLast(a);
}
else
{
Mensaje mensa = new Mensaje();
mensajes.AddLast(mensa.error("No se reconoce el tipo " + a.type + " en el USER TYPE : " + id, linea, columna, "Semantico"));
}
}
return(newL);
}
/*
* Metodo que ejecutara las acciones
* @ts tabla de simbolos
* @user usuario que ejecuta la accion
* return Mensaje LUP de Correcta accion o Incorrecta
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
BaseDeDatos db = TablaBaseDeDatos.getBase(bd);
if (db == null)
{
ambito.mensajes.AddLast(mensa.error("La base de datos: " + bd + " no existe ", linea, columna, "Semantico"));
ambito.listadoExcepciones.AddLast(new Excepcion("bddontexists", "La base de datos: " + bd + " no existe "));
return(null);
}
if (TablaBaseDeDatos.getEnUso(bd, ambito.usuario))
{
ambito.mensajes.AddLast(mensa.error("La base de datos: " + bd + " esta siendo utilizada por otro usuario ", linea, columna, "Semantico"));
return(null);
}
Usuario usu = TablaBaseDeDatos.getUsuario(ambito.usuario);
if (usu == null && !ambito.usuario.Equals("admin"))
{
ambito.mensajes.AddLast(mensa.error("El usuario: " + ambito.usuario + " no existe ", linea, columna, "Semantico"));
return(null);
}
ambito.baseD = bd;
USO newU = new USO(ambito.baseD, ambito.usuario);
TablaBaseDeDatos.deleteMine(ambito.usuario);
TablaBaseDeDatos.listaEnUso.AddLast(newU);
ambito.mensajes.AddLast(mensa.message("Se esta utilizando la base " + ambito.baseD + " exitosamente"));
return("");
}
public object ejecutar()
{
if (usuario.Equals("admin"))
{
return(true);
}
Usuario user = TablaBaseDeDatos.getUsuario(usuario.ToLower().TrimEnd().TrimStart());
if (user != null)
{
TablaBaseDeDatos.deleteMine(usuario);
return(true);
}
return(false);
}
public Object ejecutar()
{
if (usuario.Equals("admin") && password.Equals("admin"))
{
return(true);
}
Usuario user = TablaBaseDeDatos.getUsuario(usuario.ToLower().TrimEnd().TrimStart());
if (user == null)
{
return(false);
}
System.Diagnostics.Debug.WriteLine("US:" + usuario + "PAS:" + password);
return(password.Equals(user.password));
}
/*
* Metodo de la implementacion de InstruccionCQL
* @ts tabla de simbolos global
* @user usuario que esta ejecutando la accion
* @baseD es la base actual en este caso sera none
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje ms = new Mensaje();
BaseDeDatos db = TablaBaseDeDatos.getBase(id);
//--------------------------- si existe una base de datos pero no tiene un if not exist --------------------------------------------
if (db != null && !ifnot)
{
ambito.listadoExcepciones.AddLast(new Excepcion("bdalreadyexists", " Ya existe una base de datos llamada " + id));
Mensaje mes = new Mensaje();
ambito.mensajes.AddLast(mes.error(" Ya existe una base de datos llamada " + id, linea, columna, "Semantico"));
return(null);
}
else if (db != null)
{
return("");
}
else if (db == null)
{
Objeto ls = new Objeto();
BaseDeDatos newDb = new BaseDeDatos(id, ls);
Usuario us = TablaBaseDeDatos.getUsuario(ambito.usuario);
if (us != null || ambito.usuario.Equals("admin"))
{
Mensaje mes = new Mensaje();
us.bases.AddLast(id);
TablaBaseDeDatos.global.AddLast(newDb);
ambito.mensajes.AddLast(mes.message("La base de datos " + id + "ha sido creada exitosamente"));
return("");
}
else
{
ambito.mensajes.AddLast(ms.error("El usuario: " + ambito.usuario + " no existe", linea, columna, "Semantico"));
}
}
return(null);
}
/*
* Metodo que se encargara de ver si existen los tipos de columnas
* @lista1 nuevas columnas
* @lista2 columnas ya existentes
* @mensajes output de mensajes
*/
public Boolean searchTipo(LinkedList <Columna> lista, LinkedList <string> mensajes, BaseDeDatos db)
{
Mensaje mensa = new Mensaje();
foreach (Columna cc in lista)
{
if (cc.tipo.Equals("string") || cc.tipo.Equals("counter") || cc.tipo.Equals("double") || cc.tipo.Equals("int") || cc.tipo.Equals("boolean") || cc.tipo.Equals("date") || cc.tipo.Equals("time"))
{
}
else if (cc.tipo.Contains("map") || cc.tipo.Contains("list") || cc.tipo.Contains("set"))
{
}
else
{
Boolean existe = TablaBaseDeDatos.getUserType(cc.tipo, db);
if (!existe)
{
mensajes.AddLast(mensa.error("No existe este USER TYPE: " + cc.tipo, l, c, "Sematico"));
return(false);
}
}
}
return(true);
}
/*
* Metodo de la implementacion
* @ts tabla de simbolos global
* @user usuario que ejecuta la accion
* @baseD base de datos donde estamos ejecutando todo
* @mensajes linkedlist con la salida deseada
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje ms = new Mensaje();
BaseDeDatos db = TablaBaseDeDatos.getBase(ambito.baseD);
if (db != null)
{
if (ambito.usuario.Equals("admin"))
{
if (db.buscarProcedure(identificador) == null)
{
db.objetos.procedures.AddLast(new Procedures(id, codigo, identificador, parametros, identificadorOut, retornos, cuerpo));
return("");
}
else
{
ambito.mensajes.AddLast(ms.error("El procedure: " + id + " ya existe en esta DB: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
Usuario us = TablaBaseDeDatos.getUsuario(ambito.usuario);
if (us != null)
{
if (TablaBaseDeDatos.getPermiso(us, ambito.baseD))
{
if (!TablaBaseDeDatos.getEnUso(ambito.baseD, ambito.usuario))
{
if (db.buscarProcedure(identificador) == null)
{
db.objetos.procedures.AddLast(new Procedures(id, codigo, identificador, parametros, identificadorOut, retornos, cuerpo));
return("");
}
else
{
ambito.mensajes.AddLast(ms.error("El procedure: " + id + " ya existe en esta DB: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("La base de datos: " + ambito.baseD + " esta siendo utilizada por otro usuario", l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("El usuario: " + ambito.usuario + " no tiene permisos sobre la DB: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("No se encuentra el usuario: " + ambito.usuario, l, c, "Semantico"));
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("usedbexception", "No existe la base de datos: " + ambito.baseD + " o no se ha usado el comando use"));
ambito.mensajes.AddLast(ms.error("La base de datos ha usar: " + id + " no existe", l, c, "Semantico"));
}
return(null);
}
/*
* Metodo que verificara el tipo a guardar
* @columna columan actual
* @valor es el valor a guardar
* @original es la expresion sin ejecutar
* @mensajes output de salida
* @db BaseDeDatos actual
*/
private Atributo checkinfo(Columna columna, object valor, object original, LinkedList <string> mensajes, BaseDeDatos db, Ambito ambito)
{
Mensaje mensa = new Mensaje();
if (original == null)
{
if (!columna.pk)
{
if (columna.tipo.Equals("string") || columna.tipo.Equals("date") || columna.tipo.Equals("time"))
{
return(new Atributo(columna.name, null, columna.tipo));
}
else if (columna.tipo.Equals("int") || columna.tipo.Equals("double") || columna.tipo.Equals("boolean") || columna.tipo.Contains("map") || columna.tipo.Contains("list") || columna.tipo.Contains("set"))
{
ambito.listadoExcepciones.AddLast(new Excepcion("valuesexception", "No se le puede asignar a un tipo: " + columna.tipo + " un valor null"));
mensajes.AddLast(mensa.error("No se le puede asignar a un tipo: " + columna.tipo + " un valor null", l, c, "Semantico"));
}
else
{
Boolean temp = TablaBaseDeDatos.getUserType(columna.tipo, db);
if (temp)
{
return(new Atributo(columna.name, new InstanciaUserType(columna.tipo, null), columna.tipo));
}
else
{
mensajes.AddLast(mensa.error("No existe el USER TYPE: " + columna.tipo + " en la DB: " + db.nombre, l, c, "Semantico"));
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("valuesexception", "La columna: " + columna.name + " es clave primaria no puede asignarsele un valor null"));
mensajes.AddLast(mensa.error("La columna: " + columna.name + " es clave primaria no puede asignarsele un valor null", l, c, "Semantico"));
}
}
else
{
if (valor != null)
{
if (columna.tipo.Equals("string") && valor.GetType() == typeof(string))
{
return(new Atributo(columna.name, (string)valor, "string"));
}
else if (columna.tipo.Equals("int") && valor.GetType() == typeof(int))
{
return(new Atributo(columna.name, (int)valor, "int"));
}
else if (columna.tipo.Equals("double") && valor.GetType() == typeof(Double))
{
return(new Atributo(columna.name, (Double)valor, "double"));
}
else if (columna.tipo.Equals("boolean") && valor.GetType() == typeof(Boolean))
{
return(new Atributo(columna.name, (Boolean)valor, "boolean"));
}
else if (columna.tipo.Equals("date") && valor.GetType() == typeof(DateTime))
{
return(new Atributo(columna.name, (DateTime)valor, "date"));
}
else if (columna.tipo.Equals("time") && valor.GetType() == typeof(TimeSpan))
{
return(new Atributo(columna.name, (TimeSpan)valor, "time"));
}
else if (columna.tipo.Equals("counter") && valor.GetType() == typeof(int))
{
return(new Atributo(columna.name, (int)valor, "int"));
}
else if (columna.tipo.Contains("map") && valor.GetType() == typeof(Map))
{
Map temp = (Map)valor;
string tipo = columna.tipo.TrimStart('m').TrimStart('a').TrimStart('p').TrimStart('<');
if (tipo.EndsWith('>'))
{
tipo = tipo.Substring(0, tipo.Length - 1);
}
if (temp.id.Equals(tipo))
{
return(new Atributo(columna.name, temp, tipo));
}
mensajes.AddLast(mensa.error("No coinciden los tipos de map: " + tipo + " con: " + temp.id, l, c, "Semantico"));
}
else if (columna.tipo.Contains("set") && valor.GetType() == typeof(Set))
{
Set temp = (Set)valor;
string tipo = columna.tipo.TrimStart('s').TrimStart('e').TrimStart('t').TrimStart('<');
if (tipo.EndsWith('>'))
{
tipo = tipo.Substring(0, tipo.Length - 1);
}
if (temp.id.Equals(tipo))
{
return(new Atributo(columna.name, temp, tipo));
}
mensajes.AddLast(mensa.error("No coinciden los tipos de Set: " + tipo + " con: " + temp.id, l, c, "Semantico"));
}
else if (columna.tipo.Contains("list") && valor.GetType() == typeof(List))
{
List temp = (List)valor;
string tipo = columna.tipo.TrimStart('l').TrimStart('i').TrimStart('s').TrimStart('t').TrimStart('<');
if (tipo.EndsWith('>'))
{
tipo = tipo.Substring(0, tipo.Length - 1);
}
if (temp.id.Equals(tipo))
{
return(new Atributo(columna.name, temp, tipo));
}
mensajes.AddLast(mensa.error("No coinciden los tipos de List: " + tipo + " con: " + temp.id, l, c, "Semantico"));
}
else if (valor.GetType() == typeof(InstanciaUserType))
{
InstanciaUserType temp = (InstanciaUserType)valor;
if (columna.tipo.Equals(temp.tipo))
{
return(new Atributo(columna.name, (InstanciaUserType)valor, columna.tipo));
}
else
{
mensajes.AddLast(mensa.error("No se le puede asignar a la columna: " + columna.name + " un tipo: " + temp.tipo, l, c, "Semantico"));
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("valuesexception", "No se puede asignar a la columna: " + columna.name + " el valor: " + valor));
mensajes.AddLast(mensa.error("No se puede asignar a la columna: " + columna.name + " el valor: " + valor, l, c, "Semantico"));
}
}
else
{
if (columna.tipo.Equals("string") || columna.tipo.Equals("date") || columna.tipo.Equals("time"))
{
return(new Atributo(columna.name, null, columna.tipo));
}
else if (columna.tipo.Equals("boolean") || columna.tipo.Equals("int") || columna.tipo.Equals("double") || columna.tipo.Contains("map") || columna.tipo.Contains("list") || columna.tipo.Contains("set"))
{
ambito.listadoExcepciones.AddLast(new Excepcion("valuesexception", "No se puede asignar a la columna: " + columna.name + " el valor: " + valor + valor));
mensajes.AddLast(mensa.error("No se puede asignar a la columna: " + columna.name + " el valor: " + valor, l, c, "Semantico"));
}
else
{
return(new Atributo(columna.name, new InstanciaUserType(columna.tipo, null), columna.tipo));
}
}
}
return(null);
}
/*
* Constructor de la clase padre
* @ts tabla de simbolos padre
* @user usuario que esta ejecutando las acciones
* @baseD string por referencia de que base de datos estamos trabajando
* @mensajes el output de la ejecucion
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
string baseD = ambito.baseD;
string user = ambito.usuario;
LinkedList <string> mensajes = ambito.mensajes;
BaseDeDatos db = TablaBaseDeDatos.getBase(baseD);
Usuario us = TablaBaseDeDatos.getUsuario(user);
if (db != null)
{
if (user.Equals("admin"))
{
Tabla tabla = TablaBaseDeDatos.getTabla(db, id);
if (tabla != null)
{
object res;
if (operacion.Equals("NORMAL"))
{
res = guardarNormal(tabla, ts, db, ambito, tsT);
}
else
{
res = guardadoEspecial(tabla, ts, db, ambito, tsT);
}
if (res != null)
{
return(res);
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("tabledontexists", "La tabla: " + id + " no existe en la DB: " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("La tabla: " + id + " no existe en la DB: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
if (us != null)
{
Boolean permiso = TablaBaseDeDatos.getPermiso(us, baseD);
if (permiso)
{
Boolean enUso = TablaBaseDeDatos.getEnUso(baseD, user);
if (!enUso)
{
Tabla tabla = TablaBaseDeDatos.getTabla(db, id);
if (tabla != null)
{
object res;
if (operacion.Equals("NORMAL"))
{
res = guardarNormal(tabla, ts, db, ambito, tsT);
}
else
{
res = guardadoEspecial(tabla, ts, db, ambito, tsT);
}
if (res != null)
{
return(res);
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("tabledontexists", "La tabla: " + id + " no existe en la DB: " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("La tabla: " + id + " no existe en la DB: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("La DB: " + baseD + " ya esta siendo utilizada por alguien mas", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("El usuario " + user + " no tiene permisos sobre esta base de datos", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("El usuario " + user + " no existe", l, c, "Semantico"));
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("usedbexception", "No existe la base de datos: " + ambito.baseD + " o no se ha usado el comando use"));
ambito.mensajes.AddLast(mensa.error("La base de datos ha usar: " + ambito.baseD + " no existe", l, c, "Semantico"));
}
return(null);
}
/*
* Metodo de la implementacion
* @ts tabla de simbolos global
* @user usuario que ejecuta la accion
* @baseD base de datos donde estamos ejecutando todo
* @mensajes linkedlist con la salida deseada
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
object a = (valor == null) ? null : valor.ejecutar(ts, ambito, tsT);
LinkedList <string> mensajes = ambito.mensajes;
object res = ts.getValor(id);
string baseD = ambito.baseD;
string existe = (res == null) ? "si" : res.ToString();
if (parametro)
{
ts.AddLast(new Simbolo(tipo, id));
if (tipo.Equals("list"))
{
ts.setValor(id, new List("none", new LinkedList <object>()));
}
else if (tipo.Equals("set"))
{
ts.setValor(id, new Set("none", new LinkedList <object>()));
}
else if (tipo.Equals("map"))
{
ts.setValor(id, new Map("none", new LinkedList <KeyValue>()));
}
else if (tipo.Equals("string") || tipo.Equals("int") || tipo.Equals("double") || tipo.Equals("date") || tipo.Equals("time") || tipo.Equals("boolean") || tipo.Equals("cursor"))
{
}
else
{
ts.setValor(id, new InstanciaUserType("none", new LinkedList <Atributo>()));
}
return("");
}
else if (existe.Equals("none"))
{
if (valor == null)
{
if (tipo.Equals("int"))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, 0);
}
else if (tipo.Equals("double"))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, 0.0);
}
else if (tipo.Equals("boolean"))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, false);
}
else if (tipo.Equals("string") || tipo.Equals("date") || tipo.Equals("time"))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, null);
return("");
}
else if (tipo.Equals("map"))
{
mensajes.AddLast(mensa.error("El tipo MAP necesita ser instanciado", l, c, "Semantico"));
return(null);
}
else if (tipo.Equals("list"))
{
mensajes.AddLast(mensa.error("El tipo LIST necesita ser instanciado", l, c, "Semantico"));
return(null);
}
else if (tipo.Equals("set"))
{
mensajes.AddLast(mensa.error("El tipo SET necesita ser instanciado", l, c, "Semantico"));
return(null);
}
else if (tipo.Equals("cursor"))
{
mensajes.AddLast(mensa.error("El tipo CURSOR necesita ser instanciado", l, c, "Semantico"));
return(null);
}
else
{
BaseDeDatos bd = TablaBaseDeDatos.getBase(baseD);
if (bd != null)
{
if (TablaBaseDeDatos.getUserType(tipo.ToLower(), bd))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, new InstanciaUserType(tipo, null));
}
else
{
mensajes.AddLast(mensa.error("El tipo " + tipo + " no es un userType en esta base de datos: " + baseD, l, c, "Semantico"));
return(null);
}
}
return("");
}
}
else
{
if (a != null)
{
if (tipo.Equals("string") && a.GetType() == typeof(string))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, (string)a);
}
else if (tipo.Equals("int") && a.GetType() == typeof(int))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, (int)a);
}
else if (tipo.Equals("int") && a.GetType() == typeof(Double))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, Convert.ToInt32((Double)a));
}
else if (tipo.Equals("double") && a.GetType() == typeof(Double))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, (Double)a);
}
else if (tipo.Equals("double") && a.GetType() == typeof(int))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, Convert.ToDouble((int)a));
}
else if (tipo.Equals("boolean") && a.GetType() == typeof(Boolean))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, (Boolean)a);
}
else if (tipo.Equals("date") && a.GetType() == typeof(DateTime))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, (DateTime)a);
}
else if (tipo.Equals("time") && a.GetType() == typeof(TimeSpan))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, (TimeSpan)a);
}
else if (tipo.Equals("map") && a.GetType() == typeof(Map))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, (Map)a);
}
else if (tipo.Equals("list") && a.GetType() == typeof(List))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, (List)a);
}
else if (tipo.Equals("set") && a.GetType() == typeof(Set))
{
ts.AddLast(new Simbolo(tipo, id));
Set temp = (Set)a;
object resp = temp.buscarRepetidos(mensajes, l, c);
if (resp == null)
{
return(null);
}
temp.order();
ts.setValor(id, temp);
}
else if (tipo.Equals("cursor") && a.GetType() == typeof(TypeCursor))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, (TypeCursor)a);
}
else if (a.GetType() == typeof(InstanciaUserType))
{
InstanciaUserType ins = (InstanciaUserType)a;
if (tipo.Equals(ins.tipo.ToLower()))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, ins);
}
else
{
Mensaje me = new Mensaje();
mensajes.AddLast(me.error("La variable " + id + " es de Tipo: " + tipo + " no se puede instanciar al tipo: " + ins.tipo, l, c, "Semantico"));
}
}
else
{
Mensaje me = new Mensaje();
mensajes.AddLast(me.error("La variable " + id + " no se le puede asignar este valor " + a.ToString(), l, c, "Semantico"));
return(null);
}
return("");
}
else
{
if (tipo.Equals("string") || tipo.Equals("date") || tipo.Equals("time"))
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, null);
}
else if (tipo.Equals("int") || tipo.Equals("double") || tipo.Equals("map") || tipo.Equals("set") || tipo.Equals("list") || tipo.Equals("cursor") || tipo.Equals("boolean"))
{
mensajes.AddLast(mensa.error("No se le puede asignar un valor null al tipo: " + tipo, l, c, "Semantico"));
return(null);
}
else
{
ts.AddLast(new Simbolo(tipo, id));
ts.setValor(id, new InstanciaUserType(tipo, null));
}
return("");
}
}
}
else
{
Mensaje me = new Mensaje();
ambito.listadoExcepciones.AddLast(new Excepcion("objectalreadyexists", "La variable " + id + " ya existe en este ambito"));
mensajes.AddLast(me.error("La variable " + id + " ya existe en este ambito", l, c, "Semantico"));
}
return(null);
}
/*
* Constructor de la clase padre
* @ts tabla de simbolos padre
* @user usuario que esta ejecutando las acciones
* @baseD string por referencia de que base de datos estamos trabajando
* @mensajes el output de la ejecucion
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
string user = ambito.usuario;
string baseD = ambito.baseD;
LinkedList <string> mensajes = ambito.mensajes;
BaseDeDatos db = TablaBaseDeDatos.getBase(baseD);
Usuario us = TablaBaseDeDatos.getUsuario(user);
if (db != null)
{
if (user.Equals("admin"))
{
Tabla tabla = TablaBaseDeDatos.getTabla(db, id);
if (tabla != null)
{
LinkedList <Columna> cabecera = new LinkedList <Columna>();
if (campos == null)
{
cabecera = new LinkedList <Columna>(cabecera.Union(tabla.columnas));
}
else
{
cabecera = getColumnas(tabla, ts, ambito);
}
if (cabecera != null)
{
LinkedList <Data> datos = new LinkedList <Data>();
if (campos == null)
{
datos = getAllData(tabla, ts, ambito, cabecera);
}
else
{
datos = getData(tabla, ts, ambito, cabecera);
}
if (datos != null)
{
TablaSelect tablaSelect = new TablaSelect(cabecera, datos);
System.Diagnostics.Debug.WriteLine(operacion);
if (operacion.Equals("none"))
{
}
else
{
if (operacion.Contains("b"))
{
if (checkOrder(tablaSelect.columnas, mensajes))
{
LinkedList <int> pos = posicionesColumnas(tablaSelect.columnas);
try
{
if (pos.Count() > 0)
{
tablaSelect.datos = new LinkedList <Data>(sort(tablaSelect.datos, pos, 0));
}
}
catch (Exception)
{
mensajes.AddLast(mensa.error("Esta intentando ordenar por un dato no primitivo", l, c, "Semantico"));
}
}
else
{
return(null);
}
}
if (operacion.Contains("c"))
{
tablaSelect.datos = limitar(tablaSelect.datos, ts, ambito, tsT);
if (datos == null)
{
return(null);
}
}
}
mensajes.AddLast(mensa.consulta(tablaSelect));
return(tablaSelect);
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("tabledontexists", "La tabla: " + id + " no existe en la DB: " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("La tabla: " + id + " no existe en la DB: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
if (us != null)
{
Boolean permiso = TablaBaseDeDatos.getPermiso(us, baseD);
if (permiso)
{
Boolean enUso = TablaBaseDeDatos.getEnUso(baseD, user);
if (!enUso)
{
Tabla tabla = TablaBaseDeDatos.getTabla(db, id);
if (tabla != null)
{
LinkedList <Columna> cabecera = new LinkedList <Columna>();
if (campos == null)
{
cabecera = new LinkedList <Columna>(cabecera.Union(tabla.columnas));
}
else
{
cabecera = getColumnas(tabla, ts, ambito);
}
if (cabecera != null)
{
LinkedList <Data> datos = new LinkedList <Data>();
if (campos == null)
{
datos = getAllData(tabla, ts, ambito, cabecera);
}
else
{
datos = getData(tabla, ts, ambito, cabecera);
}
if (datos != null)
{
TablaSelect tablaSelect = new TablaSelect(cabecera, datos);
System.Diagnostics.Debug.WriteLine(operacion);
if (operacion.Equals("none"))
{
}
else
{
if (operacion.Contains("b"))
{
if (checkOrder(tablaSelect.columnas, mensajes))
{
LinkedList <int> pos = posicionesColumnas(tablaSelect.columnas);
try
{
if (pos.Count() > 0)
{
tablaSelect.datos = new LinkedList <Data>(sort(tablaSelect.datos, pos, 0));
}
}
catch (Exception)
{
mensajes.AddLast(mensa.error("Esta intentando ordenar por un dato no primitivo", l, c, "Semantico"));
}
}
else
{
return(null);
}
}
if (operacion.Contains("c"))
{
tablaSelect.datos = limitar(tablaSelect.datos, ts, ambito, tsT);
if (datos == null)
{
return(null);
}
}
}
mensajes.AddLast(mensa.consulta(tablaSelect));
return(tablaSelect);
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("tabledontexists", "La tabla: " + id + " no existe en la DB: " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("La tabla: " + id + " no existe en la DB: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("La DB: " + baseD + " ya esta siendo utilizada por alguien mas", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("El usuario " + user + " no tiene permisos sobre esta base de datos", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("El usuario " + user + " no existe", l, c, "Semantico"));
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("usedbexception", "No existe la base de datos: " + ambito.baseD + " o no se ha usado el comando use"));
ambito.mensajes.AddLast(mensa.error("La base de datos ha usar: " + ambito.baseD + " no existe", l, c, "Semantico"));
}
return(null);
}
/*
* Constructor de la clase padre
* @ts tabla de simbolos padre
* @user usuario que esta ejecutando las acciones
* @baseD string por referencia de que base de datos estamos trabajando
* @mensajes el output de la ejecucion
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
string user = ambito.usuario;
string baseD = ambito.baseD;
LinkedList <string> mensajes = ambito.mensajes;
BaseDeDatos db = TablaBaseDeDatos.getBase(baseD);
if (db != null)
{
if (user.Equals("admin"))
{
Tabla tabla = TablaBaseDeDatos.getTabla(db, id);
if (tabla != null)
{
db.objetos.tablas.Remove(tabla);
mensajes.AddLast(mensa.message("La tabla: " + id + " fue eliminada con exito"));
return("");
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("tabledontexists", "La tabla: " + id + " no existe en la DB: " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("La tabla: " + id + " no existe en la DB: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
Usuario usuario = TablaBaseDeDatos.getUsuario(user);
if (usuario != null)
{
Boolean permiso = TablaBaseDeDatos.getPermiso(usuario, baseD);
if (permiso)
{
Boolean enUso = TablaBaseDeDatos.getEnUso(baseD, user);
if (!enUso)
{
Tabla tabla = TablaBaseDeDatos.getTabla(db, id);
if (tabla != null)
{
db.objetos.tablas.Remove(tabla);
mensajes.AddLast(mensa.message("La tabla: " + id + " fue eliminada con exito"));
return("");
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("tabledontexists", "La tabla: " + id + " no existe en la DB: " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("La tabla: " + id + " no existe en la DB: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("La DB: " + baseD + " esta siendo utilizada por otro usuario", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("El usuario " + user + " no tiene permisos en la DB: " + baseD, l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("No existe el usuario: " + user, l, c, "Semantico"));
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("usedbexception", "No existe la base de datos: " + ambito.baseD + " o no se ha usado el comando use"));
ambito.mensajes.AddLast(mensa.error("La base de datos ha usar: " + ambito.baseD + " no existe", l, c, "Semantico"));
}
return(null);
}
/*
* CONSTRUCTOR DE LA CLASE PADRE
* @return string con la informacion
*/
public object ejecutar()
{
string salida = "[+DATABASES]\n";
Usuario user = TablaBaseDeDatos.getUsuario(usuario);
if (user != null)
{
LinkedList <string> lista = user.bases;
foreach (string s in lista)
{
BaseDeDatos db = TablaBaseDeDatos.getBase(s);
if (db != null)
{
salida += "[+DATABASE]\n";
salida += "[+NAME]\n" + db.nombre + "\n[-NAME]\n";
salida += "[+TABLES]\n";
//---------------------------------------- TABLAS -------------------------------------------------------
foreach (Tabla t in db.objetos.tablas)
{
salida += "[+TABLE]\n";
salida += "[+NAME]\n" + t.nombre + "\n[-NAME]\n";
salida += "[+COLUMNS]\n";
foreach (Columna c in t.columnas)
{
salida += "[+COLUMN]\n" + c.name + "\n[-COLUMN]\n";
}
salida += "[-COLUMNS]\n";
salida += "[-TABLE]\n";
}
salida += "[-TABLES]\n";
//-------------------------------------------- USER TYPE ----------------------------------------------------
salida += "[+TYPES]\n";
foreach (User_Types u in db.objetos.user_types)
{
salida += "[+TYPE]\n";
salida += "[+NAME]\n" + u.name + "\n[-NAME]\n";
salida += "[+ATTRIBUTES]\n";
foreach (Attrs a in u.type)
{
salida += "[+ATTRIBUTE]\n";
salida += a.name + "\n";
salida += "[-ATTRIBUTE]\n";
}
salida += "[-ATTRIBUTES]\n";
salida += "[-TYPE]\n";
}
salida += "[-TYPES]\n";
//----------------------------------------------- PROCEDURES --------------------------------------------------
salida += "[+PROCEDURES]\n";
foreach (Procedures p in db.objetos.procedures)
{
salida += "[+PROCEDURE]\n";
salida += p.nombre + "\n";
salida += "[-PROCEDURE]\n";
}
salida += "[-PROCEDURES]\n";
salida += "[-DATABASE]\n";
}
}
}
salida += "[-DATABASES]";
return(salida);
}
/*
* Metodo del padre
* @ts tabla de simbolos global
* @user usuario que esta ejecutando la accion
* @baseD base de datos donde se esta ejecutando la accion
* @mensajes respuesta por parte de la accion
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
BaseDeDatos db = TablaBaseDeDatos.getBase(ambito.baseD);
if (db != null)
{
if (ambito.usuario.Equals("admin"))
{
if (!TablaBaseDeDatos.getUserType(id, db))
{
LinkedList <Attrs> newL = newLista(lista, ambito.mensajes, db);
if (lista.Count() == newL.Count())
{
User_Types u = new User_Types(id, newL);
db.objetos.user_types.AddLast(u);
}
return("");
}
else
{
if (!flag)
{
ambito.listadoExcepciones.AddLast(new Excepcion("typealreadyexists", "El USER TYPE : " + id + " ya existe en la base de datos : " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("El USER TYPE : " + id + " ya existe en la base de datos : " + ambito.baseD, linea, columna, "Semantico"));
}
else
{
return("");
}
}
}
else
{
Usuario us = TablaBaseDeDatos.getUsuario(ambito.usuario);
if (us != null)
{
if (TablaBaseDeDatos.getPermiso(us, ambito.baseD))
{
if (!TablaBaseDeDatos.getUserType(id, db))
{
LinkedList <Attrs> newL = newLista(lista, ambito.mensajes, db);
if (lista.Count() == newL.Count())
{
User_Types u = new User_Types(id, newL);
db.objetos.user_types.AddLast(u);
}
return("");
}
else
{
if (!flag)
{
ambito.listadoExcepciones.AddLast(new Excepcion("typealreadyexists", "El USER TYPE : " + id + " ya existe en la base de datos : " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("El USER TYPE : " + id + " ya existe en la base de datos : " + ambito.baseD, linea, columna, "Semantico"));
}
else
{
return("");
}
}
}
else
{
ambito.mensajes.AddLast(mensa.error("El usuario : " + ambito.usuario + " no tiene permisos sobre la base de datos : " + ambito.baseD, linea, columna, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(mensa.error("El usuario : " + ambito.usuario + " no existe ", linea, columna, "Semantico"));
}
}
}
else
{
ambito.mensajes.AddLast(mensa.error("La base de datos : " + ambito.baseD + " no existe o seleccione una antes Comando (USE) ", linea, columna, "Semantico"));
}
return(null);
}
/*
* Metodo de la implementacion
* @ts tabla de simbolos global
* @user usuario que ejecuta la accion
* @baseD base de datos donde estamos ejecutando todo
* @mensajes linkedlist con la salida deseada
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
BaseDeDatos db = TablaBaseDeDatos.getBase(id);
Usuario us = TablaBaseDeDatos.getUsuario(ambito.usuario);
string user = ambito.usuario;
string baseD = ambito.baseD;
LinkedList <string> mensajes = ambito.mensajes;
if (db != null)
{
if (ambito.usuario.Equals("admin"))
{
TablaBaseDeDatos.global.Remove(db);
ambito.mensajes.AddLast(mensa.message("La base de datos: " + id + " ha sido eliminada con exito"));
return("");
}
else
{
if (us != null)
{
Boolean permiso = TablaBaseDeDatos.getPermiso(us, id);
if (permiso)
{
Boolean enUso = TablaBaseDeDatos.getEnUso(id, user);
if (!enUso)
{
TablaBaseDeDatos.global.Remove(db);
mensajes.AddLast(mensa.message("La base de datos: " + id + " ha sido eliminada con exito"));
return("");
}
else
{
mensajes.AddLast(mensa.error("La base de datos: " + id + "esta siendo utilizada por otro usuario", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("El usuario " + user + " no tiene permisos sobre esta base de datos", l, c, "Semantico"));
}
}
else
{
if (!flag)
{
mensajes.AddLast(mensa.error("El usuario " + user + " no existe", l, c, "Semantico"));
}
else
{
return("");
}
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("bddontexists", "La base de datos ha eliminar: " + id + " no existe"));
mensajes.AddLast(mensa.error("La base de datos ha eliminar: " + id + " no existe", l, c, "Semantico"));
}
return(null);
}
/*
* Metodo de la implementacion
* @ts tabla de simbolos global
* @user usuario que ejecuta la accion
* @baseD base de datos donde estamos ejecutando todo
* @mensajes linkedlist con la salida deseada
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
BaseDeDatos db = TablaBaseDeDatos.getBase(ambito.baseD);
Usuario usuario = TablaBaseDeDatos.getUsuario(ambito.usuario);
if (db != null)
{
if (ambito.usuario.Equals("admin"))
{
//------------------------------------ SOLO HAY UNA PRIMARIA ------------------------------------------------------------
if (primarias == null)
{
if (!(cantidadDePrimarias(lista) > 1))
{
if (!columnasRepetidas(lista, lista, ambito.mensajes))
{
Tabla old = TablaBaseDeDatos.getTabla(db, nombre);
if (old == null)
{
if (searchTipo(lista, ambito.mensajes, db))
{
Tabla nueva = new Tabla(nombre, lista, new LinkedList <Data>());
db.objetos.tablas.AddLast(nueva);
ambito.mensajes.AddLast(mensa.message("Se creo exitosamente la tabla: " + nombre));
return("");
}
}
else
{
if (flag)
{
return("");
}
ambito.listadoExcepciones.AddLast(new Excepcion("tablealreadyexists", "La tabla: " + nombre + " ya existe en la DB: " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("La tabla: " + nombre + " ya existe en la DB: " + ambito.baseD, l, c, "Semantico"));
return(null);
}
}
}
else
{
ambito.mensajes.AddLast(mensa.error("La tabla: " + nombre + " solo puede tener una clave primaria o use llaves compuestas", l, c, "Semantico"));
}
}
//-------------------------------------- LLAVE PRIMARIA COMPUESTA -------------------------------------------------------
else
{
if (!(cantidadDePrimarias(lista) > 0))
{
if (!(columnasRepetidas(lista, lista, ambito.mensajes)))
{
if (!hayCounter(primarias, lista, ambito.mensajes))
{
if (existenColumnas(primarias, lista, ambito.mensajes))
{
Tabla temp = TablaBaseDeDatos.getTabla(db, nombre);
if (temp == null)
{
if (searchTipo(lista, ambito.mensajes, db))
{
temp = new Tabla(nombre, lista, new LinkedList <Data>());
db.objetos.tablas.AddLast(temp);
ambito.mensajes.AddLast(mensa.message("Se creo exitosamente la tabla: " + nombre));
return("");
}
}
else
{
if (flag)
{
return("");
}
ambito.mensajes.AddLast(mensa.error("La tabla: " + nombre + " ya existe en la DB: " + ambito.baseD, l, c, "Semantico"));
}
}
}
}
}
else
{
ambito.mensajes.AddLast(mensa.error("La tabla: " + nombre + " solo puede tener primarias compuestas", l, c, "Semantico"));
}
}
}
else
{
if (usuario != null)
{
Boolean permiso = TablaBaseDeDatos.getPermiso(usuario, ambito.baseD);
if (permiso)
{
Boolean enUso = TablaBaseDeDatos.getEnUso(ambito.baseD, ambito.usuario);
if (!enUso)
{
//------------------------------------ SOLO HAY UNA PRIMARIA ------------------------------------------------------------
if (primarias == null)
{
if (!(cantidadDePrimarias(lista) > 1))
{
if (!columnasRepetidas(lista, lista, ambito.mensajes))
{
Tabla old = TablaBaseDeDatos.getTabla(db, nombre);
if (old == null)
{
if (searchTipo(lista, ambito.mensajes, db))
{
Tabla nueva = new Tabla(nombre, lista, new LinkedList <Data>());
db.objetos.tablas.AddLast(nueva);
ambito.mensajes.AddLast(mensa.message("Se creo exitosamente la tabla: " + nombre));
return("");
}
}
else
{
if (flag)
{
return("");
}
ambito.listadoExcepciones.AddLast(new Excepcion("tablealreadyexists", "La tabla: " + nombre + " ya existe en la DB: " + ambito.baseD));
ambito.mensajes.AddLast(mensa.error("La tabla: " + nombre + " ya existe en la DB: " + ambito.baseD, l, c, "Semantico"));
return(null);
}
}
}
else
{
ambito.mensajes.AddLast(mensa.error("La tabla: " + nombre + " solo puede tener una clave primaria o use llaves compuestas", l, c, "Semantico"));
}
}
//-------------------------------------- LLAVE PRIMARIA COMPUESTA -------------------------------------------------------
else
{
if (!(cantidadDePrimarias(lista) > 0))
{
if (!(columnasRepetidas(lista, lista, ambito.mensajes)))
{
if (!hayCounter(primarias, lista, ambito.mensajes))
{
if (existenColumnas(primarias, lista, ambito.mensajes))
{
Tabla temp = TablaBaseDeDatos.getTabla(db, nombre);
if (temp == null)
{
if (searchTipo(lista, ambito.mensajes, db))
{
temp = new Tabla(nombre, lista, new LinkedList <Data>());
db.objetos.tablas.AddLast(temp);
ambito.mensajes.AddLast(mensa.message("Se creo exitosamente la tabla: " + nombre));
return("");
}
}
else
{
if (flag)
{
return("");
}
ambito.mensajes.AddLast(mensa.error("La tabla: " + nombre + " ya existe en la DB: " + ambito.baseD, l, c, "Semantico"));
}
}
}
}
}
else
{
ambito.mensajes.AddLast(mensa.error("La tabla: " + nombre + " solo puede tener primarias compuestas", l, c, "Semantico"));
}
}
}
else
{
ambito.mensajes.AddLast(mensa.error("La base de datos: " + ambito.baseD + "esta siendo usada por otro usuario", l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(mensa.error("El usuario: " + ambito.usuario + " no tiene permisos en la base de datos: " + ambito.baseD, l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(mensa.error("No existe el usuario: " + ambito.usuario, l, c, "Semantico"));
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("usedbexception", "No existe la base de datos: " + ambito.baseD + " o no se ha usado el comando use"));
ambito.mensajes.AddLast(mensa.error("No se encuentra la base de datos: " + ambito.baseD + " o no se ha usado el comando USE", l, c, "Semantico"));
}
return(null);
}
/*
* Metodo que se encargara de editar todos los campos
* @ts tabla de simbolos padre
* @user usuario que esta ejecutando las acciones
* @baseD string por referencia de que base de datos estamos trabajando
* @mensajes el output de la ejecucion
* @tsT se encargara de guardar todos los datos en una tabla temporal para la tabla
* @t tabla actual
*/
private object changeAll(TablaDeSimbolos ts, Ambito ambito, Tabla t)
{
Mensaje mensa = new Mensaje();
string baseD = ambito.baseD;
LinkedList <string> mensajes = ambito.mensajes;
BaseDeDatos db = TablaBaseDeDatos.getBase(baseD);
foreach (Data data in t.datos)
{
TablaDeSimbolos tsT = new TablaDeSimbolos();
guardarTemp(data.valores, tsT);
if (checkColumns(t.columnas, mensajes, ambito))
{
foreach (SetCQL set in asignacion)
{
foreach (Atributo atributo in data.valores)
{
object op1 = (set.valor == null) ? null : set.valor.ejecutar(ts, ambito, tsT);
if (set.operacion.Equals("NORMAL"))
{
if (set.campo.Equals(atributo.nombre))
{
Atributo temp = checkinfo(getColumna(t.columnas, set.campo), op1, set.valor, mensajes, db, ambito);
if (temp != null)
{
atributo.valor = temp.valor;
}
else
{
return(null);
}
}
}
else
{
object op2 = (set.accesoUS == null) ? null : set.accesoUS.ejecutar(ts, ambito, tsT);
if (op2 != null)
{
if (op2.GetType() == typeof(InstanciaUserType))
{
InstanciaUserType temp = (InstanciaUserType)op2;
foreach (Atributo a in temp.lista)
{
if (a.nombre.Equals(set.campo))
{
Columna co = new Columna(a.nombre, a.tipo, false);
Atributo temp2 = checkinfo(co, op1, set.valor, mensajes, db, ambito);
if (temp2 != null)
{
a.valor = temp2.valor;
}
else
{
return(null);
}
}
}
}
else if (op2.GetType() == typeof(Map))
{
object campo = (set.key == null) ? null : set.key.ejecutar(ts, ambito, tsT);
Map temp = (Map)op2;
string tipo = temp.id.Split(new[] { ',' }, 2)[1];
foreach (KeyValue ky in temp.datos)
{
if (ky.key.ToString().Equals(campo))
{
Columna co = new Columna(ky.key.ToString(), tipo, false);
Atributo temp2 = checkinfo(co, op1, set.valor, mensajes, db, ambito);
if (temp2 != null)
{
ky.value = temp2.valor;
}
else
{
return(null);
}
}
}
ambito.listadoExcepciones.AddLast(new Excepcion("indexoutexception", "No se encontro la key"));
}
else if (op2.GetType() == typeof(List))
{
List temp = (List)op2;
object campo = (set.key == null) ? null : set.key.ejecutar(ts, ambito, tsT);
if (campo != null)
{
if (campo.GetType() == typeof(int))
{
if ((int)campo > -1)
{
if ((int)campo < temp.lista.Count())
{
if (temp.lista.Count() > 0)
{
var node = temp.lista.First;
int index = 0;
while (node != null)
{
var nodeNext = node.Next;
if (index == (int)campo)
{
Columna co = new Columna("", temp.id, false);
Atributo temp2 = checkinfo(co, op1, set.valor, mensajes, db, ambito);
if (temp2 != null)
{
node.Value = temp2.valor;
}
else
{
return(null);
}
break;
}
node = nodeNext;
index++;
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("indexoutexception", "El index es mayor al tamaño de la lista"));
mensajes.AddLast(mensa.error("El index supera el tamanio de la lista", l, c, "Semantico"));
return(null);
}
}
else
{
ambito.mensajes.AddLast(mensa.error("Index tiene que ser mayor a 0 ", l, c, "Semantico"));
mensajes.AddLast(mensa.error("El index debe de ser positivo: " + campo, l, c, "Semantico"));
return(null);
}
}
else
{
mensajes.AddLast(mensa.error("El index debe de ser de tipo numerico: " + campo, l, c, "Semantico"));
return(null);
}
}
else
{
mensajes.AddLast(mensa.error("El index no puede ser null", l, c, "Semantico"));
return(null);
}
}
}
}
}
}
}
else
{
return(null);
}
}
mensajes.AddLast(mensa.message("Datos actualizados con exito"));
return("");
}
/*
* Constructor de la clase
* @id nombre de la tabla
* @l linea del id
* @c columna del id
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
string user = ambito.usuario;
string baseD = ambito.baseD;
LinkedList <string> mensajes = ambito.mensajes;
BaseDeDatos db = TablaBaseDeDatos.getBase(iddb);
Usuario us = TablaBaseDeDatos.getUsuario(user);
if (db != null)
{
if (user.Equals("admin"))
{
Usuario usuario2 = TablaBaseDeDatos.getUsuario(id);
if (usuario2 != null)
{
if (operacion.Equals("GRANT"))
{
usuario2.bases.AddLast(iddb);
mensajes.AddLast(mensa.message("Se le dio permiso al usuario: " + id + " sobre la DB: " + iddb));
}
else
{
usuario2.bases.Remove(iddb);
mensajes.AddLast(mensa.message("Se le quitaron permisos al usuario: " + id + " sobre la DB: " + iddb));
}
return("");
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("userdontexists", "El usuario " + id + " no existe"));
mensajes.AddLast(mensa.error("El usuario " + id + " no existe", l, c, "Semantico"));
}
}
else
{
if (us != null)
{
Boolean permiso = TablaBaseDeDatos.getPermiso(us, iddb);
if (permiso)
{
Usuario usuario2 = TablaBaseDeDatos.getUsuario(id);
if (usuario2 != null)
{
if (operacion.Equals("GRANT"))
{
usuario2.bases.AddLast(iddb);
mensajes.AddLast(mensa.message("Se le dio permiso al usuario: " + id + " sobre la DB: " + iddb));
}
else
{
usuario2.bases.Remove(iddb);
mensajes.AddLast(mensa.message("Se le quitaron permisos al usuario: " + id + " sobre la DB: " + iddb));
}
return("");
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("userdontexists", "El usuario " + id + " no existe"));
mensajes.AddLast(mensa.error("El usuario " + id + " no existe", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("El usuario " + user + " no tiene permisos sobre esta base de datos", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("El usuario " + user + " no existe", l, c, "Semantico"));
}
}
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("usedbexception", "No existe la base de datos: " + iddb + " o no se ha usado el comando use"));
ambito.mensajes.AddLast(mensa.error("No existe la base de datos: " + iddb + " o no se ha usado el comando use", l, c, "Semantico"));
}
return(null);
}
