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])