def FunctionWithBucket(self, funcion, parametros, exp1, exp2, exp3, exp4):
if (parametros == 4):
if (exp1 < exp2 or exp1 > exp3):
reporteerrores.append(
Lerrores("Error Semantico", "Valor" + str(exp1) + "no se encuentra en el rango", 0, 0))
return "Error: El valor: " + str(exp1) + " no esta en el rango de: (" + str(exp2) + "," + str(
exp3) + ")"
else:
contador = 1
for x in range(exp2, exp3):
contador = contador + 1
columnas = int(contador / exp4)
inicio = int(exp2)
final = int(exp2) + (columnas)
posbucket = 0
for fila in range(0, exp4):
for valores in range(inicio, final):
if (exp1 == valores):
posbucket = fila + 1
msg="El valor de: " + str(exp1) + " esta en el bucket: " + str(posbucket)
tipo =Tipo('varchar',self.l(msg),-1,-1)
return Terminal(tipo,msg)
inicio = final
final = final + columnas
else:
reporteerrores.append(
Lerrores("Error Semantico", "La funcion" + funcion + "solo recibe 2 parametros", 0, 0))
return "Error: La funcion: " + funcion + " recibe 4 parametro"
def FunctionWithTreeParameter(self, funcion, parametros, exp1, exp2, exp3):
if (parametros == 3):
if (funcion == "substring"):
inicio = exp2 - 1
fin = inicio + exp3
sub = exp1[inicio:fin]
return Terminal(Tipo('decimal', sub, self.l(sub), -1), sub)
elif (funcion == "substr"):
inicio = exp2 - 1
fin = inicio + exp3
sub = exp1[inicio:fin]
return Terminal(Tipo('decimal', sub, self.l(sub), -1), sub)
else:
reporteerrores.append(
Lerrores("Error Semantico", "La funcion" + funcion + "solo recibe 3 parametros", 0, 0))
return "Error: La funcion: " + funcion + " recibe 3 parametro"
def ejecutar(self, ent:Entorno):
completo=str(self.nombre+'_'+ ent.getDataBase())
tabla:Simbolo = ent.buscarSimbolo(completo)
if tabla != None:
columnas=tabla.valor
i=0
contador=0
columnaunique=[]
for columna in columnas:
verificarnull=tabla.valor[i].atributos.get('not null')
verificarprimary=tabla.valor[i].atributos.get('primary')
verificarunique=tabla.valor[i].atributos.get('unique')
verificarcheck=tabla.valor[i].atributos.get('check')
condicion1:Expresion
condicion2:Expresion
if verificarunique!=None:
columnaunique.append(columna.nombre)
if(verificarcheck!=None):
check=ent.buscarSimbolo(verificarcheck)
#print("Condicion:",check.valor.exp1.getval(ent).valor,check.valor.simbolo,check.valor.exp2.getval(ent).valor)
if isinstance(check.valor.exp1,Identificador):
condicion1=check.valor.exp1.getval(ent)
if condicion1==None:
condicion1=Terminal(columna.tipo, check.valor.exp1.nombre)
else:
condicion1 = Terminal(columna.tipo, check.valor.exp1.getval(ent).valor)
if isinstance(check.valor.exp2, Identificador):
condicion2 = check.valor.exp2.getval(ent)
if condicion2 == None:
condicion2 = Terminal(columna.tipo, check.valor.exp2.nombre)
else:
condicion2 = Terminal(columna.tipo, check.valor.exp2.getval(ent).valor)
operador=check.valor.simbolo
l=0
for columna in columnas:
#tipo=columna.tipo
if(check.valor.exp1.getval(ent)==columna.nombre):
k=0
for actual in self.namecolums:
if(check.valor.exp1.getval(ent)==actual.getval(ent).valor):
condicion1=Terminal(columna.tipo,self.valores[k].getval(ent).valor)
k=k+1
l=l+1
n=0
for columna in columnas:
if(check.valor.exp2.getval(ent)==columna.nombre):
k=0
for actual in self.namecolums:
if(check.valor.exp2.getval(ent)==actual.getval(ent).valor):
condicion2=Terminal(columna.tipo,self.valores[k].getval(ent).valor)
k=k+1
n=n+1
correcto=False
if operador in ('>','<','>=','<=','='):
#print(condicion1.getval(ent).valor,operador,condicion2.getval(ent).valor)
nuevaop = Relacional(condicion1,condicion2,operador);
if nuevaop.getval(ent):
correcto=True
else:
variables.consola.insert(INSERT,'Error Registro no cumple con condicion check\n')
reporteerrores.append(Lerrores("Error Semantico", 'Registro no cumple con condicion check','',''))
return
elif operador in ('or','and','not'):
nuevaop = Logica(condicion1,condicion2,operador);
if nuevaop.getval(ent):
correcto=True
else:
variables.consola.insert(INSERT,'Error Registro no cumple con condicion check\n')
reporteerrores.append(Lerrores("Error Semantico", 'Registro no cumple con condicion check','',''))
return
if(verificarnull !=None or verificarprimary!=None or verificarunique!=None):
contador=contador+1
i=i+1
#print("contador",contador)
if( (len(self.valores) >= contador) and (len(self.valores) == len(self.namecolums)) and (len(self.namecolums)<=len(columnas))):
j=0
t=0
correcto=True
terminales = []
for columna in columnas:
if j < len(self.namecolums):
nombre=columna.nombre
tipo=columna.tipo
util=Tipo(None,None,-1,-1)
if isinstance(self.namecolums[j],Identificador):
v=self.namecolums[j].getval(ent)
if v==None:
self.namecolums[j] = Terminal(self.namecolums[j].tipo, self.namecolums[j].nombre)
else:
self.namecolums[j]=v
if(nombre==self.namecolums[j].valor):
#print("iguales",nombre,":",self.namecolums[j].getval(ent).valor,"J",j,"t",t)
for colunique in columnaunique:
if nombre==colunique:
#print("UNIQUE",colunique,"colactual",nombre,"valor",self.valores[j].getval(ent).valor,"---")
v=self.validarunique(ent,tabla,colunique,self.valores[j].getval(ent).valor)
#print("-----",v)
if v:
variables.consola.insert(INSERT,'Error Violacion de Constraint Unique en columna:'+colunique +' : '+str(self.valores[j].getval(ent).valor)+'\n')
reporteerrores.append(Lerrores("Error Semantico", 'Error Violacion de Constraint Unique en columna:'+colunique +' : '+str(self.valores[j].getval(ent).valor),'',''))
return
buscado=str('ENUM_'+ent.getDataBase()+'_'+tipo.tipo)
types:Simbolo= ent.buscarSimbolo(buscado)
tipocorrecto = False
if types!=None:
tiposenum=types.valor
print("Comparando Enum")
for valenum in tiposenum:
if str(valenum.getval(ent).valor).lower() == str(self.valores[j].getval(ent).valor).lower():
tipocorrecto=True
if not tipocorrecto:
variables.consola.insert(INSERT,str('Error Tipo enum no correcto en valor: '+self.valores[j].getval(ent).valor)+'\n')
reporteerrores.append(Lerrores("Error Semantico",str('Tipo enum no correcto en valor: '+self.valores[j].getval(ent).valor),'',''))
return
if not tipocorrecto:
if util.comparetipo(tipo,self.valores[j].getval(ent).tipo):
'todo correcto'
else:
correcto=False
variables.consola.insert(INSERT,'Error los tipos no coinciden con la definicion de la tabla\n')
reporteerrores.append(Lerrores("Error Semantico",'Tipo de datos en columanas no son iguales','',''))
return
terminales.append(self.valores[j].valor)
j=j+1
else:
#print("diferentes",nombre,":",self.namecolums[j].getval(ent).valor,"J",j,"t",t)
terminales.append('')
else:
terminales.append('')
r=DBMS.insert(ent.getDataBase(),self.nombre,terminales)
if(r==4):
variables.consola.insert(INSERT,'Error violacion de Constraint Primary key\n')
reporteerrores.append(Lerrores("Error Semantico",'Violacion de Constraint primary Key','',''))
return
elif r==0:
variables.consola.insert(INSERT, 'Registros Ingresados EXITOSAMENTE\n')
else:
variables.consola.insert(INSERT,'Error Numero Parametros en tabla '+self.nombre+' Incorrectos\n')
reporteerrores.append(Lerrores('Erro semantico','Numero Parametros en tabla '+self.nombre+' Incorrectos','',''))
return
else:
variables.consola.insert(INSERT,'Error Tabla '+self.nombre+' No Existe en la BD actual\n')
reporteerrores.append(Lerrores('Error Semantico','Numero Parametros en tabla '+self.nombre+' Incorrectos','',''))
return
def ejecutar(self, ent:Entorno):
completo=str(self.nombre+'_'+ent.getDataBase())
tabla:Simbolo = ent.buscarSimbolo(completo)
if tabla != None:
columnas=tabla.valor
columnaunique=[]
columnacheck=[]
if len(self.valores)== len(columnas):
i=0
correcto=True
for columna in columnas:
verificarunique=tabla.valor[i].atributos.get('unique')
verificarcheck=tabla.valor[i].atributos.get('check')
nombre=columna.nombre
tipo=columna.tipo
condicion1:Expresion
condicion2:Expresion
if verificarunique!=None:
#print("unique",verificarunique,"m--",nombre)
columnaunique.append(columna.nombre)
for colunique in columnaunique:
if nombre==colunique:
#print("UNIQUE",colunique,"colactual",nombre,"valor",self.valores[i].getval(ent).valor,"---")
exp=self.valores[i].getval(ent)
exp=exp.valor
v=self.validarunique(ent,tabla,colunique,exp)
#print("-----",v)
if v:
#print('Error Violacion de Constraint Unique en:',colunique,' : ',self.valores[i].getval(ent).valor)
variables.consola.insert(INSERT,'Error Violacion de Constraint Unique en columna:'+colunique +' : '+str(self.valores[i].getval(ent).valor)+'\n')
reporteerrores.append(Lerrores("Error Semantico", 'Error Violacion de Constraint Unique en columna:'+colunique +' : '+str(self.valores[i].getval(ent).valor),'',''))
return
if(verificarcheck!=None):
check=ent.buscarSimbolo(verificarcheck)
#print("Condicion:",check.valor.exp1.getval(ent).valor,check.valor.simbolo,check.valor.exp2.getval(ent).valor)
if isinstance(check.valor.exp1, Identificador):
condicion1 = check.valor.exp1.getval(ent)
if condicion1 == None:
condicion1 = Terminal(columna.tipo, check.valor.exp1.nombre)
else:
condicion1 = Terminal(columna.tipo, check.valor.exp1.getval(ent).valor)
if isinstance(check.valor.exp2, Identificador):
condicion2 = check.valor.exp2.getval(ent)
if condicion2 == None:
condicion2 = Terminal(columna.tipo, check.valor.exp2.nombre)
else:
condicion2 = Terminal(columna.tipo, check.valor.exp2.getval(ent).valor)
operador=check.valor.simbolo
l=0
for columna in columnas:
#tipo=columna.tipo
if isinstance(check.valor.exp1, Identificador):
check.valor.exp1 = Terminal(check.valor.exp1.tipo, check.valor.exp1.nombre)
if(check.valor.exp1.getval(ent).valor==columna.nombre):
condicion1=Terminal(columna.tipo,self.valores[l].getval(ent).valor)
l=l+1
n=0
for columna in columnas:
if isinstance(check.valor.exp2, Identificador):
check.valor.exp2 = Terminal(check.valor.exp2.tipo, check.valor.exp2.nombre)
if(check.valor.exp2.getval(ent).valor==columna.nombre):
condicion2=Terminal(columna.tipo,self.valores[n].getval(ent).valor)
n=n+1
correcto=False
if operador in ('>','<','>=','<=','='):
#print(condicion1.getval(ent).valor,operador,condicion2.getval(ent).valor)
nuevaop = Relacional(condicion1,condicion2,operador)
if nuevaop.getval(ent).valor:
correcto=True
else:
variables.consola.insert(INSERT,'Error Registro no cumple con condicion check\n')
reporteerrores.append(Lerrores("Error Semantico", 'Registro no cumple con condicion check','',''))
return
elif operador in ('or','and','not'):
nuevaop = Logica(condicion1,condicion2,operador);
if nuevaop.getval(ent).valor:
correcto=True
else:
variables.consola.insert(INSERT,'Error Registro no cumple con condicion check\n')
reporteerrores.append(Lerrores("Error Semantico", 'Error Registro no cumple con condicion check','',''))
return
buscado=str('ENUM_'+ent.getDataBase()+'_'+tipo.tipo)
types:Simbolo= ent.buscarSimbolo(buscado)
tipocorrecto = False
if types!=None:
tiposenum=types.valor
print("Comparando Enum")
for valenum in tiposenum:
if str(valenum.getval(ent).valor).lower() == str(self.valores[i].getval(ent).valor).lower():
tipocorrecto=True
if not tipocorrecto:
variables.consola.insert(INSERT,str('Error Tipo enum no correcto en valor: '+self.valores[i].getval(ent).valor)+'\n')
reporteerrores.append(Lerrores("Error Semantico",str('Error Tipo enum no correcto en valor: '+self.valores[i].getval(ent).valor),'',''))
return
if not tipocorrecto:
util=Tipo(None,None,-1,-1)
#tabla:Simbolo = ent.buscarSimbolo(completo)
self.valores[i]=self.valores[i].getval(ent)
if util.comparetipo(tipo,self.valores[i].tipo):
'todo correcto'
else:
correcto=False
variables.consola.insert(INSERT,'Error los tipos no coinciden con la definicion de la tabla\n')
reporteerrores.append(Lerrores("Error Semantico",'Tipo de datos en columanas no son iguales','',''))
return
i=i+1
terminales = []
for val in self.valores:
terminales.append(val.valor)
r=DBMS.insert(ent.getDataBase(),self.nombre,terminales)
if(r==4):
variables.consola.insert(INSERT,'Error violacion de Constraint Primary key\n')
reporteerrores.append(Lerrores("Error Semantico",'Violacion de Constraint primary Key','',''))
return
variables.consola.insert(INSERT,'Registros Ingresados EXITOSAMENTE\n')
return
def FunctionWithTwoParameter(self, funcion, parametros, exp1, exp2):
if (parametros == 2):
if (funcion == "div"):
return Terminal(Tipo('decimal', exp1 / exp2, self.l(exp1 / exp2), -1), exp1 / exp2)
elif (funcion == "gcd"):
return Terminal(Tipo('integer', math.gcd(exp1, exp2), self.l(math.gcd(exp1, exp2)), -1),
math.gcd(exp1, exp2))
elif (funcion == "mod"):
return Terminal(Tipo('integer', exp1 % exp2, self.l(exp1 % exp2), -1), exp1 % exp2)
elif (funcion == "power"):
return Terminal(Tipo('decimal', math.pow(exp1, exp2), self.l(math.pow(exp1, exp2)), -1),
math.pow(exp1, exp2))
elif (funcion == "round"):
return Terminal(Tipo('decimal', round(exp1, exp2), self.l(round(exp1, exp2)), -1), round(exp1, exp2))
elif (funcion == "atan2"):
return Terminal(Tipo('decimal', math.atan(exp1 / exp2), self.l(math.atan(exp1 / exp2)), -1),
math.atan(exp1 / exp2))
elif (funcion == "atan2d"):
return Terminal(
Tipo('decimal', math.degrees(math.atan(exp1 / exp2)), self.l(math.atan(exp1 / exp2)), -1),
math.degrees(math.atan(exp1 / exp2)))
elif (funcion == "encode"):
if (exp2.lower() == "base64"):
cascci = exp1.encode('ascii')
codificado = base64.b64encode(cascci)
return Terminal(Tipo('varchar', codificado.decode('utf-8'), self.l(codificado.decode('utf-8')), -1),
codificado.decode('utf-8'))
elif (exp2.lower() == "hex"):
cascci = exp1.encode('utf-8')
codificado = base64.b16encode(cascci)
return Terminal(Tipo('varchar', codificado.decode('utf-8'), self.l(codificado.decode('utf-8')), -1),
codificado.decode('utf-8'))
elif (exp2.lower() == "escape"):
codificado = exp1.encode('unicode_escape').decode('utf-8')
return Terminal(Tipo('varchar', codificado, self.l(codificado), -1), codificado)
elif (funcion == "decode"):
if (exp2.lower() == "base64"):
codificado = base64.b64decode(exp1)
return Terminal(Tipo('varchar', codificado.decode('utf-8'), self.l(codificado.decode('utf-8')), -1),
codificado.decode('utf-8'))
elif (exp2.lower() == "hex"):
codificado = base64.b16decode(exp1)
return Terminal(Tipo('varchar', codificado.decode('utf-8'), self.l(codificado.decode('utf-8')), -1),
codificado.decode('utf-8'))
elif (exp2.lower() == "escape"):
codificado = exp1.encode('utf-8').decode('unicode_escape')
return Terminal(Tipo('varchar', codificado, self.l(codificado), -1), codificado)
elif (funcion == "date_part"):
datepart = Date_Part(exp1, exp2)
datepart=datepart.getval()
return Terminal(Tipo('integer', datepart, self.l(datepart), -1), datepart)
elif (funcion == "trim"):
print('exp',exp2)
trim = exp1.strip(exp2)
return Terminal(Tipo('varchar', trim, self.l(trim), -1), trim)
else:
reporteerrores.append(
Lerrores("Error Semantico", "La funcion" + funcion + "solo recibe 2 parametros", 0, 0))
return "Error: La funcion: " + funcion + " recibe 2 parametro"
def FunctionWithOneParameter(self, funcion, parametros, exp):
result = None
if (parametros == 1):
if (funcion == "abs"):
if (exp < 0):
return Terminal(Tipo('numeric', exp * -1, self.l(exp * -1), -1), exp * -1)
else:
return Terminal(Tipo('numeric', exp, self.l(exp), -1), exp)
elif (funcion == "cbrt"):
return Terminal(Tipo('decimal', math.pow(exp, 3), self.l(math.pow(exp, 3)), -1), math.pow(exp, 3))
elif (funcion == "ceil"):
return Terminal(Tipo('numeric', math.ceil(exp), self.l(math.ceil(exp)), -1), math.ceil(exp))
elif (funcion == "ceiling"):
return Terminal(Tipo('numeric', math.ceil(exp), self.l(math.ceil(exp)), -1), math.ceil(exp))
elif (funcion == "degrees"):
return Terminal(Tipo('decimal', math.degrees(exp), self.l(math.degrees(exp)), -1), math.degrees(exp))
elif (funcion == "exp"):
return Terminal(Tipo('numeric', math.exp(exp), self.l(math.exp(exp)), -1), math.exp(exp))
elif (funcion == "factorial"):
return Terminal(Tipo('numeric', math.factorial(exp), self.l(math.factorial(exp)), -1),
math.factorial(exp))
elif (funcion == "floor"):
return Terminal(Tipo('integer', math.floor(exp), self.l(math.floor(exp)), -1), math.floor(exp))
elif (funcion == "ln"):
return Terminal(Tipo('decimal', math.log(exp), self.l(math.log(exp)), -1), math.log(exp))
elif (funcion == "log"):
return Terminal(Tipo('decimal', math.log10(exp), self.l(math.log10(exp)), -1), math.log10(exp))
elif (funcion == "radians"):
return Terminal(Tipo('decimal', math.radians(exp), self.l(math.radians(exp)), -1), math.radians(exp))
elif (funcion == "sing"):
if (exp > 0):
return Terminal(Tipo('integer', 1, self.l(1), -1), 1)
else:
return Terminal(Tipo('integer', -1, self.l(-1), -1), -1)
elif (funcion == "sqrt"):
return Terminal(Tipo('decimal', math.sqrt(exp), self.l(math.sqrt(exp)), -1), math.sqrt(exp))
elif (funcion == "trunc"):
return Terminal(Tipo('numeric', math.trunc(exp), self.l(math.trunc(exp)), -1), math.trunc(exp))
elif (funcion == "acos"):
return Terminal(Tipo('decimal', math.acos(exp), self.l(math.acos(exp)), -1), math.acos(exp))
elif (funcion == "acosd"):
return Terminal(Tipo('decimal', math.degrees(math.acos(exp)), self.l(math.degrees(math.acos(exp))), -1),
math.degrees(math.acos(exp)))
elif (funcion == "asin"):
return Terminal(Tipo('decimal', math.asin(exp), self.l(math.asin(exp)), -1), math.asin(exp))
elif (funcion == "asind"):
return Terminal(Tipo('decimal', math.degrees(math.asin(exp)), self.l(math.degrees(math.asin(exp))), -1),
math.degrees(math.asin(exp)))
elif (funcion == "atan"):
return Terminal(Tipo('decimal', math.atan(exp), self.l(math.atan(exp)), -1), math.atan(exp))
elif (funcion == "atand"):
return Terminal(Tipo('decimal', math.degrees(math.atan(exp)), self.l(math.degrees(math.atan(exp))), -1),
math.degrees(math.atan(exp)))
elif (funcion == "cos"):
return Terminal(Tipo('decimal', math.cos(exp), self.l(math.cos(exp)), -1), math.cos(exp))
elif (funcion == "cosd"):
return Terminal(Tipo('decimal', math.degrees(math.cos(exp)), self.l(math.degrees(math.cos(exp))), -1),
math.degrees(math.cos(exp)))
elif (funcion == "cot"):
return Terminal(Tipo('decimal', (1 / math.tan(exp)), self.l((1 / math.tan(exp))), -1),
(1 / math.tan(exp)))
elif (funcion == "cotd"):
return Terminal(
Tipo('decimal', math.degrees(1 / math.tan(exp)), self.l(math.degrees(1 / math.tan(exp))), -1),
math.degrees(1 / math.tan(exp)))
elif (funcion == "sin"):
return Terminal(Tipo('decimal', math.sin(exp), self.l(math.sin(exp)), -1), math.sin(exp))
elif (funcion == "sind"):
return Terminal(Tipo('decimal', math.degrees(math.sin(exp)), self.l(math.degrees(math.sin(exp))), -1),
math.degrees(math.sin(exp)))
elif (funcion == "sin"):
return Terminal(Tipo('decimal', math.sin(exp), self.l(math.sin(exp)), -1), math.sin(exp))
elif (funcion == "sind"):
return Terminal(Tipo('decimal', math.degrees(math.sin(exp)), self.l(math.degrees(math.sin(exp))), -1),
math.degrees(math.sin(exp)))
elif (funcion == "tan"):
return Terminal(Tipo('decimal', math.tan(exp), self.l(math.tan(exp)), -1), math.tan(exp))
elif (funcion == "tand"):
return Terminal(Tipo('decimal', math.degrees(math.tan(exp)), self.l(math.degrees(math.tan(exp))), -1),
math.degrees(math.tan(exp)))
elif (funcion == "sinh"):
return Terminal(Tipo('decimal', math.sinh(exp), self.l(math.sinh(exp)), -1), math.sinh(exp))
elif (funcion == "cosh"):
return Terminal(Tipo('decimal', math.cosh(exp), self.l(math.cosh(exp)), -1), math.cosh(exp))
elif (funcion == "tanh"):
return Terminal(Tipo('decimal', math.tanh(exp), self.l(math.tanh(exp)), -1), math.tanh(exp))
elif (funcion == "asinh"):
return Terminal(Tipo('decimal', math.asinh(exp), self.l(math.asinh(exp)), -1), math.asinh(exp))
elif (funcion == "acosh"):
return Terminal(Tipo('decimal', math.acosh(exp), self.l(math.acosh(exp)), -1), math.acosh(exp))
elif (funcion == "atanh"):
return Terminal(Tipo('decimal', math.atanh(exp), self.l(math.atanh(exp)), -1), math.atanh(exp))
elif (funcion == "length"):
self.leng = len(exp)
return Terminal(Tipo('smallint', self.leng, self.l(self.leng), -1), self.leng)
elif (funcion == "md5"):
m = exp
result = hashlib.md5(m.encode())
return Terminal(Tipo('varchar', result.hexdigest(), self.l(result.hexdigest()), -1), result.hexdigest())
elif (funcion == "sha256"):
m = exp
result = hashlib.sha256(m.encode()).hexdigest()
return Terminal(Tipo('decimal', result, self.l(result), -1), result)
elif (funcion == "convert"):
return self.expresiones[0]
elif (funcion == "trim"):
trim = exp.strip()
return Terminal(Tipo('varchar', trim, self.l(trim), -1), trim)
else:
reporteerrores.append(
Lerrores("Error Semantico", "La funcion" + funcion + "solo recibe 2 parametros", 0, 0))
return "Error: La funcion: " + funcion + " recibe un parametro"
def ejecutar(self, ent: Entorno):
completo = self.nombre + '_' + ent.getDataBase()
tabla: Simbolo = ent.buscarSimbolo(completo)
if tabla != None:
columnas = tabla.valor
i = 0
contador = 0
for columna in columnas:
verificarnull = tabla.valor[i].atributos.get('not null')
verificarprimary = tabla.valor[i].atributos.get('primary')
verificarunique = tabla.valor[i].atributos.get('unique')
verificarcheck = tabla.valor[i].atributos.get('check')
condicion1: Expresion
condicion2: Expresion
if (verificarcheck != None):
check = ent.buscarSimbolo(verificarcheck)
print("Condicion:", check.valor.exp1.getval(ent),
check.valor.simbolo, check.valor.exp2.getval(ent))
condicion1 = Terminal(columna.tipo,
check.valor.exp1.getval(ent))
condicion2 = Terminal(columna.tipo,
check.valor.exp2.getval(ent))
operador = check.valor.simbolo
l = 0
for columna in columnas:
tipo = columna.tipo
if (check.valor.exp1.getval(ent) == columna.nombre):
k = 0
for actual in self.namecolums:
if (check.valor.exp1.getval(ent) ==
actual.getval(ent)):
condicion1 = Terminal(
tipo, self.valores[k].getval(ent))
k = k + 1
l = l + 1
n = 0
for columna in columnas:
if (check.valor.exp2.getval(ent) == columna.nombre):
k = 0
for actual in self.namecolums:
if (check.valor.exp2.getval(ent) ==
actual.getval(ent)):
condicion2 = Terminal(
columna.tipo,
self.valores[k].getval(ent))
k = k + 1
n = n + 1
correcto = False
if operador in ('>', '<', '>=', '<=', '='):
print(condicion1.getval(ent), operador,
condicion2.getval(ent))
nuevaop = Relacional(condicion1, condicion2, operador)
if nuevaop.getval(ent):
correcto = True
else:
return ('Registro no cumple con condicion check')
elif operador in ('or', 'and', 'not'):
nuevaop = Logica(condicion1, condicion2, operador)
if nuevaop.getval(ent):
correcto = True
else:
return ('Registro no cumple con condicion Check')
if (verificarnull != None or verificarprimary != None
or verificarunique != None):
contador = contador + 1
i = i + 1
#print("contador",contador)
if ((len(self.valores) >= contador)
and (len(self.valores) == len(self.namecolums))
and (len(self.namecolums) <= len(columnas))):
j = 0
t = 0
correcto = True
terminales = []
for columna in columnas:
nombre = columna.nombre
tipo = columna.tipo
util = Tipo(None, None, -1, -1)
if (nombre == self.namecolums[j].getval(ent)):
#print("iguales",nombre,":",self.namecolums[j].getval(ent),"J",j,"t",t)
if util.comparetipo(tipo, self.valores[j].tipo):
'todo correcto'
else:
correcto = False
return 'Error los tipos de los valores no coinciden con la definicion de la tabla'
terminales.append(self.valores[j].getval(ent))
j = j + 1
else:
#print("diferentes",nombre,":",self.namecolums[j].getval(ent),"J",j,"t",t)
terminales.append('')
r = DBMS.insert(ent.getDataBase(), self.nombre, terminales)
if (r == 4):
return 'Error al Insertar Registro Violacion de Constraint Primary Key'
print("Insert: ", terminales)
return 'Registro insertado exitosamente'
#print("insertando",r)
else:
return str('Error Numero Parametros en tabla ' + self.nombre +
' Incorrectos')
else:
return str('Error Tabla ' + self.nombre +
' No Existe en la BD actual')
def ejecutar(self, ent: Entorno):
completo = self.nombre + '_' + ent.getDataBase()
tabla: Simbolo = ent.buscarSimbolo(completo)
if tabla != None:
columnas = tabla.valor
columnaunique = []
columnacheck = []
if len(self.valores) == len(columnas):
i = 0
correcto = True
for columna in columnas:
verificarnull = tabla.valor[i].atributos.get('not null')
verificarprimary = tabla.valor[i].atributos.get('primary')
verificarunique = tabla.valor[i].atributos.get('unique')
verificarcheck = tabla.valor[i].atributos.get('check')
nombre = columna.nombre
tipo = columna.tipo
condicion1: Expresion
condicion2: Expresion
if verificarunique != None:
#print("unique",verificarunique,"m--",nombre)
columnaunique.append(columna.nombre)
for colunique in columnaunique:
if nombre == colunique:
#print("UNIQUE",colunique,"colactual",nombre,"valor",self.valores[i].getval(ent),"---")
v = self.validarunique(ent, tabla, colunique,
self.valores[i].getval(ent))
#print("-----",v)
if v:
print(
'Error Violacion de Constraint Unique en:',
colunique, ' : ',
self.valores[i].getval(ent))
return 'Error Violacion de Constraint Unique en columna:' + colunique + ' : ' + self.valores[
i].getval(ent)
if (verificarcheck != None):
check = ent.buscarSimbolo(verificarcheck)
#print("Condicion:",check.valor.exp1.getval(ent),check.valor.simbolo,check.valor.exp2.getval(ent))
condicion1 = Terminal(columna.tipo,
check.valor.exp1.getval(ent))
condicion2 = Terminal(columna.tipo,
check.valor.exp2.getval(ent))
operador = check.valor.simbolo
l = 0
for columna in columnas:
tipo = columna.tipo
if (check.valor.exp1.getval(ent) == columna.nombre
):
condicion1 = Terminal(
tipo, self.valores[l].getval(ent))
l = l + 1
n = 0
for columna in columnas:
if (check.valor.exp2.getval(ent) == columna.nombre
):
condicion2 = Terminal(
columna.tipo, self.valores[n].getval(ent))
n = n + 1
correcto = False
if operador in ('>', '<', '>=', '<=', '='):
#print(condicion1.getval(ent),operador,condicion2.getval(ent))
nuevaop = Relacional(condicion1, condicion2,
operador)
if nuevaop.getval(ent):
correcto = True
else:
return (
'Registro no cumple con condicion check')
elif operador in ('or', 'and', 'not'):
nuevaop = Logica(condicion1, condicion2, operador)
if nuevaop.getval(ent):
correcto = True
else:
return (
'Registro no cumple con condicion Check')
util = Tipo(None, None, -1, -1)
if isinstance(self.valores[i], FuncionesNativas):
self.valores[i] = self.valores[i].getval(ent)
if util.comparetipo(tipo, self.valores[i].tipo):
'todo correcto'
else:
correcto = False
return 'Error los tipos de los valores no coinciden con la definicion de la tabla'
i = i + 1
terminales = []
for val in self.valores:
terminales.append(val.getval(ent))
r = DBMS.insert(ent.getDataBase(), self.nombre, terminales)
if (r == 4):
return 'Error al Insertar Registro Violacion de Constraint Primary Key'
return 'Registros insertados con exito'