def ejecutar(self, ent: Entorno):
'ejecutar declaracion'
simbolo = Simbolo(self.tipo, self.id, self.valor.getval(ent).valor, -1)
simbolo.atributos = {
'constant': self.constant,
'nullable': self.nullable
}
s = ent.nuevoSimbolo(simbolo)
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):
'ejecucion de la definicion de la funcion'
simbolo = Simbolo(self.tipo, '_f' + self.nombre,
[self.params, self.instrucciones], -1)
s = ent.nuevoSimbolo(simbolo)
if s != 'ok':
variables.consola.insert(
INSERT, 'La funcion ' + self.nombre +
' no se pudo crear porque ya existe\n')
def ejecutar(self, ent):
'ejecucion de la definicion del procedimiento'
simbolo = Simbolo(Tipo('Procedure', None, -1, -1), '_P' + self.nombre,
[self.params, self.instrucciones], -1)
s = ent.nuevoSimbolo(simbolo)
if s != 'ok':
variables.consola.insert(
INSERT, 'La funcion ' + self.nombre +
' no se pudo crear porque ya existe\n')
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):
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
DBMS.dropAll()
DBMS.createDatabase("prueba")
DBMS.createTable("prueba",self.id,self.numColumnas)
print("---------------------------------------------")
DBMS.showCollection()
print("---------------------------------------------")
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")
def ejecutar(self, ent):
'ejecucion de la definicion de la funcion'
simbolo = Simbolo(self.tipo, '_f'+self.nombre, [self.params,self.instrucciones], -1)
s = ent.nuevoSimbolo(simbolo)
