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 ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
resultado = self.valor.ejecutar(tabla, arbol)
if isinstance(resultado, Excepcion):
return resultado
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)
minimo = np.amin(listaNums)
return np.array([[minimo]])
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 comprobar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
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
return variable.valor.ejecutar(tabla, arbol)
def analizar(self, tabla, arbol):
super().analizar(tabla, arbol)
resultado = self.condicion.analizar(tabla, arbol)
if not isinstance(resultado, Excepcion):
self.tipo = resultado
if isinstance(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
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
prim = None
strGram = ""
if self.tipo.tipo == Tipo_Dato.SMALLINT:
prim = Primitivo(0, Tipo(Tipo_Dato.SMALLINT), strGram, 0, 0)
elif self.tipo.tipo == Tipo_Dato.INTEGER:
prim = Primitivo(0, Tipo(Tipo_Dato.INTEGER), strGram, 0, 0)
elif self.tipo.tipo == Tipo_Dato.BIGINT:
prim = Primitivo(0, Tipo(Tipo_Dato.BIGINT), strGram, 0, 0)
elif self.tipo.tipo == Tipo_Dato.DECIMAL:
prim = Primitivo(0, Tipo(Tipo_Dato.DECIMAL), strGram, 0, 0)
elif self.tipo.tipo == Tipo_Dato.NUMERIC:
prim = Primitivo(0, Tipo(Tipo_Dato.NUMERIC), strGram, 0, 0)
elif self.tipo.tipo == Tipo_Dato.REAL:
prim = Primitivo(0, Tipo(Tipo_Dato.REAL), strGram, 0, 0)
elif self.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
prim = Primitivo(0, Tipo(Tipo_Dato.DOUBLE_PRECISION), strGram, 0,
0)
elif self.tipo.tipo == Tipo_Dato.MONEY:
prim = Primitivo(0, Tipo(Tipo_Dato.MONEY), strGram, 0, 0)
elif self.tipo.tipo == Tipo_Dato.DATE:
prim = Primitivo('1900-01-01', Tipo(Tipo_Dato.DATE), strGram, 0, 0)
elif self.tipo.tipo == Tipo_Dato.TIMESTAMP:
prim = Primitivo('1900-01-01', Tipo(Tipo_Dato.TIMESTAMP), strGram,
0, 0)
elif self.tipo.tipo == Tipo_Dato.TIME:
prim = Primitivo('1900-01-01', Tipo(Tipo_Dato.DATE), strGram, 0, 0)
elif self.tipo.tipo == Tipo_Dato.BOOLEAN:
prim = Primitivo(True, Tipo(Tipo_Dato.BOOLEAN), strGram, 0, 0)
variable = Simbolo(self.nombre, self.tipo, prim.valor, 0, 0)
resultadoInsertar = tabla.setVariable(variable)
if resultadoInsertar != None:
error = Excepcion("100", "Semantico",
"La columna " + self.nombre + " yo existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if self.expresion != None:
resultado = self.expresion.ejecutar(tabla, arbol)
if isinstance(resultado, Excepcion):
return resultado
return 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.")
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 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 abs(" + self.valor.tipo.toString() + ")",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if isinstance(resultado, int):
self.tipo = Tipo(Tipo_Dato.INTEGER)
return int(abs(resultado))
else:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return abs(resultado)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
print(self.tipos)
if (arbol.getBaseDatos() != None):
#aqui vamos a renombrar el alter
alterTable(arbol.getBaseDatos(), self.TablaAntigua,
self.TablaNueva)
else:
Excepcion(3, "Semántico", "No se encuentra la base de datos",
self.linea, self.columna)
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)
# 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
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)
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 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 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)
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 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 (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)
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)
# 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.")
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 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 tanh("+self.valor.tipo.toString()+")",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
try:
return math.tanh(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 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)
# 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
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)
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 ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
val = self.identificador.devolverTabla(tabla, arbol)
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
tablaUpdate = extractTable(arbol.getBaseDatos(), val)
arbol.setTablaActual(tablaUpdate)
columnas = arbol.devolverColumnasTabla(val)
data = np.array((tablaUpdate))
res = []
# vamos a mostrar todos
for x in range(0, len(columnas)):
col = columnas[x].obtenerNombre()
res.append(col)
arbol.setColumnasActual(res)
listaMods = []
if self.insWhere != None:
listaMods = self.insWhere.ejecutar(tabla, arbol)
primaryKey = self.getPrimaryKeyCol(columnas)
arbol.setUpdate()
if self.listaDeColumnas and len(listaMods) > 0:
for y in range(0, len(listaMods)):
tupla = listaMods[y]
lPK = self.obtenerValores(tupla, primaryKey)
for x in range(0, len(self.listaDeColumnas)):
variable = self.listaDeColumnas[x].ejecutar(tabla, arbol)
if isinstance(variable, Alias):
#id es la posicione en la que se encuentra
#expresion es el valor que se le asigna a la actualizacion
validar = self.validacionTipos(
columnas[variable.id].tipo, variable.tipo,
variable.expresion, arbol)
if isinstance(validar, Excepcion):
arbol.excepciones.append(validar)
arbol.consola.append(validar.toString())
arbol.setUpdate()
return validar
if not validar:
error = Excepcion(
'42804', "Semántico",
"La columna «" + columnas[variable.id].nombre +
"» es de tipo " +
columnas[variable.id].tipo.toString() +
" pero la expresión es de tipo " +
variable.tipo.toString(), self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.setUpdate()
return
resultado = update(
arbol.getBaseDatos(), val,
dict({variable.id: variable.expresion}), lPK)
if resultado == 1:
error = Excepcion("00XX", "Semantico",
"Error de operacion interno",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.setUpdate()
return error
elif resultado == 2:
error = Excepcion(
"42P12", "Semantico",
"Error de operacion base de datos no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.setUpdate()
return error
elif resultado == 3:
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())
arbol.setUpdate()
return error
elif resultado == 4:
error = Excepcion(
"42P01", "Semantico",
"La llave " + str(lPK[0]) + " de la tabla " +
str(self.identificador.devolverId(
tabla, arbol)) + " no existe", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.setUpdate()
return error
else:
print('Nel la cagaste prro :\'v')
arbol.setUpdate()
return variable
elif self.listaDeColumnas and self.insWhere == None:
for x in range(0, len(self.listaDeColumnas)):
variable = self.listaDeColumnas[x].ejecutar(tabla, arbol)
if isinstance(variable, Alias):
validar = self.validacionTipos(columnas[variable.id].tipo,
variable.tipo,
variable.expresion, arbol)
if isinstance(validar, Excepcion):
arbol.excepciones.append(validar)
arbol.consola.append(validar.toString())
arbol.setUpdate()
return validar
if not validar:
error = Excepcion(
'42804', "Semántico", "La columna «" +
columnas[variable.id].nombre + "» es de tipo " +
columnas[variable.id].tipo.toString() +
" pero la expresión es de tipo " +
variable.tipo.toString(), self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.setUpdate()
return
for tupla in arbol.getTablaActual():
lPK = self.obtenerValores(tupla, primaryKey)
resultado = update(
arbol.getBaseDatos(), val,
dict({variable.id: variable.expresion}), lPK)
if resultado == 1:
error = Excepcion("00XX", "Semantico",
"Error de operacion interno",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.setUpdate()
return error
elif resultado == 2:
error = Excepcion(
"42P12", "Semantico",
"Error de operacion base de datos no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.setUpdate()
return error
elif resultado == 3:
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())
arbol.setUpdate()
return error
elif resultado == 4:
error = Excepcion(
"42P01", "Semantico",
"La llave " + str(lPK[0]) + " de la tabla " +
str(self.identificador.devolverId(
tabla, arbol)) + " no existe", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.setUpdate()
return error
else:
arbol.setUpdate()
return variable
else:
error = Excepcion("42P12", "Semantico",
"Error de operacion base de datos no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
arbol.setUpdate()
return error
arbol.consola.append(f"Se actualizo el registro ")
arbol.setUpdate()
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if arbol.bdUsar != None:
objetoTabla = arbol.devolviendoTablaDeBase(self.tabla)
if objetoTabla != 0:
tablaForanea = arbol.devolviendoTablaDeBase(self.tabla2)
if tablaForanea != 0:
listaTabla1 = []
tabla1Nombres = []
for c in self.lista_id1:
for columnas in objetoTabla.lista_de_campos:
if columnas.nombre == c:
listaTabla1.append(columnas)
tabla1Nombres.append(columnas.nombre)
if (len(listaTabla1) == len(self.lista_id1)):
listaForaneas = []
tabla2Nombres = []
for c in self.lista_id2:
for columnas in tablaForanea.lista_de_campos:
if columnas.nombre == c:
listaForaneas.append(columnas)
tabla2Nombres.append(columnas.nombre)
if (len(listaForaneas) == len(self.lista_id2)):
listaPrimarias = 0
for columna in listaForaneas:
if columna.constraint != None:
for i in columna.constraint:
if i.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
listaPrimarias += 1
else:
error = Excepcion(
'42P01', "Semántico",
"No hay restricción unique que coincida con las columnas dadas en la tabla referida «"
+ self.tabla2 + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return
if listaPrimarias == len(self.lista_id2):
for c in range(0, len(listaTabla1)):
if listaTabla1[c].constraint != None:
restriccion = Tipo_Constraint(
self.id_constraint,
Tipo_Dato_Constraint.FOREIGN_KEY,
listaForaneas[c])
restriccion.referencia = self.tabla2
listaTabla1[c].constraint.append(
restriccion)
else:
listaTabla1[c].constraint = []
restriccion = Tipo_Constraint(
self.id_constraint,
Tipo_Dato_Constraint.FOREIGN_KEY,
listaForaneas[c])
restriccion.referencia = self.tabla2
listaTabla1[c].constraint.append(
restriccion)
arbol.consola.append(
"Consulta devuelta correctamente.")
else:
error = Excepcion(
'42P01', "Semántico",
"No hay restricción unique que coincida con las columnas dadas en la tabla referida «"
+ self.tabla2 + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return
else:
lista = set(self.lista_id2) - set(tabla2Nombres)
#print(tabla2Nombres,self.lista_id2)
#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:
lista = set(self.lista_id1) - set(tabla1Nombres)
#print(tabla1Nombres,self.lista_id1)
#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.tabla2,
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 validacionTipos(self, tipoColumna, tipoValor, val, arbol):
if (tipoColumna.tipo == Tipo_Dato.MONEY) and (tipoValor.tipo
== Tipo_Dato.CHAR):
if ',' in val:
val = val.replace(',', '')
try:
val = float(val)
except:
error = Excepcion(
'22P02', "Semántico",
"La sintaxis de entrada no es válida para tipo money",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return True
if tipoColumna.tipo == Tipo_Dato.TIPOENUM:
existe = arbol.getEnum(tipoColumna.nombre)
existeValor = existe.buscarTipo(val)
if existeValor == None:
error = Excepcion(
'2BP01', "Semántico", "El valor " + val +
" no existe dentro del TYPE ENUM " + tipoColumna.nombre,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return True
if (tipoColumna.tipo == Tipo_Dato.CHAR or tipoColumna.tipo
== Tipo_Dato.VARCHAR or tipoColumna.tipo == Tipo_Dato.VARYING
or tipoColumna.tipo == Tipo_Dato.CHARACTER
or tipoColumna.tipo == Tipo_Dato.TEXT) and (
tipoValor.tipo == Tipo_Dato.CHAR or tipoValor.tipo
== Tipo_Dato.VARCHAR or tipoValor.tipo == Tipo_Dato.VARYING
or tipoValor.tipo == Tipo_Dato.CHARACTER
or tipoValor.tipo == Tipo_Dato.TEXT):
if tipoColumna.dimension != None:
if len(val) >= tipoColumna.dimension:
error = Excepcion(
'2BP01', "Semántico",
"el valor es demasiado largo para el tipo " +
tipoColumna.toString() + "(" +
str(tipoColumna.dimension) + ")", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return True
elif (tipoColumna.tipo == Tipo_Dato.SMALLINT or tipoColumna.tipo
== Tipo_Dato.INTEGER or tipoColumna.tipo == Tipo_Dato.BIGINT
or tipoColumna.tipo == Tipo_Dato.DECIMAL or tipoColumna.tipo
== Tipo_Dato.NUMERIC or tipoColumna.tipo == Tipo_Dato.REAL
or tipoColumna.tipo == Tipo_Dato.DOUBLE_PRECISION
or tipoColumna.tipo == Tipo_Dato.MONEY) and (
tipoValor.tipo == Tipo_Dato.SMALLINT or tipoValor.tipo
== Tipo_Dato.INTEGER or tipoValor.tipo == Tipo_Dato.BIGINT
or tipoValor.tipo == Tipo_Dato.DECIMAL or tipoValor.tipo
== Tipo_Dato.NUMERIC or tipoValor.tipo == Tipo_Dato.REAL
or tipoValor.tipo == Tipo_Dato.DOUBLE_PRECISION
or tipoValor.tipo == Tipo_Dato.MONEY):
if tipoColumna.tipo == Tipo_Dato.SMALLINT:
if (val < -32768 or val > 32767):
error = Excepcion(
'2BP01', "Semántico",
tipoColumna.toString() + " fuera de rango", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif tipoColumna.tipo == Tipo_Dato.INTEGER:
if (val < -2147483648 or val > 2147483647):
error = Excepcion(
'2BP01', "Semántico",
tipoColumna.toString() + " fuera de rango", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif tipoColumna.tipo == Tipo_Dato.BIGINT:
if (val < -9223372036854775808 or val > 9223372036854775807):
error = Excepcion(
'2BP01', "Semántico",
tipoColumna.toString() + " fuera de rango", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return True
elif (tipoColumna.tipo == Tipo_Dato.DATE or tipoColumna.tipo
== Tipo_Dato.TIMESTAMP or tipoColumna.tipo == Tipo_Dato.TIME
or tipoColumna.tipo == Tipo_Dato.INTERVAL or tipoColumna.tipo
== Tipo_Dato.CHAR) and (tipoValor.tipo == Tipo_Dato.DATE
or tipoValor.tipo == Tipo_Dato.TIMESTAMP
or tipoValor.tipo == Tipo_Dato.TIME
or tipoValor.tipo == Tipo_Dato.INTERVAL
or tipoValor.tipo == Tipo_Dato.CHAR):
return True
elif (tipoColumna.tipo
== Tipo_Dato.BOOLEAN) and (tipoValor.tipo == Tipo_Dato.BOOLEAN):
return True
return False
'''if(self.identificador != None):
if(self.listaDeColumnas != None):
if(self.insWhere != None):
update(arbol.database())
'''
'''
