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()
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")