def especificarColumnas(self, nodoActual, columna, baseDatos,
listaErrores):
if nodoActual != None:
for i in range(len(nodoActual.hijos)):
self.especificarColumnas(nodoActual.hijos[i], columna,
baseDatos, listaErrores)
try:
if nodoActual.hijos[i].nombreNodo == "DEFAULT":
#print("setear valor default a columna: " + str(nodoActual.hijos[i+1].valor))
columna.setDefaultValue(
str(nodoActual.hijos[i + 1].valor))
elif nodoActual.hijos[i].nombreNodo == "NULL":
#print("setear valor TRUE a NULL en columna: ")
columna.setPropiedadNull()
elif nodoActual.hijos[i].nombreNodo == "NOTNULL":
#print("setear valor FALSE a NULL en columna: ")
columna.setPropiedadNotNull()
elif nodoActual.hijos[i].nombreNodo == "CONSTRAINT":
#print("setear constaint a columna:" + str(nodoActual.hijos[i+1].valor))
columna.setNombreConstraint(
str(nodoActual.hijos[i + 1].valor))
elif nodoActual.hijos[i].nombreNodo == "UNIQUE":
#print("setear TRUE a UNIQUE en columna:")
columna.setPropiedadUnique()
elif nodoActual.hijos[i].nombreNodo == "CHECK":
#print("setear condicion --nodoActual.hijos[i+2].hijos-- a check en columna:")
columna.setCheck(nodoActual.hijos[i + 2])
elif nodoActual.hijos[i].nombreNodo == "PRIMARY":
#print("setear TRUE a primary key en columna:")
columna.crearLlavePrimaria()
elif nodoActual.hijos[i].nombreNodo == "REFERENCES":
#print("hacer referencia a llave primaria si existe tabla Error 42P01 "+ nodoActual.hijos[i+1].valor)
tablaReferencia = baseDatos.obtenerTabla(
nodoActual.hijos[i + 1].valor)
if tablaReferencia != None:
contador = 0
for columnaActual in tablaReferencia.columnas:
if columnaActual.primaryKey == True:
contador = contador + 1
if contador == 1:
for columnaActual in tablaReferencia.columnas:
if columnaActual.primaryKey == True:
columna.setearTablaForanea(
tablaReferencia.nombre)
columna.setearColumnaForanea(
columnaActual.nombre)
else:
#Numero de referencias no concuerdan
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 42830")
listaErrores.append(errorEnviar)
else:
#No existe la tabla
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 42P01")
listaErrores.append(errorEnviar)
except:
pass
def ejecutar(self, tabalSimbolos, listaErrores):
baseDatos = tabalSimbolos.useDataBase
bandera = baseDatos.comprobarNombreTabla(self.nombre)
if bandera == 1:
#Tabla existente en base de datos
respuesta = jsonMode.dropTable(baseDatos.nombre, self.nombre)
if respuesta == 0:
eliminar = baseDatos.eliminarTabla(self.nombre)
if eliminar == 0:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 42P01, Tabla no existe")
listaErrores.append(errorEnviar)
return
elif respuesta == 1:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error en la operacion")
listaErrores.append(errorEnviar)
return
elif respuesta == 2:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 3D000, base de datos no existe")
listaErrores.append(errorEnviar)
return
elif respuesta == 3:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 42P01, Tabla no existe")
listaErrores.append(errorEnviar)
return
elif bandera == 0:
#Tabla no existente en base de datos
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 42P01, Tabla no existe")
listaErrores.append(errorEnviar)
return
pass
def ejecutar(self, tabalSimbolos, listaErrores):
bandera = tabalSimbolos.comprobarNombreBaseDatos(self.nombre)
if bandera == 1:
#Si existe la db
respuesta = jsonMode.dropDatabase(self.nombre)
if respuesta == 0:
eliminar = tabalSimbolos.eliminarBaseDatos(self.nombre)
if eliminar == 0:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 3D000, no existe la base de datos")
listaErrores.append(errorEnviar)
return
elif respuesta == 1:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error en la operacion")
listaErrores.append(errorEnviar)
return
elif respuesta == 2:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 3D000, no existe la base de datos")
listaErrores.append(errorEnviar)
return
elif bandera == 0 and self.si_existe == False:
#No existe la db
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 3D000, no existe la base de datos")
listaErrores.append(errorEnviar)
return
elif bandera == 0 and self.si_existe == True:
return
pass
def ejecutar(self, tabalSimbolos, listaErrores):
bandera = tabalSimbolos.comprobarNombreBaseDatos(self.nombre)
if bandera == 0:
#Nombre no existe
errorEnviar = errorReportar.ErrorReportar(self.fila,self.columna,"Ejecucion","No existe la base de datos :" + self.nombre)
listaErrores.append(errorEnviar)
return
elif bandera == 1:
#Nombre si existe, hacer alter
baseDatos = tabalSimbolos.obtenerBaseDatos(self.nombre)
nodoAlter = self.instrucciones
if nodoAlter[0].nombreNodo == "RENAME":
repetido = tabalSimbolos.comprobarNombreBaseDatos(nodoAlter[1].valor)
if repetido == 0:
respuesta = jsonMode.alterDatabase(self.nombre,nodoAlter[1].valor)
if respuesta == 0:
baseDatos.setearNombre(nodoAlter[1].valor)
elif respuesta == 1:
errorEnviar = errorReportar.ErrorReportar(self.fila,self.columna,"Ejecucion","error en la operación")
listaErrores.append(errorEnviar)
return
elif respuesta == 2:
errorEnviar = errorReportar.ErrorReportar(self.fila,self.columna,"Ejecucion","databaseOld no existente")
listaErrores.append(errorEnviar)
return
elif respuesta == 3:
errorEnviar = errorReportar.ErrorReportar(self.fila,self.columna,"Ejecucion","databaseNew existente")
listaErrores.append(errorEnviar)
return
elif repetido == 1:
errorEnviar = errorReportar.ErrorReportar(self.fila,self.columna,"Ejecucion","Error 42P04, ya existe la base de datos :" + nodoAlter[1].valor)
listaErrores.append(errorEnviar)
return
elif nodoAlter[0].nombreNodo == "OWNER":
baseDatos.setearPropietario(nodoAlter[1].valor)
pass
def ejecutar(self, tabalSimbolos, listaErrores):
baseDatos = tabalSimbolos.obtenerBaseDatos(tabalSimbolos.useDataBase)
bandera = baseDatos.comprobarNombreTipo(self.nombre)
if bandera == 1:
#Tipo ya existe
errorEnviar = errorReportar.ErrorReportar(self.fila, self.columna,
"Ejecucion",
"Error 42P07")
listaErrores.append(errorEnviar)
return
elif bandera == 0:
nuevoTipo = simboloNuevoTipo.SimboloNuevoTipo(
self.nombre, self.listaExpresiones)
baseDatos.agregarTipo(nuevoTipo)
pass
def ejecutar(self, tabalSimbolos, listaErrores):
if self.identificador != None:
bandera = tabalSimbolos.comprobarNombreBaseDatos(
self.identificador)
if bandera == 1:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Nombre de base de datos repetido")
listaErrores.append(errorEnviar)
return
else:
# llamar funcion ingeniero
dbGuardar = simboloBaseDatos.SimboloBaseDatos(
self.identificador)
tabalSimbolos.guardarBaseDatos(dbGuardar)
def ejecutar(self, tabalSimbolos, listaErrores):
#Se evalua que la base de datos exista:
if tabalSimbolos.setUseDataBase(self.nombreBaseDatos) == 0:
# Base de datos no existe
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Base de datos con nombre: " + self.nombreBaseDatos +
", no existe")
listaErrores.append(nodoError)
nodoRetorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR, None)
return nodoRetorno
else:
#Base de datos encontrada
tabalSimbolos.guardarMensajeEjecucion(
"Sentencia Use ejecutada correctamente")
nodoRetorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.NORMAL, None)
return nodoRetorno
def ejecutar(self, tabalSimbolos, listaErrores):
bandera = tabalSimbolos.comprobarNombreBaseDatos(self.identificador)
if bandera == 1 and self.reemplazar == None:
if self.si_no_existe == None:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion", "Error 42P04")
listaErrores.append(errorEnviar)
return
else:
#si es un id repetido pero dice crear si no existe
return
elif bandera == 1 and self.reemplazar != None:
#si es un id repetido pero hay que eliminarlo y reemplazarlo
#eliminarlo
respuesta = jsonMode.dropDatabase(self.identificador)
if respuesta == 0:
tabalSimbolos.eliminarBaseDatos(self.identificador)
elif respuesta == 1:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error en la operacion")
listaErrores.append(errorEnviar)
return
elif respuesta == 2:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 3D000, no existe la base de datos")
listaErrores.append(errorEnviar)
return
print(
"si es un id repetido pero hay que eliminarlo y reemplazarlo "
+ str(respuesta))
#reemplazarlo
respuesta2 = jsonMode.createDatabase(self.identificador)
if respuesta2 == 0:
dbGuardar = simboloBaseDatos.SimboloBaseDatos(
self.identificador)
for i in range(len(self.opciones)):
try:
if self.opciones[i].nombreNodo == "OWNER":
print(self.opciones[i + 2].valor)
dbGuardar.setearPropietario(self.opciones[i +
2].valor)
elif self.opciones[i].nombreNodo == "modo":
print(self.opciones[i].hijos[3])
dbGuardar.setearModo(self.opciones[i].hijos[3])
except:
pass
tabalSimbolos.guardarBaseDatos(dbGuardar)
else:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion", "Error 42P04")
listaErrores.append(errorEnviar)
return
print("reemplazo " + str(respuesta))
else:
#Llamar funcion de ingeniero
respuesta = jsonMode.createDatabase(self.identificador)
if respuesta == 0:
dbGuardar = simboloBaseDatos.SimboloBaseDatos(
self.identificador)
for i in range(len(self.opciones)):
try:
if self.opciones[i].nombreNodo == "OWNER":
print(self.opciones[i + 2].valor)
dbGuardar.setearPropietario(self.opciones[i +
2].valor)
elif self.opciones[i].nombreNodo == "modo":
print(self.opciones[i].hijos[3])
dbGuardar.setearModo(self.opciones[i].hijos[3])
except:
pass
tabalSimbolos.guardarBaseDatos(dbGuardar)
else:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion", "Error 42P04")
listaErrores.append(errorEnviar)
return
pass
def ejecutar(self, tabalSimbolos, listaErrores):
# ----------------------------------------------------------FUNCIONES MATEMATICAS----------------------------------------------------------
if str.lower(self.TipoFuncion.valor) == "abs":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = abs(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "cbrt":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = Res.valorRetorno**(1 / 3)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "ceil":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.ceil(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "ceiling":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.ceil(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "degrees":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.degrees(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "div":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
Res2 = self.Param2.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = Res.valorRetorno / Res2.valorRetorno
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "exp":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.exp(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "factorial":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.factorial(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "floor":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.floor(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "gcd":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
Res2 = self.Param2.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.gcd(Res.valorRetorno,
Res2.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "ln":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.log(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "log":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.log10(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "mod":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
Res2 = self.Param2.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = Res.valorRetorno % Res2.valorRetorno
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "pi":
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.double_precision, float(math.pi))
return simboloRetornar
elif str.lower(self.TipoFuncion.valor) == "power":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
Res2 = self.Param2.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = Res.valorRetorno**Res2.valorRetorno
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "radians":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.radians(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "round":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
Res2 = self.Param2.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = round(Res.valorRetorno, Res2.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "sign":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
if Res.valorRetorno > 0:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.double_precision, int(1))
return simboloRetornar
else:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.double_precision, int(-1))
return simboloRetornar
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "sqrt":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.sqrt(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "width_bucket": # Pendiente
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.double_precision, int(1))
return simboloRetornar
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "trunc":
Res = self.Param1.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.bigInit or Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.double_precision or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = math.trunc(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "random":
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.double_precision, random.random())
return simboloRetornar
# ---------------------------------------------------FUNCIONES TRIGONOMETRICAS----------------------------------------------------------
elif str.lower(self.TipoFuncion.valor) == "acos":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = cosenoinv(Res.valorRetorno)
if res.valorRetorno == None:
# agregar a lista de errores en ejecucion
print("Error de dominio")
else:
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "acosd":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = cosenoinvd(Res.valorRetorno)
if res.valorRetorno == None:
# agregar a lista de errores en ejecucion
print("Error de dominio")
else:
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "asin":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = senoinv(Res.valorRetorno)
if res.valorRetorno == None:
# agregar a lista de errores en ejecucion
print("Error de dominio")
else:
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "asind":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = senoinvd(Res.valorRetorno)
if res.valorRetorno == None:
# agregar a lista de errores en ejecucion
print("Error de dominio")
else:
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "atan":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = tangenteinv(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "atand":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = tangenteinvd(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "atan2":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
Res2 = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if (
Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer
or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal
) and (Res2.tipoDatoRetorno == simboloColumna.TiposDatos.integer or
Res2.tipoDatoRetorno == simboloColumna.TiposDatos.decimal):
Res.valorRetorno = tangenteinv2(Res.valorRetorno,
Res2.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "atan2d":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
Res2 = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if (
Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer
or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal
) and (Res2.tipoDatoRetorno == simboloColumna.TiposDatos.integer or
Res2.tipoDatoRetorno == simboloColumna.TiposDatos.decimal):
Res.valorRetorno = tangenteinv2d(Res.valorRetorno,
Res2.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "cos":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = coseno(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "cosd":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = cosenod(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "cot":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = coseno(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "cot":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = cotangente(Res.valorRetorno)
if res.valorRetorno == None:
# agregar a lista de errores en ejecucion
print("Error de dominio")
else:
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "cotd":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = cotangented(Res.valorRetorno)
if res.valorRetorno == None:
# agregar a lista de errores en ejecucion
print("Error de dominio")
else:
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "sin":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = seno(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "sind":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = senod(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "tan":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = tangente(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "tand":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = tangented(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "sinh":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = senohiper(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "cosh":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = cosenohiper(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "tanh":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = tangentehiper(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "asinh":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = senoinversohiper(Res.valorRetorno)
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "acosh":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = cosenoinversohiper(Res.valorRetorno)
if res.valorRetorno == None:
# agregar a lista de errores en ejecucion
print("Error de dominio")
else:
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
elif str.lower(self.TipoFuncion.valor) == "atanh":
Res = self.Parametro.ejecutar(tabalSimbolos, listaErrores)
if Res.tipoDatoRetorno == simboloColumna.TiposDatos.integer or Res.tipoDatoRetorno == simboloColumna.TiposDatos.decimal:
Res.valorRetorno = tangenteinversahiper(Res.valorRetorno)
if res.valorRetorno == None:
# agregar a lista de errores en ejecucion
print("Error de dominio")
else:
return Res
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"El parametro de la funcion no es un numero")
listaErrores.append(nodoError)
return None
def ejecutar(self, tabalSimbolos, listaErrores):
#se evalua que haya una base de datos en use
if tabalSimbolos.useDataBase == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Ninguna base de datos en uso")
listaErrores.append(nodoError)
nodoRetorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR, None)
return nodoRetorno
else:
#se evalua que la tabla a la que se va hacer el insert exista y se obtine el nodo de esa tabla
simTabla = tabalSimbolos.useDataBase.obtenerTabla(self.nombreTabla)
if simTabla == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"42P01 - undefined_table " + self.nombreTabla)
listaErrores.append(nodoError)
nodoRetorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR, None)
return nodoRetorno
else:
#Se evalua si es un delete con condición where o NO
if self.condicion == None:
# *************************************************************
# Funcion del Ingeniero *
# *************************************************************
resultado = jsonMode.truncate(
str(tabalSimbolos.useDataBase.nombre),
self.nombreTabla)
if resultado == 0:
tabalSimbolos.guardarMensajeEjecucion(
"Sentencia delete ejecutada correctamente")
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.NORMAL,
None)
return retorno
elif resultado == 1:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error al intentar hacer el delete de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR,
None)
return retorno
elif resultado == 2:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La base de datos no existe ")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR,
None)
return retorno
elif resultado == 3:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La tabla no existe: " + self.nombreTabla)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR,
None)
return retorno
else:
#Se trae la tabla de datos con la informacion
tablaDatos = jsonMode.extractTable(
tabalSimbolos.useDataBase.nombre, self.nombreTabla)
if tablaDatos == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"No existe informacion en la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR,
None)
return Retorno
simboloCondicion = self.condicion.ejecutar(
tabalSimbolos, listaErrores)
if simboloCondicion != None:
if simboloCondicion.tipoDatoRetorno == simboloColumna.TiposDatos.columna:
nombreColumnaIzquierda = simboloCondicion.nombreColumnaIzquierdo
nombreColumnaDerecha = simboloCondicion.nombreColumnaDerecho
listaIndices = []
if nombreColumnaIzquierda != None and nombreColumnaDerecha != None:
#Se va a traer la información de las dos columnas
columnaIzquierda = simTabla.obtenerSimboloColumna(
nombreColumnaIzquierda)
columnaDerecha = simTabla.obtenerSimboloColumna(
nombreColumnaDerecha)
if columnaIzquierda == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"La columna con nombre: " +
nombreColumnaIzquierda +
", no existe dentro de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
if columnaDerecha == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"La columna con nombre: " +
nombreColumnaDerecha +
", no existe dentro de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indiceIzquierdo = columnaIzquierda.indice
indiceDerecho = columnaDerecha.indice
tipoDatoIzquierdo = columnaIzquierda.tipoDato
tipoDatoDerecho = columnaDerecha.tipoDato
if tipoDatoIzquierdo == simboloColumna.TiposDatos.enum:
tipoDatoIzquierdo = simboloColumna.TiposDatos.varchar
if tipoDatoDerecho == simboloColumna.TiposDatos.enum:
tipoDatoDerecho = simboloColumna.TiposDatos.varchar
indice = 0
for tupla in tablaDatos:
valorIzquierdo = tupla[indiceIzquierdo]
valorDerecho = tupla[indiceDerecho]
expIzquierdo = Expresion()
expIzquierdo.valorPrimitivo(
valorIzquierdo, tipoDatoIzquierdo)
expDerecho = Expresion()
expDerecho.valorPrimitivo(
valorDerecho, tipoDatoDerecho)
operacion = Expresion()
operacion.operacionBinaria(
expIzquierdo, expDerecho,
simboloCondicion.tipoOperacion)
simboOperacion = operacion.ejecutar(
tabalSimbolos, listaErrores)
if simboOperacion != None:
if simboOperacion.tipoDatoRetorno == simboloColumna.TiposDatos.boolean:
if str(simboOperacion.valorRetorno
).lower() == "true":
listaIndices.append[indice]
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna,
"Ejecucion",
"Error al ejecutar la condición del delete"
)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indice = indice + 1
# SOLO Columna Izquierda
elif nombreColumnaIzquierda != None:
#Se va a traer la información de las dos columnas
columnaIzquierda = simTabla.obtenerSimboloColumna(
nombreColumnaIzquierda)
if columnaIzquierda == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"La columna con nombre: " +
nombreColumnaIzquierda +
", no existe dentro de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indiceIzquierdo = columnaIzquierda.indice
tipoDatoIzquierdo = columnaIzquierda.tipoDato
tipoDatoDerecho = simboloCondicion.descripcionError
if tipoDatoIzquierdo == simboloColumna.TiposDatos.enum:
tipoDatoIzquierdo = simboloColumna.TiposDatos.varchar
indice = 0
for tupla in tablaDatos:
valorIzquierdo = tupla[indiceIzquierdo]
valorDerecho = simboloCondicion.valorRetorno
expIzquierdo = Expresion()
expIzquierdo.valorPrimitivo(
valorIzquierdo, tipoDatoIzquierdo)
expDerecho = Expresion()
expDerecho.valorPrimitivo(
valorDerecho, tipoDatoDerecho)
operacion = Expresion()
operacion.operacionBinaria(
expIzquierdo, expDerecho,
simboloCondicion.tipoOperacion)
simboOperacion = operacion.ejecutar(
tabalSimbolos, listaErrores)
if simboOperacion != None:
if simboOperacion.tipoDatoRetorno == simboloColumna.TiposDatos.boolean:
if str(simboOperacion.valorRetorno
).lower() == "true":
listaIndices.append(indice)
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna,
"Ejecucion",
"Error al ejecutar la condición del delete"
)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indice = indice + 1
else:
#Se va a traer la información de la columna Derecha
columnaDerecha = simTabla.obtenerSimboloColumna(
nombreColumnaDerecha)
if columnaDerecha == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"La columna con nombre: " +
nombreColumnaDerecha +
", no existe dentro de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indiceDerecho = columnaDerecha.indice
tipoDatoDerecho = columnaDerecha.tipoDato
tipoDatoIzquierdo = simboloCondicion.descripcionError
if indiceDerecho == simboloColumna.TiposDatos.enum:
indiceDerecho = simboloColumna.TiposDatos.varchar
indice = 0
for tupla in tablaDatos:
valorIzquierdo = simboloCondicion.valorRetorno
valorDerecho = tupla[indiceIzquierdo]
expIzquierdo = Expresion()
expIzquierdo.valorPrimitivo(
valorIzquierdo, tipoDatoIzquierdo)
expDerecho = Expresion()
expDerecho.valorPrimitivo(
valorDerecho, tipoDatoDerecho)
operacion = Expresion()
operacion.operacionBinaria(
expIzquierdo, expDerecho,
simboloCondicion.tipoOperacion)
simboOperacion = operacion.ejecutar(
tabalSimbolos, listaErrores)
if simboOperacion != None:
if simboOperacion.tipoDatoRetorno == simboloColumna.TiposDatos.boolean:
if str(simboOperacion.valorRetorno
).lower() == "true":
listaIndices.append[indice]
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna,
"Ejecucion",
"Error al ejecutar la condición del delete"
)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indice = indice + 1
# se hacen los delete
contador = 0
for miIndice in listaIndices:
resultado = jsonMode.delete(
tabalSimbolos.useDataBase.nombre,
self.nombreTabla, [str(miIndice)])
if resultado == 0:
contador = contador + 1
elif resultado == 1:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error al intentar eliminar la información de la columna: "
+ self.nombreTabla)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 2:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La base de datos con nombre: " +
tabalSimbolos.useDataBase.nombre +
", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 3:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La tabla de datos con nombre: " +
self.nombreTabla + ", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 4:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La llave primaria no se encontro, no se pudo realizar la eliminación "
)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
tabalSimbolos.guardarMensajeEjecucion(
"Se eliminaron: " + str(contador) +
" registros de la tabla: " + self.nombreTabla)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.
NORMAL, None)
return Retorno
else:
#No hay condiciónn que comparar, se afecta a todos los registros
indice = 0
contador = 0
for tupla in tablaDatos:
resultado = jsonMode.delete(
tabalSimbolos.useDataBase.nombre,
self.nombreTabla, [str(indice)])
if resultado == 0:
contador = contador + 1
elif resultado == 1:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error al intentar eliminar la información de la columna: "
+ self.nombreTabla)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 2:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La base de datos con nombre: " +
tabalSimbolos.useDataBase.nombre +
", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 3:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La tabla de datos con nombre: " +
self.nombreTabla + ", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 4:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La llave primaria no se encontro, no se pudo realizar la eliminacion "
)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
indice = indice + 1
tabalSimbolos.guardarMensajeEjecucion(
"Se eliminaron: " + str(contador) +
" registros de la tabla: " + self.nombreTabla)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.
NORMAL, None)
return Retorno
else:
tabalSimbolos.guardarMensajeEjecucion(
"Se eliminaron: 0 registros de la tabla: " +
self.nombreTabla)
nodoRetorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR,
None)
return nodoRetorno
def ejecutar(self, tabalSimbolos, listaErrores):
#Esta clase va a devolver un simbolos
#se evalua que haya una base de datos en use
if tabalSimbolos.useDataBase == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Ninguna base de datos en uso")
listaErrores.append(nodoError)
return None
else:
#se evalua que la tabla a la que se va hacer el insert exista y se obtine el nodo de esa tabla
simTabla = tabalSimbolos.useDataBase.obtenerTabla(self.nombreTabla)
if simTabla == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"42P01 - undefined_table " + self.nombreTabla)
listaErrores.append(nodoError)
return None
else:
# Se ejecuta el valor que se le va a setear a la columna
simboloRec = self.valorActualizar.ejecutar(
tabalSimbolos, listaErrores)
if simboloRec == None:
#Hubo error en la ejecución
return None
else:
#Se evalua que el tipo de dato retorno sea igual al de la columna
columna = simTabla.obtenerSimboloColumna(
self.nombreColumna)
if (columna == None):
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"La columna con nombre: " + self.nombreColumna +
", no existe dentro de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
return None
else:
if columna.tipoDato == simboloColumna.TiposDatos.enum:
#Es un enum
simboloEnum = columna.tipoDatoNOprimitivo
if simboloEnum != None:
bandera = False
for enumm in simboloEnum.posiblesValores:
if (enumm.lower() == str(
simboloRec.valorRetorno).lower()):
bandera = True
if bandera == False:
NodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"El valor a ingresar no se encuentra dentro del enumn: "
+ simboloEnum.nombre)
listaErrores.append(NodoErr)
return None
else:
simboloRec.nombreColumnaIzquierdo = self.nombreColumna
simboloRec.nombreColumnaDerecho = columna.indice #Se guarda el indice de la columna
return simboloRec
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La columna esta declarada cono tipo de dato Enum, pero no tienen ningún enum asociado"
)
listaErrores.append(nodoErr)
return None
else:
if simboloRec.tipoDatoRetorno == simboloColumna.TiposDatos.default:
if columna.defaultValue != None:
simboloRec.nombreColumnaIzquierdo = self.nombreColumna
simboloRec.nombreColumnaDerecho = columna.indice #Se guarda el indice de la columna
return simboloRec
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La columna con nombre: " +
columna.nombre +
" no tiene valor por default asignado")
listaErrores.append(nodoErr)
return None
elif simboloRec.tipoDatoRetorno == simboloColumna.TiposDatos.nulo:
if columna.null == True:
simboloRec.nombreColumnaIzquierdo = self.nombreColumna
simboloRec.nombreColumnaDerecho = columna.indice #Se guarda el indice de la columna
return simboloRec
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La columna con nombre: " +
columna.nombre +
", no acepta valores nulos")
listaErrores.append(nodoErr)
return None
filaa = columna.tipoDato.value
columnaaInt = simboloRec.tipoDatoRetorno.value
#Se realiza la comprobación de tipos
comprobarTipos = tabalSimbolos.obtenerTipoDato(
filaa, columnaaInt)
simboloRecibido = comprobarTipos.operar(
tipoSimbolo.TipoSimbolo.COLUMNA_DATO)
if simboloRecibido != None:
if simboloRecibido.descripcionError == None:
# Son del mismo tipo
simboloRec.nombreColumnaIzquierdo = self.nombreColumna
simboloRec.nombreColumnaDerecho = columna.indice #Se guarda el indice de la columna
return simboloRec
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
simboloRecibido.descripcionError)
listaErrores.append(nodoErr)
return None
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error de tipos al intentar insertar valor a la columna: "
+ columna.nombre)
listaErrores.append(nodoErr)
return None
def ejecutar(self, tabalSimbolos, listaErrores):
#se evalua que haya una base de datos en use
if tabalSimbolos.useDataBase == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Ninguna base de datos en uso")
listaErrores.append(nodoError)
nodoRetorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR, None)
return nodoRetorno
else:
#se evalua que la tabla a la que se va hacer el insert exista y se obtine el nodo de esa tabla
simTabla = tabalSimbolos.useDataBase.obtenerTabla(self.nombreTabla)
if simTabla == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"42P01 - undefined_table " + self.nombreTabla)
listaErrores.append(nodoError)
nodoRetorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR, None)
return nodoRetorno
else:
# Se evalua que no vengan dos columnas con el mismo nombre
for nodoColumnaSet in self.listaUpdates:
nombreCol = nodoColumnaSet.nombreColumna
contador = 0
for nodoCol2 in self.listaUpdates:
if nombreCol == nodoCol2.nombreColumna:
contador = contador + 1
if contador > 1:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Nombre de columna: " + nombreCol +
" aparece con más de una asignacion")
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR,
None)
return Retorno
# se empiezan a ejecutar todos los sets
listaSets = {
} #Guardará los simbolos ejecutados con su nombre de columna
for nodoColumnaSet in self.listaUpdates:
if isinstance(nodoColumnaSet, UpdateColumna):
# Se setea el nombre de la tabla
nodoColumnaSet.nombreTabla = self.nombreTabla
simbRecibido = nodoColumnaSet.ejecutar(
tabalSimbolos, listaErrores)
if simbRecibido != None:
#Se guarde el indice de la columna que viene en nombreColumnaDerecho y su valor que viene en valorRetorno
listaSets[int(simbRecibido.nombreColumnaDerecho
)] = simbRecibido.valorRetorno
else:
#Hubo error, el error ya fue reportado
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.
ERROR, None)
return retorno
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"No se pudo ejecutar la instruccion para setera el valor a la columna"
)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR,
None)
return Retorno
#Se trae la tabla de datos con la informacion
tablaDatos = jsonMode.extractTable(
tabalSimbolos.useDataBase.nombre, self.nombreTabla)
if tablaDatos == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"No ahy informacion en la tabla: " + self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR, None)
return Retorno
#Se manda a ejecutar la condicion
if self.condicion != None:
simboloCondicion = self.condicion.ejecutar(
tabalSimbolos, listaErrores)
if simboloCondicion != None:
if simboloCondicion.tipoDatoRetorno == simboloColumna.TiposDatos.columna:
nombreColumnaIzquierda = simboloCondicion.nombreColumnaIzquierdo
nombreColumnaDerecha = simboloCondicion.nombreColumnaDerecho
listaIndices = []
if nombreColumnaIzquierda != None and nombreColumnaDerecha != None:
#Se va a traer la información de las dos columnas
columnaIzquierda = simTabla.obtenerSimboloColumna(
nombreColumnaIzquierda)
columnaDerecha = simTabla.obtenerSimboloColumna(
nombreColumnaDerecha)
if columnaIzquierda == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"La columna con nombre: " +
nombreColumnaIzquierda +
", no existe dentro de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
if columnaDerecha == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"La columna con nombre: " +
nombreColumnaDerecha +
", no existe dentro de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indiceIzquierdo = columnaIzquierda.indice
indiceDerecho = columnaDerecha.indice
tipoDatoIzquierdo = columnaIzquierda.tipoDato
tipoDatoDerecho = columnaDerecha.tipoDato
if tipoDatoIzquierdo == simboloColumna.TiposDatos.enum:
tipoDatoIzquierdo = simboloColumna.TiposDatos.varchar
if tipoDatoDerecho == simboloColumna.TiposDatos.enum:
tipoDatoDerecho = simboloColumna.TiposDatos.varchar
indice = 0
for tupla in tablaDatos:
valorIzquierdo = tupla[indiceIzquierdo]
valorDerecho = tupla[indiceDerecho]
expIzquierdo = Expresion()
expIzquierdo.valorPrimitivo(
valorIzquierdo, tipoDatoIzquierdo)
expDerecho = Expresion()
expDerecho.valorPrimitivo(
valorDerecho, tipoDatoDerecho)
operacion = Expresion()
operacion.operacionBinaria(
expIzquierdo, expDerecho,
simboloCondicion.tipoOperacion)
simboOperacion = operacion.ejecutar(
tabalSimbolos, listaErrores)
if simboOperacion != None:
if simboOperacion.tipoDatoRetorno == simboloColumna.TiposDatos.boolean:
if str(simboOperacion.valorRetorno
).lower() == "true":
listaIndices.append[indice]
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna,
"Ejecucion",
"Error al ejecutar la condición del update"
)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indice = indice + 1
# SOLO Columna Izquierda
elif nombreColumnaIzquierda != None:
#Se va a traer la información de las dos columnas
columnaIzquierda = simTabla.obtenerSimboloColumna(
nombreColumnaIzquierda)
if columnaIzquierda == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"La columna con nombre: " +
nombreColumnaIzquierda +
", no existe dentro de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indiceIzquierdo = columnaIzquierda.indice
tipoDatoIzquierdo = columnaIzquierda.tipoDato
tipoDatoDerecho = simboloCondicion.descripcionError
if tipoDatoIzquierdo == simboloColumna.TiposDatos.enum:
tipoDatoIzquierdo = simboloColumna.TiposDatos.varchar
indice = 0
for tupla in tablaDatos:
valorIzquierdo = tupla[indiceIzquierdo]
valorDerecho = simboloCondicion.valorRetorno
expIzquierdo = Expresion()
expIzquierdo.valorPrimitivo(
valorIzquierdo, tipoDatoIzquierdo)
expDerecho = Expresion()
expDerecho.valorPrimitivo(
valorDerecho, tipoDatoDerecho)
operacion = Expresion()
operacion.operacionBinaria(
expIzquierdo, expDerecho,
simboloCondicion.tipoOperacion)
simboOperacion = operacion.ejecutar(
tabalSimbolos, listaErrores)
if simboOperacion != None:
if simboOperacion.tipoDatoRetorno == simboloColumna.TiposDatos.boolean:
if str(simboOperacion.valorRetorno
).lower() == "true":
listaIndices.append(indice)
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna,
"Ejecucion",
"Error al ejecutar la condición del update"
)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indice = indice + 1
else:
#Se va a traer la información de la columna Derecha
columnaDerecha = simTabla.obtenerSimboloColumna(
nombreColumnaDerecha)
if columnaDerecha == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"La columna con nombre: " +
nombreColumnaDerecha +
", no existe dentro de la tabla: " +
self.nombreTabla)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indiceDerecho = columnaDerecha.indice
tipoDatoDerecho = columnaDerecha.tipoDato
tipoDatoIzquierdo = simboloCondicion.descripcionError
if indiceDerecho == simboloColumna.TiposDatos.enum:
indiceDerecho = simboloColumna.TiposDatos.varchar
indice = 0
for tupla in tablaDatos:
valorIzquierdo = simboloCondicion.valorRetorno
valorDerecho = tupla[indiceIzquierdo]
expIzquierdo = Expresion()
expIzquierdo.valorPrimitivo(
valorIzquierdo, tipoDatoIzquierdo)
expDerecho = Expresion()
expDerecho.valorPrimitivo(
valorDerecho, tipoDatoDerecho)
operacion = Expresion()
operacion.operacionBinaria(
expIzquierdo, expDerecho,
simboloCondicion.tipoOperacion)
simboOperacion = operacion.ejecutar(
tabalSimbolos, listaErrores)
if simboOperacion != None:
if simboOperacion.tipoDatoRetorno == simboloColumna.TiposDatos.boolean:
if str(simboOperacion.valorRetorno
).lower() == "true":
listaIndices.append[indice]
else:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna,
"Ejecucion",
"Error al ejecutar la condición del update"
)
listaErrores.append(nodoError)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return Retorno
indice = indice + 1
# se hacen los update
contador = 0
for miIndice in listaIndices:
resultado = jsonMode.update(
tabalSimbolos.useDataBase.nombre,
self.nombreTabla, listaSets,
[str(miIndice)])
if resultado == 0:
contador = contador + 1
elif resultado == 1:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error al intentar actualiazar la información de la columna: "
+ self.nombreTabla)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 2:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La base de datos con nombre: " +
tabalSimbolos.useDataBase.nombre +
", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 3:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La tabla de datos con nombre: " +
self.nombreTabla + ", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 4:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La llave primaria no se encontro, no se pudo realizar la actualización "
)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
tabalSimbolos.guardarMensajeEjecucion(
"Se actualizaron: " + str(contador) +
" registros de la tabla: " + self.nombreTabla)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.
NORMAL, None)
return Retorno
else:
#No hay condiciónn que comparar, se afecta a todos los registros
indice = 0
contador = 0
for tupla in tablaDatos:
resultado = jsonMode.update(
tabalSimbolos.useDataBase.nombre,
self.nombreTabla, listaSets, [str(indice)])
if resultado == 0:
contador = contador + 1
elif resultado == 1:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error al intentar actualiazar la información de la columna: "
+ self.nombreTabla)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 2:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La base de datos con nombre: " +
tabalSimbolos.useDataBase.nombre +
", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 3:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La tabla de datos con nombre: " +
self.nombreTabla + ", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
elif resultado == 4:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La llave primaria no se encontro, no se pudo realizar la actualización "
)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.
TipoRetornoInstruccion.ERROR, None)
return retorno
indice = indice + 1
tabalSimbolos.guardarMensajeEjecucion(
"Se actualizaron: " + str(contador) +
" registros de la tabla: " + self.nombreTabla)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.
NORMAL, None)
return Retorno
else:
tabalSimbolos.guardarMensajeEjecucion(
"Se actualizaron: 0 registros de la tabla: " +
self.nombreTabla)
nodoRetorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.ERROR,
None)
return nodoRetorno
else:
#no hay condición se actualizan todos los registros
indice = 0
contador = 0
for tupla in tablaDatos:
resultado = jsonMode.update(
tabalSimbolos.useDataBase.nombre, self.nombreTabla,
listaSets, [str(indice)])
if resultado == 0:
contador = contador + 1
elif resultado == 1:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error al intentar actualiazar la información de la columna: "
+ self.nombreTabla)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.
ERROR, None)
return retorno
elif resultado == 2:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La base de datos con nombre: " +
tabalSimbolos.useDataBase.nombre +
", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.
ERROR, None)
return retorno
elif resultado == 3:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La tabla de datos con nombre: " +
self.nombreTabla + ", no existe")
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.
ERROR, None)
return retorno
elif resultado == 4:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"La llave primaria no se encontro, no se pudo realizar la actualización "
)
listaErrores.append(nodoError)
retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.
ERROR, None)
return retorno
indice = indice + 1
tabalSimbolos.guardarMensajeEjecucion(
"Se actualizaron: " + str(contador) +
" registros de la tabla: " + self.nombreTabla)
Retorno = retornoInstruccion.RetornoInstruccion(
retornoInstruccion.TipoRetornoInstruccion.NORMAL, None)
return Retorno
def ejecutar(self, tabalSimbolos, listaErrores):
#Se verifica si hay una base de datos en uso
if tabalSimbolos.useDataBase == None:
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Ninguna base de datos en uso")
listaErrores.append(nodoError)
else:
#Select sin tablas en el FROM y se asume que viene una funcion matematica
if self.selectTablas is None:
for elemento in self.selectColumnas.hijos:
Res = elemento.hijos[0].ejecutar(tabalSimbolos,
listaErrores)
if Res != None:
print(Res.valorRetorno)
#Select con tablas en el FROM
else:
ListaTablasFrom = {"Nombre": [], "ID": []}
ListaSubquerysFrom = {"Subquery": [], "ID": []}
#Se obtienen todos los nombres de las tablas del from y los subquerys
for Tabla in self.selectTablas.hijos:
#Es una declaracion simple de una tabla
if str.lower(Tabla.hijos[0].nombreNodo) == "dec_id_from":
if len(Tabla.hijos[0].hijos) == 1:
ListaTablasFrom["Nombre"].append(
Tabla.hijos[0].hijos[0].valor)
ListaTablasFrom["ID"].append(
Tabla.hijos[0].hijos[0].valor)
elif len(Tabla.hijos[0].hijos) == 2:
ListaTablasFrom["Tabla"].append(
Tabla.hijos[0].hijos[0].valor)
ListaTablasFrom["ID"].append(
Tabla.hijos[0].hijos[1].valor)
#Es un subquery
else:
if len(Tabla.hijos) == 1:
ListaSubquerysFrom["Subquery"].append(
Tabla.hijos[0])
ListaSubquerysFrom["ID"].append(None)
if len(Tabla.hijos) == 2:
ListaSubquerysFrom["Subquery"].append(
Tabla.hijos[0])
ListaSubquerysFrom["ID"].append(
Tabla.hijos[0].valor)
#Se extraen de la base de datos las tablas del from
TablasDatosCompletos = {
"Nombre": [],
"Campos": [],
"TipoCampos": [],
"Datos": []
}
for tabla in ListaTablasFrom["Nombre"]:
TablasDatosCompletos["Nombre"].append(tabla)
tiposcolumnas = []
columnas = []
for col in tabalSimbolos.useDataBase.obtenerTabla(
tabla).columnas:
tiposcolumnas.append(col.tipoDato)
columnas.append(col.nombre)
TablasDatosCompletos["Campos"].append(columnas)
TablasDatosCompletos["TipoCampos"].append(tiposcolumnas)
TablasDatosCompletos["Datos"].append(
jsonMode.extractTable(tabalSimbolos.useDataBase.nombre,
tabla))
#Se verifica si se mando a llamar un Selec *
if self.selectColumnas.valor == "*":
Tablas = []
for i in range(0, len(TablasDatosCompletos["Nombre"])):
TablaPrint = PrettyTable()
TablaPrint.field_names = TablasDatosCompletos[
"Campos"][i]
TablaPrint.add_rows(TablasDatosCompletos["Datos"][i])
Tablas.append(TablaPrint)
for T in Tablas:
print(T)
else:
#No vienen ninguna condicion where
if self.selectCondiciones == None:
TablaPrint = PrettyTable()
rownum = 1
for elemento in self.selectColumnas.hijos:
#La columna es solo un campo simple
if elemento.nombreNodo == "TABLA_CAMPO_ALIAS":
nombrecampo = ""
datoscolumnatmp = []
if len(elemento.hijos) == 1:
nombrecampo = elemento.hijos[0].valor
else:
nombrecampo = elemento.hijos[1].valor
for i in range(
0,
len(TablasDatosCompletos["Nombre"])):
for j in range(
0,
len(TablasDatosCompletos["Campos"]
[i])):
if TablasDatosCompletos["Campos"][i][
j] == nombrecampo:
for k in range(
0,
len(TablasDatosCompletos[
"Datos"][i])):
datoscolumnatmp.append(
TablasDatosCompletos[
"Datos"][i][k][j])
if k > rownum:
rownum = k
TablaPrint.add_column(nombrecampo,
datoscolumnatmp)
#la columna es una funcion
else:
resfuncion = elemento.hijos[0].ejecutar(
tabalSimbolos, listaErrores)
if resfuncion != None:
res = []
for i in range(0, rownum + 1):
res.append(resfuncion.valorRetorno)
TablaPrint.add_column(
elemento.hijos[0].hijos[0].valor, res)
print(TablaPrint)
#Se aplican las condiciones en el where
else:
for clausula in self.selectCondiciones.hijos:
if str.lower(clausula.hijos[0].valor) == "where":
print("vino un where")
elif str.lower(clausula.hijos[0].valor) == "group":
print("vino un group")
elif str.lower(
clausula.hijos[0].valor) == "having":
print("vino un having")
elif str.lower(clausula.hijos[0].valor) == "order":
print("vino un order")
elif str.lower(clausula.hijos[0].valor) == "limit":
print("vino un limit")
else:
print("vino desconocido")
def ejecutar(self, tabalSimbolos, listaErrores):
if self.tipoExpresion == 0:
if self.tipoOperacion == tipoSimbolo.TipoSimbolo.NOMBRE_COLUMNA:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.columna, str(self.valor))
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.columna)
simboloRetornar.nombreColumnaIzquierdo = str(self.valor)
return simboloRetornar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.ENTERO:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.bigInit, int(self.valor))
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.bigInit)
return simboloRetornar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.DECIMAL:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.double_precision,
float(self.valor))
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.double_precision)
return simboloRetornar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.CADENA:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.varchar, str(self.valor))
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.varchar)
return simboloRetornar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.BOOLEANO:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.boolean)
return simboloRetornar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.NULO:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.nulo, "null")
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.nulo)
return simboloRetornar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.DEFAULT:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.default, "default")
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.default)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.smallInt:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.smallInt, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.smallInt)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.integer:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.integer, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.integer)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.bigInit:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.bigInit, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.bigInit)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.decimal:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.decimal, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.decimal)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.numeric:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.numeric, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.numeric)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.real:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.real, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.real)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.double_precision:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.double_precision, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.double_precision)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.money:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.money, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.money)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.varchar:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.varchar, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.varchar)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.character:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.character, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.character)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.text:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.text, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.text)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.date:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.date, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.date)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.time_No_zone:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.time_No_zone, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.time_No_zone)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.time_si_zone:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.time_si_zone, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.time_si_zone)
return simboloRetornar
elif self.tipoOperacion == simboloColumna.TiposDatos.boolean:
simboloRetornar = simbolo.Simbolo()
simboloRetornar.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean, self.valor)
simboloRetornar.setTipoDatosCasteo(
simboloColumna.TiposDatos.boolean)
return simboloRetornar
else:
return None
# ******************************************************************************************
# *************************************** OPERACIONES UNARIAS ******************************
# ******************************************************************************************
elif self.tipoExpresion == 1:
simboloEnviar = self.opIzquierdo.ejecutar(tabalSimbolos,
listaErrores)
if simboloEnviar != None:
if isinstance(simboloEnviar, simbolo.Simbolo):
valorOperar = None
if simboloEnviar.descripcionError != None:
# Error de tipos se registra el error
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna, "Semántico",
simboloEnviar.descripcionError)
listaErrores.append(nodoError)
return None
# Se realiza la operacion
if self.tipoOperacion == tipoSimbolo.TipoSimbolo.POSITIVO_UNARIO:
# Se obtiene el tipo de dato
if (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.smallInt) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.integer) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.bigInit):
valorOperar = int(simboloEnviar.valorRetorno)
elif (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.decimal) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.numeric
) or (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.real) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.
double_precision
) or (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.money):
valorOperar = float(simboloEnviar.valorRetorno)
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Semántico",
"Tipo de dato no válido para la operacion de Unario Positivo"
)
listaErrores.append(nodoErr)
return None
#Por ser positivo no se hace nada
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.NEGATIVO_UNARIO:
if (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.smallInt) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.integer) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.bigInit):
valorOperar = int(simboloEnviar.valorRetorno)
elif (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.decimal) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.numeric
) or (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.real) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.
double_precision
) or (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.money):
valorOperar = float(simboloEnviar.valorRetorno)
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Semántico",
"Tipo de dato no válido para la operacion de Unario Negativo"
)
listaErrores.append(nodoErr)
return None
valorOperar = valorOperar * -1
simboloEnviar.valorRetorno = valorOperar
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.NOT:
if simboloEnviar.tipDatoCasteo == simboloColumna.TiposDatos.boolean:
valorOperar = str(simboloEnviar.valorRetorno)
if valorOperar.lower() == "true":
valorOperar = True
else:
valorOperar = False
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Semántico",
"Tipo de dato no válido para la operacion Not")
listaErrores.append(nodoErr)
return None
valorOperar = not valorOperar
simboloEnviar.valorRetorno = valorOperar
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.BETWEEN:
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.NOT_BETWEEN:
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.INN:
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.IS_NULL:
if simboloEnviar.tipDatoCasteo == simboloColumna.TiposDatos.columna:
simboloEnviar.tipoDatoRetorno = simboloColumna.TiposDatos.columna
simboloEnviar.tipoOperacion = tipoSimbolo.TipoSimbolo.IS_NULL
return simboloEnviar
elif simboloEnviar.setTipoDatosCasteo == simboloColumna.TiposDatos.nulo:
simboloEnviar.setTipoDatoRetorno(
simboloColumna.TiposDatos.boolean)
simboloEnviar.setTipoDatosCasteo(
simboloColumna.TiposDatos.boolean)
simboloEnviar.valorRetorno = True
return simboloEnviar
else:
simboloEnviar.setTipoDatoRetorno(
simboloColumna.TiposDatos.boolean)
simboloEnviar.setTipoDatosCasteo(
simboloColumna.TiposDatos.boolean)
simboloEnviar.valorRetorno = False
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.IS_NOT_NULL:
if simboloEnviar.tipDatoCasteo == simboloColumna.TiposDatos.columna:
simboloEnviar.tipoDatoRetorno = simboloColumna.TiposDatos.columna
simboloEnviar.tipoOperacion = tipoSimbolo.TipoSimbolo.IS_NOT_NULL
return simboloEnviar
elif simboloEnviar.tipDatoCasteo == simboloColumna.TiposDatos.nulo:
simboloEnviar.setTipoDatoRetorno(
simboloColumna.TiposDatos.boolean)
simboloEnviar.setTipoDatosCasteo(
simboloColumna.TiposDatos.boolean)
simboloEnviar.valorRetorno = False
return simboloEnviar
else:
simboloEnviar.setTipoDatoRetorno(
simboloColumna.TiposDatos.boolean)
simboloEnviar.setTipoDatosCasteo(
simboloColumna.TiposDatos.boolean)
simboloEnviar.valorRetorno = True
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.NOT_INN:
return simboloEnviar
else:
return None
else:
return None
else:
return None
# **********************************************************************************************
# ************************************* OPERACION BINARIA **************************************
# **********************************************************************************************
elif self.tipoExpresion == 2:
#se mandan a ejecutar los operadores izquierdo y derecho
simboloIzquierdo = None
simboloDerecho = None
if self.opIzquierdo != None:
if isinstance(self.opIzquierdo, InstruccionAbstracta):
simboloIzquierdo = self.opIzquierdo.ejecutar(
tabalSimbolos, listaErrores)
if self.opDerecho != None:
if isinstance(self.opDerecho, InstruccionAbstracta):
simboloDerecho = self.opDerecho.ejecutar(
tabalSimbolos, listaErrores)
if simboloIzquierdo != None and simboloDerecho != None:
if isinstance(simboloIzquierdo,
simbolo.Simbolo) and isinstance(
simboloDerecho, simbolo.Simbolo):
#Se evalua si el simbolo es una columna para operarlo de otra forma
if simboloIzquierdo.tipoDatoRetorno == simboloColumna.TiposDatos.columna and simboloDerecho.tipoDatoRetorno == simboloColumna.TiposDatos.columna:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.tipoDatoRetorno = simboloColumna.TiposDatos.columna
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.columna
enviarSimbolo.nombreColumnaIzquierdo = simboloIzquierdo.nombreColumnaIzquierdo
enviarSimbolo.nombreColumnaDerecho = simboloDerecho.nombreColumnaIzquierdo
enviarSimbolo.tipoOperacion = self.tipoOperacion
return enviarSimbolo
elif simboloIzquierdo.tipoDatoRetorno == simboloColumna.TiposDatos.columna:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.tipoDatoRetorno = simboloColumna.TiposDatos.columna
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.columna
enviarSimbolo.nombreColumnaIzquierdo = simboloIzquierdo.nombreColumnaIzquierdo
enviarSimbolo.valorRetorno = simboloDerecho.valorRetorno
enviarSimbolo.descripcionError = simboloDerecho.tipoDatoRetorno
enviarSimbolo.tipoOperacion = self.tipoOperacion
return enviarSimbolo
elif simboloDerecho.tipoDatoRetorno == simboloColumna.TiposDatos.columna:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.tipoDatoRetorno = simboloColumna.TiposDatos.columna
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.columna
enviarSimbolo.valorRetorno = simboloIzquierdo.valorRetorno
enviarSimbolo.descripcionError = simboloIzquierdo.tipoDatoRetorno
enviarSimbolo.nombreColumnaDerecho = simboloDerecho.nombreColumnaIzquierdo
enviarSimbolo.tipoOperacion = self.tipoOperacion
return enviarSimbolo
else:
#Se evaula si viene algun simbolo tipo nulo o default
if simboloIzquierdo.tipoDatoRetorno == simboloColumna.TiposDatos.nulo:
if self.tipoOperacion == tipoSimbolo.TipoSimbolo.IGUALACION:
if simboloDerecho.tipoDatoRetorno == simboloColumna.TiposDatos.nulo:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean,
True)
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.boolean
return enviarSimbolo
else:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean,
False)
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.boolean
return enviarSimbolo
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.DISTINTO:
if simboloDerecho.tipoDatoRetorno == simboloColumna.TiposDatos.nulo:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean,
False)
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.boolean
return enviarSimbolo
else:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean,
True)
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.boolean
return enviarSimbolo
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"Operacion no valida con el tipo de dato null"
)
listaErrores.append(nodoErr)
return None
elif simboloDerecho.tipoDatoRetorno == simboloColumna.TiposDatos.default:
if self.tipoOperacion == tipoSimbolo.TipoSimbolo.IGUALACION:
if simboloIzquierdo.tipoDatoRetorno == simboloColumna.TiposDatos.default:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean,
True)
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.boolean
return enviarSimbolo
else:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean,
False)
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.boolean
return enviarSimbolo
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.DISTINTO:
if simboloIzquierdo.tipoDatoRetorno == simboloColumna.TiposDatos.default:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean,
False)
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.boolean
return enviarSimbolo
else:
enviarSimbolo = simbolo.Simbolo()
enviarSimbolo.crearSimboloPrimitivo(
simboloColumna.TiposDatos.boolean,
True)
enviarSimbolo.tipDatoCasteo = simboloColumna.TiposDatos.boolean
return enviarSimbolo
else:
nodoErr = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecución",
"Operacion no valida con el tipo de dato default"
)
listaErrores.append(nodoErr)
return None
#Se manda a evaluar si la operacion es valida con los tipos de datos obtenidos
fila = simboloIzquierdo.tipoDatoRetorno.value
columna = simboloDerecho.tipoDatoRetorno.value
nodoRecibido = tabalSimbolos.obtenerTipoDato(
fila, columna)
if nodoRecibido != None:
if isinstance(nodoRecibido,
nodoPosicion.NodoPosicion):
#se opera con la operacion indicada
simboloEnviar = nodoRecibido.operar(
self.tipoOperacion)
if simboloEnviar != None:
valorIzquierdo = None
valorDerecho = None
if simboloEnviar.descripcionError != None:
# Error de tipos se registra el error
nodoError = errorReportar.ErrorReportar(
self.fila, self.columna,
"Semántico",
simboloEnviar.descripcionError)
listaErrores.append(nodoError)
return None
elif (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.smallInt
) or (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.
integer) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.
TiposDatos.bigInit):
valorIzquierdo = int(
simboloIzquierdo.valorRetorno)
valorDerecho = int(
simboloDerecho.valorRetorno)
elif (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.decimal
) or (
simboloEnviar.tipDatoCasteo ==
simboloColumna.TiposDatos.numeric
) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.real
) or (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.
double_precision) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.
TiposDatos.money):
valorIzquierdo = float(
simboloIzquierdo.valorRetorno)
valorDerecho = float(
simboloDerecho.valorRetorno)
elif (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.varchar
) or (simboloEnviar.tipDatoCasteo
== simboloColumna.TiposDatos.
character) or (
simboloEnviar.tipDatoCasteo
== simboloColumna.
TiposDatos.text):
valorIzquierdo = str(
simboloIzquierdo.valorRetorno)
valorDerecho = str(
simboloDerecho.valorRetorno)
elif (simboloEnviar.tipDatoCasteo ==
simboloColumna.TiposDatos.date):
pass
elif simboloEnviar.tipDatoCasteo == simboloColumna.TiposDatos.time_No_zone:
pass
elif simboloEnviar.tipDatoCasteo == simboloColumna.TiposDatos.time_si_zone:
pass
elif simboloEnviar.tipDatoCasteo == simboloColumna.TiposDatos.boolean:
valorIzquierdo = str(
simboloIzquierdo.valorRetorno)
valorDerecho = str(
simboloDerecho.valorRetorno)
if valorIzquierdo.lower() == "true":
valorIzquierdo = True
else:
valorIzquierdo = False
if valorDerecho.lower() == "false":
valorDerecho = True
else:
valorDerecho = False
# se ve que tipo de operacion es
if self.tipoOperacion == tipoSimbolo.TipoSimbolo.SUMA:
resultado = valorIzquierdo + valorDerecho
simboloEnviar.valorRetorno = resultado
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.RESTA:
resultado = valorIzquierdo - valorDerecho
simboloEnviar.valorRetorno = resultado
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.MULTIPLICACION:
resultado = valorIzquierdo * valorDerecho
simboloEnviar.valorRetorno = resultado
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.DIVISION:
resultado = valorIzquierdo / valorDerecho
simboloEnviar.valorRetorno = resultado
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.POTENCIA:
resultado = pow(
valorIzquierdo, valorDerecho)
simboloEnviar.valorRetorno = resultado
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.MODULO:
resultado = valorIzquierdo % valorDerecho
simboloEnviar.valorRetorno = resultado
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.IGUALACION:
if valorIzquierdo == valorDerecho:
simboloEnviar.valorRetorno = True
else:
simboloEnviar.valorRetorno = False
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.DISTINTO:
if valorIzquierdo != valorDerecho:
simboloEnviar.valorRetorno = True
else:
simboloEnviar.valorRetorno = False
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.MAYOR_QUE:
if valorIzquierdo > valorDerecho:
simboloEnviar.valorRetorno = True
else:
simboloEnviar.valorRetorno = False
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.MAYOR_IGUAL:
if valorIzquierdo >= valorDerecho:
simboloEnviar.valorRetorno = True
else:
simboloEnviar.valorRetorno = False
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.MENOR_QUE:
if valorIzquierdo < valorDerecho:
simboloEnviar.valorRetorno = True
else:
simboloEnviar.valorRetorno = False
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.MENOR_IGUAL:
if valorIzquierdo <= valorDerecho:
simboloEnviar.valorRetorno = True
else:
simboloEnviar.valorRetorno = False
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.AND:
if valorIzquierdo and valorDerecho:
simboloEnviar.valorRetorno = True
else:
valorDerecho.valorRetorno = False
return simboloEnviar
elif self.tipoOperacion == tipoSimbolo.TipoSimbolo.OR:
if valorIzquierdo or valorDerecho:
simboloEnviar.valorRetorno = True
else:
simboloEnviar.valorRetorno = False
return simboloEnviar
else:
errorRep = errorReportar.ErrorReportar(
self.fila, self.columna, "Semántico",
"Tipos de datos no encontrados para la operacion"
)
listaErrores.append(errorRep)
return None
else:
errorRep = errorReportar.ErrorReportar(
self.fila, self.columna, "Semántico",
"Tipos de datos no encontrados para la operacion"
)
listaErrores.append(errorRep)
return None
else:
errorRep = errorReportar.ErrorReportar(
self.fila, self.columna, "Semántico",
"Tipos de datos no encontrados para la operacion"
)
listaErrores.append(errorRep)
return None
else:
return None
else:
return None
return None
def ejecutar(self, tabalSimbolos, listaErrores):
baseDatos = tabalSimbolos.useDataBase
bandera = baseDatos.comprobarNombreTabla(self.identificador)
if bandera == 1:
#Tabla ya existe
errorEnviar = errorReportar.ErrorReportar(self.fila, self.columna,
"Ejecucion",
"Error 42P07")
listaErrores.append(errorEnviar)
return
else:
#Nombre de tabla no existe en base de datos
numColumnas = 0
for columna in self.columnas:
try:
if columna.hijos[0].nombreNodo == "ID":
numColumnas = numColumnas + 1
except:
pass
respuesta = jsonMode.createTable(tabalSimbolos.useDataBase.nombre,
self.identificador, numColumnas)
#Valor de retorno: 0 operación exitosa, 1 error en la operación, 2 base de datos inexistente, 3 tabla existente.
if respuesta == 2:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error, base de datos inexistente")
listaErrores.append(errorEnviar)
return
elif respuesta == 3:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion", "Error 42P07")
listaErrores.append(errorEnviar)
return
elif respuesta == 1:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error en la operacion")
listaErrores.append(errorEnviar)
return
elif respuesta == 0:
#modificar el nombre que se envia de base de datos
tablaGuardar = simboloTabla.SimboloTablas(self.identificador)
try:
if self.herencia[0].hijos[0].nombreNodo == "ID":
comprobar = baseDatos.comprobarNombreTabla(
self.herencia[0].hijos[0].valor)
if comprobar == 1:
tablaHerencia = baseDatos.obtenerTabla(
self.herencia[0].hijos[0].valor)
tablaGuardar.columnas = tablaHerencia.columnas
except:
pass
indice = len(tablaGuardar.columnas)
for columna in self.columnas:
try:
if columna.hijos[0].nombreNodo == "ID":
nuevaColumna = simboloColumna.SimboloColumna(
indice, columna.hijos[0].valor,
columna.hijos[1].valor)
#Es un tipo de dato no primitivo
if nuevaColumna.tipoDato == simboloColumna.TiposDatos.enum:
simboloNuevo = baseDatos.obtenerTipoDatoNoPrimitivo(
columna.hijos[1].valor)
if simboloNuevo != None:
# seteas la instancia de nodo simboloNuevoTipo
nuevaColumna.tipoDatoNOprimitivo = simboloNuevo
else:
#mandas error
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 42704: Tipo de dato no existe")
listaErrores.append(errorEnviar)
return
pass
self.especificarColumnas(columna.hijos[2],
nuevaColumna, baseDatos,
listaErrores)
tablaGuardar.agregarColumna(nuevaColumna)
elif columna.hijos[0].nombreNodo == "PRIMARY":
encontro = False
for nodoId in columna.hijos[1].hijos:
for columnaEvaluar in tablaGuardar.columnas:
if nodoId.valor.lower(
) == columnaEvaluar.nombre.lower():
encontro = True
columnaEvaluar.crearLlavePrimaria()
print(
"setear llave primaria si existen las columnas: "
+ nodoId.valor.lower())
if encontro == False:
#Id de columna llamado en llave no existe Error 42703
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 42703")
listaErrores.append(errorEnviar)
print(
"Id de columna llamado en llave no existe: "
+ nodoId.valor.lower())
return
elif encontro == True:
encontro = False
elif columna.hijos[0].nombreNodo == "FOREIGN":
print(
"setear llave foranea si existen las columnas")
elif columna.hijos[0].nombreNodo == "UNIQUE":
print(
"setear llave foranea si existen las columnas")
except:
pass
indice = indice + 1
baseDatos.agregarTabla(tablaGuardar)
return
pass
