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 log(" + 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 LOG ú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.log(resultado)
else:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return math.log(resultado)
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)
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.")
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)
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
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)
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
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)
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)
# 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 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 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)
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:
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 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)
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)
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)
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)
#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 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)
# Si existe algún error en el operador izquierdo, retorno el error.
#Aqui vamos a verificar si hay un alias
if isinstance(self.opIzq, Alias):
nombreColumna = self.opIzq.expresion
nombreTabla = tabla.getVariable(self.opIzq.id)
#obtener la posicion
posicion = arbol.devolverOrdenDeColumna(nombreTabla.valor,
nombreColumna)
resultadoIzq = posicion
else:
resultadoIzq = self.opIzq.ejecutar(tabla, arbol)
if isinstance(resultadoIzq, Excepcion):
return resultadoIzq
# Si existe algún error en el operador derecho, retorno el error.
if isinstance(self.opDer, Alias):
nombreColumna = self.opDer.expresion
nombreTabla = tabla.getVariable(self.opDer.id)
#obtener la posicion
posicion = arbol.devolverOrdenDeColumna(nombreTabla.valor,
nombreColumna)
resultadoDer = posicion
else:
resultadoDer = self.opDer.ejecutar(tabla, arbol)
if isinstance(resultadoDer, Excepcion):
return resultadoDer
# Si existe algún error en el operador derecho, retorno el error.
if isinstance(self.opDer2, Alias):
nombreColumna = self.opDer2.expresion
nombreTabla = tabla.getVariable(self.opDer2.id)
#obtener la posicion
posicion = arbol.devolverOrdenDeColumna(nombreTabla.valor,
nombreColumna)
resultadoDer2 = posicion
else:
resultadoDer2 = self.opDer2.ejecutar(tabla, arbol)
if isinstance(resultadoDer2, Excepcion):
return resultadoDer2
# Comprobamos el tipo de operador
if arbol.getWhere():
fila = []
tabla = []
tablaRes = []
#devolver columna
tabla = arbol.getTablaActual()
#aqui vamos a dividir por columnas
data = np.array((tabla))
#recorrer columna y ver si es == la posicion
nueva_Columna = data[:, resultadoIzq]
for x in range(0, len(nueva_Columna)):
variableNC = nueva_Columna[x]
variableComp = None
if (str.isdigit(variableNC)):
variableComp = int(variableNC)
elif str.isdecimal(variableNC):
variableComp = float(variableNC)
else:
variableComp = nueva_Columna[x]
if self.operador == "NOT":
if not ((variableComp >= resultadoDer) and
(variableComp <= resultadoDer2)):
#agregar a filas
fila.append(x)
else:
if (variableComp >= resultadoDer) and (variableComp <=
resultadoDer2):
#agregar a filas
fila.append(x)
#Recorrer la tabla Completa y devolver el numero de filas
for x in range(0, len(fila)):
fil = tabla[fila[x]]
tablaRes.append(fil)
#agregar la tabla al arbol
arbol.setTablaActual(tablaRes)
return tablaRes
else:
if (self.opIzq.tipo.tipo == Tipo_Dato.SMALLINT
or self.opIzq.tipo.tipo == Tipo_Dato.INTEGER
or self.opIzq.tipo.tipo == Tipo_Dato.BIGINT
or self.opIzq.tipo.tipo == Tipo_Dato.DECIMAL
or self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC
or self.opIzq.tipo.tipo == Tipo_Dato.REAL
or self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION
or self.opIzq.tipo.tipo == Tipo_Dato.MONEY) and (
self.opDer.tipo.tipo == Tipo_Dato.SMALLINT
or self.opDer.tipo.tipo == Tipo_Dato.INTEGER
or self.opDer.tipo.tipo == Tipo_Dato.BIGINT
or self.opDer.tipo.tipo == Tipo_Dato.DECIMAL
or self.opDer.tipo.tipo == Tipo_Dato.NUMERIC
or self.opDer.tipo.tipo == Tipo_Dato.REAL
or self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION
or self.opDer.tipo.tipo == Tipo_Dato.MONEY):
if self.operador == "NOT":
return not ((resultadoIzq >= resultadoDer) and
(resultadoIzq <= resultadoDer2))
else:
return (resultadoIzq >= resultadoDer) and (resultadoIzq <=
resultadoDer2)
elif (self.opIzq.tipo.tipo == Tipo_Dato.DATE
or self.opIzq.tipo.tipo == Tipo_Dato.TIME
or self.opIzq.tipo.tipo == Tipo_Dato.TIMESTAMP
or self.opIzq.tipo.tipo == Tipo_Dato.CHAR) and (
self.opDer.tipo.tipo == Tipo_Dato.DATE
or self.opDer.tipo.tipo == Tipo_Dato.TIME
or self.opDer.tipo.tipo == Tipo_Dato.TIMESTAMP
or self.opDer.tipo.tipo == Tipo_Dato.CHAR):
formats = ("%d-%m-%Y", "%Y-%m-%d", "%d-%M-%Y", "%Y-%M-%d",
"%Y-%b-%d", "%d-%b-%Y")
val1 = None
val2 = None
val3 = None
for fmt in formats:
valid_date = ""
try:
valid_date = time.strptime(resultadoIzq, fmt)
if isinstance(valid_date, time.struct_time):
val1 = time.strftime('%Y-%m-%d', valid_date)
except ValueError as e:
pass
for fmt in formats:
valid_date = ""
try:
valid_date = time.strptime(resultadoDer, fmt)
if isinstance(valid_date, time.struct_time):
val2 = time.strftime('%Y-%m-%d', valid_date)
except ValueError as e:
pass
for fmt in formats:
valid_date = ""
try:
valid_date = time.strptime(resultadoDer2, fmt)
if isinstance(valid_date, time.struct_time):
val3 = time.strftime('%Y-%m-%d', valid_date)
except ValueError as e:
pass
if self.operador == "NOT":
if val1 != None and val2 != None and val3 != None:
return not ((resultadoIzq >= resultadoDer) and
(resultadoIzq <= resultadoDer2))
else:
if val1 != None and val2 != None and val3 != None:
return (resultadoIzq >= resultadoDer) and (
resultadoIzq <= resultadoDer2)
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
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)
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 ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if arbol.bdUsar != None:
objetoTabla = arbol.devolviendoTablaDeBase(self.valor)
if objetoTabla != 0:
#print('Ok!')
lista = []
# Si el insert tiene la lista de columnas
if (self.lcol != None):
tablaLocal = Tabla(tabla)
# Se valia que la lista de columnas este bien.
listaNombreColumnas = []
listaColumnas = []
indices = []
for c in self.lcol:
for col in objetoTabla.lista_de_campos:
if col.nombre == c:
listaNombreColumnas.append(col.nombre)
listaColumnas.append(col)
indices.append(col.orden)
listaNoEncontrados = list(
set(self.lcol) - set(listaNombreColumnas))
if len(listaNoEncontrados) > 0:
for c in listaNoEncontrados:
error = Excepcion(
'42703', "Semántico",
"No existe la columna «" + c +
"» en la relación «" + self.valor + "»",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return
# Se valida que la lista de expresiones sea igual a la lista de columnas
if len(self.lexpre) != len(self.lcol):
error = Excepcion(
'23505', "Semántico",
"INSERT tiene más o menos expresiones que columnas de destino",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
# Recorrido para insertar
for c in range(0, len(listaColumnas)):
res = self.lexpre[c].ejecutar(tabla, arbol)
if isinstance(res, Excepcion):
return res
if listaColumnas[c].constraint != None:
for constraint in listaColumnas[c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
valida = self.validacionesPrimary(
listaColumnas[c].nombre, res, arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Llave duplicada viola restricción de unicidad «"
+ constraint.id + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if constraint.tipo == Tipo_Dato_Constraint.UNIQUE:
valida = self.validacionesPrimary(
listaColumnas[c].nombre, res, arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Llave duplicada viola restricción de unicidad «"
+ constraint.id + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif constraint.tipo == Tipo_Dato_Constraint.NOT_NULL:
pass
elif constraint.tipo == Tipo_Dato_Constraint.FOREIGN_KEY:
valida = self.validacionesForeign(
constraint.referencia,
constraint.expresion.nombre, res,
arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Inserción o actualización en la tabla «"
+ self.valor +
"» viola la llave foránea " +
constraint.id, self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
# Comprobación de que el tipo sea el mismo
comprobar = self.comprobarTipo(listaColumnas[c].tipo,
self.lexpre[c].tipo,
res, arbol)
if isinstance(comprobar, Excepcion):
return comprobar
if comprobar:
if listaColumnas[c].constraint != None:
for constraint in listaColumnas[c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.CHECK:
arbol.comprobacionCreate = True
resultado = self.validacionesCheck(
listaColumnas[c].nombre,
listaColumnas[c].tipo, res,
constraint.expresion, tablaLocal,
arbol)
if isinstance(resultado, Excepcion):
return resultado
if not resultado:
error = Excepcion(
'23505', "Semántico",
"El nuevo registro para la relación «"
+ self.valor +
"» viola la restricción «check» «"
+ constraint.id + "»",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(
error.toString())
return error
arbol.comprobacionCreate = False
lista.append(res)
else:
error = Excepcion(
'42804', "Semántico", "La columna «" +
listaColumnas[c].nombre + "» es de tipo " +
listaColumnas[c].tipo.toString() +
" pero la expresión es de tipo " +
self.lexpre[c].tipo.toString(), self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
columnasNulas = list(
set(objetoTabla.lista_de_campos) - set(listaColumnas))
for c in range(0, len(columnasNulas)):
if columnasNulas[c].constraint != None:
for constraint in columnasNulas[c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
error = Excepcion(
'23505', "Semántico",
"El valor nulo en la columna «" +
columnasNulas[c].nombre +
"» de la relación «" + self.valor +
"» viola la restricción de no nulo",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if constraint.tipo == Tipo_Dato_Constraint.UNIQUE:
error = Excepcion(
'23505', "Semántico",
"El valor nulo en la columna «" +
columnasNulas[c].nombre +
"» de la relación «" + self.valor +
"» viola la restricción de no nulo",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif constraint.tipo == Tipo_Dato_Constraint.NOT_NULL:
error = Excepcion(
'23505', "Semántico",
"El valor nulo en la columna «" +
columnasNulas[c].nombre +
"» de la relación «" + self.valor +
"» viola la restricción de no nulo",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif constraint.tipo == Tipo_Dato_Constraint.FOREIGN_KEY:
error = Excepcion(
'23505', "Semántico",
"El valor nulo en la columna «" +
columnasNulas[c].nombre +
"» de la relación «" + self.valor +
"» viola la restricción de no nulo",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
lista.append("Null")
indices.append(columnasNulas[c].orden)
listaOrden = []
for i in range(0, len(indices)):
objeto = [indices[i], lista[i]]
listaOrden.append(objeto)
ordenados = sorted(listaOrden)
listaFinal = [item[1] for item in ordenados]
if len(lista) != len(objetoTabla.lista_de_campos):
return
resultado = insert(arbol.getBaseDatos(), self.valor,
listaFinal)
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.valor, self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 4:
error = Excepcion(
'2BP01', "Semántico",
"Llave duplicada viola restricción de unicidad «" +
self.valor + "_pkey»", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 5:
error = Excepcion(
'XX002', "Semántico",
"Columna fuera de limites." + self.valor,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
arbol.consola.append(
f"el registro se inserto correctamente.")
# El insert no tiene una lista de columnas
else:
if len(self.lexpre) != len(objetoTabla.lista_de_campos):
error = Excepcion(
'23505', "Semántico",
"INSERT tiene más o menos expresiones que columnas de destino",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
tablaLocal = Tabla(tabla)
for c in range(0, len(objetoTabla.lista_de_campos)):
res = self.lexpre[c].ejecutar(tabla, arbol)
if isinstance(res, Excepcion):
return res
if objetoTabla.lista_de_campos[c].constraint != None:
for constraint in objetoTabla.lista_de_campos[
c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
valida = self.validacionesPrimary(
objetoTabla.lista_de_campos[c].nombre,
res, arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Llave duplicada viola restricción de unicidad «"
+ constraint.id + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if constraint.tipo == Tipo_Dato_Constraint.UNIQUE:
valida = self.validacionesPrimary(
objetoTabla.lista_de_campos[c].nombre,
res, arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Llave duplicada viola restricción de unicidad «"
+ constraint.id + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif constraint.tipo == Tipo_Dato_Constraint.NOT_NULL:
pass
elif constraint.tipo == Tipo_Dato_Constraint.FOREIGN_KEY:
valida = self.validacionesForeign(
constraint.referencia,
constraint.expresion.nombre, res,
arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Inserción o actualización en la tabla «"
+ self.valor +
"» viola la llave foránea " +
constraint.id, self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
# Comprobación de que el tipo sea el mismo
comprobar = self.comprobarTipo(
objetoTabla.lista_de_campos[c].tipo,
self.lexpre[c].tipo, res, arbol)
if isinstance(comprobar, Excepcion):
return comprobar
if comprobar:
if objetoTabla.lista_de_campos[
c].constraint != None:
for constraint in objetoTabla.lista_de_campos[
c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.CHECK:
arbol.comprobacionCreate = True
resultado = self.validacionesCheck(
objetoTabla.lista_de_campos[c].
nombre, objetoTabla.
lista_de_campos[c].tipo, res,
constraint.expresion, tablaLocal,
arbol)
if isinstance(resultado, Excepcion):
return resultado
if not resultado:
error = Excepcion(
'23505', "Semántico",
"El nuevo registro para la relación «"
+ self.valor +
"» viola la restricción «check» «"
+ constraint.id + "»",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(
error.toString())
return error
arbol.comprobacionCreate = False
lista.append(res)
else:
error = Excepcion(
'42804', "Semántico", "La columna «" +
objetoTabla.lista_de_campos[c].nombre +
"» es de tipo " +
objetoTabla.lista_de_campos[c].tipo.toString()
+ " pero la expresión es de tipo " +
self.lexpre[c].tipo.toString(), self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
if len(lista) != len(self.lexpre):
return
#print("esta es la insercion de lista, ya inserto estaticamente")
resultado = insert(arbol.getBaseDatos(), self.valor, lista)
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.valor, self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 4:
error = Excepcion(
'2BP01', "Semántico",
"Llave duplicada viola restricción de unicidad «" +
self.valor + "_pkey»", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 5:
error = Excepcion(
'XX002', "Semántico",
"Columna fuera de limites." + self.valor,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
arbol.consola.append(
f"el registro se inserto correctamente.")
else:
error = Excepcion('42P01', "Semántico",
"No existe la relación " + self.valor,
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())
'''
'''
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 analizar(self, tabla, arbol):
super().analizar(tabla,arbol)
# Operación con dos operadores
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
# Comprobamos el tipo de operador
if self.operador == '+':
if self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.INTEGER)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.CHAR and self.opDer.tipo.tipo == Tipo_Dato.CHAR:
self.tipo = Tipo(Tipo_Dato.CHAR)
return self.tipo
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
elif self.operador == '-':
if self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.INTEGER)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
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
elif self.operador == '*':
if self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.INTEGER)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
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
elif self.operador == '/':
if self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
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
self.tipo = Tipo(Tipo_Dato.INTEGER)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and 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
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
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
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and 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
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
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
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
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
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
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
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and 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
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
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
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
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
elif self.operador == '^':
if self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
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
elif self.operador == '%':
if self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
if resultadoDer == 0:
error = Excepcion('42883',"Semántico","División entera o módulo por cero",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
self.tipo = Tipo(Tipo_Dato.INTEGER)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
if resultadoDer == 0:
error = Excepcion('42883',"Semántico","División entera o módulo por cero",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.INTEGER and self.opDer.tipo.tipo == Tipo_Dato.NUMERIC:
if resultadoDer == 0:
error = Excepcion('42883',"Semántico","División entera o módulo por cero",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
elif self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC and self.opDer.tipo.tipo == Tipo_Dato.INTEGER:
if resultadoDer == 0:
error = Excepcion('42883',"Semántico","División entera o módulo por cero",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
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
else:
error = Excepcion('42883',"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.ejecutar(tabla, arbol)
if isinstance(resultadoIzq, Excepcion):
return resultadoIzq
if self.operador == '-':
if self.opIzq.tipo.tipo == Tipo_Dato.INTEGER:
self.tipo = Tipo(Tipo_Dato.INTEGER)
return self.tipo
if self.opIzq.tipo.tipo == Tipo_Dato.NUMERIC:
self.tipo = Tipo(Tipo_Dato.NUMERIC)
return self.tipo
if self.opIzq.tipo.tipo == Tipo_Dato.DOUBLE_PRECISION:
self.tipo = Tipo(Tipo_Dato.DOUBLE_PRECISION)
return self.tipo
else:
error = Excepcion('42883',"Semántico","Tipo de datos incorrectos en la operación negativo",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion('42883',"Semántico","Operador desconocido.",self.linea,self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return None
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.constraint != None:
for const in columnas.constraint:
if const.id == self.id:
existe = True
if existe:
error = Excepcion(
'42P01', "Semántico",
"la relación «" + self.id + "» ya existe", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
listaUnique = []
listaNombres = []
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
for c in listaUnique:
if c.constraint != None:
c.constraint.append(
Tipo_Constraint(self.id,
Tipo_Dato_Constraint.UNIQUE,
None))
#print("MÁS DE UNA-----------------",c.nombre, c.tipo.toString(),len(c.constraint))
else:
c.constraint = []
c.constraint.append(
Tipo_Constraint(self.id,
Tipo_Dato_Constraint.UNIQUE,
None))
#print("SOLO UNA-------------",c.nombre, c.tipo.toString(),len(c.constraint))
arbol.consola.append("Consulta devuelta correctamente.")
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())
