def ejecutar(self, ts):
if len(self.fuentes) > 1:
encabezados = []
lista = []
columns = []
nuevasFuentes = []
for tabla in self.fuentes:
if isinstance(tabla, ITEM_ALIAS):
tb = extractTable(DB_ACTUAL.name, tabla.item)
lista.append(tb)
clm = getColumns(DB_ACTUAL.name, tabla.item)
columns.append(clm)
for encabezado in clm:
encabezados.append(tabla.alias + "." + encabezado)
nuevasFuentes.append(tabla.alias)
else:
tb = extractTable(DB_ACTUAL.name, tabla)
lista.append(tb)
clm = getColumns(DB_ACTUAL.name, tabla)
columns.append(clm)
for encabezado in clm:
encabezados.append(tabla + "." + encabezado)
nuevasFuentes.append(tabla)
tabla_fuente = productoCruz(lista)
resultado = matriz(encabezados, tabla_fuente,
TABLA_TIPO.PRODUCTO_CRUZ, "nueva tabla",
nuevasFuentes, columns)
return resultado
else:
if isinstance(self.fuentes[0], ITEM_ALIAS):
encabezados = []
tb = extractTable(DB_ACTUAL.name, self.fuentes[0].item)
clm = getColumns(DB_ACTUAL.name, self.fuentes[0].item)
for encabezado in clm:
encabezados.append(self.fuentes[0].alias + "." +
encabezado)
resultado = matriz(encabezados, tb, TABLA_TIPO.UNICA,
self.fuentes[0].alias,
[self.fuentes[0].alias], clm)
return resultado
else:
encabezados = []
tb = extractTable(DB_ACTUAL.name, self.fuentes[0])
clm = getColumns(DB_ACTUAL.name, self.fuentes[0])
for encabezado in clm:
encabezados.append(self.fuentes[0] + "." + encabezado)
resultado = matriz(encabezados, tb, TABLA_TIPO.UNICA,
self.fuentes[0], self.fuentes, clm)
return resultado
def validarunique(self,entorno,tabla,namecolums,unique):
encontrado=0
nocol=-1
if tabla != None:
columnas=tabla.valor
i=0
param=[]
for columna in columnas:
nombre = columna.nombre
if namecolums == nombre:
encontrado+=1
tipo=columna.tipo
nocol=i
nomtabla=tabla.nombre
nomtabla=nomtabla.replace('_'+entorno.getDataBase(),'')
continue
i=i+1
if encontrado==1 and nocol>-1:
datos=DBMS.extractTable(entorno.getDataBase(),nomtabla)
if datos!= None:
self.nombreres = nomtabla
for i in range(0,len(datos)):
dato=datos[i][nocol]
param.append(dato)
for val in param:
#print("LIsta-->",val,'------',unique,"-----------")
if(val==unique and val!='' ):
return True
return False
def ejecutar(self,ent:Entorno):
tablas = []
result = []
self.encabezados = []
if self.nametable != None:
tipo = self.nametable.tipo
if tipo.tipo == 'identificador':
nombre = self.nametable.getval(ent)
self.ntabla = nombre
tabla = ent.buscarSimbolo(nombre + "_" + ent.getDataBase())
if tabla != None:
tablas.append(tabla)
else:
return "ERROR >> En la instrucción Delete, la tabla: "+self.ntabla+" NO EXISTE"
if len(tablas) > 1:
return "ERROR >> En la instrucción Delete, solo puede ingresar el nombre de una tabla"
else:
'llenar resultado desde backend'
real = tablas[0].nombre.replace('_' + ent.getDataBase(), '')
result = DBMS.extractTable(ent.getDataBase(), real)
# filtros
if self.exps != None:
result = self.wheredelete(ent, tablas)
else:
return "ERROR >> En la instrucción Delete la expresión es incorrecta"
return self.resultdelete(result,self.ntabla,ent.getDataBase())
def ejecutar(self, ent: Entorno):
dbActual = ent.getDataBase()
result = []
if dbActual != None:
tabla: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual)
if tabla != None:
'obtengo tabla'
real = tabla.nombre.replace('_' + ent.getDataBase(), '')
result = DBMS.extractTable(ent.getDataBase(), real)
columnas = tabla.valor
'lleno encabezado'
for col in columnas:
self.encabezado.append(col.nombre)
for i in range(0, len(result)):
resexp = self.resolver(self.where, ent, result, tabla, i)
try:
if resexp.valor:
dic = {}
'busco la columna y le asigno el nuevo valor'
for i in range(0, len(self.listaCampos)):
nombrecol = self.listaCampos[i].columna
expresion = self.listaCampos[i].exp
contenido = expresion.getval(ent).valor
for nocol in range(0, len(columnas)):
if nombrecol == columnas[nocol].nombre:
dic.update({nocol: contenido})
'envio datos par update'
llavePrim = []
for column in tabla.valor:
prim: Simbolo = ent.buscarSimbolo(
column.atributos.get('primary'))
llavePrim = prim.valor
break
r = DBMS.update(dbActual, self.tabla, dic,
llavePrim)
if r == 0:
variables.consola.insert(
INSERT, 'Se ha actualizado un registro \n')
except:
reporteerrores.append(
Lerrores(
"Error Semantico",
'Error el resultado del where no es booleano',
0, 0))
variables.consola.insert(
INSERT,
'Error el resultado del where no es booleano \n')
else:
variables.consola.insert(
INSERT, "La tabla '" + self.tabla +
"' que desea actualizar no existe\n")
reporteerrores.append(
Lerrores(
"Error Semántico", "La tabla '" + self.tabla +
"' que desea actualizar no existe", "", ""))
def ejecutar(self, ent: Entorno):
'Metodo Abstracto para ejecutar la instruccion'
if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None:
resultados = []
for exp in self.exps:
if exp != None:
resultados.append(exp.getval(ent))
return resultados
elif self.froms != None and self.exps != None:
tablas = []
for exp in self.froms:
if exp != None:
tipo = exp.tipo
if tipo.tipo == 'identificador':
nombre = exp.getval(ent)
tabla = ent.buscarSimbolo(nombre)
if tabla != None:
tablas.append(tabla)
#filtros
#acceder a columnas
if len(self.exps) == 1:
if self.exps[0].getval(ent) == '*':
result = []
for tabla in tablas:
result.append(
DBMS.extractTable(ent.getDataBase(), tabla.nombre))
return result
def ejecutar(self, ent: Entorno):
self.encabezado.clear()
resultfiltro = []
resultfiltro.clear()
llavesprim = []
llavesprim.clear()
dbActual = ent.getDataBase()
result = []
result.clear()
if dbActual != None:
tabla: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual)
if tabla != None:
'obtengo tabla'
real = tabla.nombre.replace('_' + ent.getDataBase(), '')
result = DBMS.extractTable(ent.getDataBase(), real)
columnas = tabla.valor
'lleno encabezado'
for col in columnas:
self.encabezado.append(col.nombre)
for i in range(0, len(result)):
resexp = self.resolver(self.where, ent, result, tabla, i)
try:
if not resexp.valor:
resultfiltro.append(result[i])
'envio datos para delete'
llavePrim = []
for column in tabla.valor:
prim: Simbolo = ent.buscarSimbolo(
column.atributos.get('primary'))
if prim != None:
llavePrim = prim.valor
break
except:
reporteerrores.append(
Lerrores(
"Error Semantico",
'Error el resultado del where no es booleano',
0, 0))
variables.consola.insert(
INSERT,
'Error el resultado del where no es booleano \n')
llavesprim = llavePrim
self.resultdelete(resultfiltro, self.tabla, ent.getDataBase(),
llavesprim)
else:
variables.consola.insert(
INSERT, "La tabla '" + self.tabla +
"' que desea eliminar no existe\n")
reporteerrores.append(
Lerrores(
"Error Semántico", "La tabla '" + self.tabla +
"' que desea eliminar no existe", "", ""))
def cmd_extractTable(self, nombreBase, nombreTabla, where, listaCampos,
listaSelect):
#if existeTabla(nombreTabla, nombreBase) == 1:
ob = pn.DevolverTabla(self.tabla)
mc.listadoResp = mc.devolverTabla(
ob.ejecutarNumpy(nombreBase, nombreTabla, where, listaCampos,
listaSelect))
EDDResp.extractTable(condb.extractTable(nombreBase, nombreTabla))
def ejecutar(self, ent: Entorno):
dbActual = ent.getDataBase()
result = []
if dbActual != None:
tabla: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual)
if tabla != None:
'obtengo tabla'
real = tabla.nombre.replace('_' + ent.getDataBase(), '')
result = DBMS.extractTable(ent.getDataBase(), real)
columnas = tabla.valor
'lleno encabezado'
for col in columnas:
self.encabezado.append(col.nombre)
for i in range(0, len(result)):
resexp = self.resolver(self.where, ent, result, tabla, i)
try:
if resexp.valor:
'envio datos par update'
llavePrim = []
for column in tabla.valor:
prim: Simbolo = ent.buscarSimbolo(
column.atributos.get('primary'))
llavePrim = prim.valor
break
#print("PK ----------",llavePrim)
r = DBMS.delete(dbActual, self.tabla, llavePrim)
#print("DELTEEEE ------------> ",r)
if r == 0:
variables.consola.insert(
INSERT, 'Se ha eliminado un registro \n')
except:
reporteerrores.append(
Lerrores(
"Error Semantico",
'Error el resultado del where no es booleano',
0, 0))
variables.consola.insert(
INSERT,
'Error el resultado del where no es booleano \n')
else:
variables.consola.insert(
INSERT, "La tabla '" + self.tabla +
"' que desea eliminar no existe\n")
reporteerrores.append(
Lerrores(
"Error Semántico", "La tabla '" + self.tabla +
"' que desea eliminar no existe", "", ""))
def getTablas(self, instr, tablas):
for nodo in instr.hijos:
if nodo.etiqueta == 'Tabla':
hijos = {}
hijos['Tabla'] = nodo.valor
if len(nodo.hijos) > 0:
hijos['As'] = nodo.hijos[0].valor
registros = jsonMode.extractTable(self.usingDB, nodo.valor)
if registros == None:
self.errors.append(
Error('42P01', EType.SEMANTICO,
'No existe la relacion ' + str(nodo.valor),
nodo.linea))
return -1
hijos['Tuplas'] = registros
tablas.append(hijos)
return 1
def execute(self, environment,tableName):
if not isinstance(self.columnName,str):
return {'Error': 'El nombre indicado de la columna no es una cadena.', 'Fila':self.row, 'Columna': self.column }
if not isinstance(tableName,str):
return {'Error': 'El nombre indicado de la tabla no es una cadena.', 'Fila':self.row, 'Columna': self.column }
db_name = environment.getActualDataBase()
database = environment.readDataBase(db_name)
table = database.getTable(tableName)
repetido = False
for item in table.constraint:
if item['name'] == self.constraintVal['name']:
repetido = True
break
if repetido == True:
return {'Error': 'ya existe una restriccion con el mismo nombre', 'Fila':self.row, 'Columna': self.column }
#columna a la que hace referencia menos el check
if self.constraintVal['type'] != 'check':
reference = False
for item in table.column:
if item.name == self.constraintVal['value']:
reference = True
break
if reference == False:
return {'Error': 'La columna a la que hace referencia la restriccion no existe en la tabla: '+tableName, 'Fila':self.row, 'Columna': self.column }
if self.constraintVal['type'] == 'primary':
for item in table.constraint:
if item['value'] == self.constraintVal['value']
if item['type'] == 'primary':
return 'la columna: '+self.columnName +' ya tiene la restriccionde llave primaria'
result = admin.extractTable(db_name, tableName)
if isinstance(result,list):
if len(result) > 0:
return {'Error': 'No se puede agregar la llave primaria a la tabla: '+tableName+' porque la tabla ya contiene valores.', 'Fila':self.row, 'Columna': self.column }
for item in table.constraint:
if item['type'] == 'primary':
self.constraintVal = {'type':self.constraintVal['type'],'name':item['name'],'value':self.constraintVal['value']}
table.createConstraint(self.constraintVal)
return 'la restriccion fue insertada en la tabla: '+tableName+' con exito.'
def ejecutar(self, ent: Entorno):
tablas = []
result = []
self.encabezado = []
'Metodo Abstracto para ejecutar la instruccion'
if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None:
resultados = []
for exp in self.exps:
if exp != None:
resultados.append(exp.getval(ent))
return resultados
elif self.froms != None and self.exps != None:
for exp in self.froms:
if exp != None:
tipo = exp.tipo
if tipo.tipo == 'identificador':
nombre = exp.getval(ent)
tabla = ent.buscarSimbolo(nombre + "_" +
ent.getDataBase())
if tabla != None:
tablas.append(tabla)
if len(tablas) > 1:
'producto cartesiano'
else:
'llenar resultado desde backend'
real = tablas[0].nombre.replace('_' + ent.getDataBase(), '')
result = DBMS.extractTable(ent.getDataBase(), real)
#filtros
if self.where != None:
result = self.execwhere(ent, tablas)
#acceder a columnas
if len(self.exps) == 1:
if self.exps[0].getval(ent) == '*':
self.mostarresult(result, 'prueba xd')
elif self.exps[0].tipo.tipo == 'identificador':
'obtengo solo columnas pedidas'
else:
'pendientes subconsultas y funciones'
def unaTabla(self, nombreBase, nombreTabla, where, listaCampos):
tabla_result = []
tabla_result.append(self.devolverCampos(nombreBase, nombreTabla))
resultados = condb.extractTable(nombreBase, nombreTabla)
arr = np.array(resultados)
if where == -1: # no viene where, guarda todo lo que viene
for i in range(0, len(resultados), 1):
tabla_result.append(arr[i])
elif listaCampos == -1:
for i in range(0, len(resultados), 1):
tabla_result.append(arr[i])
else: # si viene where
for i in range(0, len(resultados), 1):
nuevoWhere = where
for j in listaCampos:
print(len(listaCampos), "tam de la lista de campos")
if nuevoWhere.__contains__(str(j)):
posicion = self.devolverPosicionCampos(
nombreBase, nombreTabla, j)
print("entre al if con ", j, " posicion ", posicion)
nuevoWhere = nuevoWhere.replace(
str(j), "\"" + arr[i][posicion] + "\"")
print("reemplazando ", j, " con ",
"\"" + arr[i][posicion] + "\"", "-- resultado ",
nuevoWhere)
#val = where.replace("col0", "\"" + arr[i][0] + "\"").replace("col2", "\"" + arr[i][2]+ "\"")
print(nuevoWhere, "<----")
respuesta = eval(nuevoWhere)
if (respuesta == True):
tabla_result.append(arr[i])
return tabla_result
def FROM(self, db_name, database, tableArray, environment):
# recorremos el tableList para ver si todas las tablas pertenecen a la base de datos y las almacenamos en table Array
if isinstance(self.tableList, list):
for item in self.tableList:
table = database.getTable(item['id'])
if table == None:
if len(self.tableList) > 1:
return {
'Error': 'La tabla: ' + item['id'] +
' no existe en la base de datos',
'Linea': self.row,
'Columna': self.column
}
else:
return {
'Error': 'La tabla: ' + item['id'] +
' no existe en la base de datos',
'Linea': self.row,
'Columna': self.column
}
val = admin.extractTable(db_name, table.name)
if val == None:
return {
'Error': 'La tabla: ' + item['id'] +
' no existe en la base de datos',
'Linea': self.row,
'Columna': self.column
}
table.alias = item['as']
valor = {'table': table, 'data': val}
tableArray.append(valor)
elif isinstance(self.tableList, Select):
tableArray.push(self.tableList.execute(environment))
else:
return {
'Error': 'Formato no válido en el FROM',
'Fila': self.row,
'Columna': self.column
}
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
}
if not isinstance(self.idList, list):
db_name = environment.getActualDataBase()
database = environment.readDataBase(db_name)
if database == None:
return {
'Error': 'Error al buscar en la base de datos',
'Fila': self.row,
'Columna': self.column
}
table = database.getTable(self.tableName)
if table == None:
return {
'Error':
'La tabla: ' + self.tableName +
' no existe en la base de datos: ' + db_name,
'Fila':
self.row,
'Columna':
self.column
}
if len(table.columns) != len(self.valueList):
return {
'Error':
'El numero de valores a insertar es diferente que el numero de columnas de la tabla: '
+ self.tableName,
'Fila':
self.row,
'Columna':
self.column
}
for i in range(len(self.valueList)):
columna = table.columns[i]
valor = self.valueList[i].execute(environment)
res = check(columna.tipo, valor['typ'], valor['value'],
columna.lenght)
if not isinstance(res, bool):
return {
'Error': res,
'Fila': self.row,
'Columna': self.column
}
for index in range(len(self.valueList)):
nombreVariable = table.columns[index].name
valorVariable = self.valueList[index].execute(environment)
environment.guardarVariableins(nombreVariable,
valorVariable['typ'],
valorVariable['value'], None)
for item in table.constraint:
if item['type'] == 'primary':
var = environment.buscarVariable(item['value'], None)
if var == None:
return {
'Error': 'Variable no encontrada',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.NULL:
return {
'Error': 'La primary key no puede ser nula',
'Fila': self.row,
'Columna': self.column
}
elif item['type'] == 'foreign':
#no hay validaciones por el momento
print('foreign')
elif item['type'] == 'not null':
var = environment.buscarVariable(item['value'], None)
if var == None:
return {
'Error': 'Variable no encontrada',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.NULL:
return {
'Error':
'El campo: ' + var['name'] + ' no puede ser nulo',
'Fila': self.row,
'Columna': self.column
}
elif item['type'] == 'check':
var = item['value'].execute(environment)
if var['typ'] != Type.BOOLEAN:
return {
'Error': 'La condicion del check, no es booleana',
'Fila': self.row,
'Columna': self.column
}
if var['value'] != True:
return {
'Error':
'No se cumple con la restriccion: ' + item['name'],
'Fila':
self.row,
'Columna':
self.column
}
elif item['type'] == 'unique':
val = admin.extractTable(db_name, self.tableName)
if val == None:
return {
'Error':
'La base de datos o la tabla a la que desea hacer referencia no existe.',
'Fila': self.row,
'Columna': self.column
}
elif len(val) == 0:
#pasa de largo porque no hay registros
print('')
elif len(val) > 0:
aux = -1
for i in range(len(table.columns)):
if table.columns[i].name == item['value']:
aux = i
break
if aux == -1:
return {
'Error':
'No se encontro la columna: ' + item['value'],
'Fila':
self.row,
'Columna':
self.column
}
searched = environment.buscarVariable(
item['value'], None)
for tupla in val:
if tupla[aux] == searched['value']:
if isinstance(searched['value'], int):
return {
'Error':
'Ya existe un registro con el valor: '
+ str(searched['value']) +
' en la columna: ' + item['value'] +
' lo cual viola la restriccion unique',
'Fila':
self.row,
'Columna':
self.column
}
else:
return {
'Error':
'Ya existe un registro con el valor: '
+ searched['value'] +
' en la columna: ' + item['value'] +
' lo cual viola la restriccion unique',
'Fila':
self.row,
'Columna':
self.column
}
else:
return {
'Error': 'Error desconocido al insertar.',
'Fila': self.row,
'Columna': self.column
}
#guardando en el storage
listaValores = []
for item in self.valueList:
valorLista = item.execute(environment)
if valorLista['typ'] == Type.DATE or valorLista[
'typ'] == Type.TIME:
listaValores.append(str(valorLista['value']))
else:
listaValores.append(valorLista['value'])
valorRetorno = admin.insert(db_name, self.tableName, listaValores)
print(listaValores)
if valorRetorno == 0:
return 'Se ha insertado con exito la tupla ' + str(
listaValores) + ' en la tabla: ' + self.tableName
elif valorRetorno == 1:
return {
'Error': 'Error en la operación insertar.',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 2:
return {
'Error':
'La base de datos a la que desea referenciar no existe',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 3:
return {
'Error':
'La tabla en la que desea insertar registros no existe',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 4:
return {
'Error': 'Llave primaria duplicada',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 5:
return {
'Error': 'columna fuera de limites',
'Fila': self.row,
'Columna': self.column
}
else:
return {
'Error': 'Error desconocido al insertar registros',
'Fila': self.row,
'Columna': self.column
}
else:
# aqui es el segundo formato de insert
db_name = environment.getActualDataBase()
database = environment.readDataBase(db_name)
if database == None:
return {
'Error': 'Error al buscar en la base de datos',
'Fila': self.row,
'Columna': self.column
}
table = database.getTable(self.tableName)
if table == None:
return {
'Error':
'La tabla: ' + self.tableName +
' no existe en la base de datos: ' + db_name,
'Fila':
self.row,
'Columna':
self.column
}
if len(table.columns) < len(self.idList):
return {
'Error':
'El numero de columnas indicadas es mayor al numero de columnas de la tabla: '
+ self.tableName,
'Fila':
self.row,
'Columna':
self.column
}
#if len(self.valueList) != len(self.idList):
#return {'Error': 'El numero de registros a insertar difiere del numero de columnas indicadas: '+self.tableName, 'Fila':self.row, 'Columna': self.column }
#TODO verificar tipos
for i in range(len(self.valueList)):
columna = table.readColumn(self.idList[i])
if columna == None:
return {
'Error':
'La columna: ' + self.idList[i] +
' no existe en la tabla ' + table.name,
'Fila':
self.row,
'Columna':
self.column
}
valor = self.valueList[i].execute(environment)
res = check(columna.tipo, valor['typ'], valor['value'],
columna.lenght)
if not isinstance(res, bool):
return {
'Error': res,
'Fila': self.row,
'Columna': self.column
}
# verificar que el id list coincida con los nombres de las columnas
for item in self.idList:
exist = False
for col in table.columns:
if col.name == item:
exist = True
if exist == False:
return {
'Error':
'La columna: ' + item + ' no existe en la tabla: ' +
self.tableName,
'Fila':
self.row,
'Columna':
self.column
}
for index in range(len(self.valueList)):
nombreVariable = self.idList[index]
valorVariable = self.valueList[index].execute(environment)
environment.guardarVariableins(nombreVariable,
valorVariable['typ'],
valorVariable['value'], None)
for item in table.columns:
var = environment.buscarVariable(item.name, None)
if var == None:
if item.default == None:
nombreVariable = item.name
valorVariable = 'null'
tipoVariable = Type.NULL
environment.guardarVariableins(nombreVariable,
tipoVariable,
valorVariable, None)
else:
nombreVariable = item.name
valorVariable = item.default
tipoVariable = item.tipo
environment.guardarVariableins(nombreVariable,
tipoVariable,
valorVariable, None)
for item in table.constraint:
if item['type'] == 'primary':
var = environment.buscarVariable(item['value'], None)
if var == None:
return {
'Error': 'Variable no encontrada',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.NULL:
return {
'Error': 'La primary key no puede ser nula',
'Fila': self.row,
'Columna': self.column
}
elif item['type'] == 'foreign':
#no hay validaciones por el momento
print('foreign')
elif item['type'] == 'not null':
var = environment.buscarVariable(item['value'], None)
if var == None:
return {
'Error': 'Variable no encontrada',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.NULL:
return {
'Error':
'El campo: ' + var['name'] + ' no puede ser nulo',
'Fila': self.row,
'Columna': self.column
}
elif item['type'] == 'check':
var = item['value'].execute(environment)
if var['typ'] != Type.BOOLEAN:
return {
'Error': 'La condicion del check, no es booleana',
'Fila': self.row,
'Columna': self.column
}
if var['value'] != True:
return {
'Error':
'No se cumple con la restriccion: ' + item['name'],
'Fila':
self.row,
'Columna':
self.column
}
elif item['type'] == 'unique':
val = admin.extractTable(db_name, self.tableName)
if val == None:
return {
'Error':
'La base de datos o la tabla a la que desea hacer referencia no existe.',
'Fila': self.row,
'Columna': self.column
}
elif len(val) == 0:
#pasa de largo porque no hay registros
print('')
elif len(val) > 0:
aux = -1
for i in range(len(table.columns)):
if table.columns[i].name == item['value']:
aux = i
break
if aux == -1:
return {
'Error':
'No se encontro la columna: ' + item['value'],
'Fila':
self.row,
'Columna':
self.column
}
searched = environment.buscarVariable(
item['value'], None)
for tupla in val:
if tupla[aux] == searched['value']:
if isinstance(searched['value'], int):
return {
'Error':
'Ya existe un registro con el valor: '
+ str(searched['value']) +
' en la columna: ' + item['value'] +
' lo cual viola la restriccion unique',
'Fila':
self.row,
'Columna':
self.column
}
else:
return {
'Error':
'Ya existe un registro con el valor: '
+ searched['value'] +
' en la columna: ' + item['value'] +
' lo cual viola la restriccion unique',
'Fila':
self.row,
'Columna':
self.column
}
else:
return {
'Error': 'Error desconocido al insertar.',
'Fila': self.row,
'Columna': self.column
}
#ordenar la lista de valores
#guardando en el storage
valOrden = []
for item in table.columns:
var = environment.buscarVariable(item.name, None)
if var == None:
return {
'Error': 'Error desconocido al insertar 2.',
'Fila': self.row,
'Columna': self.column
}
if var['tipo'] == Type.DATE or var['tipo'] == Type.TIME:
valOrden.append(str(var['value']))
else:
valOrden.append(var['value'])
valorRetorno = admin.insert(db_name, self.tableName, valOrden)
if valorRetorno == 0:
return 'Se ha insertado con exito la tupla ' + str(
valOrden) + ' en la tabla: ' + self.tableName
elif valorRetorno == 1:
return {
'Error': 'Error en la operación insertar.',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 2:
return {
'Error':
'La base de datos a la que desea referenciar no existe',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 3:
return {
'Error':
'La tabla en la que desea insertar registros no existe',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 4:
return {
'Error': 'Llave primaria duplicada',
'Fila': self.row,
'Columna': self.column
}
elif valorRetorno == 5:
return {
'Error': 'columna fuera de limites',
'Fila': self.row,
'Columna': self.column
}
else:
return {
'Error': 'Error desconocido al insertar registros',
'Fila': self.row,
'Columna': self.column
}
def ejecutar(self, ent: Entorno,imp=1):
#try:
tablas = []
result = []
self.encabezado = []
self.aliast=[]
if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None:
resultados = []
newenc=[]
for i in range(0,len(self.exps)):
exp=self.exps[i]
if isinstance(self.exps[i], FuncionesNativas):
newenc.append(self.exps[i].identificador+str(i))
elif isinstance(self.exps[i], Alias):
newenc.append(self.exps[i].nombre)
exp = self.exps[i].expresion
elif isinstance(self.exps[i],Identificador):
newenc.append(self.exps[i].nombre)
else:
newenc.append('Exp' + str(len(newenc)))
result.append(exp.getval(ent).valor)
result=[result]
self.encabezado=newenc
elif self.froms != None and self.exps != None:
for exp in self.froms:
if isinstance(exp,Identificador) or isinstance(exp,Terminal):
self.aliast.append('')
tipo = exp.tipo
tablas=self.gettablas(tipo,exp,ent,tablas)
elif isinstance(exp,Alias):
self.aliast.append(exp.nombre)
expre=exp.expresion
tipo=expre.tipo
tablas=self.gettablas(tipo,expre,ent,tablas)
if len(tablas) > 1:
'Obteniendo encabezados de las tablas'
for tabla in tablas:
cols = tabla.valor
for columna in cols:
nombre = columna.nombre
self.encabezado.append(nombre + "." + tabla.nombre.replace('_' + ent.getDataBase(), ''))
'producto cartesiano'
real = tablas[0].nombre.replace('_' + ent.getDataBase(), '')
result = DBMS.extractTable(ent.getDataBase(), real)
self.nombreres = real
for i in range(0, len(tablas) - 1):
real2 = tablas[i + 1].nombre.replace('_' + ent.getDataBase(), '')
self.nombreres += "_" + real2
tabla2 = DBMS.extractTable(ent.getDataBase(), real2)
result = self.producto(result, tabla2)
else:
'llenar resultado desde backend'
real = tablas[0].nombre.replace('_' + ent.getDataBase(), '')
result = DBMS.extractTable(ent.getDataBase(), real)
'encabezados 1 tabla'
if (len(self.encabezado) == 0):
for tabla in tablas:
cols = tabla.valor
for columna in cols:
nombre = columna.nombre
self.encabezado.append(nombre)
# add columnas
newenc = []
newres = []
for i in range(0, len(self.exps)):
if isinstance(self.exps[i], Terminal) or isinstance(self.exps[i], Identificador):
'aqui no agrego las que ya existen'
else:
exp = self.exps[i]
'aqui agrego las expresiones que se agregaran para filtrar'
if isinstance(self.exps[i], FuncionesNativas):
newenc.append(self.exps[i].identificador)
elif isinstance(self.exps[i], Alias):
newenc.append(self.exps[i].nombre)
exp = self.exps[i].expresion
elif isinstance(self.exps[i], Identificador):
newenc.append(self.exps[i].nombre)
else:
newenc.append('Exp' + str(len(newenc)))
for fila in range(0, len(result)):
res = self.resolver(exp, ent, result, tablas, fila)
if fila == 0:
self.tipos.append([newenc[len(newenc) - 1], res.tipo])
if len(newres) != len(result):
newres.append([res.valor])
else:
newres[fila].append(res.valor)
for i in range(0, len(result)):
if newres != []:
result[i] = result[i] + newres[i]
self.encabezado = (self.encabezado + newenc)
# filtros
if self.where != None:
result = self.optwhere(ent,result,tablas)
#DEVUELVO SOLO COLUMNAS PEDIDAS
newenc = []
newres = []
for i in range(0, len(self.exps)):
if isinstance(self.exps[i],Identificador):
for j in range(0, len(self.encabezado)):
nombrediv = self.encabezado[j].split('.')
nombrecol = nombrediv[0]
if self.exps[i].nombre == nombrecol:
newenc.append(self.encabezado[j])
for x in range(0, len(result)):
valcol = result[x][j]
if len(newres) != len(result):
newres.append([valcol])
else:
newres[x].append(valcol)
elif isinstance(self.exps[i], Terminal):
if self.exps[i].tipo.tipo == 'acceso':
expresion=self.exps[i]
campos = expresion.getval(ent).valor.split('.')
if campos[1] == '*':
tablares=self.getasterisco(campos[0], tablas, result, ent,newres,newenc)
newenc=tablares[0]
newres=tablares[1]
#busco el campo pedido si no es *
for j in range(0, len(self.encabezado)):
nombrediv = self.encabezado[j].split('.')
nombrecol = nombrediv[0]
nombretabla = nombrediv[1]
nombrecol = nombretabla + '.' + nombrecol
if expresion.getval(ent).valor == nombrecol:
newenc.append(self.encabezado[j])
for x in range(0, len(result)):
dato = result[x][j]
if len(newres) != len(result):
newres.append([dato])
else:
newres[x].append(dato)
for k in range(0, len(self.aliast)):
nombreacc = self.aliast[k] + '.' + nombrediv[0]
if expresion.getval(ent).valor == nombreacc and nombrediv[1] == tablas[k].nombre.replace('_' + ent.getDataBase(), ''):
newenc.append(self.encabezado[j])
for x in range(0, len(result)):
dato = result[x][j]
if len(newres) != len(result):
newres.append([dato])
else:
newres[x].append(dato)
elif len(self.exps)==1 and self.exps[0].valor=='*':
newres=result[:]
newenc=self.encabezado[:]
break
else:
exp = self.exps[i]
if isinstance(self.exps[i],FuncionesNativas):
newenc.append(self.exps[i].identificador+str(i))
elif isinstance(self.exps[i], Alias):
newenc.append(self.exps[i].nombre)
exp = self.exps[i].expresion
else:
newenc.append('Exp'+len(newenc))
for fila in range(0,len(result)):
res=self.resolver(exp,ent,result,tablas,fila)
'''if isinstance(res,str):
if len(newres) != len(result):
newres.append([''])
else:
newres[fila].append('')
continue'''
if len(newres) != len(result) :
newres.append([res.valor])
else:
newres[fila].append(res.valor)
result = newres[:]
self.encabezado = newenc[:]
# combining(union,intersect,except)
if self.combinig != None:
datos2 = self.combinig.select.ejecutar(ent, 0)
enc2 = datos2[0]
res2 = datos2[1]
result = self.m_combining(self.combinig, self.encabezado, result, enc2, res2)
aber = result
# limitar resultados
if self.limit != None:
a = self.limit
result = self.m_limit(result, a.limit, a.off)
#distinct
if self.distinct!=None:
newres=[]
'elimino duplicados'
for i in range(0,len(result)):
encontrado=False
fila=result[i]
for j in range(0,len(result)):
if j!= i:
if fila==result[j]:
encontrado=True
if encontrado==False:
newres.append(fila)
result=newres
#imprimir resultado solo si no se llamo de un subquery,union,intersect,except
if self.agregacion==1:
result=[result[0]]
if imp == 1:
self.mostarresult(result, self.encabezado, self.nombreres)
return [self.encabezado, result]
def execute(self, environment):
#NOMBRE DE LA BD
dbname = environment.getActualDataBase()
db = environment.readDataBase(dbname)
if (db == None):
return {
'Error': 'No se encuentra una base de datos en uso',
'Fila': self.row,
'Columna': self.column
}
#NOMBRE DE LA TABLA
tbname = self.idTable
#LISTA CON LOS INDEX DE LAS COLUMNAS QUE SON LLAVES PRIMARIAS
table = db.getTable(self.idTable)
#Diccionario con las clave el nombre de la tabla y valor el indice
indColumnas = {}
for c in range(len(table.columns)):
indColumnas[table.columns[c].name] = c
#--Busco los nombres de los campos que son primary key
pkNames = []
for con in table.constraint:
if con['type'] == 'primary':
pkNames.append(con['value'])
#--Busco los indices de los campos correspondientes
pkIndexes = []
for i in range(len(table.columns)):
for item in pkNames:
if table.columns[i].name == item:
pkIndexes.append(i)
#LISTA DE LLAVE VALOR
tuplas = admin.extractTable(dbname, tbname)
if len(tuplas) == 0:
return {
'Error': 'La tabla no contiene registros a actualizar.',
'Fila': self.row,
'Columna': self.column
}
if tuplas == None:
return {
'Error':
'La tabla no ha podido encontrarse, error en el Storage.',
'Fila': self.row,
'Columna': self.column
}
#POR CADA TUPLA QUE HAYA
for tindex in range(len(tuplas)):
#POR CADA CAMPO EN LA TUPLA CREO EN LA TABLA DE SIMBOLOS LA VARIABLE DE CADA CAMPO
for index in range(len(tuplas[tindex])):
#TIPOS, PROBABLEMENTE SE DEBA CAMBIAR
tipo = Type.STRING
if isinstance(tuplas[tindex][index], int):
tipo = Type.DECIMAL
#GUARDAR EN EL ENTORNO UNA VARIALBE CON EL NOMBRE DE LA COLUMNA
environment.guardarVariable(table.columns[index].name, tipo,
tuplas[tindex][index])
#CREO EL DICCIONARIO CON LOS VALORES A MODIFICAR
tuplaModificada = {}
for asign in self.assignList:
clave = indColumnas[asign['id']]
valor = asign['value'].execute(environment)['value']
tuplaModificada[clave] = valor
#CREO UN ARREGLO CON LA LLAVE PRIMARIA DE ESE REGISTRO
primaryKey = []
for val in pkIndexes:
primaryKey.append(tuplas[tindex][val])
#VERIFICO LA CONDICIÓN DEL WHERE
where = True
if not isinstance(self.condition, bool):
where = self.condition.execute(environment)['value']
if where == True:
res = admin.update(dbname, tbname, tuplaModificada, primaryKey)
switcher = {
0:
'Se ha realizado el update en el registro con la FK: ' +
str(primaryKey),
1: {
'Error:': 'Error en la operación update.',
'Fila': self.row,
'Columna': self.column
},
2: {
'Error:': 'La base de datos buscada no existe.',
'Fila': self.row,
'Columna': self.column
},
3: {
'Error:': 'La tabla ' + self.idTable + ' no existe.',
'Fila': self.row,
'Columna': self.column
},
4: {
'Error:':
'No existe el registro buscado: ' + str(primaryKey),
'Fila':
self.row,
'Columna':
self.column
},
}
return switcher.get(
res,
'Error en la respuesta del update en el StorageManager.')
def execute(self, environment):
dbname = environment.getActualDataBase()
db = environment.readDataBase(dbname)
if (db == None):
return {'Error': 'No se encuentra una base de datos referenciada.'}
tbname = self.idTable
table = db.getTable(self.idTable)
indColumnas = {}
for c in range(len(table.columns)):
indColumnas[table.columns[c].name] = c
pkNames = []
for con in table.constraint:
if con['type'] == 'primary':
pkNames.append(con['value'])
pkIndexes = []
for i in range(len(table.columns)):
for item in pkNames:
if table.columns[i].name == item:
pkIndexes.append(i)
#LISTA DE LLAVE VALOR
tuplas = admin.extractTable(dbname, tbname)
if len(tuplas) == 0:
return {
'Error': 'La tabla no contiene registros a actualizar.',
'Fila': self.row,
'Columna': self.column
}
if tuplas == None:
return {
'Error':
'La tabla no ha podido encontrarse, error en el Storage.',
'Fila': self.row,
'Columna': self.column
}
#POR CADA TUPLA QUE HAYA
for tindex in range(len(tuplas)):
#POR CADA CAMPO EN LA TUPLA CREO EN LA TABLA DE SIMBOLOS LA VARIABLE DE CADA CAMPO
for index in range(len(tuplas[tindex])):
#TIPOS, PROBABLEMENTE SE DEBA CAMBIAR
tipo = Type.STRING
if isinstance(tuplas[tindex][index], int):
tipo = Type.DECIMAL
#GUARDAR EN EL ENTORNO UNA VARIALBE CON EL NOMBRE DE LA COLUMNA
environment.guardarVariable(table.columns[index].name, tipo,
tuplas[tindex][index], None)
#CREO UN ARREGLO CON LA LLAVE PRIMARIA DE ESE REGISTRO
primaryKey = []
for val in pkIndexes:
primaryKey.append(tuplas[tindex][val])
#VERIFICO LA CONDICIÓN DEL WHERE
where = True
if not isinstance(self.condition, bool):
where = self.condition.execute(environment)['value']
if where == True:
res = admin.delete(dbname, tbname, primaryKey)
switcher = {
0:
'Se ha realizado el delete en el registro con la FK: ' +
str(primaryKey),
1: {
'Error:': 'Error en la operación delete.',
'Fila': self.row,
'Columna': self.column
},
2: {
'Error:': 'La base de datos' + dbname + 'no existe.',
'Fila': self.row,
'Columna': self.column
},
3: {
'Error:': 'La tabla ' + self.idTable + ' no existe.',
'Fila': self.row,
'Columna': self.column
},
4: {
'Error:':
'No existe el registro buscado: ' + str(primaryKey),
'Fila':
self.row,
'Columna':
self.column
},
}
return switcher.get(
res,
'Error en la respuesta del update en el StorageManager.')
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
def ejecutar(self, ent: Entorno):
self.encabezado.clear()
dbActual = ent.getDataBase()
result = []
result.clear()
llavesprim = []
llavesprim.clear()
if dbActual != None:
tabla: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual)
if tabla != None:
'obtengo tabla'
real = tabla.nombre.replace('_' + ent.getDataBase(), '')
result = DBMS.extractTable(ent.getDataBase(), real)
columnas = tabla.valor
'lleno encabezado'
for col in columnas:
self.encabezado.append(col.nombre)
colsupdate = []
poscolsupdate = []
newvals = []
colsupdate.clear()
poscolsupdate.clear()
newvals.clear()
for i in range(0, len(self.listaCampos)):
nombrecol = self.listaCampos[i].columna
expresion = self.listaCampos[i].exp
contenido = expresion.getval(ent).valor
colsupdate.append(nombrecol)
newvals.append(contenido)
for x in range(0, len(colsupdate)):
for y in range(0, len(self.encabezado)):
print("comparando" + colsupdate[x])
print("con+" + self.encabezado[y])
if (colsupdate[x] == self.encabezado[y]):
poscolsupdate.append(y)
print(poscolsupdate)
for i in range(0, len(result)):
resexp = self.resolver(self.where, ent, result, tabla, i)
try:
if resexp.valor:
cont = 0
for a in poscolsupdate:
result[i][a] = newvals[cont]
cont += 1
llavePrim = []
for column in tabla.valor:
prim: Simbolo = ent.buscarSimbolo(
column.atributos.get('primary'))
llavePrim = prim.valor
break
except:
reporteerrores.append(
Lerrores(
"Error Semantico",
'Error el resultado del where no es booleano',
0, 0))
variables.consola.insert(
INSERT,
'Error el resultado del where no es booleano \n')
llavesprim = llavePrim
self.resultupdate(result, self.tabla, ent.getDataBase(),
llavesprim)
else:
variables.consola.insert(
INSERT, "La tabla '" + self.tabla +
"' que desea actualizar no existe\n")
reporteerrores.append(
Lerrores(
"Error Semántico", "La tabla '" + self.tabla +
"' que desea actualizar no existe", "", ""))
def wheredelete(self,entorno,tablas):
filtrado=[]
exp1:Expresion
exp2:Expresion
colres=[]
tipo=''
isid=False
posid=-1
if isinstance(self.exps, Relacional) or isinstance(self.exps,Logica):
encontrado=0
nocol=-1
nomtabla=''
'realizar operacion'
exp1=self.exps.exp1
exp2=self.exps.exp2
op=self.exps.operador
if (op==">"):
op="<"
elif (op=="<"):
op=">"
elif (op=="!="):
op="="
elif (op=="="):
op="!="
elif (op==">="):
op="<="
elif (op=="<="):
op=">="
else:
print("")
val=''
if (exp1.tipo.tipo=='identificador'):
val = exp1.getval(entorno)
posid = 1
else:
return ("ERROR >> En la instrucción Delete hay problema con la expresión, debe ingresar un identificador antes del operador")
for tabla in tablas:
columnas=tabla.valor
i=0
for columna in columnas:
nombre = columna.nombre
self.encabezados.append(nombre)
if val == nombre:
encontrado+=1
tipo=columna.tipo
nocol=i
nomtabla=tabla.nombre
nomtabla=nomtabla.replace('_'+entorno.getDataBase(),'')
continue
i=i+1
if encontrado==1 and nocol>-1:
datos=DBMS.extractTable(entorno.getDataBase(),nomtabla)
if datos!= None:
self.nombreres = nomtabla
for i in range(0,len(datos)):
dato=datos[i][nocol]
expi = Terminal(tipo, dato)
expd = exp2
if op in ('>','<','>=','<=','='):
nuevaop = Relacional(expi,expd,op);
if nuevaop.getval(entorno):
'Agrego la fila al resultado'
filtrado.append(datos[i])
elif op in ('or','and','not'):
nuevaop = Logica(expi,expd,op);
if nuevaop.getval(entorno):
'Agrego la fila al resultado'
filtrado.append(datos[i])
else:
return ('ERROR >> En la instrucción Delete, el resultado del where no es booleano')
return filtrado
else:
return ("ERROR >> En la instrucción Delete, el nombre de las columnas es ambiguo")
else:
return ("ERROR >> En la instrucción Delete, no ingreso una expresión relacional")
def ejecutar(self, ent:Entorno):
dbActual = ent.getDataBase()
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)
if tt.lista != None: #aca se mete si viene por ejemplo: columna1 integer references tabla2
tamano = len(tt.lista)
for y in range(tamano):
atrColumna = tt.lista[y]
if atrColumna.tipo == AtributosColumna.UNICO:
nuevoUnico = Simbolo(TipoSimbolo.CONSTRAINT_UNIQUE,atrColumna.valor)
nuevoUnico.baseDatos = dbActual
nuevoUnico.tabla = self.id
ent.nuevoSimbolo(nuevoUnico)
nuevaColumna.atributos.update({'unique':atrColumna.valor})
elif atrColumna.tipo == AtributosColumna.CHECK:
nuevoCheck = Simbolo(TipoSimbolo.CONSTRAINT_CHECK,atrColumna.valor)
nuevoCheck.baseDatos = dbActual
nuevoCheck.tabla = self.id
ent.nuevoSimbolo(nuevoCheck)
nuevaColumna.atributos.update({'check':atrColumna.valor})
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:
nuevaPrimaria = Simbolo(TipoSimbolo.CONSTRAINT_PRIMARY,str("PK_" + self.id))
nuevaPrimaria.baseDatos = dbActual
nuevaPrimaria.tabla = self.id
ent.nuevoSimbolo(nuevaPrimaria)
nuevaColumna.atributos.update({'primary':str("PK_" + self.id)})
elif atrColumna.tipo == AtributosColumna.REFERENCES:
rr = DBMS.extractTable(dbActual,atrColumna.valor)
if rr == []:
return str("La tabla \'" + atrColumna.valor + "\' a la que está referenciando, no existe")
else:
nuevaForanea = Simbolo(TipoSimbolo.CONSTRAINT_FOREIGN,str("FK_" + self.id))
nuevaForanea.baseDatos = dbActual
nuevaForanea.tabla = self.id
ent.nuevoSimbolo(nuevaForanea)
nuevaColumna.atributos.update({'foreign':str("FK_" + self.id)})
listaColumnas.append(nuevaColumna)
#considerar la situacion de cuando no se haya creado la tabla pero ya se hayan
#agregado los constraint a la tabla de simbolos
nuevaTabla.valor = listaColumnas
if dbActual != None:
estado = DBMS.createTable(dbActual,self.id, self.numColumnas)
if estado == 0:
nuevaTabla.baseDatos = dbActual
ent.nuevoSimbolo(nuevaTabla)
DBMS.showCollection()
return str("Tabla " + nuevaTabla.nombre + " creada exitosamente")
def ejecutar(self, ent: Entorno, imp=1):
try:
tablas = []
result = []
self.encabezado = []
aliast = []
'Metodo Abstracto para ejecutar la instruccion'
if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None:
resultados = []
for exp in self.exps:
if exp != None:
res = exp.getval(ent)
resultados.append(res.valor)
variables.consola.insert(INSERT, str(res.valor))
variables.consola.insert(INSERT, '\n')
return resultados
elif self.froms != None and self.exps != None:
for exp in self.froms:
if isinstance(exp, Terminal):
aliast.append('')
tipo = exp.tipo
tablas = self.gettablas(tipo, exp, ent, tablas)
elif isinstance(exp, Alias):
aliast.append(exp.nombre)
expre = exp.expresion
tipo = exp.tipo
tablas = self.gettablas(tipo, expre, ent, tablas)
if len(tablas) > 1:
'Obteniendo encabezados de las tablas'
for tabla in tablas:
cols = tabla.valor
for columna in cols:
nombre = columna.nombre
self.encabezado.append(
nombre + "." +
tabla.nombre.replace('_' +
ent.getDataBase(), ''))
'producto cartesiano'
real = tablas[0].nombre.replace('_' + ent.getDataBase(),
'')
result = DBMS.extractTable(ent.getDataBase(), real)
self.nombreres = real
for i in range(0, len(tablas) - 1):
real2 = tablas[i + 1].nombre.replace(
'_' + ent.getDataBase(), '')
self.nombreres += "_" + tabla.nombre.replace(
'_' + ent.getDataBase(), '')
tabla2 = DBMS.extractTable(ent.getDataBase(), real2)
result = self.producto(result, tabla2)
else:
'llenar resultado desde backend'
real = tablas[0].nombre.replace('_' + ent.getDataBase(),
'')
result = DBMS.extractTable(ent.getDataBase(), real)
'encabezados 1 tabla'
if (len(self.encabezado) == 0):
for tabla in tablas:
cols = tabla.valor
for columna in cols:
nombre = columna.nombre
self.encabezado.append(nombre)
#lleno arreglo de alias
for exp in self.exps:
self.aliast.append('')
for x in range(0, len(self.exps)):
if isinstance(self.exps[x], Alias):
self.aliast[i] = self.exps[i].nombre
# filtros
if self.where != None:
result = self.optwhere(ent, result, tablas)
# combining(union,intersect,except)
if self.combinig != None:
datos2 = self.combinig.select.ejecutar(ent, 0)
enc2 = datos2[0]
res2 = datos2[1]
result = self.m_combining(self.combinig, self.encabezado,
result, enc2, res2)
aber = result
# limitar resultados
if self.limit != None:
a = self.limit
result = self.m_limit(result, a.limit, a.off)
# acceder a columnas
if len(self.exps) == 1:
if self.exps[0].tipo.tipo == 'identificador':
newenc = []
'obtengo solo columnas pedidas'
for i in range(0, len(self.encabezado)):
nombrediv = self.encabezado[i].split('.')
nombrecol = nombrediv[0]
if self.exps[0].getval(ent).valor == nombrecol:
for x in range(0, len(result)):
valcol = result[x][i]
result[x] = [valcol]
if (len(newenc) == 0):
newenc.append(self.encabezado[i])
self.encabezado = newenc
else:
''
else:
newenc = []
newres = []
for i in range(0, len(self.exps)):
if isinstance(self.exps[i], Terminal):
if self.exps[i].tipo.tipo == 'identificador':
for j in range(0, len(self.encabezado)):
nombrediv = self.encabezado[j].split('.')
nombrecol = nombrediv[0]
if self.exps[i].getval(
ent).valor == nombrecol:
newenc.append(self.encabezado[j])
for x in range(0, len(result)):
valcol = result[x][j]
if len(newres) != len(result):
newres.append([valcol])
else:
newres[x].append(valcol)
else:
if isinstance(self.exps[i], FuncionesNativas):
newenc.append(self.exps[i].identificador)
else:
newenc.append('Exp' + len(newenc))
for fila in range(0, len(result)):
exp = self.exps[i]
res = self.resolver(exp, ent, result, tablas,
fila)
if len(newres) != len(result):
newres.append([res.valor])
else:
newres[fila].append(res.valor)
result = newres
self.encabezado = newenc
#distinct
if self.distinct != None:
newres = []
'elimino duplicados'
for i in range(0, len(result)):
encontrado = False
fila = result[i]
for j in range(0, len(result)):
if j != i:
if fila == result[j]:
encontrado = True
if encontrado == False:
newres.append(fila)
result = newres
if imp == 1:
self.mostarresult(result, self.encabezado, self.nombreres)
return [self.encabezado, result]
except Exception as inst:
print(inst)
return
def where2id(self,entorno,tablas):
filtrado=[]
exp1:Expresion
exp2:Expresion
colres=[]
tipo1=''
tipo2= ''
encontrado1=0
encontrado2= 0
nocol1 = -1
nocol2 = -1
nomtabla1 = ''
nomtabla2 = ''
'realizar operacion'
exp1=self.where.exp1
exp2=self.where.exp2
val1=exp1.getval(entorno)
val2=exp2.getval(entorno)
op=self.where.operador
for tabla in tablas:
columnas=tabla.valor
i=0
for columna in columnas:
nombre = columna.nombre
self.encabezado.append(nombre)
if val1 == nombre:
encontrado1+=1
tipo1=columna.tipo
nocol1=i
nomtabla1=tabla.nombre
nomtabla1=nomtabla1.replace('_'+entorno.getDataBase(),'')
i=i+1
continue
if val2 == nombre:
encontrado2+=1
tipo2=columna.tipo
nocol2 = i
nomtabla2=tabla.nombre
nomtabla2=nomtabla2.replace('_'+entorno.getDataBase(),'')
i=i+1
continue
i=i+1
if encontrado1 == 1 and encontrado2 == 1:
datos1 = DBMS.extractTable(entorno.getDataBase(),nomtabla1)
datos2 = DBMS.extractTable(entorno.getDataBase(), nomtabla2)
if datos1 == datos2:
self.nombreres=nomtabla1
for i in range(0,len(datos1)):
dato1=datos1[i][nocol1]
dato2=datos1[i][nocol2]
expi = Terminal(tipo1, dato1)
expd = Terminal(tipo2, dato2)
if op in ('>','<','>=','<=','='):
nuevaop = Relacional(expi,expd,op);
if nuevaop.getval(entorno):
'Agrego la fila al resultado'
filtrado.append(datos1[i])
elif op in ('or','and','not'):
nuevaop = Logica(expi,expd,op);
if nuevaop.getval(entorno):
'Agrego la fila al resultado'
filtrado.append(datos1[i])
else:
variables.consola.insert('Error el resultado del where no es booleano \n')
return filtrado
else:
variables.consola.insert('Error el nombre de las columnas es ambiguo \n')
def execwhere(self,entorno,tablas):
filtrado=[]
exp1:Expresion
exp2:Expresion
colres=[]
tipo=''
isid=False
posid=-1
if isinstance(self.where, Relacional) or isinstance(self.where,Logica):
encontrado=0
nocol=-1
nomtabla=''
'realizar operacion'
exp1=self.where.exp1
exp2=self.where.exp2
op=self.where.operador
val=''
if(exp1.tipo.tipo=='identificador') and exp2.tipo.tipo=='identificador':
return self.where2id(entorno,tablas)
elif (exp1.tipo.tipo=='identificador'):
val = exp1.getval(entorno)
posid = 1
else:
val = exp2.getval(entorno)
posid=2
for tabla in tablas:
columnas=tabla.valor
i=0
for columna in columnas:
nombre = columna.nombre
self.encabezado.append(nombre)
if val == nombre:
encontrado+=1
tipo=columna.tipo
nocol=i
nomtabla=tabla.nombre
nomtabla=nomtabla.replace('_'+entorno.getDataBase(),'')
continue
i=i+1
if encontrado==1 and nocol>-1:
datos=DBMS.extractTable(entorno.getDataBase(),nomtabla)
if datos!= None:
self.nombreres = nomtabla
for i in range(0,len(datos)):
dato=datos[i][nocol]
expi = None
expd = None
if posid == 1:
expi = Terminal(tipo, dato)
expd = exp2
else:
expi = exp1
expd = Terminal(tipo, dato)
if op in ('>','<','>=','<=','='):
nuevaop = Relacional(expi,expd,op);
if nuevaop.getval(entorno):
'Agrego la fila al resultado'
filtrado.append(datos[i])
elif op in ('or','and','not'):
nuevaop = Logica(expi,expd,op);
if nuevaop.getval(entorno):
'Agrego la fila al resultado'
filtrado.append(datos[i])
else:
variables.consola.insert('Error el resultado del where no es booleano \n')
return filtrado
else:
variables.consola.insert('Error el nombre de las columnas es ambiguo \n')
elif isinstance(self.where,Unaria):
'busco columna y resulvo unaria'
else:
'ya veremos dijo el ciego'
def ejecutar(self,ent:Entorno):
tablas = []
result = []
self.encabezado = []
'Metodo Abstracto para ejecutar la instruccion'
if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None:
resultados = [];
for exp in self.exps:
if exp != None:
resultados.append(exp.getval(ent))
return resultados
elif self.froms != None and self.exps!= None:
for exp in self.froms:
if exp != None:
tipo =exp.tipo;
if tipo.tipo=='identificador':
nombre=exp.getval(ent)
self.nombreres = nombre
tabla=ent.buscarSimbolo(nombre+"_"+ent.getDataBase())
if tabla!=None:
tablas.append(tabla)
else:
return ("ERROR >> En la instrucción Select, la tabla: "+nombre+" NO EXISTE")
else:
return ("ERROR >> En la instrucción Select, ingreso un nombre de tabla incorrecto")
else:
return ("Algo paso")
if len(tablas)>1:
'producto cartesiano'
'Obteniendo encabezados de las tablas'
postab = 1
for tabla in tablas:
cols = tabla.valor
for columna in cols:
nombre = columna.nombre
self.encabezados.append(nombre+"_T"+str(postab))
postab = postab +1
'producto cartesiano'
real = tablas[0].nombre.replace('_' + ent.getDataBase(), '')
result = DBMS.extractTable(ent.getDataBase(), real)
self.nombreres = real+"(T1)"
for i in range(0, len(tablas)-1):
real2 = tablas[i+1].nombre.replace('_' + ent.getDataBase(), '')
self.nombreres += '_' + real2 + "(T"+str(i+2)+")"
tabla2 = DBMS.extractTable(ent.getDataBase(), real2)
result = self.producto(result, tabla2)
else:
'llenar resultado desde backend'
real=tablas[0].nombre.replace('_'+ent.getDataBase(),'')
result=DBMS.extractTable(ent.getDataBase(),real)
#filtros
if self.where != None:
result=self.execwhere(ent,tablas)
else:
if (len(self.encabezados)==0):
for tabla in tablas:
cols = tabla.valor
for columna in cols:
nombre = columna.nombre
self.encabezados.append(nombre)
#acceder a columnas
if len(self.exps) == 1:
if self.exps[0].getval(ent) == '*':
self.mostarresult(result, self.nombreres)
elif self.exps[0].tipo.tipo=='identificador':
'obtengo solo columnas pedidas'
else:
'pendientes subconsultas y funciones'
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])
# show all data
#j.showCollection()
a=j.extractTable("BD1", "personas")
horaActual= datetime.now().strftime("%H:%M:%S")
print(horaActual)
# 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
# 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']]
