def resultupdate(self, result, nomresult, DB, llaves):
if not len(result) > 0:
return (
"En la instrucción Delete no hay registros que cumplan la expresión"
)
else:
if not len(llaves) > 0:
columnas = len(self.encabezado)
DBMS.dropTable(DB, nomresult)
DBMS.createTable(DB, nomresult, columnas)
for x in range(0, len(result)):
DBMS.insert(DB, nomresult, result[x])
self.encabezado.clear()
variables.consola.insert(
INSERT, "La instrucción UPDATE se realizó exitosamente \n")
return "La instrucción UPDATE se realizó exitosamente"
else:
columnas = len(self.encabezado)
DBMS.dropTable(DB, nomresult)
DBMS.createTable(DB, nomresult, columnas)
DBMS.alterAddPK(DB, nomresult, llaves)
for x in range(0, len(result)):
DBMS.insert(DB, nomresult, result[x])
self.encabezado.clear()
variables.consola.insert(
INSERT, "La instrucción UPDATE se realizó exitosamente \n")
return "La instrucción UPDATE se realizó exitosamente"
def EDropTable():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
drop_tb = listaMemoria[0]
EDD.dropTable(drop_tb[0], drop_tb[1])
print("tabla eliminada: ", drop_tb[1])
listaMemoria.pop(0)
def ejecutar(self, ts):
if DB_ACTUAL.getName() == None:
return ErrorReport('Semantico', 'Not defined database to used', 0)
elif not TRef.databaseExist(DB_ACTUAL.getName()):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_invalid_schema_name.invalid_schema_name), 0)
elif TRef.tableExist(DB_ACTUAL.getName(), self.tabla):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.undefined_table), 0)
DBMS.dropTable(DB_ACTUAL.getName(), self.tabla)
TRef.dropTable(DB_ACTUAL.getName(), self.tabla)
return 'Successful table dropped'
def execute(self, environment):
if not isinstance(self.tableName,str):
return {'Error': 'El nombre indicado de la tabla no es una cadena.', 'Fila':self.row, 'Columna': self.column }
name = environment.getActualDataBase()
result = 4
result = admin.dropTable(name, self.tableName)
if result == 0:
database = environment.readDataBase(name)
table = database.getTable(self.tableName)
if table == None:
return {'Error':'Ocurrió un error en la metadata, la tabla' + self.tableName + ' no pudo ser Eliminada.', 'Fila':self.row, 'Columna':self.column}
database.deleteTable(self.tableName)
#metodo para verificar si existe la tabla en la base de datos
# si existe la tabla, metodo para verificar que la tabla no sea llave foranea de otra tabla
# si no es llave foranea, elimnar la tabla
return 'La Tabla ' + self.table + ' ha sido eliminada con éxito.'
elif result == 1:
#Error al crear
return {'Error':'Ocurrió un error en el storage manager Tabla' + self.tableName + ' no pudo ser Eliminada.', 'Fila':self.row, 'Columna':self.column}
elif result == 2:
#Error al crear
return {'Error':'Base de datos' + name + ' no existe.', 'Fila':self.row, 'Columna':self.column}
elif result == 3:
#Error al crear
return {'Error':'La tabla: ' + self.tableName + ' no existe en la base de datos: '+name, 'Fila':self.row, 'Columna':self.column}
elif result == 4:
#Error al crear
return {'Error':'Error desconocido al intentar eliminar la tabla: '+self.tableName, 'Fila':self.row, 'Columna':self.column}
def deleteTable(self, database: Database, name: str, line, column):
"""
Method to remove a table in database
:param database: Table database
:param name: The name of table
:param line: The instruction line
:param column: The instruction column
:return: Returns nothing
"""
dbStatement = jsonMode.dropTable(database.name, name)
if dbStatement == 0:
table = self.searchTable(database, name)
database.tables.remove(table)
self.writeFile()
print('Table deleted successfully')
elif dbStatement == 1:
desc = f": Can't drop table {name}"
ErrorController().addExecutionError(34, 'Execution', desc, line,
column)
elif dbStatement == 2:
desc = f": Database {database.name} does not exist"
ErrorController().addExecutionError(35, 'Execution', desc, line,
column)
elif dbStatement == 3:
desc = f": Table {name} does not exist"
ErrorController().addExecutionError(27, 'Execution', desc, line,
column)
def ejecutar(self, ent: Entorno):
if (ent.getDataBase() == None):
variables.consola.insert(
INSERT, "ERROR >> En la instrucción Drop Table " + self.id +
", actualmente no hay ninguna base de datos en uso\n")
reporteerrores.append(
Lerrores(
"Error Semántico",
"En la instrucción Drop Table " + self.id +
", actualmente no hay ninguna base de datos en uso", "",
""))
else:
resultado = DBMS.dropTable(ent.getDataBase(), self.id)
if (resultado == 0):
ent.eliminarSimbolo(self.id + "_" + ent.getDataBase())
ent.eliminarSymTabla(self.id)
variables.consola.insert(
INSERT, "La tabla: (" + self.id +
") ha sido eliminada con exito\n")
else:
variables.consola.insert(
INSERT, "ERROR >> En la instrucción Drop Table " +
self.id + ", La tabla a eliminar NO EXISTE\n")
reporteerrores.append(
Lerrores(
"Error Semántico", "En la instrucción Drop Table " +
self.id + ", La tabla a eliminar NO EXISTE", "", ""))
def ejecutar(self, ent:Entorno):
if (ent.getDataBase()==None):
return "ERROR >> En la instrucción Drop Table "+self.id+", actualmente no hay ninguna base de datos en uso"
else:
resultado = DBMS.dropTable(ent.getDataBase(),self.id)
if (resultado==0):
ent.eliminarSimbolo(self.id+"_"+ent.getDataBase())
return "La tabla: ("+self.id+") ha sido eliminada con exito"
else:
return "ERROR >> En la instrucción Drop Table "+self.id+", La tabla a eliminar NO EXISTE"
def resultdelete(self,result,nomresult,DB):
if not len(result)>0:
return ("En la instrucción Delete no hay registros que cumplan la expresión")
else:
columnas = len(self.encabezados)
print(DBMS.dropTable(DB, nomresult))
print(DBMS.createTable(DB, nomresult, columnas))
for x in range(0,len(result)):
DBMS.insert(DB,nomresult,result[x])
self.encabezados.clear()
return "La instrucción DELETE se realizó exitosamente"
def procesar_drop(instr,ts,tc):
if instr.lista_ids != []:
for datos in instr.lista_ids:
#print(datos.id)
result = j.dropTable(str(useCurrentDatabase),str(datos.id))
global salida
if result == 0:
global salida
salida = "\nDROP TABLE"
ts.deleteDatabase(datos.id)
tc.eliminarTabla(useCurrentDatabase,datos.id)
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result == 2 :
salida = "\nERROR: database \"" + str(useCurrentDatabase) +"\" does not exist \nSQL state: 3D000"
elif result == 3 :
salida = "\nERROR: table \"" + str(datos.id) +"\" does not exist \nSQL state: 42P01"
def eliminarTabla(self, nodo):
tb_name = nodo.valor
result = jsonMode.dropTable(self.usingDB, tb_name)
if result == 0: # Operación exitosa
self.output.append('Eliminación de tabla \"' + tb_name +
'\" exitosa.')
database = self.ts[self.usingDB]
del database.tables[tb_name]
elif result == 1: # Error en la operación
self.errors.append(
Error('XX000', EType.SEMANTICO, 'internal_error', nodo.linea))
elif result == 2: # Base de datos no existe
self.errors.append(
Error('-----', EType.SEMANTICO, 'database_non_exist',
nodo.linea))
elif result == 3: # Tabla no existe
self.errors.append(
Error('42P01', EType.SEMANTICO, 'undefined_table', nodo.linea))
def execute(self, environment):
if (self.structure == "TABLE"):
if dbtemp != "":
valor = jsonMode.dropTable(dbtemp, self.name)
if valor == 2:
return "La base de datos no existe"
if valor == 3:
return "La tabla no existe en la base de datos"
if valor == 1:
return "Hubo un problema en la ejecucion de la sentencia"
if valor == 0:
return "Instruccion ejecutada con exito"
return "El nombre de la base de datos no esta especificado operacion no realizada"
else:
valor = jsonMode.dropDatabase(self.name)
if valor == 1:
return "Hubo un problema en la ejecucion de la sentencia"
if valor == 2:
return "La base de datos no existe"
if valor == 0:
return "Instruccion ejecutada con exito"
def cmd_dropTable(self, database, table):
if existeTabla(table, database) == 1:
self.tabla.eliminarTS_Tabla(database, table)
condb.dropTable(database, table)
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"))
# 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']]