def EObtenerTabla():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
get_tb = listaMemoria[0]
result = EDD.showTables(get_tb[0])
if get_tb[1] in result:
listaMemoria.pop(0)
return True
return False
def procesar_showTables(instr,ts,tc):
print("SHOW TABLES")
global salida
dataT = []
dataTables = j.showTables(useCurrentDatabase)
dataT.append(['tables'])
for tables in dataTables:
dataT.append([tables])
if dataTables == []:
salida = "\nERROR: Tables does not exist \nSQL state: 3D000"
else:
salida = dataT
def ejecutar(self, ent):
variables.consola.insert(INSERT,"Ejecutando Show Tables para la base de datos: "+self.id+" \n")
resultado = DBMS.showTables(self.id)
if(resultado==None):
variables.consola.insert(INSERT,"ERROR >> En la instrucción Show Tables("+self.id+"), base de datos: "+self.id+" NO existe\n")
reporteerrores.append(Lerrores("Error Semántico","En la instrucción Show Tables("+self.id+"), base de datos: "+self.id+" NO existe","",""))
else:
variables.x.title="DB: "+self.id
variables.x.add_column("Tables",resultado)
variables.consola.insert(INSERT,variables.x)
variables.x.clear()
variables.consola.insert(INSERT,"\n")
return "Show Tables Exitoso"
def cmd_showTables(self, database):
condb.showTables(database)
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
print(j.showDatabases())
# drop db3 and db1, return two 0's
print(j.dropDatabase("db3"))
print(j.dropDatabase("db1"))
# show empty-list of databases
print(j.showDatabases())
# again create db1 and db2, return two 0's and show return list of databases
print(j.createDatabase("db1"))
print(j.createDatabase("db2"))
print(j.showDatabases())
# create two table in db1 and show return tables list of db1 database
print(j.createTable("db1", "table1", 5))
print(j.createTable("db1", "table2", 8))
print(j.showTables("db1"))
# rename table1 to table 3 and show return tables list of db1 database
print(j.alterTable("db1", "table1","table3"))
print(j.showTables("db1"))
# drop table3 of db1 and show return tables list of db1 database
print(j.dropTable("db1", "table3"))
print(j.showTables("db1"))
# drop db1 with tables, first return 0 and second return None
print(j.dropDatabase("db1"))
print(j.showTables("db1"))
print("---------Creamos Tabla Acceso---------")
print("Estado Tabla:", j.createTable("BD3", "Acceso", 2))
print("Estado PKS:", j.alterAddPK("BD3", "Acceso", [0, 1]))
print("Estado Inserts", j.loadCSV("./BD3/Acceso.csv", "BD3", "Acceso"))
'Creamos tablas para sistema de peliculas y series'
print("---------Creamos Tabla Pelicula---------")
print("Estado Tabla:", j.createTable("BD4", "Pelicula", 5))
print("Estado Inserts", j.loadCSV("./BD4/Pelicula.csv", "BD4", "Pelicula"))
print("---------Creamos Tabla Serie---------")
print("Estado Tabla:", j.createTable("BD4", "Serie", 5))
print("Estado PKS:", j.alterAddPK("BD4", "Serie", [0]))
print("Estado Inserts", j.loadCSV("./BD4/Serie.csv", "BD4", "Serie"))
print("---------Creamos Tabla Capitulo---------")
print("Estado Tabla:", j.createTable("BD4", "Capitulo", 5))
print("Estado Inserts", j.loadCSV("./BD4/Capitulo.csv", "BD4", "Capitulo"))
print(
"------------------Listado de Tablas de las bases de datos-----------------------"
)
print("Tablas de BD1:", j.showTables("BD1"))
print("Tablas de BD2:", j.showTables("BD2"))
print("Tablas de BD3:", j.showTables("BD3"))
print("Tablas de BD4:", j.showTables("BD4"))
final = time.time()
print("------------------------------------------------------------------")
print("Tiempo de Ejecucion:", final - inicio, "segundos")
# test Databases CRUD
print(j.createDatabase('db1')) # 0
print(j.createDatabase('db1')) # 2
print(j.createDatabase('db4')) # 0
print(j.createDatabase('db5')) # 0
print(j.createDatabase(0)) # 1
print(j.alterDatabase('db5', 'db1')) # 3
print(j.alterDatabase('db5', 'db2')) # 0
print(j.dropDatabase('db4')) # 0
print(j.showDatabases()) # ['db1','db2']
# test Tables CRUD
print(j.createTable('db1', 'tb4', 3)) # 0
print(j.createTable('db1', 'tb4', 3)) # 3
print(j.createTable('db1', 'tb1', 3)) # 0
print(j.createTable('db1', 'tb2', 3)) # 0
print(j.alterTable('db1', 'tb4', 'tb3')) # 0
print(j.dropTable('db1', 'tb3')) # 0
print(j.alterAddPK('db1', 'tb1', 0)) # 1
print(j.alterAddPK('db1', 'tb1', [0])) # 0
print(j.showTables('db1')) # ['tb1', 'tb2']
# test Registers CRUD
print(j.insert('db1', 'tb1', [1, 1])) # 5
print(j.insert('db1', 'tb1', ['1', 'line', 'one'])) # 0
print(j.loadCSV('tb1.csv', 'db1', 'tb1')) # [0, 0, 0, 0, 0]
print(j.extractTable('db1', 'tb1'))
# [['1', 'line', 'one'], ['2', 'line', 'two'],
# ['3', 'line', 'three'], ['4', 'line', 'four'],
# ['5', 'line', 'five'], ['6', 'line', 'six']]
