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)
for c in self.lista_col:
resultado = 0
#resultado = alterAddColumn(arbol.getBaseDatos(),self.tabla,c.id)
if resultado == 1:
error = Excepcion('XX000', "Semántico", "Error interno",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 2:
error = Excepcion(
'42P00', "Semántico", "La base de datos " +
str(arbol.getBaseDatos()) + " no existe", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 3:
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
arbol.consola.append("Consulta devuelta correctamente.")
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla,arbol)
bandera = False
arbol.lRepDin.append(self.strGram)
#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)
# 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)
resultado = self.valor.ejecutar(tabla,arbol)
try:
if self.count.tipo.tipo == Tipo_Dato.INTEGER:
print(self.count.tipo.toString(),Tipo_Dato.INTEGER)
temp = (self.max.valor - self.min.valor)/self.count.valor
contador= float(self.min.valor)
cubo=0
if float(resultado)==contador:
self.tipo = Tipo(Tipo_Dato.INTEGER)
return 1
while contador < float(self.max.valor):
if float(resultado)<contador:
self.tipo = Tipo(Tipo_Dato.INTEGER)
return cubo
contador += temp
cubo+=1
self.tipo = Tipo(Tipo_Dato.INTEGER)
return cubo +1
else:
error = Excepcion('42883',"Semántico",f"No existe la función width_bucket({self.valor.tipo.toString()},{self.min.tipo.toString()},{self.max.tipo.toString()},{self.count.tipo.toString()})",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.consola.append("El Cuarto Párametro debe ser Integer.")
return error
except:
error = Excepcion('XX000',"Semántico",f"Error Interno width_bucket",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 and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
if resultadoDer < 0 or resultadoIzq < 0:
error = Excepcion(
'42883', "Semántico",
"La función GCD únicamente acepta valores númericos positivos",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return math.gcd(resultadoIzq, resultadoDer)
else:
error = Excepcion(
'42883', "Semántico",
"No existe la función gcd(" + 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)
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.")
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)
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 exp(" + 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 EXP ú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.exp(resultado)
else:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return math.exp(resultado)
def analizar(self, tabla, arbol):
super().analizar(tabla,arbol)
tablaLocal = Tabla(None)
for i in self.parametros:
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, Return):
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.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.")
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
try:
if self.tipo_salida.tipo == Tipo_Dato.INTEGER:
int(resultado)
self.tipo = Tipo("",Tipo_Dato.INTEGER)
return resultado
elif self.tipo_salida.tipo == Tipo_Dato.SMALLINT:
int(resultado)
self.tipo = Tipo("",Tipo_Dato.SMALLINT)
return resultado
elif self.tipo_salida.tipo == Tipo_Dato.DECIMAL:
float(resultado)
self.tipo = Tipo("",Tipo_Dato.DECIMAL)
return resultado
elif self.tipo_salida.tipo == Tipo_Dato.BOOLEAN:
if bool(resultado):
verdadero = ("true","t","1","yes")
false = ("false","f","0","not")
if resultado in (verdadero + false):
self.tipo = Tipo("",Tipo_Dato.BOOLEAN)
return str(resultado).lower() in verdadero
else:
error = Excepcion('22P02',"Semántico",f"La sintaxis de entrada no es válida para tipo {self.valor.tipo.toString()}: << {resultado} >> a Boolean",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif self.tipo_salida.tipo == Tipo_Dato.DATE:
#formats = ("%d-%m-%Y %I:%M %p", "%d/%m/%Y %I:%M %p")
formats = ("%d-%m-%Y", "%Y-%m-%d","%d-%M-%Y", "%Y-%M-%d","%Y-%b-%d", "%d-%b-%Y")
for fmt in formats:
valid_date=""
try:
valid_date = time.strptime(resultado, fmt)
if isinstance(valid_date, time.struct_time):
self.tipo = Tipo("",Tipo_Dato.DATE)
return time.strftime('%Y-%m-%d',valid_date)
except ValueError as e:
pass
error = Excepcion('22007',"Semántico",f"la sintaxis de entrada no es válida para tipo date: << {resultado} >>",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
except:
error = Excepcion('22P02',"Semántico",f"La sintaxis de entrada no es válida para tipo {self.valor.tipo.toString()}: << {resultado} >>",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
'''
def analizar(self, tabla, arbol):
super().analizar(tabla,arbol)
# Operación con dos operadores
resultadoDer=""
if(self.opDer != None):
# Si existe algún error en el operador izquierdo, retorno el error.
resultadoIzq = self.opIzq.analizar(tabla, arbol)
if isinstance(resultadoIzq, Excepcion):
return resultadoIzq
# Si existe algún error en el operador derecho, retorno el error.
resultadoDer = self.opDer.analizar(tabla, arbol)
if isinstance(resultadoDer, Excepcion):
return resultadoDer
self.opIzq.tipo = resultadoIzq
self.opDer.tipo = resultadoDer
# Comprobamos el tipo de operador
if self.operador == 'OR':
if self.opIzq.tipo.tipo == Tipo_Dato.BOOLEAN and self.opDer.tipo.tipo == Tipo_Dato.BOOLEAN:
return self.tipo
else:
error = Excepcion('42804',"Semántico","El argumento de OR debe ser de tipo boolean",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif self.operador == 'AND':
if self.opIzq.tipo.tipo == Tipo_Dato.BOOLEAN and self.opDer.tipo.tipo == Tipo_Dato.BOOLEAN:
return self.tipo
else:
error = Excepcion('42804',"Semántico","El argumento de AND debe ser de tipo boolean",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion('42804',"Semántico","Operador desconocido.",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
# Operación unaria
else:
# Si existe algún error en el operador izquierdo, retorno el error.
resultadoIzq = self.opIzq.analizar(tabla, arbol)
if isinstance(resultadoIzq, Excepcion):
return resultadoIzq
self.opIzq.tipo = resultadoIzq
if self.operador == 'NOT':
if self.opIzq.tipo.tipo == Tipo_Dato.BOOLEAN:
return self.tipo
else:
error = Excepcion('42804',"Semántico","Tipo de datos incorrectos en la operación lógica not",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion('42804',"Semántico","Operador desconocido.",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 (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 analizar(self, tabla, arbol):
super().analizar(tabla, arbol)
existe = tabla.getSimboloFuncion(self.id)
if existe != None:
if self.parametros == None:
if existe.funcion.activa:
existe.funcion.activa = False
return
else:
error = Excepcion(
"42723", "Semantico",
f"El procedimiento almacenado: {self.id} no existe.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
listaArgumentos = []
for i in self.parametros:
listaArgumentos.append(i.tipo)
listaParametros = []
for i in existe.funcion.parametros:
listaParametros.append(i.tipo.tipo)
if (listaParametros == listaArgumentos):
if existe.funcion.activa:
existe.funcion.activa = False
return
else:
error = Excepcion(
"42723", "Semantico",
f"El procedimiento almacenado: {self.id} no existe.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion(
"42723", "Semantico",
f"El procedimiento almacenado: {self.id} no existe. Los tipos de parámetros no coinciden.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
if self.if_exists == None:
error = Excepcion("42723", "Semantico",
f"La función: {self.id} no existe.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
self.ignora = True
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if arbol.bdUsar != None:
objetoTabla = arbol.devolviendoTablaDeBase(self.tabla)
if objetoTabla != 0:
existe = None
for columnas in objetoTabla.lista_de_campos:
if columnas.nombre == self.col:
existe = columnas
if existe != None:
#print(len(listaUnique),self.tabla, self.id)
#Insertar llaves Unique
if existe.constraint != None:
existe.constraint.append(
Tipo_Constraint(None,
Tipo_Dato_Constraint.NOT_NULL,
None))
#print("MÁS DE UNA-----------------",existe.nombre, existe.tipo.toString(),len(existe.constraint))
else:
existe.constraint = []
existe.constraint.append(
Tipo_Constraint(None,
Tipo_Dato_Constraint.NOT_NULL,
None))
#print("SOLO UNA-------------",existe.nombre, existe.tipo.toString(),len(existe.constraint))
arbol.consola.append("Consulta devuelta correctamente.")
print(
"Consulta ALTER TABLE ALTER COLUMN devuelta correctamente"
)
else:
#print(listaNombres,self.lista_col)
#print(lista)
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)
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 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
else:
if not f.funcion.activa:
error = Excepcion("42723", "Semantico", f"La función: {self.id} no existe.", 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 ejecutar(self, tabla, arbol):
super().ejecutar(tabla,arbol)
resultado = self.valor.ejecutar(tabla, arbol)
if isinstance(resultado, Excepcion):
return resultado
#convertimos los strings a entero
#hacemos un arreglo de ejemplo
listaejemplo = []
for x in range(0, len(resultado)):
print(f"posicion {x}")
print(f"valor {resultado[x][0]}")
if str.isnumeric(resultado[x][0]) :
listaejemplo.append(int(resultado[x][0]))
elif str.isdecimal(resultado[x][0]):
listaejemplo.append(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
listaNums = np.array(listaejemplo)
maximo = np.amax(listaNums)
return np.array([[maximo]])
def llenarTS(self, tabla, arbol):
existe = tabla.getSimboloFuncion(self.id)
if existe != None:
if self.replace != None:
# Espacio para el return
arbol.contador += 1
# Espacio para los parámetros
arbol.contador += len(self.parametros)
existe.rol = "Metodo"
existe.funcion = self
existe.tamanio = arbol.contador
arbol.contador = 0
#print("se limpió? ------------>",arbol.contador, existe.tamanio)
return
else:
error = Excepcion("42723", "Semantico", f"La función {self.id} ya existe.", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if self.tipo.tipo != Tipo_Dato.VOID:
# Espacio para el return
arbol.contador += 1
# Espacio para los parámetros
arbol.contador += len(self.parametros)
f = Simbolo(self.id, self.tipo, "", self.linea, self.columna)
f.rol = "Metodo"
f.funcion = self
f.tamanio = arbol.contador
tabla.agregarSimbolo(f)
arbol.contador = 0
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)
if self.existe == 1:
error = Excepcion(
"42P01", "Semantico",
"El indice " + str(self.id_indice) + " no existe", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
print('ERROR: tabla no existe')
return error
val = self.id_tabla.devolverTabla(tabla, arbol)
objetoTabla = arbol.devolviendoTablaDeBase(val)
# objetoTabla.lista_de_indices.remove(self.id_indice)
for i in objetoTabla.lista_de_indices:
# print("***", i.nombre.id)
ind = Indice(i.nombre.id, "Indice")
# print("---", ind.lRestricciones)
# ind.lRestricciones.remove('id#[\'ASC\', \'NULLS LAST\']')
for a in objetoTabla.lista_de_indices:
if a.nombre.id == self.id_indice:
a.nombre.id = ''
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}.")
elif self.existe=="IF NOT EXISTS" and bandera==False:
arbol.consola.append(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)
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.")
createDatabase(str(self.base))
nueva = BaseDeDatos(str(self.base))
arbol.setListaBd(nueva)
def traducir(self, tabla, arbol,cadenaTraducida):
#Si existe algun error en la expresion logica se devuelve el error
expresion_logica = self.expLogica.traducir(tabla, arbol,cadenaTraducida)
if isinstance(expresion_logica, Excepcion):
return expresion_logica
if expresion_logica.tipo.tipo == Tipo_Dato.BOOLEAN or expresion_logica.tipo.tipo == Tipo_Dato.ID:
#Inicia traduccion
codigo = expresion_logica.codigo
etiquetaSalida = cadenaTraducida
codigo += "\tlabel " + expresion_logica.etiquetaV.replace(":","") + "\n"
for i in self.instrucciones:
instruccion_if = i.traducir(tabla, arbol,cadenaTraducida)
if isinstance(instruccion_if, Excepcion):
return instruccion_if
codigo += instruccion_if
codigo += "\tgoto ." + etiquetaSalida + "\n"
codigo += "\tlabel " + expresion_logica.etiquetaF.replace(":","") + "\n"
return codigo
# ...
# if temporal_logico:
# goto L1
# goto L2
# label L1
# instrucciones_if
# goto Lsalida
# label L2
# ...
else:
error = Excepcion('42804',"Semántico","La expresion logica debe ser de tipo boolean",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
def traducir(self, tabla, arbol, cadenaTraducida):
#Si existe algun error en la expresion logica se devuelve el error
expresion_logica = self.expLogica.traducir(tabla, arbol,
cadenaTraducida)
if isinstance(expresion_logica, Excepcion):
return expresion_logica
if expresion_logica.tipo.tipo == Tipo_Dato.BOOLEAN or expresion_logica.tipo.tipo == Tipo_Dato.ID:
#Inicia traduccion
etiquetaSalida = arbol.generaEtiqueta()
codigo = expresion_logica.codigo
codigo += "\tlabel " + expresion_logica.etiquetaF.replace(
":", "") + "\n"
#Sentencias elseif
for s_if in self.l_elseif:
sentencia_if = s_if.traducir(tabla, arbol, etiquetaSalida)
if isinstance(sentencia_if, Excepcion):
return sentencia_if
codigo += sentencia_if
#Label si el primer if es verdadero
codigo += "\tgoto " + etiquetaSalida + "\n"
codigo += "\tlabel " + expresion_logica.etiquetaV.replace(
":", "") + "\n"
#instrucciones if principal
for i in self.instrIfVerdadero:
instruccion_if = i.traducir(tabla, arbol, cadenaTraducida)
if isinstance(instruccion_if, Excepcion):
return instruccion_if
codigo += instruccion_if
codigo += "\tlabel " + etiquetaSalida + "\n"
return codigo
# ...
# if temporal_logico:
# goto L1
# goto L10
# label L10
# ................
#
# if temporal_logico2:
# goto L3
# goto L4
# Label L3
# instrucciones_elseif
# goto L2
# label L4
#
# ....................
# label L1
# instrucciones_if
# label L2
# ...
else:
error = Excepcion('42804', "Semántico",
"La expresion logica debe ser de tipo boolean",
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 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 arbol.bdUsar != None:
objetoTablas = arbol.devolverTablas()
objetoIndice = None
objetoTabla = None
for t in objetoTablas:
for i in t.lista_de_indices:
if i.nombre == self.nombreIndice:
objetoIndice = i
objetoTabla = t
if objetoIndice == None:
error = Excepcion(
'42P01', "Semántico",
"El indice «" + self.nombreIndice + "» no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
listaColumnas = []
for t in objetoTabla.lista_de_campos:
listaColumnas.append(t.nombre)
if (self.id1 in listaColumnas and self.id2 in listaColumnas):
for l in objetoIndice.lRestricciones:
if self.id1 in l:
nuevo = l.replace(self.id1, self.id2)
objetoIndice.lRestricciones.remove(l)
objetoIndice.lRestricciones.append(nuevo)
arbol.consola.append(
"Consulta devuelta correctamente.")
else:
error = Excepcion(
'42701', "Semántico",
f"Las columnas {self.id1} y {self.id2} no existen en la 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)
if arbol.bdUsar != None:
objetoTabla = arbol.devolviendoTablaDeBase(self.tabla)
if objetoTabla != 0:
existeColumna = False
for c in self.lista_col:
for columnas in objetoTabla.lista_de_campos:
# Si la columna ya existe retorna error semántico
if columnas.nombre == c.id:
existeColumna = True
error = Excepcion('42701',"Semántico","Ya existe la columna «"+c.id+"» en la relación «"+self.tabla+"»",c.linea,c.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
if existeColumna:
return
# Existen columnas con el mismo nombre a insertar
nombres = []
for columnas in self.lista_col:
nombres.append(columnas.id)
duplicados = [item for item, count in collections.Counter(nombres).items() if count > 1]
for columnas in duplicados:
existeColumna = True
error = Excepcion('42701',"Semántico","Ya existe la columna «"+columnas+"» en la relación «"+self.tabla+"»",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
if existeColumna:
return
# Las columnas se almacenan en memoria.
for c in self.lista_col:
objetoTabla.agregarColumna(c.id, c.tipo,None, None)
# Las columnas se almacenan en disco.
for columnas in self.lista_col:
resultado = alterAddColumn(arbol.getBaseDatos(),self.tabla,columnas.id)
if resultado == 1:
error = Excepcion('XX000',"Semántico","Error interno",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 2:
error = Excepcion('42P00',"Semántico","La base de datos "+str(arbol.getBaseDatos())+" no existe",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 3:
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
arbol.consola.append("Consulta devuelta correctamente.")
print("Consulta ALTER TABLE ADD COLUMN devuleta 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.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 ceiling("+self.valor.tipo.toString()+")",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return math.degrees(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())
