def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
# Si existe algún error en el operador izquierdo, retorno el error.
resultadoIzq = self.opIzq.ejecutar(tabla, arbol)
if isinstance(resultadoIzq, Excepcion):
return resultadoIzq
# Si existe algún error en el operador derecho, retorno el error.
resultadoDer = self.opDer.ejecutar(tabla, arbol)
if isinstance(resultadoDer, Excepcion):
return resultadoDer
if (self.opIzq.tipo.tipo == Tipo_Dato.INTEGER
or self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION
or self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC) and (
self.opDer.tipo.tipo == Tipo_Dato.INTEGER
or self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION
or self.opDer.tipo.tipo == Tipo_Dato.NUMERIC):
if resultadoDer == 0:
error = Excepcion('42883', "Semántico",
"No se puede dividir entre cero", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return int(resultadoIzq // resultadoDer)
else:
error = Excepcion(
'42883', "Semántico",
"el operador no existe: " + self.opIzq.tipo.toString() +
" / " + self.opDer.tipo.toString(), self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
bandera = False
#SE OBTIENE LA LISTA DE BD
lb = showDatabases()
#SE RECORRE LA BD PARA VERIFICAR QUE NO EXISTA
if self.base in lb:
dropDatabase(self.base)
result = createDatabase(self.base)
if result == 0:
#CUANDO LA TABLA SE CREA CORRECTAMENTE
arbol.consola.append(
f"La Base de Datos: {self.base} fue reemplazada.")
arbol.eliminarBD(self.base)
nueva = BaseDeDatos(str(self.base))
arbol.setListaBd(nueva)
elif result == 2:
error = Excepcion("100", "Semantico", "Error Interno.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
else:
result = createDatabase(self.base)
if result == 0:
#CUANDO LA TABLA SE CREA CORRECTAMENTE
arbol.consola.append(
f"La Base de Datos: {self.base} se creo correctamente.")
nueva = BaseDeDatos(str(self.base))
arbol.setListaBd(nueva)
elif result == 2:
error = Excepcion("100", "Semantico", "Error Interno.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
'''for bd in lb:
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
resultado = self.valor.ejecutar(tabla, arbol)
if isinstance(resultado, Excepcion):
return resultado
if self.valor.tipo.tipo != Tipo_Dato.SMALLINT and self.valor.tipo.tipo != Tipo_Dato.INTEGER and self.valor.tipo.tipo != Tipo_Dato.BIGINT and self.valor.tipo.tipo != Tipo_Dato.DECIMAL and self.valor.tipo.tipo != Tipo_Dato.NUMERIC and self.valor.tipo.tipo != Tipo_Dato.REAL and self.valor.tipo.tipo != Tipo_Dato.DOUBLE_PRECISION:
error = Excepcion(
'42883', "Semántico", "No existe la función tand(" +
self.valor.tipo.toString() + ")", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
try:
if resultado % 90 == 0:
return (0, float('inf'), 0,
float('-inf'))[int(resultado // 90) % 4]
else:
return math.tan(math.radians(resultado))
except ValueError as c:
error = Excepcion('22003', "Semántico",
"La entrada está fuera de rango", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
resultado = self.valor.ejecutar(tabla, arbol)
if self.valor.tipo.tipo != Tipo_Dato.SMALLINT and self.valor.tipo.tipo != Tipo_Dato.INTEGER and self.valor.tipo.tipo != Tipo_Dato.BIGINT and self.valor.tipo.tipo != Tipo_Dato.DECIMAL and self.valor.tipo.tipo != Tipo_Dato.NUMERIC and self.valor.tipo.tipo != Tipo_Dato.REAL and self.valor.tipo.tipo != Tipo_Dato.DOUBLE_PRECISION:
error = Excepcion(
'42883', "Semántico",
"No existe la función ln(" + self.valor.tipo.toString() + ")",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if resultado < 0:
error = Excepcion(
'2201F', "Semántico",
"La función LN únicamente acepta valores númericos positivos",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if isinstance(resultado, int):
self.tipo = Tipo("", Tipo_Dato.DOUBLE_PRECISION)
return math.log2(resultado)
else:
self.tipo = Tipo("", Tipo_Dato.NUMERIC)
return math.log2(resultado)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if arbol.bdUsar != None:
objetoTabla = arbol.devolviendoTablaDeBase(self.tabla)
if objetoTabla != None:
listaUnique = []
listaNombres = []
'''
for columnas in objetoTabla.lista_de_campos:
listaNombres.append(columnas.nombre)
'''
for c in self.lista_col:
for columnas in objetoTabla.lista_de_campos:
if columnas.nombre == c:
listaUnique.append(columnas)
listaNombres.append(columnas.nombre)
if (len(listaUnique) == len(self.lista_col)):
print(len(listaUnique), self.tabla, self.id)
#Insertar llaves Unique
else:
lista = set(self.lista_col) - set(listaNombres)
#print(listaNombres,self.lista_col)
#print(lista)
for i in lista:
error = Excepcion(
'42P01', "Semántico",
"No existe la columna «" + i + "» en la llave",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return
else:
error = Excepcion('42P01', "Semántico",
"No existe la relación " + self.tabla,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion("100", "Semantico",
"No ha seleccionado ninguna Base de Datos.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
def t_error(t):
global columna
#print("Illegal character '%s'" % t.value[0])
#print(t.value)
#print("fila ", t.lexer.lineno)
#print("Columna ", columas(columna))
col = columas(columna)
dato = Excepcion(
0, "Error Lexico",
f"El Simbolo << {t.value[0]} >> No Pertenece al Lenguaje",
t.lexer.lineno, col)
lista_errores_lexico.append(dato)
t.lexer.skip(1)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
#SE OBTIENE LA LISTA DE BD
arbol.lRepDin.append(self.strGram)
lb = showDatabases()
#SE RECORRE LA BD PARA VERIFICAR QUE NO EXISTA
for bd in lb:
if bd == self.valor:
#SI SE ENCUENTRA LA BD SE TERMINA EL RECORRIDO
arbol.setBaseDatos(self.valor)
#llenar la base de datos
if (arbol.existeBd(self.valor) == 0):
nueva = BaseDeDatos(self.valor)
arbol.setListaBd(nueva)
arbol.llenarTablas(nueva)
arbol.consola.append(
f"Se selecciono la BD: {self.valor} correctamente.")
return
error = Excepcion("100", "Semantico", f"No existe la BD: {self.valor}",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
resultado = self.valor.ejecutar(tabla, arbol)
if isinstance(resultado, Excepcion):
return resultado
suma = 0
for x in range(0, len(resultado)):
print(f"posicion {x}")
print(f"valor {resultado[x][0]}")
if str.isnumeric(resultado[x][0]):
suma += int(resultado[x][0])
elif str.isdecimal(resultado[x][0]):
suma += float(resultado[x][0])
else:
error = Excepcion("22023", "Semantico",
"Parametro de evaluacion invalido",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
suma = suma / len(resultado)
return np.array([[suma]])
def analizar(self, tabla, arbol):
super().analizar(tabla,arbol)
# ¿Hay errrores en los parámetros?
listaTiposArgumentos = []
for i in self.lista_expresion:
resultado = i.analizar(tabla, arbol)
if isinstance(resultado, Excepcion):
return resultado
listaTiposArgumentos.append(resultado)
f = tabla.getSimboloFuncion(self.id)
if f == None:
error = Excepcion("42723", "Semantico", f"No existe la función {self.id}.", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
listaTiposFuncion = []
for i in f.funcion.parametros:
listaTiposFuncion.append(i.tipo)
if len(listaTiposArgumentos) != len(listaTiposFuncion):
error = Excepcion("42723", "Semantico", f"La cantidad de argumentos no coincide con la cantidad de parámetros en la función {self.id}.", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
hayError = False
for i in range(0,len(listaTiposFuncion)):
comprobar = self.comprobarTipo(listaTiposFuncion[i], listaTiposArgumentos[i], None)
if not comprobar:
error = Excepcion("42723", "Semantico", f"Los tipos de argumentos no coincide con los tipos de parámetros en la función {self.id}.", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
if hayError:
return
if f.tipo.tipo == Tipo_Dato.VOID:
return None
return f.tipo
def analizar(self, tabla, arbol):
super().analizar(tabla, arbol)
retorno = None
resultado = self.condicion.analizar(tabla, arbol)
if not isinstance(resultado, Excepcion):
self.tipo = resultado
for i in self.instrucciones:
r = i.analizar(tabla, arbol)
if isinstance(r, Excepcion):
return None
if isinstance(r, Return):
retorno = r
if resultado.tipo != Tipo_Dato.BOOLEAN:
error = Excepcion(
"22023", "Semantico",
"Tipo de datos incorrecto, se esperaba un valor de tipo boolean para la condición.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return retorno
def p_error(p):
if not p:
print("Fin del Archivo!")
return
dato = Excepcion(1, "Error Sintáctico",
f"Se esperaba una instrucción y viene {p.value}",
p.lexer.lineno, find_column(lexer.lexdata, p))
lista_lexicos.append(dato)
while True:
tok = parser.token() # Get the next token
if not tok or tok.type == 'PUNTO_COMA':
if not tok:
print("FIN DEL ARCHIVO")
else:
print("Se recupero con ;")
break
dato = Excepcion(1, "Error Sintáctico",
f"Se esperaba una instrucción y viene {tok.value}",
p.lexer.lineno, find_column(lexer.lexdata, tok))
lista_lexicos.append(dato)
parser.restart()
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
val = self.idTabla.devolverTabla(tabla, arbol)
print("El wkkkkkkene vacio")
if (val == 0):
error = Excepcion(
"42P01", "Semantico", "La tabla " +
str(self.identificador.devolverId(tabla, arbol)) +
" no existe", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
print('Error tabla no existe')
return error
print("Eiiiiiiiviene vacio")
tablaIndex = extractTable(arbol.getBaseDatos(), val)
arbol.setTablaActual(tablaIndex)
columnas = arbol.devolverColumnasTabla(val)
print("El jjjjjjjjene vacio")
data = np.array((tablaIndex))
res = []
# vamos a mostrar todos
for x in range(0, len(columnas)):
col = columnas[x].obtenerNombre()
res.append(col)
arbol.setColumnasActual(res)
## solo me quedaria buscar entre las columnas si existe la columnas
print(res)
print("El wheracio")
if self.where:
print("El where no viene vacio")
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
bandera = False
#SE OBTIENE LA LISTA DE BD
lb = showDatabases()
#SE RECORRE LA BD PARA VERIFICAR QUE NO EXISTA
for bd in lb:
if bd == self.base:
#SI SE ENCUENTRA LA BD SE TERMINA EL RECORRIDO
bandera = True
break
if self.existe == "IF NOT EXISTS" and bandera == True:
arbol.consola.append(f"La Base de Datos ya existe: {self.base}.")
print(f"LA BASE DE DATOS: {self.base} YA EXISTE.")
elif self.existe == "IF NOT EXISTS" and bandera == False:
arbol.consola.append(
f"Se Creo la base de datos: {self.base} correctamente.")
print(f"SE CREO LA BASE DE DATOS: {self.base} CORRECTAMENTE.")
createDatabase(str(self.base))
nueva = BaseDeDatos(str(self.base))
arbol.setListaBd(nueva)
elif self.existe == "NULL" and bandera == True:
error = Excepcion("42P04", "Semantico",
f"La Base de Datos {self.base} ya Existe.",
self.linea, self.columna)
print(f"LA BASE DE DATOS: {self.base} YA EXISTE.")
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
elif self.existe == "NULL" and bandera == False:
#AVISOS
arbol.consola.append(
f"Se Creo la base de datos: {self.base} correctamente.")
print(f"SE CREO LA BASE DE DATOS: {self.base} CORRECTAMENTE.")
createDatabase(str(self.base))
nueva = BaseDeDatos(str(self.base))
arbol.setListaBd(nueva)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
#aqui vamos a renombrar el alter
res = alterDatabase(self.nombreAntiguo, self.nombreNuevo)
if (res == 1):
Excepcion(3, "Semántico", "No se pudo renombrar la base de datos",
self.linea, self.columna)
elif (res == 2):
error = Excepcion("100", "Semantico", "La bd no existe.",
self.linea, self.columna)
elif (res == 3):
error = Excepcion("100", "Semantico", "La bd nueva ya existe.",
self.linea, self.columna)
else:
if (len(arbol.listaBd) == 0):
#aqui vamos a renombrar en memoria
Instruccion = ShowDatabases(None, None, self.linea,
self.columna)
Instruccion.ejecutar(tabla, arbol)
'''
import os
archivo = "/home/decodigo/Documentos/python/archivos/archivo.txt"
nombre_nuevo = "/home/decodigo/Documentos/python/archivos/archivo_renombrado.txt"
os.rename(archivo, nombre_nuevo)
'''
arbol.consola.append(
f"La base de datos se cambio: {self.nombreNuevo} correctamente."
)
else:
#aqui vamos a renombrar en memoria
arbol.renombrarBd(self.nombreAntiguo, self.nombreNuevo)
arbol.consola.append(
f"La base de datos se cambio: {self.nombreNuevo} correctamente."
)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if (arbol.getWhere() or arbol.getUpdate()):
print("True")
res = 0
encontrado = 0
#aqui deberia tener un arbol con lista de columnas
for x in range(0, len(arbol.getColumnasActual())):
print(x)
valor = arbol.getColumnasActual()
if (valor[x] == self.id):
res = x
encontrado = 1
if (encontrado == 0):
error = Excepcion("42P10", "Semantico",
"La columna " + str(self.id) + " no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
return res
#self.id
else:
# Tengo que traer la variable
indice = arbol.devolverOrdenDeColumna(arbol.getNombreTabla(),
self.id)
#print("INDICE----------->",arbol.getNombreTabla(),indice,self.id)
columnas = arbol.getTablaActual()
columnas = np.array(columnas)
columna = columnas[:, [indice]]
self.tipo = arbol.devolverTipoColumna(arbol.getNombreTabla(),
self.id)
return columna
'''
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if arbol.bdUsar != None:
objetoTabla = arbol.devolviendoTablaDeBase(self.tabla)
if objetoTabla != 0:
existe = None
constraintBorrar = None
for columnas in objetoTabla.lista_de_campos:
if columnas.constraint != None:
for const in columnas.constraint:
if const.id == self.col:
existe = columnas
constraintBorrar = const
if existe != None:
existe.constraint.remove(constraintBorrar)
arbol.consola.append("Consulta devuelta correctamente.")
print(
"Consulta ALTER TABLE DROP CONSTRAINT devuelta correctamente"
)
else:
error = Excepcion(
'42P01', "Semántico",
"No existe la columna «" + self.col + "» en la llave",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion('42P01', "Semántico",
"No existe la relación " + self.tabla,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion("100", "Semantico",
"No ha seleccionado ninguna Base de Datos.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
'''
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
encontrado = False
for db in arbol.listaBd:
for t in db.tablas:
for i in range(len(t.lista_de_campos)):
c = t.lista_de_campos[i]
if c.tipo.toString() == "index":
if c.nombre == self.nombre:
encontrado = True
break
if not encontrado and self.existe:
error = Excepcion('INX03', "Semántico", "No existe un índice llamado «" + self.nombre + "»", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append("\n" + error.toString())
err = True
return
elif not encontrado:
arbol.consola.append("\nNo se ha encontrado el índice «" + self.nombre + "».")
return
else:
t.lista_de_campos.pop(i)
arbol.consola.append("\nSe ha eliminado el índice «" + self.nombre + "» correctamente.")
return
def obtenerCampo(self, indice, ntabla, lista):
actual = 0
for tabla in lista:
if tabla.nombreDeTabla == ntabla:
for atributo in tabla.lista_de_campos:
if atributo.tipo.toString() != "index":
actual = actual + 1
if actual == indice:
self.ncolum = atributo
return
self.ncolum = Excepcion(
"INX04", "Semántico",
"El número de columna «" + str(indice) +
"» no se encuentra en el rango de campos de la tabla «" +
ntabla + "».", self.linea, self.columna)
return
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if (arbol.getWhere() or arbol.getUpdate()):
print("True")
res = 0
encontrado = 0
#aqui deberia tener un arbol con lista de columnas
for x in range(0, len(arbol.getColumnasActual())):
print(x)
valor = arbol.getColumnasActual()
if (isinstance(valor[x], Campo)):
if (valor[x].nombre == self.id):
res = x
encontrado = 1
else:
if (valor[x] == self.id):
res = x
encontrado = 1
if (encontrado == 0):
error = Excepcion("42P10", "Semantico",
"La columna " + str(self.id) + " no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
return res
#self.id
elif arbol.comprobacionCreate:
variable = tabla.getVariable(self.id)
if variable == None:
error = Excepcion("42P10", "Semantico",
"La columna " + str(self.id) + " no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
self.tipo = variable.tipo
arbol.columnaCheck = self.id
return variable.valor
else:
# Tengo que traer la variable
indice = arbol.devolverOrdenDeColumna(arbol.getNombreTabla(),
self.id)
#print("INDICE----------->",arbol.getNombreTabla(),indice,self.id)
tablaSelect = extractTable(arbol.getBaseDatos(),
arbol.getNombreTabla())
col = [[item[indice]] for item in tablaSelect]
columnas = np.array(col)
#print(col)
self.tipo = arbol.devolverTipoColumna(arbol.getNombreTabla(),
self.id)
return columnas
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
# Ambito para la tabla
tablaLocal = Tabla(tabla)
if arbol.bdUsar != None:
objetoTabla = arbol.devolviendoTablaDeBase(self.tabla)
if objetoTabla != 0:
for columnas in objetoTabla.lista_de_campos:
arbol.comprobacionCreate = True
objeto = Declaracion(columnas.nombre, columnas.tipo, None)
objeto.ejecutar(tablaLocal, arbol)
resultado = self.condicion.ejecutar(tablaLocal, arbol)
if isinstance(resultado, Excepcion):
return resultado
# Buscamos el nombre del constraint
col = None
for columnas in objetoTabla.lista_de_campos:
if columnas.nombre == arbol.columnaCheck:
col = columnas
break
nombre = ''
if col.constraint != None:
for const in columnas.constraint:
if const.tipo == Tipo_Dato_Constraint.CHECK:
nombre = const.id
last_char = nombre[-1]
sinNumero = nombre[:-1]
nuevo = sinNumero + str(int(last_char) + 1)
col.constraint.append(
Tipo_Constraint(nuevo, Tipo_Dato_Constraint.CHECK,
self.condicion))
else:
col.constraint = []
col.constraint.append(
Tipo_Constraint(
self.tabla + "_" + arbol.columnaCheck + "_check1",
Tipo_Dato_Constraint.CHECK, self.condicion))
arbol.comprobacionCreate = False
arbol.columnaCheck = None
arbol.consola.append("Consulta devuelta correctamente.")
print("Constulta ALTER CHECK devuelta correctamente")
else:
error = Excepcion('42P01', "Semántico",
"No existe la relación " + self.tabla,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion("100", "Semantico",
"No ha seleccionado ninguna Base de Datos.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla,arbol)
resultado = self.valor.ejecutar(tabla,arbol)
if self.valor.tipo.tipo != Tipo_Dato.INTEGER:
error = Excepcion('42883',"Semántico","No existe la función factorial("+self.valor.tipo.toString()+")",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if resultado < 0:
error = Excepcion('2201F',"Semántico","La función FACTORIAL únicamente acepta valores númericos positivos",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return math.factorial(resultado)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla,arbol)
resultado = self.valor.ejecutar(tabla,arbol)
if self.valor.tipo.tipo != Tipo_Dato.SMALLINT and self.valor.tipo.tipo != Tipo_Dato.INTEGER and self.valor.tipo.tipo != Tipo_Dato.BIGINT and self.valor.tipo.tipo != Tipo_Dato.DECIMAL and self.valor.tipo.tipo != Tipo_Dato.NUMERIC and self.valor.tipo.tipo != Tipo_Dato.REAL and self.valor.tipo.tipo != Tipo_Dato.DOUBLE_PRECISION:
error = Excepcion('42883',"Semántico","No existe la función sqrt("+self.valor.tipo.toString()+")",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if resultado < 0:
error = Excepcion('42883',"Semántico","No se puede calcular la raíz cuadrada un de número negativo",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if isinstance(resultado,int):
return int(math.sqrt(resultado))
else:
return math.sqrt(resultado)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if (self.valor != None):
if (self.insWhere != None):
#delete(database: str, table: str, columns: list)
arregloDeColumnasAEliminar = []
#primero vamos a extraer la tabla
if (arbol.getBaseDatos() != None):
#resE = extractTable(arbol.getBaseDatos(),self.valor)
#print("Entro al delete")
tablaSelect = extractTable(arbol.getBaseDatos(),
self.valor)
if (self.insWhere != None):
#ejecutar el inswhere que me devuelva las columnas
arbol.setTablaActual(tablaSelect)
columnas = arbol.devolverColumnasTabla(self.valor)
arbol.setColumnasActual(columnas)
arregloDeColumnasAEliminar = self.insWhere.ejecutar(
tabla, arbol)
arregloAEliminar = self.devolverIdentificadores(
tablaSelect, arregloDeColumnasAEliminar)
for d in arregloAEliminar:
res = delete(arbol.getBaseDatos(), self.valor,
[d]) #SI IMPRIME 0, BORRO CON EXITO
if (res == 0):
arbol.consola.append(
f"Se elimino el siguiente registro { d } correctamente."
)
print(
"Se ejecutó correctamente el DELETE FROM\n"
)
else:
error = Excepcion("42P10", "Semantico",
f"No se elimino :'( ",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
else:
#error no hay base de datos
error = Excepcion("42P10", "Semantico",
f"No hay base de datos", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla,arbol)
resultado = self.valor.ejecutar(tabla,arbol)
if isinstance(resultado, Excepcion):
return resultado
if self.valor.tipo.tipo != Tipo_Dato.SMALLINT and self.valor.tipo.tipo != Tipo_Dato.INTEGER and self.valor.tipo.tipo != Tipo_Dato.BIGINT and self.valor.tipo.tipo != Tipo_Dato.DECIMAL and self.valor.tipo.tipo != Tipo_Dato.NUMERIC and self.valor.tipo.tipo != Tipo_Dato.REAL and self.valor.tipo.tipo != Tipo_Dato.DOUBLE_PRECISION:
error = Excepcion('42883',"Semántico","No existe la función asind("+self.valor.tipo.toString()+")",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
try:
if resultado == 1: return 90
if resultado == 0: return 0
if resultado == -1: return -90
return math.degrees(math.asin(resultado))
except ValueError as c:
error = Excepcion('22003',"Semántico","La entrada está fuera de rango",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
# Si existe algún error en el operador izquierdo, retorno el error.
resultadoIzq = self.opIzq.ejecutar(tabla, arbol)
if isinstance(resultadoIzq, Excepcion):
return resultadoIzq
# Si existe algún error en el operador derecho, retorno el error.
resultadoDer = self.opDer.ejecutar(tabla, arbol)
if isinstance(resultadoDer, Excepcion):
return resultadoDer
if (self.opIzq.tipo.tipo != Tipo_Dato.SMALLINT
and self.opIzq.tipo.tipo != Tipo_Dato.INTEGER
and self.opIzq.tipo.tipo != Tipo_Dato.BIGINT
and self.opIzq.tipo.tipo != Tipo_Dato.DECIMAL
and self.opIzq.tipo.tipo != Tipo_Dato.NUMERIC
and self.opIzq.tipo.tipo != Tipo_Dato.REAL
and self.opIzq.tipo.tipo != Tipo_Dato.DOUBLE_PRECISION) or (
self.opDer.tipo.tipo != Tipo_Dato.SMALLINT
and self.opDer.tipo.tipo != Tipo_Dato.INTEGER
and self.opDer.tipo.tipo != Tipo_Dato.BIGINT
and self.opDer.tipo.tipo != Tipo_Dato.DECIMAL
and self.opDer.tipo.tipo != Tipo_Dato.NUMERIC
and self.opDer.tipo.tipo != Tipo_Dato.REAL
and self.opDer.tipo.tipo != Tipo_Dato.DOUBLE_PRECISION):
error = Excepcion(
'42883', "Semántico",
"No existe la función atan2d(" + self.opIzq.tipo.toString() +
"," + self.opDer.tipo.toString() + ")", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
try:
return math.degrees(math.atan2(resultadoIzq, resultadoDer))
except ValueError as c:
error = Excepcion('22003', "Semántico",
"La entrada está fuera de rango", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
def analizar(self, tabla, arbol):
super().analizar(tabla, arbol)
tablaLocal = Tabla(None)
for i in self.parametros:
i.analizar(tablaLocal, arbol)
for i in self.declaraciones:
i.analizar(tablaLocal, arbol)
tablaLocal.anterior = tabla
esFuncion = False
if self.tipo.tipo != Tipo_Dato.VOID:
esFuncion = True
hayReturn = False
for i in self.instrucciones:
resultado = i.analizar(tablaLocal, arbol)
if isinstance(i, Retorno):
if isinstance(resultado, Excepcion):
return resultado
hayReturn = True
if esFuncion and not hayReturn:
error = Excepcion(
"42723", "Semantico",
f"La función {self.id} requiere un valor de retorno",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if not esFuncion and hayReturn:
error = Excepcion(
"42723", "Semantico",
f"El método {self.id} no requiere un valor de retorno",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if self.label is not None:
if self.label[0] == self.label[1]:
self.label = (self.label[0])[2:-2]
else:
error = Excepcion("LOO00", "Semántico",
"Los labels de inicio y fin no coinciden.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return
for s in self.sentencias:
if isinstance(s, Exit):
if s.label is not None and self.label != s.label:
error = Excepcion(
"LOO01", "Semántico",
"El label de Exit no coincide con el del Loop.",
s.linea, s.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
def analizar(self, tabla, arbol):
super().analizar(tabla, arbol)
existe = tabla.getSimboloVariable(self.id)
if existe != None:
error = Excepcion("42723", "Semantico",
f"La variable {self.id} ya ha sido declarada",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if self.expresion == None:
variable = Simbolo(self.id, self.tipo, None, self.linea,
self.columna)
if self.constante:
variable.rol = "Variable Local"
else:
variable.rol = "Constante"
tabla.agregarSimbolo(variable)
else:
resultado = self.expresion.analizar(tabla, arbol)
if isinstance(resultado, Excepcion):
return resultado
comprobar = self.comprobarTipo(self.tipo, resultado, None)
if not comprobar:
error = Excepcion("42723", "Semantico",
f"Los tipos de datos no coinciden",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
variable = Simbolo(self.id, self.tipo, None, self.linea,
self.columna)
if self.constante:
variable.rol = "Variable Local"
else:
variable.rol = "Constante"
tabla.agregarSimbolo(variable)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla,arbol)
objetoTabla = arbol.devolviendoTablaDeBase(self.id_tabla)
if objetoTabla !=None:
bandera =False
for indi in objetoTabla.lista_de_indices:
if indi.nombre == self.id_index:
objetoTabla.lista_de_indices.remove(indi)
bandera= True
arbol.consola.append(f"Se borro el Index: {self.id_index} correctamente.")
break
if not bandera:
error = Excepcion('42704',"Semántico","No existe el indice «"+ self.id_tabla +"».",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion('42704',"Semántico","La Tabla: «"+ self.id_tabla +"» no existe.",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
# Si existe algún error en el operador izquierdo, retorno el error.
resultadoIzq = self.opIzq.ejecutar(tabla, arbol)
if isinstance(resultadoIzq, Excepcion):
return resultadoIzq
# Si existe algún error en el operador derecho, retorno el error.
resultadoDer = self.opDer.ejecutar(tabla, arbol)
if isinstance(resultadoDer, Excepcion):
return resultadoDer
if (self.opIzq.tipo.tipo == Tipo_Dato.INTEGER
or self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION
or self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC) and (
self.opDer.tipo.tipo == Tipo_Dato.INTEGER
or self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION
or self.opDer.tipo.tipo == Tipo_Dato.NUMERIC):
if resultadoDer < 0 or resultadoIzq < 0:
error = Excepcion(
'42883', "Semántico",
"La función POWER únicamente acepta valores númericos positivos",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if isinstance(resultadoIzq, int) and isinstance(resultadoDer, int):
self.tipo = Tipo("", Tipo_Dato.DOUBLE_PRECISION)
return int(math.pow(resultadoIzq, resultadoDer))
else:
self.tipo = Tipo("", Tipo_Dato.NUMERIC)
return math.pow(resultadoIzq, resultadoDer)
else:
error = Excepcion(
'42883', "Semántico",
"No existe la función power(" + self.opIzq.tipo.toString() +
", " + self.opDer.tipo.toString() + ")", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error