def ejecutar(use, ts, consola, exceptions):
if ts.validar_sim("usedatabase1234") == -1:
lb = showDatabases()
for bd in lb:
if bd == str(use.id):
simbolo_use = TS.Simbolo(TS.TIPO_DATO.USE,
"usedatabase1234", None, use.id,
None)
ts.agregar_sim(simbolo_use)
consola.append(
f"Seleccionando {simbolo_use.valor} base de datos\n")
return
consola.append(f"La Base de Datos {use.id} no existe\n")
else:
lb = showDatabases()
for bd in lb:
if bd == use.id:
use_anterior = ts.buscar_sim("usedatabase1234")
simbolo_use = TS.Simbolo(TS.TIPO_DATO.USE,
"usedatabase1234", None, use.id,
None)
ts.actualizar_sim(simbolo_use)
consola.append(
f"Cambiando use de {use_anterior.valor} ahora el actual es: {simbolo_use.valor}\n"
)
return
consola.append(f"La Base de Datos {use.id} no existe\n")
def ejecutar(Index, ts, consola, exceptions):
bdactual = ts.buscar_sim("usedatabase1234")
BD = ts.buscar_sim(bdactual.valor)
entornoBD = BD.Entorno
#print(Index.caso)
listaId = []
try:
if entornoBD.validar_sim(Index.tabla) == 1:
if entornoBD.validar_sim(Index.id) == 1:
consola.append(
f"No se puede crear el Index {Index.id} , ya existe en la base de datos \n"
)
else:
if Index.caso == 1:
for idcito in Index.columnref:
#print(idcito.id)
listaId.append(idcito.id)
#print(str(listaId))
sim = TS.Simbolo(TS.TIPO_DATO.INDEX_SIMPLE, Index.id,
None,
str(listaId)[1:-1], None)
entornoBD.agregar_sim(sim)
elif Index.caso == 2:
for idcito in Index.columnref:
#print(idcito.id)
listaId.append(idcito.id)
#print(str(listaId))
sim = TS.Simbolo(TS.TIPO_DATO.INDEX_HASH, Index.id,
None,
str(listaId)[1:-1], None)
entornoBD.agregar_sim(sim)
elif Index.caso == 3:
for idcito in Index.columnref:
#print(idcito.id)
listaId.append(idcito.id)
#print(str(listaId))
sim = TS.Simbolo(TS.TIPO_DATO.INDEX_UNIQUE, Index.id,
None,
str(listaId)[1:-1], None)
entornoBD.agregar_sim(sim)
elif Index.caso == 4:
sim = TS.Simbolo(TS.TIPO_DATO.INDEX_ORDER, Index.id,
Index.order, Index.columnref, None)
entornoBD.agregar_sim(sim)
else:
sim = TS.Simbolo(TS.TIPO_DATO.INDEX_LOWER, Index.id,
None, Index.columnref, None)
entornoBD.agregar_sim(sim)
consola.append(
f"Index {Index.id} se ha creado exitosamente\n")
else:
consola.append(f" 42P01 : undefined_table {Index.tabla}\n")
return
except:
consola.append("XX000 : internal_error")
def ejecutarDeclaracion(declaracion,simboloFuncion,ts,consola,exception):
entornoFN = simboloFuncion.Entorno
nuevosimbolo = None
if declaracion.asignacion == None:
nuevosimbolo = TS.Simbolo(TS.TIPO_DATO.DECLARE, declaracion.id, declaracion.tipo, None, None)
else:
expre = Expresion.Resolver(declaracion.asignacion,ts,consola,exception)
nuevosimbolo = TS.Simbolo(TS.TIPO_DATO.DECLARE, declaracion.id, declaracion.tipo, expre, None)
entornoFN.agregar_sim(nuevosimbolo)
def ejecutar(CreateFunction, ts, consola, exceptions):
try:
bdactual = ts.buscar_sim("usedatabase1234")
BD = ts.buscar_sim(bdactual.valor)
entornoBD = BD.Entorno
paramcorrectos = True
if entornoBD.validar_sim(CreateFunction.id) == -1:
dicci = {}
if CreateFunction.parametros is not None:
for parametro in CreateFunction.parametros:
existe = dicci.get(parametro.id, False)
if existe == False:
dicci[parametro.id] = parametro.tipo.tipo
else:
consola.append(
f"Existe parametros con el mismo nombre en la función: {CreateFunction.id}\n No se pudo crear la función."
)
paramcorrectos = False
break
if paramcorrectos:
entornoFuncion = TS.TablaDeSimbolos({})
if CreateFunction.declare != None:
simdeclare = TS.Simbolo(TS.TIPO_DATO.DECLARE,
"DECLARE", None,
CreateFunction.declare, None)
entornoFuncion.agregar_sim(simdeclare)
#Esto siempre se realiza
simbegin = TS.Simbolo(TS.TIPO_DATO.BEGIN, "BEGIN", None,
CreateFunction.begin, None)
entornoFuncion.agregar_sim(simbegin)
#Agregamos las variables de parametros al entorno de la función de una vez
for clave, valor in dicci.items(): #id,tipo
nuevaVariable = TS.Simbolo(TS.TIPO_DATO.PARAMETRO,
clave, valor, None, None)
entornoFuncion.agregar_sim(nuevaVariable)
#Creamos la nuevafuncion en el entorno global de la base de datos
nuevaFuncion = TS.Simbolo(TS.TIPO_DATO.FUNCTION,
CreateFunction.id,
CreateFunction.returns, None,
entornoFuncion)
entornoBD.agregar_sim(nuevaFuncion)
consola.append(
f"Se añadio una nueva funcion llamada: {CreateFunction.id}"
)
else:
consola.append(f"Ya existe esta función en la base de datos")
except:
consola.append("XX000 : internal_error")
def ejecutar(createDataBase, ts,consola,exceptions):
if createDataBase.complemento is not None:
if createDataBase.complemento.mode is not None:
if createDataBase.complemento.mode > 5 or createDataBase.complemento.mode < 1:
consola.append(f"El modo para la base de datos {createDataBase.id} debe estar entre 1 y 5\n")
return
lb = showDatabases()
if createDataBase.id in lb:
if createDataBase.exists:
print("no pasa nada")
return
elif createDataBase.caso == 2:
# se borra a nivel de memoria en disco
dropDatabase(str(createDataBase.id))
# se quita el id de la tabla de simbolos
ts.eliminar_sim(str(createDataBase.id))
else:
consola.append(f"La Base de Datos {createDataBase.id} ya existe, error al crear\n")
return
createDatabase(str(createDataBase.id))
entorno_bd = {}
ts_local = TS.TablaDeSimbolos(entorno_bd)
# simbolo (self, categoria,id, tipo, valor,Entorno):
simbolo = TS.Simbolo(TS.TIPO_DATO.BASEDEDATOS, createDataBase.id, None, 0, ts_local) # inicializamos con 0 como valor por defecto
ts.agregar_sim(simbolo)
if (createDataBase.id in lb) and createDataBase.caso == 2:
consola.append(f"Replace, la base de datos {createDataBase.id} se ha creado exitosamente\n")
else:
consola.append(f"Se creo la base de datos {createDataBase.id} exitosamente\n")
print(ts.simbolos)
def ejecutar(alterdatabase, ts, consola, exceptions):
#por el momemnto solo renombrar
print("Estoy aqui")
if ts.validar_sim(alterdatabase.name) == 1 and alterdatabase.caso == 1:
anterior = ts.buscar_sim(alterdatabase.name)
nuevo = TS.Simbolo(anterior.categoria, alterdatabase.newName,
anterior.tipo, anterior.valor, anterior.Entorno)
ts.agregar_sim(nuevo)
ts.eliminar_sim(alterdatabase.name)
alterDatabase(alterdatabase.name, alterdatabase.newName)
consola.append(
f"BD {alterdatabase.name} renombrada a {alterdatabase.newName}"
)
else:
consola.append(
f"42P01 undefined_table, Error alter no existe la tabla {alterdatabase.name}"
)
exceptions.append(
f"Error semantico-42P01- 42P01 undefined_table, no existe la tabla {alterdatabase.name}-fila-columna"
)
#caso 1
print("")
def ejecutar(createType,ts,consola,exceptions):
if ts.validar_sim(createType.id) == -1:
datavalidada = []
for data in createType.lista:
resultado = Expresion.Resolver(data,ts,consola,exceptions)
datavalidada.append(resultado)
nuevo_tipo = TS.Simbolo(TS.TIPO_DATO.CLASEENUMERADA, createType.id, "Enum", datavalidada, None)
ts.agregar_sim(nuevo_tipo)
consola.append(f"Se añadio una clase enum llamada {createType.id}")
else:
consola.append(f"Ya existe esta clase enumerada")
def ejecutar(AlterIndex, ts, consola, exceptions):
try:
if AlterIndex.caso == 1:
bdactual = ts.buscar_sim("usedatabase1234")
# se busca el simbolo y por lo tanto se pide el entorno de la bd
BD = ts.buscar_sim(bdactual.valor)
entornoBD = BD.Entorno
if entornoBD.validar_sim(AlterIndex.id) == 1:
simbolo = entornoBD.buscar_sim(AlterIndex.id)
#print(simbolo.valor)
cadena = str(simbolo.valor)
cadena1 = cadena.replace(str(AlterIndex.noCol),
str(AlterIndex.columnas))
nuevo = TS.Simbolo(simbolo.categoria, simbolo.id,
simbolo.tipo, cadena1, simbolo.Entorno)
entornoBD.eliminar_sim(AlterIndex.id)
entornoBD.agregar_sim(nuevo)
consola.append(
f"Index {AlterIndex.id}, actualizado exitosamente")
else:
consola.append(
f"42P01 undefined_index, no existe el index {AlterIndex.id}"
)
exceptions.append(
f"Error semantico-42P01- 42P01 undefined_Index, no existe el index {AlterIndex.id}-fila-columna"
)
else:
pass
# agregar alter si viene el no de columna
except:
consola.append("XX000 : internal_error")
def ejecutar(alterTable, ts, consola, exceptions):
if ts.validar_sim("usedatabase1234") == 1:
# nombre de la bd
bdactual = ts.buscar_sim("usedatabase1234")
# se busca el simbolo y por lo tanto se pide el entorno de la bd
BD = ts.buscar_sim(bdactual.valor)
entornoBD = BD.Entorno
if entornoBD.validar_sim(alterTable.id) == 1:
simbolo_tabla = entornoBD.buscar_sim(alterTable.id)
entornoTabla = simbolo_tabla.Entorno
banderaTodoBien = True
for altirto in alterTable.alter:
if altirto.caso == 1:
#print("caso 1")
#alter table add column ( listaids)
for idcito in altirto.id:
if entornoTabla.validar_sim(idcito.id) == -1:
#print(idcito.id, "<-----------------------------------")
valores = []
columna_nueva = TS.Simbolo(
TS.TIPO_DATO.CAMPO, idcito.id,
altirto.tipo.tipo, valores, None)
simbolo_tabla.valor = simbolo_tabla.valor + 1
entornoTabla.agregar_sim(columna_nueva)
alterAddColumn(BD.id, simbolo_tabla.id, 1)
consola.append(
f"Alter ejecutado correctamente en tabla , {alterTable.id}, add column {idcito.id}"
)
else:
consola.append(
f"42701 Duplicate column, No se puede agregar la columna {idcito}"
)
exceptions.append(
f"Error semantico-42701 - Duplicate column, No se puede agregar la columna {idcito} -fila-columna"
)
elif altirto.caso == 2:
#print("caso 2")
#alter table drop column ( listaids)
for idcito in altirto.id:
if entornoTabla.validar_sim(idcito.id) == 1:
#print(idcito.id, "<-----------------------------------")
valores = []
#columna_nueva = TS.Simbolo(TS.TIPO_DATO.CAMPO,idcito.id,altirto.tipo.tipo,valores,None)
entornoTabla.eliminar_sim(idcito.id)
simbolo_tabla.valor = simbolo_tabla.valor - 1
alterDropColumn(BD.id, simbolo_tabla.id,
len(entornoTabla.simbolos) - 1)
consola.append(
f"Alter ejecutado correctamente en tabla , {alterTable.id}, drop column {idcito.id}"
)
else:
consola.append(
f"42703 Undefined column, No se puede eliminar la columna {idcito.id}"
)
exceptions.append(
f"Error semantico-42701 - Duplicate column, No se puede agregar la columna {idcito.id} - fila - columna"
)
elif altirto.caso == 3:
#print("caso 3")
#print(altirto.check)
datos = altirto.check
campo = datos.iz
#print(campo.id)
data2 = datos.dr
#print(data2)
##print(data2.valor)
operador = datos.operador
#print(operador)
if entornoTabla.validar_sim(campo.id) == 1:
#
if isinstance(data2, Id):
if entornoTabla.validar_sim(data2.id) == 1:
simbolo = entornoTabla.buscar_sim(campo.id)
simbolo.valor.append(
f"CHECK:{campo.id}:{operador}:{data2.id}"
)
simbolo.Entorno = altirto.check
nueva_Data = TS.Simbolo(
simbolo.categoria, simbolo.id,
simbolo.tipo, simbolo.valor,
simbolo.Entorno)
entornoTabla.actualizar_sim(nueva_Data)
# en los checks va el entorno de expresion
consola.append(
f"Add check hacia la tabla {alterTable.id}, en la columna {campo.id}\n"
)
else:
consola.append(
f"42703 Undefined column, No se puede agregar check a la columna {campo.id}"
)
exceptions.append(
f"Error semantico-42703 - Undefined, No se puede agregar la columna {campo.id} - fila - columna"
)
else:
simbolo = entornoTabla.buscar_sim(campo.id)
simbolo.valor.append(
f"CHECK:{campo.id}:{operador}:{data2.valor}"
)
simbolo.Entorno = altirto.check
nueva_Data = TS.Simbolo(
simbolo.categoria, simbolo.id,
simbolo.tipo, simbolo.valor,
simbolo.Entorno)
entornoTabla.actualizar_sim(nueva_Data)
#en los checks va el entorno de expresion
consola.append(
f"Add check hacia la tabla {alterTable.id}, en la columna {campo.id}\n"
)
else:
consola.append(
f"42703 Undefined column, No se puede agregar check a la columna {campo.id}"
)
exceptions.append(
f"Error semantico-42703 - Undefined, No se puede agregar la columna {campo.id} - fila - columna"
)
elif altirto.caso == 4:
#print("caso 4")
data_borrar = altirto.id
lista = entornoTabla.simbolos
for columna in lista:
#print(columna)
indice = 0
banderaBorrar = False
for valor in lista.get(columna).valor:
#print(" ->",valor)
if "CONSTRAINT" in valor:
nombre = str(valor).split(":")[1]
#print("-- ",nombre, data_borrar)
if nombre == data_borrar:
banderaBorrar = True
break
indice = indice + 1
if banderaBorrar:
break
#print(banderaBorrar, indice)
if banderaBorrar:
lista.get(columna).valor.pop(indice)
consola.append(
f"Drop constraint eliminada de la tabla {alterTable.id}"
)
else:
consola.append(
f"23000 integrity_constraint_violation, no se encontro el constraint{data_borrar} de la tabla {alterTable.id}"
)
exceptions.append(
f"Error semantico- 23000-integrity_constraint_violation- fila - columna "
)
elif altirto.caso == 5:
#print("caso 5")
# constraint
#print("")
banderaTodoBien = True
if entornoBD.validar_sim(altirto.id2) == 1:
# referencia la tabla a cual se desea hacer la llave foranea
obtener_simbolo = entornoBD.buscar_sim(altirto.id2)
entornoTablarefrencia = obtener_simbolo.Entorno
for campito in altirto.id3:
if entornoTablarefrencia.validar_sim(
campito.id) == 1:
pass #print("todo bien")
else:
banderaTodoBien = False
break
if banderaTodoBien:
for idcito in altirto.id:
#print(idcito.id)
if entornoTabla.validar_sim(idcito.id) == 1:
obtenerCampo = entornoTabla.buscar_sim(
idcito.id)
#print("ejecutando campos------------------------------------------!!!!!!1")
tablita = []
for dataReferencia in altirto.id3:
tablita.append(dataReferencia.id)
obtenerCampo.valor.append(
f"FOREIGNKEY:{altirto.id2}:{tablita}")
# para llegar antes debe validarse que existe la tabla y los campos a los cuales
# se referencia
consola.append(
f"Add foreing key exitoso en la tabla {alterTable.id}\n"
)
else:
consola.append(
f"42P10 invalid_column_reference, Campo {idcito.id} no encontrado"
)
exceptions.append(
"Error Semantico - 42P10- invalid_column_reference-fila-columna"
)
valor = False
#print("")
else:
consola.append(
f"22005 error_in_assignment,No se creo el constraint {alterTable.id} campos incosistente \n"
)
exceptions.append(
"Error semantico-22005 error_in_assignment-Columnas check-fila-columna"
)
elif altirto.caso == 6:
#print("caso 6")
if entornoTabla.validar_sim(altirto.id) == 1:
data = entornoTabla.buscar_sim(altirto.id)
nueva_Data = TS.Simbolo(data.categoria, altirto.id,
altirto.tipo.tipo,
data.valor, data.Entorno)
entornoTabla.actualizar_sim(nueva_Data)
#print(altirto.tipo.tipo)
consola.append(
f"Alter column realizado con exito en {altirto.id}\n"
)
else:
consola.append(
f"No existe el campo {altirto.id}, Error alter columna"
)
exceptions.append(
f"Error semantico-22005 error_in_assignment-No se ha encontrado la columna {altirto.id}-fila-columna"
)
elif altirto.caso == 7:
#print("caso 6")
if entornoTabla.validar_sim(altirto.id) == 1:
data = entornoTabla.buscar_sim(altirto.id)
data.valor.append("NOTNULL")
nueva_Data = TS.Simbolo(data.categoria, altirto.id,
data.tipo, data.valor,
data.Entorno)
entornoTabla.actualizar_sim(nueva_Data)
consola.append(
f"Alter column realizado con exito en {altirto.id}\n"
)
else:
consola.append(
f"No existe el campo {altirto.id}, Error alter columna"
)
exceptions.append(
f"Error semantico-22005 error_in_assignment-No se ha encontrado la columna {altirto.id}-fila-columna"
)
elif altirto.caso == 8:
#print("caso 8")
# constraint
#print("")
banderaTodoBien = True
valor = True
if banderaTodoBien:
pks = []
for idcito in altirto.id:
#print(idcito.id)
if entornoTabla.validar_sim(idcito.id) == 1:
obtenerCampo = entornoTabla.buscar_sim(
idcito.id)
#print("ejecutando campos------------------------------------------!!!!!!1")
obtenerCampo.valor.append(f"PRIMARYKEY")
# para llegar antes debe validarse que existe la tabla y los campos a los cuales
# se referencia
consola.append(
f"Add Constraint PRIMARY key exitoso en la tabla {alterTable.id}\n"
)
i = 0
for columna in entornoTabla.simbolos:
if entornoTabla.simbolos.get(
columna).id == idcito.id:
pks.append(i)
i = i + 1
else:
consola.append(
f"42P10 invalid_column_reference, Campo {idcito.id} no encontrado"
)
exceptions.append(
"Error Semantico - 42P10- invalid_column_reference-fila-columna"
)
valor = False
if valor:
pass #print(pks)
#print(BD.id, simbolo_tabla.id, pks)
#print(alterAddPK(BD.id, simbolo_tabla.id, pks))
#print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
elif altirto.caso == 9:
#print("caso 9")
# constraint
#print("")
valor = True
if banderaTodoBien:
pks = []
for idcito in altirto.id:
#print(idcito.id)
if entornoTabla.validar_sim(idcito.id) == 1:
obtenerCampo = entornoTabla.buscar_sim(
idcito.id)
#print("ejecutando campos------------------------------------------!!!!!!1")
tablita = []
for dataReferencia in altirto.id:
tablita.append(dataReferencia.id)
if str(altirto.ccc + ":PRIMARYKEY"
) not in obtenerCampo.valor:
obtenerCampo.valor.append(
f"{altirto.ccc}:PRIMARYKEY")
# para llegar antes debe validarse que existe la tabla y los campos a los cuales
# se referencia
consola.append(
f"Add Constraint PRIMARY key exitoso en la tabla {alterTable.id}\n"
)
i = 0
for columna in entornoTabla.simbolos:
if entornoTabla.simbolos.get(
columna).id == idcito.id:
pks.append(i)
i = i + 1
else:
consola.append(
f"42P10 invalid_column_reference, Campo {idcito.id} no encontrado"
)
exceptions.append(
"Error Semantico - 42P10- invalid_column_reference-fila-columna"
)
valor = False
if valor:
pass #print(pks)
#print(BD.id, simbolo_tabla.id, pks)
#print(alterAddPK(BD.id, simbolo_tabla.id, pks))
#print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
elif altirto.caso == 10:
#print("caso 10")
# constraint
#print("")
banderaTodoBien = True
if entornoBD.validar_sim(altirto.id2) == 1:
# referencia la tabla a cual se desea hacer la llave foranea
obtener_simbolo = entornoBD.buscar_sim(altirto.id2)
entornoTablarefrencia = obtener_simbolo.Entorno
for campito in altirto.id3:
if entornoTablarefrencia.validar_sim(
campito.id) == 1:
pass #print("todo bien")
else:
banderaTodoBien = False
break
if banderaTodoBien:
for idcito in altirto.id:
#print(idcito.id)
if entornoTabla.validar_sim(idcito.id) == 1:
obtenerCampo = entornoTabla.buscar_sim(
idcito.id)
#print("ejecutando campos------------------------------------------!!!!!!1")
tablita = []
for dataReferencia in altirto.id3:
tablita.append(dataReferencia.id)
obtenerCampo.valor.append(
f"{altirto.ccc}:FOREIGNKEY:{altirto.id2}:{tablita}"
)
# para llegar antes debe validarse que existe la tabla y los campos a los cuales
# se referencia
consola.append(
f"Add Constraint foreing key exitoso en la tabla {alterTable.id}\n"
)
else:
consola.append(
f"42P10 invalid_column_reference, Campo {idcito.id} no encontrado"
)
exceptions.append(
"Error Semantico - 42P10- invalid_column_reference-fila-columna"
)
valor = False
#print("")
else:
consola.append(
f"22005 error_in_assignment,No se creo el constraint {alterTable.id} campos incosistente \n"
)
exceptions.append(
"Error semantico-22005 error_in_assignment-Columnas check-fila-columna"
)
elif altirto.caso == 11:
#print("caso 8")
# constraint
#print("")
banderaTodoBien = True
if banderaTodoBien:
for idcito in altirto.id:
#print(idcito.id)
if entornoTabla.validar_sim(idcito.id) == 1:
obtenerCampo = entornoTabla.buscar_sim(
idcito.id)
#print("ejecutando campos------------------------------------------!!!!!!1")
tablita = []
for dataReferencia in altirto.id:
tablita.append(dataReferencia.id)
obtenerCampo.valor.append(
f"{altirto.ccc}:UNIQUE")
# para llegar antes debe validarse que existe la tabla y los campos a los cuales
# se referencia
consola.append(
f"Add UNIQUE constraint exitoso en la tabla {alterTable.id}\n"
)
else:
consola.append(
f"42P10 invalid_column_reference, Campo {idcito.id} no encontrado"
)
exceptions.append(
"Error Semantico - 42P10- invalid_column_reference-fila-columna"
)
valor = False
if banderaTodoBien:
pass #print("todo correcto")
else:
pass #print("todo mal")
else:
consola.append(
f"42P01 undefined_table, no existe la tabla {alterTable.id}"
)
exceptions.append(
f"Error semantico-42P01- 42P01 undefined_table, no existe la tabla {alterTable.id}-fila-columna"
)
else:
consola.append(
"22005 error_in_assignment, No se ha seleccionado una BD\n")
exceptions.append(
"Error semantico-22005 error_in_assignment-No se ha seleccionado DB-fila-columna"
)
def ejecutar(self, ts, consola, exceptions):
try:
bdactual = ts.buscar_sim("usedatabase1234")
BD = ts.buscar_sim(bdactual.valor)
entornoBD = BD.Entorno
if self.parametros == None:
if entornoBD.validar_sim(self.id) == -1:
entornoP = TS.TablaDeSimbolos({})
if self.declare != None:
simdeclare = TS.Simbolo(TS.TIPO_DATO.DECLARE,
"DECLARE", None, self.declare,
None)
entornoP.agregar_sim(simdeclare)
print(self.sentencias)
simbegin = TS.Simbolo(TS.TIPO_DATO.BEGIN, "BEGIN", None,
self.sentencias, None)
entornoP.agregar_sim(simbegin)
nuevoP = TS.Simbolo(TS.TIPO_DATO.PROCEDURE, self.id, None,
None, entornoP)
entornoBD.agregar_sim(nuevoP)
consola.append(
f"Se añadio un nuevo procedimiento : {self.id}")
else:
paramcorrectos = True
if entornoBD.validar_sim(self.id) == -1:
dicci = {}
for parametro in self.parametros:
existe = dicci.get(parametro.id, False)
if existe == False:
dicci[parametro.id] = parametro.tipo.tipo
else:
consola.append(
f"Existe parametros con el mismo nombre en la función: {self.id}\n No se pudo crear la función."
)
paramcorrectos = False
break
if paramcorrectos:
entornoP = TS.TablaDeSimbolos({})
if self.declare != None:
simdeclare = TS.Simbolo(TS.TIPO_DATO.DECLARE,
"DECLARE", None,
self.declare, None)
entornoP.agregar_sim(simdeclare)
simbegin = TS.Simbolo(TS.TIPO_DATO.BEGIN, "BEGIN",
None, self.sentencias, None)
entornoP.agregar_sim(simbegin)
for clave, valor in dicci.items(): # id,tipo
nuevaVariable = TS.Simbolo(TS.TIPO_DATO.PARAMETRO,
clave, valor, None,
None)
entornoP.agregar_sim(nuevaVariable)
nuevoP = TS.Simbolo(TS.TIPO_DATO.PROCEDURE, self.id,
None, None, entornoP)
entornoBD.agregar_sim(nuevoP)
consola.append(
f"Se añadio una nuevo procedimiento : {self.id}")
else:
consola.append(f"Ya existe el procedimiento ")
except:
consola.append("XX000 : internal_error")
def ejecutar(CreateTable, ts, consola, exceptions):
if ts.validar_sim("usedatabase1234") == 1:
# nombre de la bd
bdactual = ts.buscar_sim("usedatabase1234")
# se busca el simbolo y por lo tanto se pide el entorno de la bd
BD = ts.buscar_sim(bdactual.valor)
entornoBD = BD.Entorno
if entornoBD.validar_sim(CreateTable.id) == 1:
consola.append("42P07 duplicate_table\n")
consola.append(
f"22005 error_in_assignment,No se creo la tabla {CreateTable.id}\n"
)
return
# creo el entorno de la tabla
print("Creando entorno tabla")
nuevo_entorno_tabla = {}
tsTabla = TS.TablaDeSimbolos(nuevo_entorno_tabla)
# recorrer campos y le mando el entorno de la tabla quien es el que adentro de este
# existaran los campos
banderaTodoBien = True
cantidad_columnas = len(CreateTable.campos)
for campo in CreateTable.campos:
if campo.caso == 2 or campo.caso == 3:
if entornoBD.validar_sim(campo.tablaR) == 1:
#referencia la tabla a cual se desea hacer la llave foranea
obtener_simbolo = entornoBD.buscar_sim(campo.tablaR)
entornoTablarefrencia = obtener_simbolo.Entorno
for campito in campo.idR:
if entornoTablarefrencia.validar_sim(
campito.id) == 1:
print("todo bien")
else:
banderaTodoBien = False
break
if banderaTodoBien:
print("todo esta bien")
banderaTodoBien = Campo.ejecutar(
campo, tsTabla, consola, exceptions)
print(banderaTodoBien)
if campo.caso == 2 or campo.caso == 3 or campo.caso == 4:
cantidad_columnas = cantidad_columnas - 1
if not banderaTodoBien:
break
else:
banderaTodoBien = False
else:
banderaTodoBien = Campo.ejecutar(campo, tsTabla, consola,
exceptions)
print(banderaTodoBien)
if campo.caso == 2 or campo.caso == 3 or campo.caso == 4:
cantidad_columnas = cantidad_columnas - 1
if not banderaTodoBien:
break
if banderaTodoBien:
if str(CreateTable.idInherits) != str(None):
print("---------", CreateTable.idInherits)
print(entornoBD.validar_sim(CreateTable.idInherits))
if entornoBD.validar_sim(CreateTable.idInherits) == 1:
simboloTabla = entornoBD.buscar_sim(
CreateTable.idInherits)
entornoTablaPadre = simboloTabla.Entorno
lista_campos = entornoTablaPadre.simbolos
contador = 0
for item in lista_campos:
simbolo_nuevo = TS.Simbolo(
lista_campos.get(item).categoria,
lista_campos.get(item).id,
lista_campos.get(item).tipo,
lista_campos.get(item).valor,
lista_campos.get(item).Entorno)
tsTabla.agregar_sim(simbolo_nuevo)
contador = contador + 1
nueva_tabla = TS.Simbolo(TS.TIPO_DATO.TABLA,
CreateTable.id, None,
cantidad_columnas + contador,
tsTabla)
entornoBD.agregar_sim(nueva_tabla)
createTable(bdactual.valor, CreateTable.id,
cantidad_columnas + contador)
columnas = tsTabla.simbolos
print("Agregando llaves primarias")
i = 0
pks = []
for columna in columnas:
print(columnas.get(columna).id)
for data in columnas.get(columna).valor:
print(" data: ", data)
if 'PRIMARYKEY' in data:
pks.append(i)
i = i + 1
alterAddPK(BD.id, CreateTable.id, pks)
consola.append(
f"Se creo la tabla {CreateTable.id}, exitosamente\n"
)
else:
consola.append(
f"f42P16 invalid_table_definition, no se creo la tabla {CreateTable.id}"
)
else:
nueva_tabla = TS.Simbolo(TS.TIPO_DATO.TABLA,
CreateTable.id, None,
cantidad_columnas, tsTabla)
entornoBD.agregar_sim(nueva_tabla)
createTable(bdactual.valor, CreateTable.id,
cantidad_columnas)
columnas = tsTabla.simbolos
print("Agregando llaves primarias")
i = 0
pks = []
for columna in columnas:
print(columnas.get(columna).id)
for data in columnas.get(columna).valor:
print(" data: ", data)
if 'PRIMARYKEY' in data:
pks.append(i)
i = i + 1
alterAddPK(BD.id, CreateTable.id, pks)
consola.append(
f"Se creo la tabla {CreateTable.id}, exitosamente\n")
else:
consola.append(
f"22005 error_in_assignment,No se creo la tabla {CreateTable.id} campos incosistente \n"
)
exceptions.append(
"Error semantico-22005 error_in_assignment-Columnas check-fila-columna"
)
else:
consola.append(
"22005 error_in_assignment, No se ha seleccionado una BD\n")
exceptions.append(
"Error semantico-22005 error_in_assignment-No se ha seleccionado DB-fila-columna"
)
def ejecutar(createDataBase, ts, consola, exceptions):
if createDataBase.caso == 1 and createDataBase.exists == False or createDataBase.exists == True:
#create database
lb = showDatabases()
for bd in lb:
if bd == createDataBase.id:
if createDataBase.exists:
print("no pasa nada")
else:
consola.append(
f"La Base de Datos {createDataBase.id} ya existe, error al crear\n"
)
return
createDatabase(str(createDataBase.id))
entorno_bd = {}
ts_local = TS.TablaDeSimbolos(entorno_bd)
# simbolo (self, categoria,id, tipo, valor,Entorno):
simbolo = TS.Simbolo(
TS.TIPO_DATO.BASEDEDATOS, createDataBase.id, None, 0,
ts_local) # inicializamos con 0 como valor por defecto
ts.agregar_sim(simbolo)
consola.append(
f"Se creo la base de datos {createDataBase.id} exitosamente\n")
print(ts.simbolos)
elif createDataBase.caso == 2 and createDataBase.exists == False:
#create or replace
lb = showDatabases()
for bd in lb:
if bd == createDataBase.id:
# se borra a nivel de memoria en disco
dropDatabase(str(createDataBase.id))
# se quita el id de la tabla de simbolos
ts.eliminar_sim(str(createDataBase.id))
# simbolo (self, categoria,id, tipo, valor,Entorno):
# se vuelve a crear un entorno para agregar de nuevo la base de datos
createDatabase(str(createDataBase.id))
entorno = {}
ts_local = TS.TablaDeSimbolos(entorno)
simbolo = TS.Simbolo(
None, createDataBase.id, TS.TIPO_DATO.BASEDEDATOS, 0,
ts_local) # inicializamos con 0 como valor por defecto
ts.agregar_sim(simbolo)
consola.append(
f"Replace, la base de datos {createDataBase.id} se ha creado exitosamente\n"
)
print(ts.simbolos)
return
createDatabase(str(createDataBase.id))
ts_local = TS.TablaDeSimbolos(ts.simbolos)
# simbolo (self, categoria,id, tipo, valor,Entorno):
simbolo = TS.Simbolo(
None, createDataBase.id, TS.TIPO_DATO.BASEDEDATOS, 0,
ts_local) # inicializamos con 0 como valor por defecto
ts.agregar_sim(simbolo)
consola.append(
f"Se creo la base de datos {createDataBase.id} exitosamente\n")
print(ts.simbolos)
elif createDataBase.caso == 2 and createDataBase.exists == True:
#create or replace if not exists
lb = showDatabases()
for bd in lb:
if bd == createDataBase.id:
if createDataBase.exists:
print("no pasa nada")
else:
consola.append(
"La Base de Datos ya existe no se puede reemplazar"
)
return
createDatabase(str(createDataBase.id))
ts_local = TS.TablaDeSimbolos(ts.simbolos)
# simbolo (self, categoria,id, tipo, valor,Entorno):
simbolo = TS.Simbolo(
None, createDataBase.id, TS.TIPO_DATO.BASEDEDATOS, 0,
ts_local) # inicializamos con 0 como valor por defecto
ts.agregar_sim(simbolo)
consola.append(
f"Se creo la base de datos {createDataBase.id} exitosamente\n")
print(ts.simbolos)
def ejecutar(campo, ts, consola, exceptions):
nombreCampo = campo.id
valor=True
if campo.caso == 1:
# id con su tipo
# verificamos tipo si viene
print("1->>>>>>>>>>>>>>>>> ",campo.id)
#if campo.tipo != None and ts.validar_sim(campo.id) == -1:
if ts.validar_sim(campo.id) == -1:
if str(campo.tipo.longitud) != None:
print("campo: ",str(campo.tipo.tipo))
if "VARCHAR" in str(campo.tipo.tipo).upper() or "CHARACTER" in str(campo.tipo.tipo).upper() or "CHARACTERVARYING" in str(campo.tipo.tipo).upper() or "DECIMAL" in str(campo.tipo.tipo).upper():
valores = []
if str(campo.acompaniamiento) != str(None):
for data in campo.acompaniamiento:
print(data.tipo ," - ",data.valorDefault)
if str(data.valorDefault) == str(None):
valores.append(data.tipo)
else:
valores.append(str(data.tipo)+":"+str(data.valorDefault))
campo_nuevo = TS.Simbolo(TS.TIPO_DATO.CAMPO, campo.id, str(campo.tipo.tipo).upper(), valores, None)
ts.agregar_sim(campo_nuevo)
return valor
elif str(campo.tipo.tipo).lower() in tipos_de_dato and ts.validar_sim(campo.id) == -1:
valores = []
check = []
if str(campo.acompaniamiento) != str(None):
for data in campo.acompaniamiento:
print(data.tipo, " - ", data.valorDefault)
if str(data.valorDefault) == str(None):
valores.append(data.tipo)
else:
if isinstance(data.valorDefault,Expresion):
check.append(data.valorDefault)
valores.append(str(data.tipo) + ":" + "expresion")
else:
valores.append(str(data.tipo)+":"+str(data.valorDefault))
print("campo-> ",str(campo.tipo.tipo)," ",campo.acompaniamiento)
campo_nuevo = TS.Simbolo(TS.TIPO_DATO.CAMPO, campo.id, str(campo.tipo.tipo).upper(), valores, check)
ts.agregar_sim(campo_nuevo)
return valor
else:
if ts.validar_sim(campo.id) == 1:
consola.append(f"Repeat identificador {campo.id}")
else:
consola.append(f"42P18 indeterminate_datatype, Tipo de dato no valido para {campo.id}\n")
exceptions.append(f"Error Semantico-NUMERO-info-fila-columna")
valor= False
return valor
# ts.agregar_sim()
elif campo.caso == 2:
# constraint
print("")
print("2->>>>>>>>>>>>>>>>> ", campo.id)
for idcito in campo.idFk:
print(idcito.id)
if ts.validar_sim(idcito.id) == 1:
obtenerCampo = ts.buscar_sim(idcito.id)
print("ejecutando campos------------------------------------------!!!!!!1")
tablita = []
for dataReferencia in campo.idR:
tablita.append(dataReferencia.id)
obtenerCampo.valor.append(f"CONSTRAINT:{campo.id}:FOREIGNKEY:{campo.tablaR}:{tablita}")
# para llegar antes debe validarse que existe la tabla y los campos a los cuales
# se referencia
else:
consola.append(f"42P10 invalid_column_reference, Campo{idcito.id} no encontrado")
exceptions.append("Error Semantico - 42P10- invalid_column_reference-fila-columna")
valor = False
print("")
elif campo.caso == 3:
# foreing key
print("3->>>>>>>>>>>>>>>>> ", campo.idFk)
for idcito in campo.idFk:
print(idcito.id)
if ts.validar_sim(idcito.id) == 1:
obtenerCampo = ts.buscar_sim(idcito.id)
print("ejecutando campos------------------------------------------!!!!!!1")
tablita = []
for dataReferencia in campo.idR:
tablita.append(dataReferencia.id)
obtenerCampo.valor.append(f"FOREIGNKEY:{campo.tablaR},{tablita}")
#para llegar antes debe validarse que existe la tabla y los campos a los cuales
#se referencia
else:
consola.append(f"42P10 invalid_column_reference, Campo{idcito.id} no encontrado")
exceptions.append("Error Semantico - 42P10- invalid_column_reference-fila-columna")
valor = False
print("")
elif campo.caso == 4:
# primary key
print("caso 4")
for campito in nombreCampo:
if ts.validar_sim(campito.id) == 1:
data =ts.buscar_sim(campito.id)
if str(data.valor) == str(None):
valores = []
campo_actualizado = TS.Simbolo(TS.TIPO_DATO.CAMPO, data.id, data.tipo,valores, data.Entorno)
ts.actualizar_sim(campo_actualizado)
valor = True
else:
data.valor.append('PRIMARYKEY')
campo_actualizado = TS.Simbolo(TS.TIPO_DATO.CAMPO, data.id, data.tipo, data.valor, data.Entorno)
ts.actualizar_sim(campo_actualizado)
valor=True
else:
valor= False
consola.append(f"Error: el identificador {campito.id},no esta definido\n")
break
print(valor)
else:
print("5->>>>>>>>>>>>>>>>> ", campo.id)
# id con su tipo
# verificamos tipo si viene
print("1->>>>>>>>>>>>>>>>> ", campo.id)
# if campo.tipo != None and ts.validar_sim(campo.id) == -1:
if ts.validar_sim(campo.id) == -1:
if ts.validar_sim(campo.id) == -1:
valores = []
check = []
if str(campo.acompaniamiento) != str(None):
for data in campo.acompaniamiento:
print(data.tipo, " - ", data.valorDefault)
if str(data.valorDefault) == str(None):
valores.append(data.tipo)
else:
if isinstance(data.valorDefault, Expresion):
check.append(data.valorDefault)
valores.append(str(data.tipo) + ":" + "expresion")
else:
valores.append(str(data.tipo) + ":" + str(data.valorDefault))
campo_nuevo = TS.Simbolo(TS.TIPO_DATO.CAMPO, campo.id, campo.tipo.upper(), valores, check)
ts.agregar_sim(campo_nuevo)
return valor
else:
if ts.validar_sim(campo.id) == 1:
consola.append(f"Repeat identificador {campo.id}")
else:
consola.append(f"42P18 indeterminate_datatype, Tipo de dato no valido para {campo.id}\n")
exceptions.append(f"Error Semantico-NUMERO-info-fila-columna")
valor = False
return valor
# ts.agregar_sim()
print(valor)
return valor