def resultupdate(self, result, nomresult, DB, llaves):
if not len(result) > 0:
return (
"En la instrucción Delete no hay registros que cumplan la expresión"
)
else:
if not len(llaves) > 0:
columnas = len(self.encabezado)
DBMS.dropTable(DB, nomresult)
DBMS.createTable(DB, nomresult, columnas)
for x in range(0, len(result)):
DBMS.insert(DB, nomresult, result[x])
self.encabezado.clear()
variables.consola.insert(
INSERT, "La instrucción UPDATE se realizó exitosamente \n")
return "La instrucción UPDATE se realizó exitosamente"
else:
columnas = len(self.encabezado)
DBMS.dropTable(DB, nomresult)
DBMS.createTable(DB, nomresult, columnas)
DBMS.alterAddPK(DB, nomresult, llaves)
for x in range(0, len(result)):
DBMS.insert(DB, nomresult, result[x])
self.encabezado.clear()
variables.consola.insert(
INSERT, "La instrucción UPDATE se realizó exitosamente \n")
return "La instrucción UPDATE se realizó exitosamente"
def ECreateType():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
crear_type = listaMemoria[0]
EDD.createTable(crear_type[0], crear_type[1], crear_type[2])
EDD.insert(crear_type[0], crear_type[1], crear_type[3])
print("creado type ", crear_type[1], " con valores ", crear_type[3])
listaMemoria.pop(0)
def EInsert():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
Data_insert = listaMemoria[0]
EDD.insert(Data_insert[0], Data_insert[1], Data_insert[2])
print("insert en tabla ", Data_insert[1], " \n\tvalores ",
Data_insert[2])
listaMemoria.pop(0)
def resultdelete(self,result,nomresult,DB):
if not len(result)>0:
return ("En la instrucción Delete no hay registros que cumplan la expresión")
else:
columnas = len(self.encabezados)
print(DBMS.dropTable(DB, nomresult))
print(DBMS.createTable(DB, nomresult, columnas))
for x in range(0,len(result)):
DBMS.insert(DB,nomresult,result[x])
self.encabezados.clear()
return "La instrucción DELETE se realizó exitosamente"
def ejecutar(self, ent: Entorno):
completo = self.nombre + '_' + ent.getDataBase()
tabla: Simbolo = ent.buscarSimbolo(completo)
if tabla != None:
columnas = tabla.valor
if len(self.valores) == len(columnas):
i = 0
correcto = True
for columna in columnas:
nombre = columna.nombre
tipo = columna.tipo
util = Tipo(None, None, -1, -1)
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))
print("T ", terminales)
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'
def ejecutar(self, ent:Entorno):
tabla:Simbolo = ent.buscarSimbolo(self.nombre)
if tabla != None:
columnas=tabla.valor
if len(self.valores)== len(columnas):
i=0
correcto=True
for columna in columnas:
nombre=columna.nombre
tipo=columna.tipo
util=Tipo(None,None,-1,-1)
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))
DBMS.insert(ent.getDataBase(),tabla.nombre,terminales)
def insertarDatos(self, nodo):
tb_name = nodo.valor
if not (self.usingDB in self.ts):
self.errors.append(
Error('-----', EType.SEMANTICO, 'database_non_exist',
nodo.linea))
return
# Recuperar la base de datos
db_obj = self.ts[self.usingDB]
# Recuperar la tabla
if not (tb_name in db_obj.tables):
self.errors.append(
Error('42P01', EType.SEMANTICO, 'undefined_table', nodo.linea))
return
# tb_obj = db_obj.tables[tb_name]
# Lista de tipos de las columnas de la tabla
# tbcoltypelist = self.getColsTypeList(tb_obj)
# Obtener lista de tipos entrante
valores = []
for p in nodo.hijos:
valores.append(p.hijos[0].valor)
result = jsonMode.insert(self.usingDB, tb_name, valores)
if result == 0: # Operación Exitosa
self.output.append('Registros en \"' + tb_name +
'\" ingresados correctamente.')
elif result == 1: # Error en la operación
self.errors.append(
Error('XX000', EType.SEMANTICO, 'internal_error', nodo.linea))
elif result == 2: # Base de datos no existente
self.errors.append(
Error('-----', EType.SEMANTICO, 'database_non_exist',
nodo.linea))
elif result == 3: # Tabla no existente
self.errors.append(
Error('42P01', EType.SEMANTICO, 'undefined_table', nodo.linea))
elif result == 4: # Llave primaria duplicada
self.errors.append(
Error('-----', EType.SEMANTICO, 'duplicate_pk', nodo.linea))
elif result == 5: # Columnas fuera de límits
self.errors.append(
Error('54011', EType.SEMANTICO, 'too_many_columns',
nodo.linea))
def execute(self):
#TODO Falta la validación de tipos
lista = []
tab = self.tabla
for p in self.parametros:
lista.append(p.execute().value)
res = jsonMode.insert(dataBase, tab, lista)
if res == 2:
return "No existe la base de datos"
elif res == 3:
print("No existe la tabla")
return "No existe la tabla"
elif res == 5:
return "Columnas fuera de los limites"
elif res == 4:
return "Llaves primarias duplicadas"
elif res == 1:
return "Error en la operacion"
elif res == 0:
return "Fila Insertada correctamente"
j.dropAll()
# create database
j.createDatabase('world')
# create tables
j.createTable('world', 'countries', 4)
j.createTable('world', 'cities', 4)
j.createTable('world', 'languages', 4)
# create simple primary keys
j.alterAddPK('world', 'countries', [0])
j.alterAddPK('world', 'cities', [0])
j.alterAddPK('world', 'languages', [0, 1])
# insert data in countries
j.insert('world', 'countries', ['GTM', 'Guatemala', 'Central America', 108889])
j.insert('world', 'countries', ['SLV', 'El Salvado', 'Central America', 21041])
# insert data in cities
j.insert('world', 'cities', [1, 'Guatemala', 'Guatemala', 'GTM'])
j.insert('world', 'cities', [2, 'Cuilapa', 'Santa Rosa', 'GTM'])
j.insert('world', 'cities', [3, 'San Salvador', 'San Salvador', 'SLV'])
j.insert('world', 'cities', [4, 'San Miguel', 'San Miguel', 'SLV'])
# inser data in languages
j.insert('world', 'languages', ['GTM', 'Spanish', 'official', 64.7])
j.insert('world', 'languages', ['SLV', 'Spanish', 'official', 100.0])
# show all data
j.showCollection()
# test Databases CRUD
print(j.createDatabase('db1')) # 0
print(j.createDatabase('db1')) # 2
print(j.createDatabase('db4')) # 0
print(j.createDatabase('db5')) # 0
print(j.createDatabase(0)) # 1
print(j.alterDatabase('db5', 'db1')) # 3
print(j.alterDatabase('db5', 'db2')) # 0
print(j.dropDatabase('db4')) # 0
print(j.showDatabases()) # ['db1','db2']
# test Tables CRUD
print(j.createTable('db1', 'tb4', 3)) # 0
print(j.createTable('db1', 'tb4', 3)) # 3
print(j.createTable('db1', 'tb1', 3)) # 0
print(j.createTable('db1', 'tb2', 3)) # 0
print(j.alterTable('db1', 'tb4', 'tb3')) # 0
print(j.dropTable('db1', 'tb3')) # 0
print(j.alterAddPK('db1', 'tb1', 0)) # 1
print(j.alterAddPK('db1', 'tb1', [0])) # 0
print(j.showTables('db1')) # ['tb1', 'tb2']
# test Registers CRUD
print(j.insert('db1', 'tb1', [1, 1])) # 5
print(j.insert('db1', 'tb1', ['1', 'line', 'one'])) # 0
print(j.loadCSV('tb1.csv', 'db1', 'tb1')) # [0, 0, 0, 0, 0]
print(j.extractTable('db1', 'tb1'))
# [['1', 'line', 'one'], ['2', 'line', 'two'],
# ['3', 'line', 'three'], ['4', 'line', 'four'],
# ['5', 'line', 'five'], ['6', 'line', 'six']]
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
# create database
j.createDatabase('BD1')
# create tables
j.createTable('BD1', 'personas', 5)
j.createTable('BD1', 'pais', 4)
j.createTable('BD1', 'idiomas', 4)
# create simple primary keys
j.alterAddPK('BD1', 'personas', [0])
j.alterAddPK('BD1', 'pais', [0])
j.alterAddPK('BD1', 'idiomas', [0])
# insert data in countries
j.insert('BD1', 'pais', ['GTM', 'Guatemala', 'Central America', 108889])
j.insert('BD1', 'pais', ['MX', 'Mexico', 'Norte America', 21041])
j.insert('BD1', 'pais', ['EEUU', 'Estados Unidos', 'Norte America', 21041])
# insert data in cities
j.insert('BD1', 'personas', [1, 'Jossie', 'Castrillo','27', 'GTM'])
j.insert('BD1', 'personas', [2, 'Juanpi', 'Garcia','27', 'GTM'])
j.insert('BD1', 'personas', [3, 'Byron', 'Cermeno','27', 'GTM'])
j.insert('BD1', 'personas', [4, 'Hayrton', 'Ixpata','27', 'GTM'])
j.insert('BD1', 'personas', [5, 'Dulce', 'DeLeon','25', 'MX'])
j.insert('BD1', 'personas', [6, 'Miguel', 'Basir','26', 'GTM'])
j.insert('BD1', 'personas', [7, 'Nose', 'Algo','30', 'EEUU'])
# inser data in languages
j.insert('BD1', 'idiomas', ['GTM', 'Espanol', 'official', 64.7])
j.insert('BD1', 'idiomas', ['EEUU', 'Espanol', 'official', 100.0])
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'
def cmd_insert(self, database, table, listaEntrada):
if existeTabla(table, database) == 1:
condb.insert(database, table, listaEntrada)
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 execute(self, environment):
if not isinstance(self.tableName, str):
return {
'Error': 'El nombre indicado de la tabla no es una cadena.',
'Fila': self.row,
'Columna': self.column
}
if not isinstance(self.idList, list):
db_name = environment.getActualDataBase()
database = environment.readDataBase(db_name)
if database == None:
return {
'Error': 'Error al buscar en la base de datos',
'Fila': self.row,
'Columna': self.column
}
table = database.getTable(self.tableName)
if table == None:
return {
'Error':
'La tabla: ' + self.tableName +
' no existe en la base de datos: ' + db_name,
'Fila':
self.row,
'Columna':
self.column
}
if len(table.columns) != len(self.valueList):
return {
'Error':
'El numero de valores a insertar es diferente que el numero de columnas de la tabla: '
+ self.tableName,
'Fila':
self.row,
'Columna':
self.column
}
for i in range(len(self.valueList)):
columna = table.columns[i]
valor = self.valueList[i].execute(environment)
res = check(columna.tipo, valor['typ'], valor['value'],
columna.lenght)
if not isinstance(res, bool):
return {
'Error': res,
'Fila': self.row,
'Columna': self.column
}
for index in range(len(self.valueList)):
nombreVariable = table.columns[index].name
valorVariable = self.valueList[index].execute(environment)
environment.guardarVariableins(nombreVariable,
valorVariable['typ'],
valorVariable['value'], None)
for item in table.constraint:
if item['type'] == 'primary':
var = environment.buscarVariable(item['value'], None)
if var == None:
return {
'Error': 'Variable no encontrada',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.NULL:
return {
'Error': 'La primary key no puede ser nula',
'Fila': self.row,
'Columna': self.column
}
elif item['type'] == 'foreign':
#no hay validaciones por el momento
print('foreign')
elif item['type'] == 'not null':
var = environment.buscarVariable(item['value'], None)
if var == None:
return {
'Error': 'Variable no encontrada',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.NULL:
return {
'Error':
'El campo: ' + var['name'] + ' no puede ser nulo',
'Fila': self.row,
'Columna': self.column
}
elif item['type'] == 'check':
var = item['value'].execute(environment)
if var['typ'] != Type.BOOLEAN:
return {
'Error': 'La condicion del check, no es booleana',
'Fila': self.row,
'Columna': self.column
}
if var['value'] != True:
return {
'Error':
'No se cumple con la restriccion: ' + item['name'],
'Fila':
self.row,
'Columna':
self.column
}
elif item['type'] == 'unique':
val = admin.extractTable(db_name, self.tableName)
if val == None:
return {
'Error':
'La base de datos o la tabla a la que desea hacer referencia no existe.',
'Fila': self.row,
'Columna': self.column
}
elif len(val) == 0:
#pasa de largo porque no hay registros
print('')
elif len(val) > 0:
aux = -1
for i in range(len(table.columns)):
if table.columns[i].name == item['value']:
aux = i
break
if aux == -1:
return {
'Error':
'No se encontro la columna: ' + item['value'],
'Fila':
self.row,
'Columna':
self.column
}
searched = environment.buscarVariable(
item['value'], None)
for tupla in val:
if tupla[aux] == searched['value']:
if isinstance(searched['value'], int):
return {
'Error':
'Ya existe un registro con el valor: '
+ str(searched['value']) +
' en la columna: ' + item['value'] +
' lo cual viola la restriccion unique',
'Fila':
self.row,
'Columna':
self.column
}
else:
return {
'Error':
'Ya existe un registro con el valor: '
+ searched['value'] +
' en la columna: ' + item['value'] +
' lo cual viola la restriccion unique',
'Fila':
self.row,
'Columna':
self.column
}
else:
return {
'Error': 'Error desconocido al insertar.',
'Fila': self.row,
'Columna': self.column
}
#guardando en el storage
listaValores = []
for item in self.valueList:
valorLista = item.execute(environment)
if valorLista['typ'] == Type.DATE or valorLista[
'typ'] == Type.TIME:
listaValores.append(str(valorLista['value']))
else:
listaValores.append(valorLista['value'])
valorRetorno = admin.insert(db_name, self.tableName, listaValores)
print(listaValores)
if valorRetorno == 0:
return 'Se ha insertado con exito la tupla ' + str(
listaValores) + ' en la tabla: ' + self.tableName
elif valorRetorno == 1:
return {
'Error': 'Error en la operación insertar.',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 2:
return {
'Error':
'La base de datos a la que desea referenciar no existe',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 3:
return {
'Error':
'La tabla en la que desea insertar registros no existe',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 4:
return {
'Error': 'Llave primaria duplicada',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 5:
return {
'Error': 'columna fuera de limites',
'Fila': self.row,
'Columna': self.column
}
else:
return {
'Error': 'Error desconocido al insertar registros',
'Fila': self.row,
'Columna': self.column
}
else:
# aqui es el segundo formato de insert
db_name = environment.getActualDataBase()
database = environment.readDataBase(db_name)
if database == None:
return {
'Error': 'Error al buscar en la base de datos',
'Fila': self.row,
'Columna': self.column
}
table = database.getTable(self.tableName)
if table == None:
return {
'Error':
'La tabla: ' + self.tableName +
' no existe en la base de datos: ' + db_name,
'Fila':
self.row,
'Columna':
self.column
}
if len(table.columns) < len(self.idList):
return {
'Error':
'El numero de columnas indicadas es mayor al numero de columnas de la tabla: '
+ self.tableName,
'Fila':
self.row,
'Columna':
self.column
}
#if len(self.valueList) != len(self.idList):
#return {'Error': 'El numero de registros a insertar difiere del numero de columnas indicadas: '+self.tableName, 'Fila':self.row, 'Columna': self.column }
#TODO verificar tipos
for i in range(len(self.valueList)):
columna = table.readColumn(self.idList[i])
if columna == None:
return {
'Error':
'La columna: ' + self.idList[i] +
' no existe en la tabla ' + table.name,
'Fila':
self.row,
'Columna':
self.column
}
valor = self.valueList[i].execute(environment)
res = check(columna.tipo, valor['typ'], valor['value'],
columna.lenght)
if not isinstance(res, bool):
return {
'Error': res,
'Fila': self.row,
'Columna': self.column
}
# verificar que el id list coincida con los nombres de las columnas
for item in self.idList:
exist = False
for col in table.columns:
if col.name == item:
exist = True
if exist == False:
return {
'Error':
'La columna: ' + item + ' no existe en la tabla: ' +
self.tableName,
'Fila':
self.row,
'Columna':
self.column
}
for index in range(len(self.valueList)):
nombreVariable = self.idList[index]
valorVariable = self.valueList[index].execute(environment)
environment.guardarVariableins(nombreVariable,
valorVariable['typ'],
valorVariable['value'], None)
for item in table.columns:
var = environment.buscarVariable(item.name, None)
if var == None:
if item.default == None:
nombreVariable = item.name
valorVariable = 'null'
tipoVariable = Type.NULL
environment.guardarVariableins(nombreVariable,
tipoVariable,
valorVariable, None)
else:
nombreVariable = item.name
valorVariable = item.default
tipoVariable = item.tipo
environment.guardarVariableins(nombreVariable,
tipoVariable,
valorVariable, None)
for item in table.constraint:
if item['type'] == 'primary':
var = environment.buscarVariable(item['value'], None)
if var == None:
return {
'Error': 'Variable no encontrada',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.NULL:
return {
'Error': 'La primary key no puede ser nula',
'Fila': self.row,
'Columna': self.column
}
elif item['type'] == 'foreign':
#no hay validaciones por el momento
print('foreign')
elif item['type'] == 'not null':
var = environment.buscarVariable(item['value'], None)
if var == None:
return {
'Error': 'Variable no encontrada',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.NULL:
return {
'Error':
'El campo: ' + var['name'] + ' no puede ser nulo',
'Fila': self.row,
'Columna': self.column
}
elif item['type'] == 'check':
var = item['value'].execute(environment)
if var['typ'] != Type.BOOLEAN:
return {
'Error': 'La condicion del check, no es booleana',
'Fila': self.row,
'Columna': self.column
}
if var['value'] != True:
return {
'Error':
'No se cumple con la restriccion: ' + item['name'],
'Fila':
self.row,
'Columna':
self.column
}
elif item['type'] == 'unique':
val = admin.extractTable(db_name, self.tableName)
if val == None:
return {
'Error':
'La base de datos o la tabla a la que desea hacer referencia no existe.',
'Fila': self.row,
'Columna': self.column
}
elif len(val) == 0:
#pasa de largo porque no hay registros
print('')
elif len(val) > 0:
aux = -1
for i in range(len(table.columns)):
if table.columns[i].name == item['value']:
aux = i
break
if aux == -1:
return {
'Error':
'No se encontro la columna: ' + item['value'],
'Fila':
self.row,
'Columna':
self.column
}
searched = environment.buscarVariable(
item['value'], None)
for tupla in val:
if tupla[aux] == searched['value']:
if isinstance(searched['value'], int):
return {
'Error':
'Ya existe un registro con el valor: '
+ str(searched['value']) +
' en la columna: ' + item['value'] +
' lo cual viola la restriccion unique',
'Fila':
self.row,
'Columna':
self.column
}
else:
return {
'Error':
'Ya existe un registro con el valor: '
+ searched['value'] +
' en la columna: ' + item['value'] +
' lo cual viola la restriccion unique',
'Fila':
self.row,
'Columna':
self.column
}
else:
return {
'Error': 'Error desconocido al insertar.',
'Fila': self.row,
'Columna': self.column
}
#ordenar la lista de valores
#guardando en el storage
valOrden = []
for item in table.columns:
var = environment.buscarVariable(item.name, None)
if var == None:
return {
'Error': 'Error desconocido al insertar 2.',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.DATE or var['tipo'] == Type.TIME:
valOrden.append(str(var['value']))
else:
valOrden.append(var['value'])
valorRetorno = admin.insert(db_name, self.tableName, valOrden)
if valorRetorno == 0:
return 'Se ha insertado con exito la tupla ' + str(
valOrden) + ' en la tabla: ' + self.tableName
elif valorRetorno == 1:
return {
'Error': 'Error en la operación insertar.',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 2:
return {
'Error':
'La base de datos a la que desea referenciar no existe',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 3:
return {
'Error':
'La tabla en la que desea insertar registros no existe',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 4:
return {
'Error': 'Llave primaria duplicada',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 5:
return {
'Error': 'columna fuera de limites',
'Fila': self.row,
'Columna': self.column
}
else:
return {
'Error': 'Error desconocido al insertar registros',
'Fila': self.row,
'Columna': self.column
}
# JSON Mode Test File
# Released under MIT License
# Copyright (c) 2020 TytusDb Team
from storageManager import jsonMode as j
print(j.extractTable('compiladores2', 'USUARIO'))
# create database
j.createDatabase('world')
j.createTable('world', 'cities', 4)
# create simple primary keys
j.alterAddPK('world', 'cities', [0])
# insert data in cities
j.insert('world', 'cities', [1, 'Guatemala', 'Guatemala', 'GTM'])
j.insert('world', 'cities', [2, 'Cuilapa', 'Santa Rosa', 'GTM'])
j.insert('world', 'cities', [3, 'San Salvador', 'San Salvador', 'SLV'])
j.insert('world', 'cities', [4, 'San Miguel', 'San Miguel', 'SLV'])
# show all datap
print(j.extractTable('world', 'cities')) #SELECT
print(j.update('world', 'cities', {
1: 'Mexico',
3: 'MX'
}, [1]))
print(j.extractTable('world', 'cities')) #SELECT
def m_carga_de_informacion(self):
# drop all databases if exists
j.dropAll()
# create database
j.createDatabase('BD1')
# create tables
j.createTable('BD1', 'personas', 5)
j.createTable('BD1', 'pais', 4)
j.createTable('BD1', 'idiomas', 4)
# create simple primary keys
j.alterAddPK('BD1', 'personas', [0])
j.alterAddPK('BD1', 'pais', [0])
j.alterAddPK('BD1', 'idiomas', [0])
# insert data in countries
j.insert('BD1', 'pais',
['GTM', 'Guatemala', 'Central America', 108889])
j.insert('BD1', 'pais', ['MX', 'Mexico', 'Norte America', 21041])
j.insert('BD1', 'pais',
['EEUU', 'Estados Unidos', 'Norte America', 21041])
# insert data in cities
j.insert('BD1', 'personas', [1, 'Jossie', 'Castrillo', '27', 'GTM'])
j.insert('BD1', 'personas', [2, 'Juanpi', 'Garcia', '27', 'GTM'])
j.insert('BD1', 'personas', [3, 'Byron', 'Cermeno', '27', 'GTM'])
j.insert('BD1', 'personas', [4, 'Hayrton', 'Ixpata', '27', 'GTM'])
j.insert('BD1', 'personas', [5, 'Dulce', 'DeLeon', '25', 'MX'])
j.insert('BD1', 'personas', [6, 'Miguel', 'Basir', '26', 'GTM'])
j.insert('BD1', 'personas', [7, 'Nose', 'Algo', '30', 'EEUU'])
# inser data in languages
j.insert('BD1', 'idiomas', ['GTM', 'Espanol', 'official', 64.7])
j.insert('BD1', 'idiomas', ['EEUU', 'Espanol', 'official', 100.0])
j.insert('BD1', 'idiomas', ['MX', 'Espanol', 'official', 100.0])
