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 EAddPK():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
crear_tabla = listaMemoria[0]
if (len(crear_tabla[2]) > 0):
EDD.alterAddPK(crear_tabla[0], crear_tabla[1], crear_tabla[2])
print("\tllave primaria:", crear_tabla[2])
listaMemoria.pop(0)
def EAltTbAlterAddConstPrim():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
res = EDD.alterAddPK(listaMemoria[0][0], listaMemoria[0][1],
[listaMemoria[0][2]])
print("Agregando en Tabla:" + listaMemoria[0][1])
print("\tADD Primary Key:" + listaMemoria[0][3])
print("\tResultado de la creacion de primary key:" + str(res))
listaMemoria.pop(0)
def procesar_createTable(instr,ts,tc) :
global pks
columns = []
i = 0
if instr.instrucciones != []:
global salida
for ins in instr.instrucciones:
if isinstance(ins, Definicion_Columnas):
i+=1
columns.append(i)
procesar_Definicion(ins,ts,tc,instr.id)
elif isinstance(ins, LLave_Primaria):
procesar_primaria(ins,ts,tc,instr.id)
elif isinstance(ins, Definicon_Foranea):
procesar_Foranea(ins,ts,tc,instr.id)
elif isinstance(ins, Lista_Parametros):
procesar_listaId(ins,ts,tc,instr.id)
elif isinstance(ins, definicion_constraint):
procesar_constraint(ins,ts,tc,instr.id)
try:
result = j.createTable(str(useCurrentDatabase),str(instr.id),int(len(columns)))
if result == 0:
salida = "\nCREATE TABLE"
temp1 = TS.Simbolo(str(instr.id),'Table',int(len(columns)),str(useCurrentDatabase))
ts.agregar(temp1)
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result == 2 :
salida = "\nERROR: database \"" + useCurrentDatabase +"\" does not exist \nSQL state: 3D000"
elif result == 3 :
salida = "\nERROR: relation \"" + str(instr.id) +"\" alredy exists\nSQL state: 42P07"
except :
pass
try:
print(pks)
result = j.alterAddPK(str(useCurrentDatabase),str(instr.id),pks)
pks = []
print(pks)
except :
pass
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
print(j.extractTable('compiladores2', 'USUARIO'))
# create database
j.createDatabase('world')
j.createTable('world', 'cities', 4)
# create simple primary keys
j.alterAddPK('world', 'cities', [0])
# 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'])
# show all datap
print(j.extractTable('world', 'cities')) #SELECT
print(j.update('world', 'cities', {
1: 'Mexico',
3: 'MX'
}, [1]))
print(j.extractTable('world', 'cities')) #SELECT
def cmd_alterAddPK(self, database, table, columns):
if existeTabla(table, database) == 1:
EDDResp.alterAddPK(condb.alterAddPK(database, table, columns))
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'])
# inser data in languages
j.insert('world', 'languages', ['GTM', 'Spanish', 'official', 64.7])
def execute(self, environment):
if not isinstance(self.table,str):
return {'Error': 'El nombre indicado de la tabla no es una cadena.', 'Fila':self.row, 'Columna': self.column }
columnas = []
restricciones = []
for column in self.fields:
if isinstance(column,Column):
columnas.append(column)
else:
restricciones.append(column)
for i in range(len(columnas)):
if i+1 < len(columnas):
for j in range(i+1, len(columnas)):
if columnas[i].name == columnas[j].name:
return {'Error': 'El nombre de columna ya está siendo utilzado' , 'Fila':self.row, 'Columna': self.column}
name = environment.getActualDataBase()
result = 3
result = admin.createTable(name, self.table, len(columnas))
if result == 0:
#Se creo la tabla en la base de datos correctamente.
#Creo una nueva database en la metadata
database = environment.readDataBase(name)
#Creo una nueva tabla con el nombre solicitado
newTable = Table(self.table,columnas,restricciones)
#Agrego a la tabla las columnas pertenecientes a la misma
primaryKeys = []
ids = []
for const in newTable.constraint:
if const['type'] == "primary":
ids.append(const['value'])
for index in range(len(newTable.columns)):
for id in ids:
if newTable.columns[index].name == id:
primaryKeys.append(index)
#Agrego la nueva tabla a la base de datos.
database.addTable(newTable)
create = admin.alterAddPK(name,self.table,primaryKeys)
if (create == 0):
return('Llave primaria agregada exitosamenta a la tabla' + self.table )
elif (create == 1):
return {'Error':'Tabla ' + self.table + ' creada, pero ocurrio un error al ingresar llaves primarias', 'Fila':self.row, 'Columna':self.column}
elif (create == 2):
return {'Error':'No se encontro la Base de datos, en agregar tabla', 'Fila':self.row, 'Columna':self.column}
elif (create == 3):
return {'Error':'No se pudo agregar llaves pirmarias a '+ self.table + ', Tabla no existente', 'Fila':self.row, 'Columna':self.column}
elif (create == 4):
return {'Error':'Llave Primaria ya existente en Tabla ' + self.table, 'Fila':self.row, 'Columna':self.column}
elif (create == 5):
return {'Error':'Columnas fuera del límites', 'Fila':self.row, 'Columna':self.column}
return 'La Tabla ' + self.table + ' ha sido creada con éxito.'
elif result == 1:
#Error al crear
return {'Error':'Ocurrió un error en el storage manager Tabla' + self.table + ' no pudo ser creada.', 'Fila':self.row, 'Columna':self.column}
elif result == 2:
#Error al crear
return {'Error':'Tabla' + self.table + ' no se encuentra en la base de datos.', 'Fila':self.row, 'Columna':self.column}
elif result == 3:
#Error al crear
return {'Error':'Tabla' + self.table + 'ya existente, no pudo ser creada.', 'Fila':self.row, 'Columna':self.column}
def ejecutar(self, ent: Entorno):
dbActual = ent.getDataBase()
if dbActual != None:
tam = len(self.listaDef)
nuevaTabla = Simbolo(TipoSimbolo.TABLA, (self.id + "_" + dbActual))
listaColumnas = []
listaAtrCol = []
hayPrimaria = False
hayForanea = False
primariaAdd: Primaria = None
foraneaAdd: Foranea = None
inicioHerencia = 0
if self.herencia != None:
r: Simbolo = ent.buscarSimbolo(self.herencia + "_" + dbActual)
if r != None:
for colPadre in r.valor:
listaColumnas.append(colPadre)
if colPadre.atributos.get('primary') != None:
coPrimary: Simbolo = ent.buscarSimbolo(
colPadre.atributos.get('primary'))
if coPrimary != None:
self.listPK = coPrimary.valor
inicioHerencia = len(r.valor)
else:
variables.consola.insert(
INSERT,
"La tabla padre '" + self.herencia + "' no existe")
reporteerrores.append(
Lerrores(
"Error Semántico",
"La tabla padre '" + self.herencia + "' no existe",
"", ""))
for x in range(0, tam, 1):
tt = self.listaDef[x]
if tt.tipo == AtributosColumna.COLUMNA_SIMPLE:
nuevaColumna = Simbolo(tt.tipoDato, tt.identificador)
if tt.lista != None: #aca se mete si viene por ejemplo: columna1 integer references tabla2
tamano = len(tt.lista)
for y in range(tamano):
hayAtr = False
nuevoSym = Simbolo("tipo", "nombre")
nuevoSym.baseDatos = dbActual
nuevoSym.tabla = self.id
atrColumna: Atributo = tt.lista[y]
if atrColumna.tipo == AtributosColumna.UNICO:
hayAtr = True
nuevoSym.tipo = TipoSimbolo.CONSTRAINT_UNIQUE
if atrColumna.valor != None: #forma de: constraint id UNIQUE
#formato de nombre: U_database_tabla_nombreColumna_idConstraint
nuevoSym.nombre = str("U_" + dbActual +
"_" + self.id + "_" +
tt.identificador +
"_" +
atrColumna.valor)
nuevaColumna.atributos.update({
'unique':
str("U_" + dbActual + "_" + self.id +
"_" + tt.identificador + "_" +
atrColumna.valor)
})
else:
#forma de: nombreColumna tipo UNIQUE
#formato: U_database_tabla_nombreColumna
nuevoSym.nombre = str("U_" + dbActual +
"_" + self.id + "_" +
tt.identificador)
nuevaColumna.atributos.update({
'unique':
str("U_" + dbActual + "_" + self.id +
"_" + tt.identificador)
})
nuevoSym.valor = tt.identificador
elif atrColumna.tipo == AtributosColumna.CHECK:
hayAtr = True
nuevoSym.tipo = TipoSimbolo.CONSTRAINT_CHECK
nuevoSym.valor = atrColumna.exp
if atrColumna.valor != None: #forma de: constraint id check cond < cond
#formato: C_database_tabla_nombreColumna_idConstraint
nuevoSym.nombre = str("C_" + dbActual +
"_" + self.id + "_" +
tt.identificador +
"_" +
atrColumna.valor)
nuevaColumna.atributos.update({
'check':
str("C_" + dbActual + "_" + self.id +
"_" + tt.identificador + "_" +
atrColumna.valor)
})
else:
#cuando viene: nombreColumna tipo CHECK cond < cond
#formato: C_database_tabla_nombreColumna
nuevoSym.nombre = str("C_" + dbActual +
"_" + self.id + "_" +
tt.identificador)
nuevaColumna.atributos.update({
'check':
str("C_" + dbActual + "_" + self.id +
"_" + tt.identificador)
})
elif atrColumna.tipo == AtributosColumna.DEFAULT:
nuevaColumna.atributos.update(
{'default': atrColumna.valor})
elif atrColumna.tipo == AtributosColumna.NO_NULO:
nuevaColumna.atributos.update(
{'not null': True})
elif atrColumna.tipo == AtributosColumna.NULO:
nuevaColumna.atributos.update({'null': True})
elif atrColumna.tipo == AtributosColumna.PRIMARY:
hayPrimaria = True
nuevaColumna.atributos.update({
'primary':
str("PK_" + dbActual + "_" + self.id)
}) # PK_database_tabla
elif atrColumna.tipo == AtributosColumna.REFERENCES:
rr = DBMS.extractTable(dbActual,
atrColumna.valor)
if rr == None:
return str(
"La tabla \'" + atrColumna.valor +
"\' a la que está referenciando, no existe"
)
else:
tablaReferencia: Simbolo = ent.buscarSimbolo(
atrColumna.valor + "_" + dbActual)
colRef = tablaReferencia.valor
for col in colRef:
nomConstraintPK = col.atributos.get(
'primary')
if nomConstraintPK != None:
consPK: Simbolo = ent.buscarSimbolo(
nomConstraintPK)
arrPk = consPK.valor
if len(arrPk) == 1:
if tablaReferencia.valor[arrPk[
0]].tipo.tipo == nuevaColumna.tipo.tipo:
hayForanea = True
hayAtr = True
nuevoSym.tipo = TipoSimbolo.CONSTRAINT_FOREIGN
# FK_database_tabla_tablaReferencia
nuevoSym.nombre = str(
"FK_" + dbActual +
"_" + self.id + "_" +
atrColumna.valor)
nuevaColumna.atributos.update(
{
'foreign':
str("FK_" +
dbActual +
"_" + self.id +
"_" +
atrColumna.
valor)
})
break
if not hayForanea:
variables.consola.insert(
INSERT,
"No se puede establecer llave foranea entre tabla '"
+ self.id + "' y '" +
atrColumna.valor + "'\n")
reporteerrores.append(
Lerrores(
"Error Semántico",
"No se puede establecer llave foranea entre tabla '"
+ self.id + "' y '" +
atrColumna.valor + "'", "",
""))
if hayAtr: listaAtrCol.append(nuevoSym)
listaColumnas.append(nuevaColumna)
if tt.tipo == AtributosColumna.PRIMARY:
if hayPrimaria:
variables.consola.insert(
INSERT,
str("La tabla \'" + self.id +
"\' ya contiene llave primaria declarada\n"))
reporteerrores.append(
Lerrores(
"Error Semántico", "La tabla \'" + self.id +
"\' ya contiene llave primaria declarada", "",
""))
else:
primariaAdd: Primaria = tt
if tt.tipo == AtributosColumna.REFERENCES:
if hayForanea:
variables.consola.insert(
INSERT,
str("La tabla \'" + self.id +
"\' ya contiene llave foranea declarada\n"))
reporteerrores.append(
Lerrores(
"Error Semántico", "La tabla \'" + self.id +
"\' ya contiene llave foranea declarada", "",
""))
else:
foraneaAdd: Foranea == tt
rr = DBMS.extractTable(dbActual, foraneaAdd.tabla)
if tt.tipo == AtributosColumna.CONSTRAINT:
if tt.contenido.tipo == AtributosColumna.PRIMARY:
if hayPrimaria:
variables.consola.insert(
INSERT,
str("La tabla \'" + self.id +
"\' ya contiene llave primaria declarada\n"
))
reporteerrores.append(
Lerrores(
"Error Semántico",
"La tabla \'" + self.id +
"\' ya contiene llave primaria declarada",
"", ""))
else:
primariaAdd: Primaria = tt.contenido
primariaAdd.idConstraint = tt.id
elif tt.contenido.tipo == AtributosColumna.REFERENCES:
if hayForanea:
variables.consola.insert(
INSERT,
str("La tabla \'" + self.id +
"\' ya contiene llave foranea declarada\n")
)
reporteerrores.append(
Lerrores(
"Error Semántico",
"La tabla \'" + self.id +
"\' ya contiene llave foranea declarada",
"", ""))
else:
foraneaAdd: Foranea == tt
rr = DBMS.extractTable(dbActual, foraneaAdd.tabla)
elif tt.contenido.tipo == AtributosColumna.UNICO:
listUnicas = tt.contenido.unicos
for x in listUnicas:
for col in listaColumnas:
if col.nombre == x.valor:
#formato: U_database_tabla_nombreColumna_idConstraint
col.atributos.update({
'unique':
str("U_" + dbActual + "_" + self.id +
"_" + col.nombre + "_" + tt.id)
})
sym = Simbolo(
TipoSimbolo.CONSTRAINT_UNIQUE,
str("U_" + dbActual + "_" + self.id +
"_" + col.nombre + "_" + tt.id))
ent.nuevoSimbolo(sym)
elif tt.contenido.tipo == AtributosColumna.CHECK:
#formato: C_database_tabla_nombreColumna_idConstraint
nombreColCheck = str(
tt.contenido.condiciones.exp1.valor)
for x in listaColumnas:
if x.nombre == nombreColCheck:
x.atributos.update({
'check':
str("C_" + dbActual + "_" + self.id + "_" +
x.nombre + "_" + tt.id)
})
sym = Simbolo(
TipoSimbolo.CONSTRAINT_CHECK,
str("C_" + dbActual + "_" + self.id + "_" +
x.nombre + "_" + tt.id))
sym.tabla = self.id
sym.baseDatos = dbActual
sym.valor = tt.contenido.condiciones
listaAtrCol.append(sym)
break
nuevaTabla.valor = listaColumnas
estado = DBMS.createTable(dbActual, self.id, len(listaColumnas))
if estado == 0:
nuevaTabla.baseDatos = dbActual
r = ent.nuevoSimbolo(nuevaTabla)
if r == "ok":
for x in listaAtrCol:
ent.nuevoSimbolo(x)
alreadyPrimary = False
for x in range(inicioHerencia, len(listaColumnas), 1):
if not alreadyPrimary:
pk = listaColumnas[x].atributos.get('primary')
if pk != None:
self.listPK.append(x)
rrr = DBMS.alterAddPK(dbActual, self.id,
self.listPK)
if rrr != 0:
variables.consola.insert(
INSERT,
"No se ha podido agregar PK en tabla \'"
+ self.id + "\'\n")
reporteerrores.append(
Lerrores(
"Error Semántico",
"No se ha podido agregar PK en tabla \'"
+ self.id + "'", "", ""))
else:
alreadyPrimary = True
sym1 = Simbolo(
TipoSimbolo.CONSTRAINT_PRIMARY,
str("PK_" + dbActual + "_" + self.id))
sym1.valor = self.listPK
sym1.tabla = self.id
sym1.baseDatos = dbActual
ent.nuevoSimbolo(sym1)
if not alreadyPrimary:
tablaB: Simbolo = ent.buscarSimbolo(nuevaTabla.nombre)
if tablaB != None:
if primariaAdd != None:
listaPrim = primariaAdd.primarias
for p in listaPrim:
for col in range(len(tablaB.valor)):
if p.valor == tablaB.valor[col].nombre:
self.listPK.append(col)
#print(p.valor)
#print(col.nombre)
if len(self.listPK) > 0:
n = DBMS.alterAddPK(
dbActual, self.id, self.listPK)
if n != 0:
variables.consola.insert(
INSERT,
"No se ha podido agregar PK en tabla \'"
+ self.id + "\'\n")
reporteerrores.append(
Lerrores(
"Error Semántico",
"No se ha podido agregar PK en tabla \'"
+ self.id + "'", "", ""))
else:
idPk = ""
alreadyPrimary = True
sym: Simbolo = None
if primariaAdd.idConstraint != "":
idPk = str(
"PK_" + dbActual + "_" +
self.id + "_" +
primariaAdd.idConstraint)
sym = Simbolo(
TipoSimbolo.CONSTRAINT_PRIMARY,
idPk)
else:
idPk = str("PK_" + dbActual + "_" +
self.id)
sym = Simbolo(
TipoSimbolo.CONSTRAINT_PRIMARY,
idPk)
for y in self.listPK:
tablaB.valor[y].atributos.update(
{'primary': idPk})
sym.valor = self.listPK
sym.tabla = self.id
sym.baseDatos = dbActual
ent.nuevoSimbolo(sym)
DBMS.showCollection()
variables.consola.insert(
INSERT,
str("Tabla " + self.id + " creada exitosamente\n"))
return
return r
from storageManager import jsonMode as j
import pandas as pd
from datetime import *
# drop all databases if exists
# 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'])
#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))
print("Estado PKS:", j.alterAddPK("BD1", "Year", [0]))
print("Estado Inserts", j.loadCSV("./BD1/Año.csv", "BD1", "Year"))
print("---------Creamos Tabla Curso---------")
print("Estado Tabla:", j.createTable("BD1", "Curso", 2))
# 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']]
