def execute(self):
lista = []
if self.like != None:
for l in jsonMode.showDatabases():
if self.like in l[1:len(l) - 1]:
lista.append(l)
else:
lista = jsonMode.showDatabases()
if len(lista) == 0:
print("No hay bases de datos")
else:
return lista
def ejecutar(self, ent: Entorno):
bases = DBMS.showDatabases()
for db in bases:
if db == self.id:
ent.database = id
#print(ent.database)
return
def ejecutar(self,ts):
if TRef.databaseExist(self.nombre):
if not self.existencia:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_database), 0)
exito = 0
databases = DBMS.showDatabases()
if self.reemplazo:
if self.nombre in databases: #Eliminamos si existe
DBMS.dropDatabase(self.nombre)
TRef.dropDatabase(self.nombre)
exito = DBMS.createDatabase(self.nombre)
elif self.existencia:
if not self.nombre in databases:
exito = DBMS.createDatabase(self.nombre)
else:
exito = DBMS.createDatabase(self.nombre)
#Si tenemos exito se crea en el type reference
if exito == 1:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_schema_definition), 0)
elif exito == 2:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_database), 0)
TRef.createDatabase(self.nombre, self.modo)
return "Database '" + self.nombre + "' succesful created"
def ejecutar(self, ent):
data = DBMS.showDatabases()
variables.consola.insert(INSERT, "Ejecutando Show Databases \n")
variables.x.add_column("Databases", data)
variables.consola.insert(INSERT, variables.x)
variables.x.clear()
variables.consola.insert(INSERT, "\n")
return "Show Databases Exitoso"
def ejecutar(self, ent):
self.traducir(ent)
data = DBMS.showDatabases()
variables.consola.insert(INSERT, "Ejecutando Show Databases \n")
variables.x.add_column("Databases", data)
variables.consola.insert(INSERT, variables.x)
variables.x.clear()
variables.consola.insert(INSERT, "\n")
variables.consola.insert(INSERT, 'Show database Exitoso\n')
return
def procesar_showDatabases(instr,ts,tc):
global salida
data = []
dataTables = j.showDatabases()
data.append(['databases'])
for databases in dataTables:
data.append([databases])
if dataTables == []:
salida = "\nERROR: databases does not exist \nSQL state: 3D000"
else:
salida = data
def showDatabase(self, like: str = ''):
query_result = jsonMode.showDatabases()
if like == '':
self.salida.append(query_result)
else:
pattern = '^' + like.replace('%','.+').replace('_','(.){0,1}') + '$'
filtrada = []
for base in query_result:
if re.match(pattern, base):
filtrada.append(base)
self.salida.append(filtrada)
self.consola.append(Codigos().successful_completion('SHOW DATABASE'))
def ejecutar(self, ent: Entorno):
bases = DBMS.showDatabases()
existe = False
for db in bases:
if db == self.id:
ent.database = self.id
existe = True
break
if existe:
return "Base de datos: " + ent.database + " en uso actualmente"
else:
return "ERROR >> En la instrucción Use " + self.id + ", La base de datos a utilizar NO EXISTE"
def ejecutar(self,ts):
exito = 0
databases = DBMS.showDatabases()
if self.reemplazo:
if self.nombre in databases: #Eliminamos si existe
DBMS.dropDatabase(self.nombre)
exito = DBMS.createDatabase(self.nombre)
elif self.existencia:
if not self.nombre in databases:
exito = DBMS.createDatabase(self.nombre)
else:
exito = DBMS.createDatabase(self.nombre)
return exito
def ejecutar(self, ent: Entorno):
self.traducir(ent)
bases = DBMS.showDatabases()
existe = False
for db in bases:
if db == self.id:
ent.database = self.id;
existe = True
break
if existe:
variables.consola.insert(INSERT, "Base de datos: " + ent.database + " en uso actualmente\n")
return
else:
return "ERROR >> En la instrucción Use " + self.id + ", La base de datos a utilizar NO EXISTE"
def getTextDotShowDB(self,padre,instr):
global contador,TextDot
contador = contador+1
TextDot.node("node"+str(contador),"SHOW DATABASES")
TextDot.edge(padre, "node"+str(contador))
aux = "node"+str(contador)
listado = EDD.showDatabases()
if not listado:
print("No hay base de datos")
else:
for val in listado:
self.getTextDotListaBD(aux,val)
print("Si hay bd")
def procesar_useDatabase(instr,ts,tc):
#print(instr.id.id)
global salida, useCurrentDatabase
encontrado = False
dataTables = j.showDatabases()
for databases in dataTables:
if databases == instr.id.id:
encontrado = True
if encontrado:
global salida, useCurrentDatabase
useCurrentDatabase = str(instr.id.id)
salida = "\nYou are now connected to database \"" + str(instr.id.id) +"\""
else:
salida = "\nERROR: database \"" + str(instr.id.id) +"\" does not exist \nSQL state: 3D000"
useCurrentDatabase = ""
def execute(self, environment):
result = admin.showDatabases() #<---------------------------
if not isinstance(result, list):
return {
'Error':
'La funcion showdatabase(), no retorna un objeto lista',
'Fila': self.row,
'Columna': self.column
}
if len(result) == 0:
#Se elimino correctamente la base de datos
return 'No hay bases de datos para mostrar, ya sea porque no existe ninguna base de datos o porque ocurrio un error desconocido'
else:
x = PrettyTable()
x.add_column("bases", result)
#print(x.get_string())
return x.get_string()
def showDB(self, nodo):
query_result = jsonMode.showDatabases()
er = ''
veces_mod = 0
pos_mod1 = 0
pos_mod2 = 0
if nodo.valor == '':
self.output.append(query_result)
else:
er = nodo.valor
er = '^' + er.replace('%', '.+').replace('_', '(.){0,1}') + '$'
# if pos_mod1 == 1 and veces_mod == 1:
filtrada = []
for base in query_result:
if re.match(er, base):
filtrada.append(base)
# print("====================================")
self.output.append(filtrada)
# JSON Mode Test File
# Released under MIT License
# Copyright (c) 2020 TytusDb Team
from storageManager import jsonMode as j
# create db1 and db2, return two 0's and show return list
print(j.createDatabase("db1"))
print(j.createDatabase("db2"))
print(j.showDatabases())
# try create db1 and db2, return error value 2 and show return list
print(j.createDatabase("db1"))
print(j.createDatabase("db2"))
print(j.showDatabases())
# rename db1 to db3, return 0 and show return list
print(j.alterDatabase("db1", "db3"))
print(j.showDatabases())
# rename db2 to db1, return 0 and show return list
print(j.alterDatabase("db2", "db1"))
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())
def procesar_showdb(query,ts):
h.textosalida+="TYTUS>> Bases de datos existentes\n"
print(store.showDatabases())
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))
def showDB(database: str):
resultado = manager.showDatabases()
print(resultado)
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 procesar_showdb(query,ts):
h.textosalida+="TYTUS>> "+str(store.showDatabases())+"\n"
def procesar_showdb(query, ts):
print("entra a Show BD")
print("entra al print con: ", query.variable)
h.textosalida += "TYTUS>> Bases de datos existentes\n"
print(store.showDatabases())
# File: JSON Mode Test File for EDD
# License: Released under MIT License
# Notice: Copyright (c) 2020 TytusDB Team
# Developer: Luis Espino
from storageManager import jsonMode as j
# assume no data exist or execute the next optional drop function
j.dropAll()
# test Databases CRUD
print(j.createDatabase('b1')) # 0
print(j.createDatabase('b1')) # 2
print(j.createDatabase('b4')) # 0
print(j.createDatabase('b5')) # 0
print(j.createDatabase(0)) # 1
print(j.alterDatabase('b5', 'b1')) # 3
print(j.alterDatabase('b5', 'b2')) # 0
print(j.dropDatabase('b4')) # 0
print(j.showDatabases()) # ['b1','b2']
from storageManager import jsonMode as j
# assume no data exist or execute the next drop function
j.dropAll()
# 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
def cmd_showDatabases(self):
EDDResp.showdatabase(condb.showDatabases())
def cmd_showDatabases(self):
mc.listadoResp = condb.showDatabases()
print(mc.listadoResp)
EDDResp.showdatabase(condb.showDatabases())
def ejecutar(self, ent):
print("---------------")
DBMS.showDatabases()
