def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
# Se verifica que se este trabajando sobre una base de datos
if entorno.BDisNull() is True:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: No se ha seleccionado una base de datos para trabajar.
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: no se a seleccionado base de datos", self.linea,
self.columna, 'Update')
arbol.ErroresSemanticos.append(Error)
print('No se ha seleccionado una base de datos para trabajar')
return
# Se verifica que exista la tabla a actualizar
else:
# Si la tabla existe
if Meta.existTable(entorno.getBD(), self.table_name) is True:
# Se obtiene los encabezados de la tabla, las columnas y sus valores a actualizar
header = dbms.extractTable(entorno.getBD(), self.table_name)[0]
columns, values = [], []
self.getdata(columns, values, entorno, arbol)
# Si no hay condicional where
if self.where is None:
pass
# Si hay condicional where
else:
self.whithwhere(columns, header, values, entorno, arbol)
def ruta_SelectComplejo(self, entorno: Tabla_de_simbolos, arbol: Arbol):
print("[Select] ruta_SelectComplejo (Go on)")
V_TablaSelect = Valor(TIPO.MATRIZ, "TablaSelect")
for i in self.listatablas:
self.virtualizar_tabla(i, entorno, arbol)
# ------------------
j = 0
for i in self.listavalores:
if self.obtener_multi(i, entorno, arbol, j):
break
j = j + 1
# ------------------
V_TablaSelect.inicializarMatrix_boring(self.tamFilaTablaSelect, len(self.listavalores))
index = 0
for i in self.listavalores:
lista: list = self.obtener_columnas(i, entorno, arbol)
for m in range(len(lista)):
V_TablaSelect.matriz[m][index] = lista[m]
index = index + 1
self.TablaSelect = V_TablaSelect
# ----------------------------------------------------------------------------------
TablaSe:Simbolo = Simbolo("TablaResult", 0, self.TablaSelect)
entorno.insertar_variable(TablaSe)
for i in self.listawhere:
i.execute(entorno, arbol)
def virtualizar_tabla_subquery(self, index: indexador_auxiliar, entorno: Tabla_de_simbolos, arbol: Arbol):
print("virtualiza subquery")
tablaVirtualizada: Valor = index.origen.execute(entorno, arbol)
nombreTabla = self.definidorDeNombre_deTabla_basadoEnIndexador(index)
tablaVirtualizada.consola_imprimirMatriz_NERY()
newSimbolo: Simbolo = Simbolo(nombreTabla, TIPO.MATRIZ, tablaVirtualizada)
entorno.insertar_variable(newSimbolo)
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
databaseName = entorno.getBD()
Meta.tableName = self.tableName
Meta.databaseName = databaseName
Meta.arbol = arbol
self.arbol = arbol
Meta.entorno = entorno
if entorno.BDisNull():
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion: BD %databaseName% no existe ("BD " + databaseName + " no existe")
'''
Error: ErroresSemanticos = ErroresSemanticos("XX00: internal_error db is not exist",
self.linea,
self.columna,
'Insert')
arbol.ErroresSemanticos.append(Error)
print('BD' + databaseName + 'no existe')
return
if not self.listColumn:
self.insertNormal(databaseName, entorno, arbol)
else:
self.insertWithListId(databaseName, entorno, arbol)
def virtualizar_tabla(self, index:indexador_auxiliar, entorno: Tabla_de_simbolos, arbol:Arbol):
# -----------------------------------------------
# Codigo para acceder a estructuras de EDD (estan quemados por el momento)
# basado en el index.origen
body = j.extractTable(entorno.getBD(),index.origen)
x = Meta.getNameColumns(body[0])
body[0] = x
# body = [['Cod', 'estado', 'ciudad', 'zona'], [1, 'Guatemala', 'Guatemala', 'GTM'], [2, 'Cuilapa', 'Santa Rosa', 'GTM'], [3, 'San Salvador', 'San Salvador', 'SLV']]
tamFila = len(body)
tamColumna = len(body[0])
if tamFila > self.tamFilaTablaSelect:
self.tamFilaTablaSelect = tamFila
'''headers:list = ['C_1', 'C_2', 'C_3', 'C_4', 'C_5']
body:list = [
'1.1', '2.1', '3.1', '4.1', '5.1',
'1.2', '2.2', '3.2', '4.2', '5.2',
'1.3', '2.3', '3.3', '4.3', '5.3'
]'''
# -----------------------------------------------
nombreTabla = self. definidorDeNombre_deTabla_basadoEnIndexador(index)
tablaVirtualizada:Valor = Valor(TIPO.MATRIZ, nombreTabla)
tablaVirtualizada.inicializarMatrix_boring(tamFila, tamColumna)
tablaVirtualizada.setearMatriz_byJespino(body)
#tablaVirtualizada.establecer_encabezados(headers)
#tablaVirtualizada.setear_body_byList_MATRIZ(body)
# self.consolaInterna = tablaVirtualizada.consola_imprimirMatriz_NERY()
tablaVirtualizada.consola_imprimirMatriz_NERY()
newSimbolo:Simbolo = Simbolo(nombreTabla, TIPO.MATRIZ, tablaVirtualizada)
entorno.insertar_variable(newSimbolo)
TSreport = ReporteTS(
nombreTabla, "Tabla", "Select", 1, 1
)
arbol.ReporteTS.append(TSreport)
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
indentificador = self.indentificador
value: Valor = Valor(TIPO.LISTA, indentificador)
lista = []
for i in self.ListaTipos:
val: Valor = i.execute(entorno, arbol)
value.insert_tipo_toType(str(val.data))
lista.append(str(val.data))
simbol: Simbolo = Simbolo(indentificador, TIPO.LISTA, value)
entorno.insertar_variable(simbol)
arbol.console.append("\n" + "Type: " + indentificador +
" --> Valores: " + str(lista) + "\n")
return
def execute(self, entorno: Tabla_de_simbolos, arbol:Arbol):
entorno.NuevoAmbito()
if self.listawhere == "N/A":
self.ruta_SelectSimple(entorno, arbol)
#arbol.console.append(self.consolaInterna)
entorno.BorrarAmbito()
return self.TablaSelect
else:
self.ruta_SelectComplejo(entorno, arbol)
#arbol.console.append(self.consolaInterna)
entorno.BorrarAmbito()
return self.TablaSelect
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
# Se ejecuta el metodo para la eliminar la base de datos
result = dbms.dropDatabase(self.database_name)
# Si la operacion fue exitosa
if result == 0:
# Si la base de datos actual es la que se va a eliminar
if entorno.getBD() == self.database_name:
# Se coloca en nulo ls base de datos actual
entorno.setBD("")
cadena = 'tytus> Base de datos \'' + self.database_name + '\' fue eliminada exitosamente'
print('tytus> Base de datos \'' + self.database_name +
'\' fue eliminada exitosamente')
arbol.console.append(cadena)
return
# Si hubo un error en la operacion
elif result == 1:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: XX000 internal_error (yo creo que seria ese)
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX01: internal_error", self.linea, self.columna,
'Drop Database')
arbol.ErroresSemanticos.append(Error)
print('XX00: internal_error')
return
# Si la base de datos no existe
elif result == 2:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: La base de datos no existe
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX01: internal_error la db no existe", self.linea,
self.columna, 'Drop Database')
arbol.ErroresSemanticos.append(Error)
print('La base de datos no existe')
return
def analizador():
'''
Se obtiene el texto del text area
se pasa el parser y se ejecuta el patron interprete
'''
my_text1.delete("1.0", END)
try:
cadena = my_text.get("1.0", END)
result: Arbol = AnaParse(cadena)
entornoCero: Tabla_de_simbolos = Tabla_de_simbolos()
entornoCero.NuevoAmbito()
for item in result.instrucciones:
item.execute(entornoCero, result)
consola = ""
for item in result.console:
consola = consola + item
my_text1.insert(END, consola)
global arboAux_errores
arboAux_errores = result
except:
print(traceback)
my_text1.insert(END, 'Ocurrio un error al compilar')
def obtener_columnas(self, index:indexador_auxiliar, entorno: Tabla_de_simbolos, arbol:Arbol):
campo = self.definidorDeNombre_deTabla_basadoEnIndexador(index)
tabla = index.origen
if len(self.listatablas) == 1:
tabla = self.definidorDeNombre_deTabla_basadoEnIndexador(self.listatablas[0])
tablaVistualizada:Valor = entorno.obtener_varibale(tabla)
columna:Valor = Valor(TIPO.LISTA, campo)
columna.inicizalizar_lista(tablaVistualizada.obtenerColumna_enBase_aEncabezado(campo))
return columna.lista
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
if self.exist(self.id) is True:
entorno.setBD(self.id)
arbol.console.append('tytus> Trabajando en: \'' + self.id + '\'')
print('tytus> Trabajando en: \'' + self.id + '\'')
else:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: BD %databaseName% no existe ("BD " + databaseName + " no existe")
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: la base de datos no existe", self.linea, self.columna,
'Use database')
arbol.ErroresSemanticos.append(Error)
print("error no existe la bd")
return
def obtener_multi(self, index:indexador_auxiliar, entorno: Tabla_de_simbolos, arbol:Arbol, indiceListaValores):
if index.referencia == "MULTI":
self.listavalores.pop(indiceListaValores)
tabla = index.origen
if len(self.listatablas) == 1:
tabla = self.definidorDeNombre_deTabla_basadoEnIndexador(self.listatablas[0])
tablaVistualizada:Valor = entorno.obtener_varibale(tabla)
encabezados:[] = tablaVistualizada.obtenerEncabezados_soloSTR()
for i in encabezados:
ind:indexador_auxiliar = indexador_auxiliar(str(tabla), str(i), 0)
self.listavalores.append(ind)
return True
else:
return False
def Seleccionar():
try:
cadena = my_text.get(SEL_FIRST, SEL_LAST)
print('>> ' + cadena)
result: Arbol = AnaParse(cadena)
entornoCero: Tabla_de_simbolos = Tabla_de_simbolos()
entornoCero.NuevoAmbito()
for item in result.instrucciones:
item.execute(entornoCero, result)
consola = ""
for item in result.console:
consola = consola + item
my_text1.insert(END, consola)
except:
my_text1.insert(END, 'Ocurrio un error al compilar')
def analizador():
'''
Se obtiene el texto del text area
se pasa el parser y se ejecuta el patron interprete
'''
global cadena, dotString
my_text1.delete("1.0", END)
try:
cadena = my_text.get("1.0", END)
result: Arbol = AnaParse(cadena)
entornoCero: Tabla_de_simbolos = Tabla_de_simbolos()
entornoCero.NuevoAmbito()
for item in result.instrucciones:
item.execute(entornoCero, result)
my_text1.insert(END, result)
except:
my_text1.insert(END, 'Ocurrio un error al compilar')
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
if self.tipocondicionante == "where":
self.condicionante.execute(entorno, arbol)
return
if self.tipocondicionante == "ORDER":
TablaResult: Valor = entorno.obtener_varibale("TablaResult")
TablaResult.inicializarPrettybabe()
consola = TablaResult.order(str(self.condicionante.referencia),
str(self.extra1))
simbol: Simbolo = Simbolo("TablaResult", 0, TablaResult)
entorno.insertar_variable(simbol)
arbol.console.append("\n" + consola + "\n")
if self.tipocondicionante == "LIMIT":
limitador = self.condicionante.execute(entorno, arbol)
TablaResult: Valor = entorno.obtener_varibale("TablaResult")
TablaResult.inicializarPrettybabe()
consola = TablaResult.limit(int(limitador.data))
simbol: Simbolo = Simbolo("TablaResult", 0, TablaResult)
entorno.insertar_variable(simbol)
arbol.console.append("\n" + consola + "\n")
val: Valor = Valor(3, False)
return val
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
# Se obtiene la base de datos actual, la tabla a crear y el numero de colúmnas
bdactual = entorno.getBD()
self.bd_actual = bdactual
nuevatabla = self.id
nocolumnas = len(self.columnas)
if self.herencia is not None:
self.inh = self.definir_inherits(self.herencia.tabla)
if self.inh is not None:
self.ifinh = True
nocolumnas = nocolumnas + len(self.inh)
else:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: ocurrio un error o no existe la base de datos
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: internal_error db is not exist", self.linea,
self.columna, 'Create Table')
arbol.ErroresSemanticos.append(Error)
print("error")
#return
# Se utiliza el paquete de almacenamiento para enviar a crear una nueva tabla y se obtiene un retorno
retorno = dbms.createTable(bdactual, nuevatabla, nocolumnas)
if retorno == 0: # Si la operacion exitosa
primarykeys = self.crear_pks(
) # Se verifican si existen llaves primarias
if len(primarykeys) != 0:
pks = self.obtenerindice(primarykeys)
dbms.alterAddPK(bdactual, nuevatabla,
pks) # Se crean las llaves primarias
cadena = "tytus> La tabla '" + self.id + "' fue creada exitosamente"
print("tytus> La tabla '" + self.id +
"' fue creada exitosamente")
arbol.console.append(cadena)
else:
pks = self.obtenerindice(primarykeys)
if len(pks) != 0:
dbms.alterAddPK(bdactual, nuevatabla,
pks) # Se crean las llaves primarias
self.crear_encabezados(
bdactual, entorno,
arbol) # Se crean los encabezados de las columnas
elif retorno == 1: # Error en la operacion
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: error en la operacion
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: internal_error error en la operacion", self.linea,
self.columna, 'Create Table')
arbol.ErroresSemanticos.append(Error)
print("Nel error")
elif retorno == 2: # La base de datos no existe
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: no existe la base de datos
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: internal_error db is not exist", self.linea,
self.columna, 'Create Table')
arbol.ErroresSemanticos.append(Error)
print("Nel no existe la bd")
elif retorno == 3: # La tabla ya existe
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: la tabla 'self.id' ya existe
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX01: internal_error id ya existe", self.linea, self.columna,
'Create Table')
arbol.ErroresSemanticos.append(Error)
print("Nel ya existe la tabla")
import traceback
from Parser.Ascendente.gramatica import parse
from Interprete.Arbol import Arbol
from Interprete.Tabla_de_simbolos import Tabla_de_simbolos
if __name__ == '__main__':
f = open("entrada.sql", "r")
try:
input = f.read()
print('====================ENTRADAInicio====================')
print(input)
print('====================ENTRADAFIN====================')
result: Arbol = parse(input)
print('====================RESULT====================')
print('Analisis Sintactico realizado con exito')
entornoCero: Tabla_de_simbolos = Tabla_de_simbolos()
entornoCero.NuevoAmbito()
try:
for item in result.instrucciones:
item.execute(entornoCero, result)
except:
traceback.print_exc()
print('Error En el analisis Semantico')
except:
print('Ocurrion un error en el analisis Sintactico')
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
izquierdo: indexador_auxiliar = self.izq
derecho: Valor = self.der.execute(entorno, arbol)
if self.tipoOperaRelacional == "=":
if entorno.varibaleExiste("TablaResult"):
TablaResult: Valor = entorno.obtener_varibale("TablaResult")
TablaResult.inicializarPrettybabe()
TablaResult.filtrarWhere("=", izquierdo.referencia,
derecho.data)
simbol: Simbolo = Simbolo("TablaResult", 0, TablaResult)
entorno.insertar_variable(simbol)
retorno: bool = not (TablaResult.matriResult_isEmpty())
arbol.console.append("\n" +
TablaResult.inicializarPrettybabe() +
"\n")
print(str(retorno) + " <--------------")
return Valor(3, retorno)
else:
# Codigo de Pablo
# Se crea una lista que contendra o no las llaves primarias que cumplan la condicion
registers = []
'''
Se obtiene la tabla, el indice de la columna que especifica el lado izquierdo de la operacion
relacional y las llaves primarias
'''
table = entorno.gettable()
pks = Meta.getPksIndex(table[0])
column = Meta.getNumberColumnByName(izquierdo.get_origen(),
table[0])
# Si la columna existe
if column != -1:
# Se recorre cada uno de los registros de la tabla
for row in range(len(table)):
# Si el registro coincide con el valor
if table[row][column] == derecho.data:
# Si no hay llaves primarias en la tabla
if not pks:
registers.append(str([row]))
# Si hay llaves primarias en la tabla
else:
inner = []
for pk in pks:
inner.append(str(table[row][pk]) + '|')
registers.append(inner)
# Se devuelven los valores de las llaves primarias de las filas que cumplen la condicion o es vacia
return registers
# Si la columna no existe
else:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: La columna especificada izquierdo.get_origen() no existe.
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX01: La columna especificada izquierdo.get_origen() no existe",
self.linea, self.columna, 'Operaciones Relacionales')
arbol.ErroresSemanticos.append(Error)
print(
'La columna especificada izquierdo.get_origen() no existe'
)
return None
elif self.tipoOperaRelacional == "u:=":
return {izquierdo: self.der}