def send_data():
print("Analizando Entrada:")
print("==============================================")
# reporteerrores = []
contenido = Tentrada.get(1.0, 'end')
Tsalida.delete("1.0", "end")
Tsalida.configure(state='normal')
# print(contenido)
jsonMode.dropAll()
jsonMode.createDatabase("DB1")
Principal = Entorno()
Principal.database = "DB1"
instrucciones = g.parse(contenido)
Tsalida.insert(INSERT, "Salida de consultas\n")
for instr in instrucciones:
if instr != None:
res = instr.ejecutar(Principal)
if res != None:
res += '\n'
Tsalida.insert(INSERT, res)
Tsalida.configure(state='disabled')
Principal.mostrarSimbolos()
reporte_lex_sin()
def send_data():
print("Analizando Entrada:")
print("==============================================")
# reporteerrores = []
contenido = Tentrada.get(1.0, 'end')
variables.consola.delete("1.0", "end")
variables.consola.configure(state='normal')
# print(contenido)
Principal = Entorno()
jsonMode.dropAll()
# Principal.database = "DB1"
instrucciones = g.parse(contenido)
variables.consola.insert(INSERT, "Salida de consultas\n")
for instr in instrucciones:
if instr != None:
instr.ejecutar(Principal)
string = str(instr)
intrprueba = string
variables.consola.configure(state='disabled')
# variables.consola.configure()
setContenido(Principal.mostrarSimbolos())
def send_data():
print("Analizando Entrada:")
print("==============================================")
# reporteerrores = []
contenido = Tentrada.get(1.0, 'end')
variables.consola.delete("1.0", "end")
variables.consola.configure(state='normal')
# print(contenido)
Principal = Entorno()
jsonMode.dropAll()
# Principal.database = "DB1"
instrucciones = g.parse(contenido)
variables.consola.insert(INSERT, "Salida de consultas\n")
for instr in instrucciones:
if instr != None:
res = instr.ejecutar(Principal)
if res != None:
res = str(res) + '\n'
variables.consola.insert(INSERT, res)
variables.consola.configure(state='disabled')
#variables.consola.configure()
tSym = Principal.mostrarSimbolos()
with open('ts.dot', 'w', encoding='utf8') as ts:
ts.write(tSym)
check_call(['dot', '-Tpdf', 'ts.dot', '-o', 'ts.pdf'])
reporte_lex_sin()
def __init__(self, tabla_simbolos, tabla_errores, consola, salida):
self.type_checker = {}
self.actual_database = ''
self.tabla_simbolos = tabla_simbolos
self.tabla_errores = tabla_errores
self.consola = consola
self.salida = salida
jsonMode.dropAll()
self.initCheck()
def __init__(self,
raiz,
usingDB='',
ts={},
userTypes={},
output=[],
errors=[]):
self.raiz = raiz
self.usingDB = usingDB
self.ts = ts
self.userTypes = userTypes
self.output = output
self.errors = errors
jsonMode.dropAll()
def traducir():
# reporteerrores = []
contenido = Tentrada.get(1.0, 'end')
variables.consola.delete("1.0", "end")
variables.consola.configure(state='normal')
Principal = Entorno()
jsonMode.dropAll()
instrucciones = g.parse(contenido)
variables.consola.insert(INSERT, "Salida de traduccion\n")
salida = ''
for instr in instrucciones:
if instr != None:
salida += instr.traducir(Principal).codigo3d
print(salida)
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 m_carga_de_informacion(self):
# drop all databases if exists
j.dropAll()
# create database
j.createDatabase('BD1')
# create tables
j.createTable('BD1', 'personas', 5)
j.createTable('BD1', 'pais', 4)
j.createTable('BD1', 'idiomas', 4)
# create simple primary keys
j.alterAddPK('BD1', 'personas', [0])
j.alterAddPK('BD1', 'pais', [0])
j.alterAddPK('BD1', 'idiomas', [0])
# insert data in countries
j.insert('BD1', 'pais',
['GTM', 'Guatemala', 'Central America', 108889])
j.insert('BD1', 'pais', ['MX', 'Mexico', 'Norte America', 21041])
j.insert('BD1', 'pais',
['EEUU', 'Estados Unidos', 'Norte America', 21041])
# insert data in cities
j.insert('BD1', 'personas', [1, 'Jossie', 'Castrillo', '27', 'GTM'])
j.insert('BD1', 'personas', [2, 'Juanpi', 'Garcia', '27', 'GTM'])
j.insert('BD1', 'personas', [3, 'Byron', 'Cermeno', '27', 'GTM'])
j.insert('BD1', 'personas', [4, 'Hayrton', 'Ixpata', '27', 'GTM'])
j.insert('BD1', 'personas', [5, 'Dulce', 'DeLeon', '25', 'MX'])
j.insert('BD1', 'personas', [6, 'Miguel', 'Basir', '26', 'GTM'])
j.insert('BD1', 'personas', [7, 'Nose', 'Algo', '30', 'EEUU'])
# inser data in languages
j.insert('BD1', 'idiomas', ['GTM', 'Espanol', 'official', 64.7])
j.insert('BD1', 'idiomas', ['EEUU', 'Espanol', 'official', 100.0])
j.insert('BD1', 'idiomas', ['MX', 'Espanol', 'official', 100.0])
# JSON Mode Test File
# Released under MIT License
# Copyright (c) 2020 TytusDb Team
from storageManager import jsonMode as j
# drop all databases if exists
j.dropAll()
# create database
j.createDatabase('world')
# create tables
j.createTable('world', 'countries', 4)
j.createTable('world', 'cities', 4)
j.createTable('world', 'languages', 4)
# create simple primary keys
j.alterAddPK('world', 'countries', [0])
j.alterAddPK('world', 'cities', [0])
j.alterAddPK('world', 'languages', [0, 1])
# insert data in countries
j.insert('world', 'countries', ['GTM', 'Guatemala', 'Central America', 108889])
j.insert('world', 'countries', ['SLV', 'El Salvado', 'Central America', 21041])
# insert data in cities
j.insert('world', 'cities', [1, 'Guatemala', 'Guatemala', 'GTM'])
j.insert('world', 'cities', [2, 'Cuilapa', 'Santa Rosa', 'GTM'])
j.insert('world', 'cities', [3, 'San Salvador', 'San Salvador', 'SLV'])
j.insert('world', 'cities', [4, 'San Miguel', 'San Miguel', 'SLV'])
import gramatica as g
import Utils.TablaSimbolos as table
import Utils.Lista as l
import storageManager.jsonMode as storage
import os
import webbrowser
from Utils.fila import fila
from error import *
import Instrucciones.DML.select as select
import json
#Finalizamos con las importaciones
##########################################################################
storage.dropAll() #Comentar si quieren que se borre todo al cerrar y abrir la app
datos = l.Lista({}, '')
##################################FUNCIONES#################################
app = Flask(__name__)
CORS(app)
#esto es el inicio (puede o no utilizarse)
@app.route('/')
def raiz():
print('estoy en el inicio')
return jsonify({"mensaje":"Menu Principal"})
def interpretar_sentencias(arbol, tablaSimbolos):
jBase.dropAll()
global consola
for nodo in arbol:
if isinstance(nodo, SCrearBase):
print("Creando Base-----")
crearBase(nodo, tablaSimbolos)
# aqui va el metodo para ejecutar crear base
elif isinstance(nodo, SShowBase):
print("Mostrando Base-----")
if nodo.like == False:
bases = jBase.showDatabases()
for base in bases:
consola += base + "\n"
else:
bases = jBase.showDatabases()
basn = []
for base in bases:
basn.append(base)
basn2 = []
r = re.compile(".*" + nodo.cadena + ".*")
basn2 = list(filter(r.match, basn))
for bas in basn2:
consola += bas + "\n"
# aqui va el metodo para ejecutar show base
elif isinstance(nodo, SUse):
global useActual
useActual = nodo.id
elif isinstance(nodo, SAlterBase):
print("Alterando Base-----")
AlterDatabase(nodo, tablaSimbolos)
# aqui va el metodo para ejecutar alter base
elif isinstance(nodo, SDropBase):
print("Drop Base-----")
if nodo.exists == False:
db = jBase.dropDatabase(nodo.id.valor)
if db == 2:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico", "Error la base de datos " +
nodo.id.valor + " no existe"))
elif db == 1:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"Error en la operacion."))
else:
b = tablaSimbolos.eliminar(nodo.id.valor)
if b == True:
consola += "La base de datos " + nodo.id.valor + " se elimino con exito. \n"
else:
db = jBase.dropDatabase(nodo.id.valor)
if db == 1:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"Error en la operacion."))
elif db == 0:
b = tablaSimbolos.eliminar(nodo.id.valor)
if b == True:
consola += "La base de datos " + nodo.id.valor + " se elimino con exito. \n"
else:
consola += "Error no se pudo elminar la base " + nodo.id.valor + " de la tabla de simbolos \n"
# aqui va el metodo para ejecutar drop base
elif isinstance(nodo, STypeEnum):
print("Enum Type------")
print(nodo.id)
for val in nodo.lista:
print(val.valor)
elif isinstance(nodo, SUpdateBase):
print("Update Table-----------")
print(nodo.id)
for val in nodo.listaSet:
print("columna------")
print(val.columna)
print("------------")
if isinstance(val.valor, SOperacion):
val2 = val.valor
print(val2.opIzq.valor)
print(val2.operador)
print(val2.opDer.valor)
else:
val2 = val.valor
print(val2.valor)
print(nodo.listaWhere)
elif isinstance(nodo, SDeleteBase):
print("Delete Table-------------")
print(nodo.id)
print("Tiene where?")
print(nodo.listaWhere)
elif isinstance(nodo, STruncateBase):
print("Truncate Table------------")
for id in nodo.listaIds:
print(id)
elif isinstance(nodo, SInsertBase):
print("Insert Table-------------")
print("nombre tabla")
print(nodo.id)
print("valores")
for val in nodo.listValores:
if isinstance(val, SExpresion):
print(val.valor)
elif isinstance(nodo, SShowTable):
print("Mostrando tablas----------")
tablas = jBase.showTables(useActual)
for tabla in tablas:
consola += tabla + "\n"
elif isinstance(nodo, SDropTable):
print("Drop table-----------")
bandera = True
for fk in listaFK:
if fk.idtlocal == nodo.id:
bandera = False
if bandera:
b = jBase.dropTable(useActual, nodo.id)
if b == 0:
base = tablaSimbolos.get(useActual)
if base.deleteTable(nodo.id) == True:
consola += "La tabla " + nodo.id + " de la base " + useActual + " se eliminó con éxito. \n"
else:
consola += "Error no se pudo eliminar la tabla " + nodo.id + " de la tabla de simbolos \n"
elif b == 2:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"Error la base de datos " + useActual +
" no existe, No se puede eliminar la tabla " +
nodo.id))
elif b == 3:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico", "Error la tabla " + nodo.id +
" no existe en la base de datos " + useActual))
elif b == 1:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"Error en la operacion."))
else:
consola += "No se puede eliminar la tabla debido a que esta siendo referenciada por una llave foranea \n"
elif isinstance(nodo, SAlterTableRenameColumn):
print("Cambiando nombre columna---")
AlterRenameColumn(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterRenameTable):
AlterRenameTable(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTableAddColumn):
print("Agregando Columna-----")
AlterAddColumn(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTableCheck):
print("Agregando check--------")
AlterTableCheck(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTableAddUnique):
print("Agregando unique-------")
AlterTableUnique(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTableAddFK):
print("Agregando llave foranea--------")
AlterTableFK(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTable_AlterColumn):
print("Alter column--------------")
print(nodo.idtabla)
for col in nodo.columnas:
print(col.idcolumna)
elif isinstance(nodo, SAlterTableDrop):
print("Alter drop----------")
print(nodo.idtabla)
print("Es un constraint?")
print(nodo.idco)
elif isinstance(nodo, SCrearTabla):
crearTabla(nodo, tablaSimbolos)
# FRANCISCO
elif isinstance(nodo, Squeries):
print("Entró a Query")
if nodo.ope == False:
print("Query Simple")
if isinstance(nodo.query1, SQuery):
Qselect = nodo.query1.select
Qffrom = nodo.query1.ffrom
Qwhere = nodo.query1.where
Qgroupby = nodo.query1.groupby
Qhaving = nodo.query1.having
Qorderby = nodo.query1.orderby
Qlimit = nodo.query1.limit
# SELECT
if isinstance(Qselect, SSelectCols):
print("Entro a Select")
# Distinct
if Qselect.distinct != False:
print("Distinct True")
# Cantidad de columnas
if Qselect.cols == "*":
print("Todas las Columnas")
else:
print("Columnas Específicas")
for col in Qselect.cols:
##LISTAS
if isinstance(col.cols, SExpresion):
print("Expre")
print(col.cols.valor)
# print("Tipo")
# print(col.cols.tipo)
elif isinstance(col.cols, SOperacion):
print("Operación")
if isinstance(col.cols.opIzq, SExpresion):
print(col.cols.opIzq.valor)
print(col.cols.operador)
print(col.cols.opDer.valor)
##FUNCIONES DE AGREGACION
elif isinstance(col.cols, SFuncAgregacion):
print("Funcion Agregación:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("val")
print(col.cols.param.valor)
else:
print("val")
print(col.cols.param)
##FUNCIONES MATH
elif isinstance(col.cols, SFuncMath):
print("Funcion Math:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("param")
print(col.cols.param.valor)
else:
print("param")
print(col.cols.param)
elif isinstance(col.cols, SFuncMath2):
print("Funcion Math2:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param2.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.param2)
elif isinstance(col.cols, SFuncMathSimple):
print("Funcion MathSimple:")
print(col.cols.funcion)
##FUNCIONES TRIG
elif isinstance(col.cols, SFuncTrig):
print("Funcion Trig1:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("param")
print(col.cols.param.valor)
else:
print("param")
print(col.cols.param)
elif isinstance(col.cols, SFuncTrig2):
print("Funcion Trig2:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param2.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.param2)
##FUNCIONES BINARIAS
elif isinstance(col.cols, SFuncBinary):
print("Funcion Binaria1:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("param")
print(col.cols.param.valor)
else:
print("param")
print(col.cols.param)
elif isinstance(col.cols, SFuncBinary2):
print("Funcion Binaria2:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param2.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.param2)
elif isinstance(col.cols, SFuncBinary3):
print("Funcion Binaria3:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param.det)
print(col.cols.param2.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.det)
print(col.cols.param2)
elif isinstance(col.cols, SFuncBinary4):
print("Funcion Binaria4:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param2.valor)
print(col.cols.param3.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.param2)
print(col.cols.param3)
# EXTRACT
elif isinstance(col.cols, SExtract):
print("Funcion Extract:")
if isinstance(col.cols.field, STipoDato):
print(col.cols.field.dato)
print(col.cols.field.tipo)
print(col.cols.field.cantidad)
print(col.cols.timestampstr)
elif isinstance(col.cols, SExtract2):
print("Funcion Extract2:")
if isinstance(col.cols.field, STipoDato):
print(col.cols.field.dato)
print(col.cols.dtype.dato)
if isinstance(col.cols.timestampstr,
SExpresion):
print("param")
print(col.cols.timestampstr.valor)
# FUNCIONES DE FECHA
elif isinstance(col.cols, SSelectFunc):
print("Funcion getFecha:")
print(col.cols.id)
elif isinstance(col.cols, SFechaFunc):
print("Funcion Fecha:")
if isinstance(col.cols.param, STipoDato):
print(col.cols.param.valor)
print(col.cols.param2.valor)
else:
print(col.cols.param)
print(col.cols.param2)
elif isinstance(col.cols, SFechaFunc2):
print("Funcion Fecha2:")
print(col.cols.id)
print(col.cols.param)
print(col.cols.tipo)
print(col.cols.param2)
# CASE
elif isinstance(col.cols, SCase):
print("Funcion Case:")
if isinstance(col.cols.casos, SCaseList):
print(col.cols.casos.param)
print(col.cols.casos.param2)
print(col.cols.casos.clist)
elif isinstance(col.cols, SCaseElse):
print("Funcion CaseElse:")
if isinstance(col.cols.casos, SCaseList):
print(col.cols.casos.param)
print(col.cols.casos.param2)
print(col.cols.casos.clist)
print(col.cols.casoelse)
# OTRAS FUNCIONES
elif isinstance(col.cols, SColumnasSubstr):
print("Funcion Substr:")
print(col.cols.st)
print(col.cols.st2)
print(col.cols.st3)
elif isinstance(col, SColumnasGreatest):
print("Funcion Greatest:")
print(col.cols)
elif isinstance(col.cols, SColumnasLeast):
print("Funcion Least:")
print(col.cols)
else:
print("Otro")
print(col.cols)
# ALIAS
if col.id != False:
if isinstance(col.id, SExpresion):
print("Alias")
print(col.id.valor)
# FROM
if isinstance(Qffrom, SFrom):
print("entro al From")
for col in Qffrom.clist:
if isinstance(col, SAlias):
if col.alias == False:
print("id")
print(col.id)
else:
print("id/alias")
print(col.id)
print(col.alias)
elif isinstance(Qffrom, SFrom2):
print("entro al From2")
# Subquerie
print(Qffrom.clist)
print(Qffrom.id)
else:
print("Otro From")
# WHERE
if isinstance(Qwhere, SWhere):
print("entro al Where")
for col in Qwhere.clist:
if isinstance(col, SWhereCond1):
print("Es where1")
print(col.conds)
# print(col.conds.param.opIzq.valor)
# print(col.conds.param.operador)
# print(col.conds.param.opDer.valor)
elif isinstance(col, SWhereCond2):
print("Es where2")
print(col.conds)
print(col.isnotNull)
elif isinstance(col, SWhereCond3):
print("Es where3")
print(col.conds)
print(col.directiva)
elif isinstance(col, SWhereCond4):
print("Es where4")
print(col.conds)
print(col.ffrom)
elif isinstance(col, SWhereCond5):
print("Es where5")
print(col.c1)
print(col.c2)
print(col.c3)
elif isinstance(col, SWhereCond6):
print("Es where6")
print(col.cols)
elif isinstance(col, SWhereCond7):
print("Es where7")
print(col.efunc)
print(col.qcols)
print(col.anyallsome)
print(col.operador)
elif isinstance(col, SWhereCond8):
print("Es where8")
print(col.qcols)
print(col.efunc)
elif isinstance(col, SWhereCond9):
print("Es where9")
print(col.between)
print(col.efunc)
print(col.efunc2)
else:
print("Otro Where")
# GROUP BY
if isinstance(Qgroupby, SGroupBy):
print("entro al Group By")
for col in Qgroupby.slist:
if isinstance(col, SExpresion):
print("Agrupado por")
print(col.valor)
else:
print("Agrupado por")
print(col)
# HAVING
if isinstance(Qhaving, SHaving):
print("entro al Having")
print(Qhaving.efunc)
# ORDER BY
if isinstance(Qorderby, sOrderBy):
print("entro al Order By")
for col in Qorderby.slist:
if isinstance(col, SListOrderBy):
if col.ascdesc == False and col.firstlast == False:
print("OrderBy1")
print(col.listorder)
elif col.ascdesc == False and col.firstlast != False:
print("OrderBy2")
print(col.listorder)
print(col.firstlast)
elif col.ascdesc != False and col.firstlast == False:
print("OrderBy3")
print(col.listorder)
print(col.ascdesc)
elif col.ascdesc != False and col.firstlast != False:
print("OrderBy4")
print(col.listorder)
print(col.ascdesc)
print(col.firstlast)
# LIMIT
if isinstance(Qlimit, SLimit):
print("Entro a Limit")
if isinstance(Qlimit.limit, SExpresion):
print(Qlimit.limit.valor)
else:
print(Qlimit.limit)
if isinstance(Qlimit.offset, SExpresion):
print(Qlimit.offset.valor)
else:
print(Qlimit.offset)
else:
print("Query anidada")
for i in listaSemanticos:
print(i)
return consola
def ejecutar(self, ent):
DBMS.dropAll()
return "Instrucción Drop All ejecutado con exito"
def __init__(self,entorno):
self.entorno=entorno
jsonMode.dropAll()
variables.consola.delete("1.0", "end")
variables.consola.configure(state='normal')
from storageManager import jsonMode as j
import time
j.dropAll() #limpieza de todos los datos
inicio = time.time()
#Area para crear bases de datos
print("Estado BD:", j.createDatabase("BD1")) #Sistema de Asignaciones
print("Estado BD:", j.createDatabase("BD2")) #Sistema de Compras de productos
print("Estado BD:", j.createDatabase(
"BD3")) #Sistema de Accesos de usuario para una base de datos
print("Estado BD:", j.createDatabase(
"BD4")) #Sistema de Peliculas y Series para una pagina web
print("Estado BD:",
j.showDatabases()) #Nos deberia mostrar todas las bases de datos
#Area para crear tablas
'Creamos Tablas Estudiante, Periodo, Año, Asignacion, Curso, Asignacion_Curso'
print("---------Creamos Tabla Estudiante---------")
print("Estado Tabla:", j.createTable("BD1", "Estudiante", 8))
print("Estado PKS:", j.alterAddPK("BD1", "Estudiante", [0]))
print("Estado Inserts", j.loadCSV("./BD1/Estudiantes.csv", "BD1",
"Estudiante"))
print("---------Creamos Tabla Periodo---------")
print("Estado Tabla:", j.createTable("BD1", "Periodo", 2))
print("Estado PKS:", j.alterAddPK("BD1", "Periodo", [0]))
print("Estado Inserts", j.loadCSV("./BD1/Periodo.csv", "BD1", "Periodo"))
print("---------Creamos Tabla Año---------")
print("Estado Tabla:", j.createTable("BD1", "Year", 2))
import sys
sys.path.append('../G26/Instrucciones')
sys.path.append('../G26/Librerias')
sys.path.append('../G26/Utils')
sys.path.append('../G26')
import gramatica as g
import Instrucciones.DML.select as select
import Instrucciones.DDL.show as show
from storageManager import jsonMode as storage
import Lista as l
from Error import *
eel.init('client')
storage.dropAll()
datos = l.Lista({}, '')
@eel.expose
def analize(texto):
global datos
instrucciones = g.parse(texto)
for instr in instrucciones['ast']:
if instr != None:
result = instr.execute(datos)
if isinstance(result, Error):
eel.printText(str(result))
elif isinstance(instr, select.Select) or isinstance(
