def ejecutar(self, ent: Entorno): dbActual = ent.getDataBase() if dbActual != None: tablaIndex: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual) if tablaIndex != None: for nombreCol in self.columnas: i = 0 fin = len(tablaIndex.valor) while i < fin: if nombreCol.valor == tablaIndex.valor[i].nombre: # IDX_database_tabla idIdex: str = "IDX_" + dbActual + "_" + self.tabla + "_" + self.iden + "_" + nombreCol.valor nuevoSym: Simbolo = Simbolo( TipoSimbolo.INDEX, idIdex, {}) nuevoSym.tabla = self.tabla nuevoSym.indexId = self.iden nuevoSym.baseDatos = dbActual nuevoSym.valor.update({ 'id': self.iden, 'columna': nombreCol.valor }) if self.unique: nuevoSym.valor.update({'unique': True}) if self.hash: nuevoSym.valor.update({'hash': True}) if self.orden != None: nuevoSym.valor.update({'orden': self.orden}) tablaIndex.valor[i].atributos.update( {'index': idIdex}) res = ent.nuevoSimbolo(nuevoSym) if res == "ok": variables.consola.insert( INSERT, "Se agregó nuevo index '" + self.iden + "' a la columna '" + nombreCol.valor + "'\n") else: variables.consola.insert( INSERT, "El nuevo index '" + self.iden + "' no se puede agregar porque ya existe.\n" ) reporteerrores.append( Lerrores( "Semántico", "El nuevo index '" + self.iden + "' no se puede agregar porque ya existe.\n", "", "")) break i = i + 1 else: variables.consola.insert( INSERT, "La tabla '" + self.tabla + "' a la que se le desea agregar el índice '" + self.iden + "' no existe.\n") reporteerrores.append( Lerrores( "Semántico", "La tabla '" + self.tabla + "' a la que se le desea agregar el índice '" + self.iden + "' no existe", "", ""))
def ejecutar(self,ent:Entorno): #formato para el enum: ENUM_database_identificador nuevoType:Simbolo = Simbolo(TipoSimbolo.TYPE_ENUM,("ENUM_" + ent.getDataBase() + "_" + self.id),self.contenido) nuevoType.baseDatos = ent.getDataBase() r = ent.nuevoSimbolo(nuevoType) if r == "ok": variables.consola.insert(INSERT,"Nuevo tipo '" + self.id + "' creado\n") return variables.consola.insert(INSERT,"El tipo '" + self.id + "' ya existe declarado\n") reporteerrores.append(Lerrores("Error Semántico","El tipo '" + self.id + "' ya existe declarado","",""))
def ejecutar(self, ent: Entorno): #formato para el enum: ENUM_database_identificador nuevoType: Simbolo = Simbolo( TipoSimbolo.TYPE_ENUM, ("ENUM_" + ent.getDataBase() + "_" + self.id), self.contenido) nuevoType.baseDatos = ent.getDataBase() r = ent.nuevoSimbolo(nuevoType) if r == "ok": return "Nuevo tipo '" + self.id + "' creado" return "El tipo '" + self.id + "' ya existe declarado"
def ejecutar(self, ent:Entorno): tam = len(self.listaDef) print (tam) nuevaTabla = Simbolo(TipoSimbolo.TABLA,self.id) listaColumnas = [] for x in range(0,tam,1): tt = self.listaDef[x] if tt.tipo == AtributosColumna.COLUMNA_SIMPLE: self.numColumnas += 1 nuevaColumna = Simbolo(tt.tipoDato,tt.identificador) listaColumnas.append(nuevaColumna) nuevaTabla.valor = listaColumnas dbActual = ent.getDataBase() if dbActual != None: estado = DBMS.createTable(dbActual,self.id, self.numColumnas) if estado == 0: nuevaTabla.baseDatos = dbActual ent.nuevoSimbolo(nuevaTabla) print("Tabla Creada") DBMS.showCollection()
def ejecutar(self, ent: Entorno): dbActual = ent.getDataBase() if dbActual != None: tam = len(self.listaDef) nuevaTabla = Simbolo(TipoSimbolo.TABLA, (self.id + "_" + dbActual)) listaColumnas = [] listaAtrCol = [] hayPrimaria = False hayForanea = False primariaAdd: Primaria = None foraneaAdd: Foranea = None inicioHerencia = 0 if self.herencia != None: r: Simbolo = ent.buscarSimbolo(self.herencia + "_" + dbActual) if r != None: for colPadre in r.valor: listaColumnas.append(colPadre) if colPadre.atributos.get('primary') != None: coPrimary: Simbolo = ent.buscarSimbolo( colPadre.atributos.get('primary')) if coPrimary != None: self.listPK = coPrimary.valor inicioHerencia = len(r.valor) else: variables.consola.insert( INSERT, "La tabla padre '" + self.herencia + "' no existe") reporteerrores.append( Lerrores( "Error Semántico", "La tabla padre '" + self.herencia + "' no existe", "", "")) for x in range(0, tam, 1): tt = self.listaDef[x] if tt.tipo == AtributosColumna.COLUMNA_SIMPLE: nuevaColumna = Simbolo(tt.tipoDato, tt.identificador) if tt.lista != None: #aca se mete si viene por ejemplo: columna1 integer references tabla2 tamano = len(tt.lista) for y in range(tamano): hayAtr = False nuevoSym = Simbolo("tipo", "nombre") nuevoSym.baseDatos = dbActual nuevoSym.tabla = self.id atrColumna: Atributo = tt.lista[y] if atrColumna.tipo == AtributosColumna.UNICO: hayAtr = True nuevoSym.tipo = TipoSimbolo.CONSTRAINT_UNIQUE if atrColumna.valor != None: #forma de: constraint id UNIQUE #formato de nombre: U_database_tabla_nombreColumna_idConstraint nuevoSym.nombre = str("U_" + dbActual + "_" + self.id + "_" + tt.identificador + "_" + atrColumna.valor) nuevaColumna.atributos.update({ 'unique': str("U_" + dbActual + "_" + self.id + "_" + tt.identificador + "_" + atrColumna.valor) }) else: #forma de: nombreColumna tipo UNIQUE #formato: U_database_tabla_nombreColumna nuevoSym.nombre = str("U_" + dbActual + "_" + self.id + "_" + tt.identificador) nuevaColumna.atributos.update({ 'unique': str("U_" + dbActual + "_" + self.id + "_" + tt.identificador) }) nuevoSym.valor = tt.identificador elif atrColumna.tipo == AtributosColumna.CHECK: hayAtr = True nuevoSym.tipo = TipoSimbolo.CONSTRAINT_CHECK nuevoSym.valor = atrColumna.exp if atrColumna.valor != None: #forma de: constraint id check cond < cond #formato: C_database_tabla_nombreColumna_idConstraint nuevoSym.nombre = str("C_" + dbActual + "_" + self.id + "_" + tt.identificador + "_" + atrColumna.valor) nuevaColumna.atributos.update({ 'check': str("C_" + dbActual + "_" + self.id + "_" + tt.identificador + "_" + atrColumna.valor) }) else: #cuando viene: nombreColumna tipo CHECK cond < cond #formato: C_database_tabla_nombreColumna nuevoSym.nombre = str("C_" + dbActual + "_" + self.id + "_" + tt.identificador) nuevaColumna.atributos.update({ 'check': str("C_" + dbActual + "_" + self.id + "_" + tt.identificador) }) elif atrColumna.tipo == AtributosColumna.DEFAULT: nuevaColumna.atributos.update( {'default': atrColumna.valor}) elif atrColumna.tipo == AtributosColumna.NO_NULO: nuevaColumna.atributos.update( {'not null': True}) elif atrColumna.tipo == AtributosColumna.NULO: nuevaColumna.atributos.update({'null': True}) elif atrColumna.tipo == AtributosColumna.PRIMARY: hayPrimaria = True nuevaColumna.atributos.update({ 'primary': str("PK_" + dbActual + "_" + self.id) }) # PK_database_tabla elif atrColumna.tipo == AtributosColumna.REFERENCES: rr = DBMS.extractTable(dbActual, atrColumna.valor) if rr == None: return str( "La tabla \'" + atrColumna.valor + "\' a la que está referenciando, no existe" ) else: tablaReferencia: Simbolo = ent.buscarSimbolo( atrColumna.valor + "_" + dbActual) colRef = tablaReferencia.valor for col in colRef: nomConstraintPK = col.atributos.get( 'primary') if nomConstraintPK != None: consPK: Simbolo = ent.buscarSimbolo( nomConstraintPK) arrPk = consPK.valor if len(arrPk) == 1: if tablaReferencia.valor[arrPk[ 0]].tipo.tipo == nuevaColumna.tipo.tipo: hayForanea = True hayAtr = True nuevoSym.tipo = TipoSimbolo.CONSTRAINT_FOREIGN # FK_database_tabla_tablaReferencia nuevoSym.nombre = str( "FK_" + dbActual + "_" + self.id + "_" + atrColumna.valor) nuevaColumna.atributos.update( { 'foreign': str("FK_" + dbActual + "_" + self.id + "_" + atrColumna. valor) }) break if not hayForanea: variables.consola.insert( INSERT, "No se puede establecer llave foranea entre tabla '" + self.id + "' y '" + atrColumna.valor + "'\n") reporteerrores.append( Lerrores( "Error Semántico", "No se puede establecer llave foranea entre tabla '" + self.id + "' y '" + atrColumna.valor + "'", "", "")) if hayAtr: listaAtrCol.append(nuevoSym) listaColumnas.append(nuevaColumna) if tt.tipo == AtributosColumna.PRIMARY: if hayPrimaria: variables.consola.insert( INSERT, str("La tabla \'" + self.id + "\' ya contiene llave primaria declarada\n")) reporteerrores.append( Lerrores( "Error Semántico", "La tabla \'" + self.id + "\' ya contiene llave primaria declarada", "", "")) else: primariaAdd: Primaria = tt if tt.tipo == AtributosColumna.REFERENCES: if hayForanea: variables.consola.insert( INSERT, str("La tabla \'" + self.id + "\' ya contiene llave foranea declarada\n")) reporteerrores.append( Lerrores( "Error Semántico", "La tabla \'" + self.id + "\' ya contiene llave foranea declarada", "", "")) else: foraneaAdd: Foranea == tt rr = DBMS.extractTable(dbActual, foraneaAdd.tabla) if tt.tipo == AtributosColumna.CONSTRAINT: if tt.contenido.tipo == AtributosColumna.PRIMARY: if hayPrimaria: variables.consola.insert( INSERT, str("La tabla \'" + self.id + "\' ya contiene llave primaria declarada\n" )) reporteerrores.append( Lerrores( "Error Semántico", "La tabla \'" + self.id + "\' ya contiene llave primaria declarada", "", "")) else: primariaAdd: Primaria = tt.contenido primariaAdd.idConstraint = tt.id elif tt.contenido.tipo == AtributosColumna.REFERENCES: if hayForanea: variables.consola.insert( INSERT, str("La tabla \'" + self.id + "\' ya contiene llave foranea declarada\n") ) reporteerrores.append( Lerrores( "Error Semántico", "La tabla \'" + self.id + "\' ya contiene llave foranea declarada", "", "")) else: foraneaAdd: Foranea == tt rr = DBMS.extractTable(dbActual, foraneaAdd.tabla) elif tt.contenido.tipo == AtributosColumna.UNICO: listUnicas = tt.contenido.unicos for x in listUnicas: for col in listaColumnas: if col.nombre == x.valor: #formato: U_database_tabla_nombreColumna_idConstraint col.atributos.update({ 'unique': str("U_" + dbActual + "_" + self.id + "_" + col.nombre + "_" + tt.id) }) sym = Simbolo( TipoSimbolo.CONSTRAINT_UNIQUE, str("U_" + dbActual + "_" + self.id + "_" + col.nombre + "_" + tt.id)) ent.nuevoSimbolo(sym) elif tt.contenido.tipo == AtributosColumna.CHECK: #formato: C_database_tabla_nombreColumna_idConstraint nombreColCheck = str( tt.contenido.condiciones.exp1.valor) for x in listaColumnas: if x.nombre == nombreColCheck: x.atributos.update({ 'check': str("C_" + dbActual + "_" + self.id + "_" + x.nombre + "_" + tt.id) }) sym = Simbolo( TipoSimbolo.CONSTRAINT_CHECK, str("C_" + dbActual + "_" + self.id + "_" + x.nombre + "_" + tt.id)) sym.tabla = self.id sym.baseDatos = dbActual sym.valor = tt.contenido.condiciones listaAtrCol.append(sym) break nuevaTabla.valor = listaColumnas estado = DBMS.createTable(dbActual, self.id, len(listaColumnas)) if estado == 0: nuevaTabla.baseDatos = dbActual r = ent.nuevoSimbolo(nuevaTabla) if r == "ok": for x in listaAtrCol: ent.nuevoSimbolo(x) alreadyPrimary = False for x in range(inicioHerencia, len(listaColumnas), 1): if not alreadyPrimary: pk = listaColumnas[x].atributos.get('primary') if pk != None: self.listPK.append(x) rrr = DBMS.alterAddPK(dbActual, self.id, self.listPK) if rrr != 0: variables.consola.insert( INSERT, "No se ha podido agregar PK en tabla \'" + self.id + "\'\n") reporteerrores.append( Lerrores( "Error Semántico", "No se ha podido agregar PK en tabla \'" + self.id + "'", "", "")) else: alreadyPrimary = True sym1 = Simbolo( TipoSimbolo.CONSTRAINT_PRIMARY, str("PK_" + dbActual + "_" + self.id)) sym1.valor = self.listPK sym1.tabla = self.id sym1.baseDatos = dbActual ent.nuevoSimbolo(sym1) if not alreadyPrimary: tablaB: Simbolo = ent.buscarSimbolo(nuevaTabla.nombre) if tablaB != None: if primariaAdd != None: listaPrim = primariaAdd.primarias for p in listaPrim: for col in range(len(tablaB.valor)): if p.valor == tablaB.valor[col].nombre: self.listPK.append(col) #print(p.valor) #print(col.nombre) if len(self.listPK) > 0: n = DBMS.alterAddPK( dbActual, self.id, self.listPK) if n != 0: variables.consola.insert( INSERT, "No se ha podido agregar PK en tabla \'" + self.id + "\'\n") reporteerrores.append( Lerrores( "Error Semántico", "No se ha podido agregar PK en tabla \'" + self.id + "'", "", "")) else: idPk = "" alreadyPrimary = True sym: Simbolo = None if primariaAdd.idConstraint != "": idPk = str( "PK_" + dbActual + "_" + self.id + "_" + primariaAdd.idConstraint) sym = Simbolo( TipoSimbolo.CONSTRAINT_PRIMARY, idPk) else: idPk = str("PK_" + dbActual + "_" + self.id) sym = Simbolo( TipoSimbolo.CONSTRAINT_PRIMARY, idPk) for y in self.listPK: tablaB.valor[y].atributos.update( {'primary': idPk}) sym.valor = self.listPK sym.tabla = self.id sym.baseDatos = dbActual ent.nuevoSimbolo(sym) DBMS.showCollection() variables.consola.insert( INSERT, str("Tabla " + self.id + " creada exitosamente\n")) return return r
def ejecutar(self, ent: Entorno): dbActual = ent.getDataBase() if dbActual != None: tablaAlterada: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual) if tablaAlterada != None: for opcionX in self.opciones: if opcionX.tipoAlter == TipoAlter.ADDCOLUMNA: addColumna: AddColumn = opcionX res = DBMS.alterAddColumn(dbActual, self.tabla, None) if res == 0: nuevaCol: Simbolo = Simbolo( addColumna.tipo, addColumna.id) nuevaCol.tabla = self.tabla nuevaCol.baseDatos = dbActual tablaAlterada.valor.append(nuevaCol) e = ent.editarSimbolo(self.tabla + "_" + dbActual, tablaAlterada) if e == "ok": variables.consola.insert( INSERT, "Se agregó nueva columna '" + str(addColumna.id) + "' a la tabla '" + str(self.tabla) + "'\n") else: reporteerrores.append( Lerrores( "Error Semantico", "No se ha podido agregar la columna '" + addColumna.id + "' a la tabla " + self.tabla, 0, 0)) variables.consola.insert( INSERT, "No se ha podido agregar la columna '" + addColumna.id + "' a la tabla ") elif opcionX.tipoAlter == TipoAlter.ADDCHECK: #formato: C_database_tabla_nombreColumna addCheck: AddCheck = opcionX nombreColCheck: str = str( addCheck.condicion.exp1.valor) for col in tablaAlterada.valor: if col.nombre == nombreColCheck: idCheck: str = str("C_" + dbActual + "_" + self.tabla + "_" + col.nombre) if addCheck.constraint != None: idCheck += "_" + str(addCheck.constraint) col.atributos.update({'check': idCheck}) nuevoSym: Simbolo = Simbolo( TipoSimbolo.CONSTRAINT_CHECK, idCheck, addCheck.condicion) nuevoSym.baseDatos = dbActual nuevoSym.tabla = self.tabla ent.nuevoSimbolo(nuevoSym) variables.consola.insert( INSERT, "Condición check agegada en columna '" + str(col.nombre) + "' en la tabla '" + str(self.tabla) + "'\n") break elif opcionX.tipoAlter == TipoAlter.ADDUNIQUE: addUnique: AddUnique = opcionX for add in addUnique.columnas: for col in tablaAlterada.valor: if col.nombre == add.valor: idUnique: str = str("U_" + dbActual + "_" + self.tabla + "_" + col.nombre) if addUnique.constraint != None: idUnique += "_" + str( addUnique.constraint) col.atributos.update({'unique': idUnique}) nuevoSym: Simbolo = Simbolo( TipoSimbolo.CONSTRAINT_UNIQUE, idUnique, col.nombre) nuevoSym.baseDatos = dbActual nuevoSym.tabla = self.tabla ent.nuevoSimbolo(nuevoSym) variables.consola.insert( INSERT, "Condición Unique agregada en columna '" + str(col.nombre) + "' en la tabla '" + str(self.tabla) + "'\n") elif opcionX.tipoAlter == TipoAlter.ADDFOREIGN: addForeign: AddForeign = opcionX tablaReferenciada: Simbolo = ent.buscarSimbolo( addForeign.referenceTable + "_" + dbActual) if tablaReferenciada != None: if len(addForeign.colAddForeign) == len( addForeign.colReferences): idFk: str = str("FK_" + dbActual + "_" + self.tabla + "_" + addForeign.referenceTable) if addForeign.constraint != None: idFk += "_" + addForeign.constraint n: Simbolo = Simbolo( TipoSimbolo.CONSTRAINT_FOREIGN, idFk) n.baseDatos = dbActual n.tabla = self.tabla ent.nuevoSimbolo(n) variables.consola.insert( INSERT, "Llave Foránea referenciando a tabla '" + str(addForeign.referenceTable) + "' en la tabla '" + str(self.tabla) + "'\n") else: variables.consola.insert( INSERT, "La cantidad de columnas no coinciden en llave foránea de la tabla '" + str(self.tabla) + "'\n") reporteerrores.append( Lerrores( "Error Semántico", "La cantidad de columnas no coinciden en llave foránea de tabla '" + self.tabla + "'", "", "")) elif opcionX.tipoAlter == TipoAlter.ADDNULL: addNulo: AddNull = opcionX for col in tablaAlterada.valor: if col.nombre == addNulo.columna: if addNulo.nulo: #setea a nulos col.atributos.update({'null': True}) else: col.atributos.update({'not null': True}) break elif opcionX.tipoAlter == TipoAlter.DROPCONSTRAINT: #formato : CONSTRAINT_database_tabla_nombreCol_idConstraint dropConstr: DropConstraint = opcionX opcConstraint = ["C", "U", "F", "P"] constr = ['check', 'unique', 'foreign', 'primary'] encontrado = False concat: str = "_" + dbActual + "_" + self.tabla + "_" for col in tablaAlterada.valor: for x in range(len(opcConstraint)): idCo: str = opcConstraint[ x] + concat + col.nombre + "_" + dropConstr.constraint r: Simbolo = ent.buscarSimbolo(idCo) if r != None: encontrado = True ent.eliminarSimbolo(idCo) del col.atributos[constr[x]] variables.consola.insert( INSERT, "El constraint '" + str(dropConstr.constraint) + "' ha sido eliminado\n") break if not encontrado: variables.consola.insert( INSERT, "El constraint '" + str(dropConstr.constraint) + "' no existe'\n") reporteerrores.append( Lerrores( "Error Semántico", "El constraint '" + str(dropConstr.constraint) + "' no existe", "", "")) elif opcionX.tipoAlter == TipoAlter.ALTERTYPE: alterTipo: AlterType = opcionX for col in tablaAlterada.valor: if col.nombre == alterTipo.columna: col.tipo = alterTipo.nuevoTipo variables.consola.insert( INSERT, "El tipo de la columna '" + str(col.nombre) + "' de la tabla '" + self.tabla + "' cambió a '" + col.tipo.tipo + "'\n") return elif opcionX.tipoAlter == TipoAlter.RENAMECOLUMN: rCol: RenameColumn = opcionX for col in tablaAlterada.valor: if col.nombre == rCol.oldColumn: col.nombre = rCol.newColumn variables.consola.insert( INSERT, "El nombre de la columna '" + str(rCol.oldColumn) + "' de la tabla '" + self.tabla + "' cambió a '" + str(rCol.newColumn) + "'\n") return elif opcionX.tipoAlter == TipoAlter.DROPCHECK: dChe: DropCheck = opcionX for col in tablaAlterada.valor: idd = "C_" + dbActual + "_" + self.tabla + "_" + str( col.nombre) + "_" + dChe.iden r: Simbolo = ent.buscarSimbolo(idd) if r != None: ent.eliminarSimbolo(idd) variables.consola.insert( INSERT, "Se ha eliminado la condición check '" + str(dChe.iden) + "'\n") break elif opcionX.tipoAlter == TipoAlter.DROPCOLUMN: index = [] dropC: DropColumns = opcionX for drop in dropC.columnas: for x in range(len(tablaAlterada.valor)): if tablaAlterada.valor[x].nombre == drop.valor: r = DBMS.alterDropColumn( dbActual, self.tabla, x) if r == 0: for z in tablaAlterada.valor[ x].atributos.values(): ent.eliminarSimbolo(z) variables.consola.insert( INSERT, "Se ha eliminado la columna '" + str(drop.valor) + "' de la tabla '" + str(self.tabla) + "'\n") index.append(x) for g in index: tablaAlterada.valor.pop(g) ent.editarSimbolo(self.tabla + "_" + dbActual, tablaAlterada)
def ejecutar(self, ent:Entorno): dbActual = ent.getDataBase() tam = len(self.listaDef) print (tam) nuevaTabla = Simbolo(TipoSimbolo.TABLA,self.id) listaColumnas = [] for x in range(0,tam,1): tt = self.listaDef[x] if tt.tipo == AtributosColumna.COLUMNA_SIMPLE: self.numColumnas += 1 nuevaColumna = Simbolo(tt.tipoDato,tt.identificador) if tt.lista != None: #aca se mete si viene por ejemplo: columna1 integer references tabla2 tamano = len(tt.lista) for y in range(tamano): atrColumna = tt.lista[y] if atrColumna.tipo == AtributosColumna.UNICO: nuevoUnico = Simbolo(TipoSimbolo.CONSTRAINT_UNIQUE,atrColumna.valor) nuevoUnico.baseDatos = dbActual nuevoUnico.tabla = self.id ent.nuevoSimbolo(nuevoUnico) nuevaColumna.atributos.update({'unique':atrColumna.valor}) elif atrColumna.tipo == AtributosColumna.CHECK: nuevoCheck = Simbolo(TipoSimbolo.CONSTRAINT_CHECK,atrColumna.valor) nuevoCheck.baseDatos = dbActual nuevoCheck.tabla = self.id ent.nuevoSimbolo(nuevoCheck) nuevaColumna.atributos.update({'check':atrColumna.valor}) elif atrColumna.tipo == AtributosColumna.DEFAULT: nuevaColumna.atributos.update({'default':atrColumna.valor}) elif atrColumna.tipo == AtributosColumna.NO_NULO: nuevaColumna.atributos.update({'not null':True}) elif atrColumna.tipo == AtributosColumna.NULO: nuevaColumna.atributos.update({'null':True}) elif atrColumna.tipo == AtributosColumna.PRIMARY: nuevaPrimaria = Simbolo(TipoSimbolo.CONSTRAINT_PRIMARY,str("PK_" + self.id)) nuevaPrimaria.baseDatos = dbActual nuevaPrimaria.tabla = self.id ent.nuevoSimbolo(nuevaPrimaria) nuevaColumna.atributos.update({'primary':str("PK_" + self.id)}) elif atrColumna.tipo == AtributosColumna.REFERENCES: rr = DBMS.extractTable(dbActual,atrColumna.valor) if rr == []: return str("La tabla \'" + atrColumna.valor + "\' a la que está referenciando, no existe") else: nuevaForanea = Simbolo(TipoSimbolo.CONSTRAINT_FOREIGN,str("FK_" + self.id)) nuevaForanea.baseDatos = dbActual nuevaForanea.tabla = self.id ent.nuevoSimbolo(nuevaForanea) nuevaColumna.atributos.update({'foreign':str("FK_" + self.id)}) listaColumnas.append(nuevaColumna) #considerar la situacion de cuando no se haya creado la tabla pero ya se hayan #agregado los constraint a la tabla de simbolos nuevaTabla.valor = listaColumnas if dbActual != None: estado = DBMS.createTable(dbActual,self.id, self.numColumnas) if estado == 0: nuevaTabla.baseDatos = dbActual ent.nuevoSimbolo(nuevaTabla) DBMS.showCollection() return str("Tabla " + nuevaTabla.nombre + " creada exitosamente")