def showDatabases():
print("AVL")
print(avl_mode.showDatabases())
print("b")
print(b_mode.showDatabases())
print("b+")
print(bplus_mode.showDatabases())
print("dict")
print(dict_mode.showDatabases())
print("isam")
print(isam_mode.showDatabases())
print("json")
print(json_mode.showDatabases())
print("hash")
print(hash_mode.showDatabases())
def loadCSV(file, database, table):
mode = None
for i in range(7):
mode = obtenerBase(database, i)
if mode == []:
continue
else:
if mode == 0:
mode = "avl"
elif mode == 1:
mode = "b"
elif mode == 2:
mode = "bplus"
elif mode == 3:
mode = "dict"
elif mode == 4:
mode = "isam"
elif mode == 5:
mode = "json"
elif mode == 6:
mode = "hash"
break
if mode == None:
return 2
if mode == "avl":
# Grupo 16
val = avl_mode.loadCSV(file, database, table)
elif mode == "b":
# Grupo 17
val = b_mode.loadCSV(file, database, table)
elif mode == "bplus":
# Grupo 18
val = bplus_mode.loadCSV(file, database, table)
elif mode == "dict":
# Auxiliar
val = dict_mode.loadCSV(file, database, table)
elif mode == "isam":
# Grupo 14
val = isam_mode.loadCSV(file, database, table)
elif mode == "json":
# Ingeniero
val = json_mode.loadCSV(file, database, table)
elif mode == "hash":
# Grupo 15
val = hash_mode.loadCSV(file, database, table)
else:
val = 3
return val
def obtenerTablas(database, estructura):
val = []
if estructura == 0:
val = avl_mode.showTables(database)
elif estructura == 1:
val = b_mode.showTables(database)
elif estructura == 2:
val = bplus_mode.showTables(database)
elif estructura == 3:
val = dict_mode.showTables(database)
elif estructura == 4:
val = isam_mode.showTables(database)
elif estructura == 5:
val = json_mode.showTables(database)
elif estructura == 6:
val = hash_mode.showTables(database)
return val
def createDatabase(database, mode, encoding):
val = 1
if encoding != "ascii" and encoding != "iso-8859-1" and encoding != "utf8":
val = 4
else:
if mode == "avl":
# Grupo 16
val = avl_mode.createDatabase(database)
elif mode == "b":
# Grupo 17
val = b_mode.createDatabase(database)
elif mode == "bplus":
# Grupo 18
val = bplus_mode.createDatabase(database)
elif mode == "dict":
# Auxiliar
val = dict_mode.createDatabase(database)
elif mode == "isam":
# Grupo 14
val = isam_mode.createDatabase(database)
elif mode == "json":
# Ingeniero
val = json_mode.createDatabase(database)
elif mode == "hash":
# Grupo 15
val = hash_mode.createDatabase(database)
else:
val = 3
if val == 0:
global Bases
try:
# Leemos el archivo binario de los registros de bases de datos
fichero_lectura = open("BD_register", "rb")
Bases = pickle.load(fichero_lectura)
Bases.update({database: {"mode": mode, "encoding": encoding}})
# Actualizamos el archivo binario de los registros de bases de datos
fichero_escritura = open("BD_register", "wb")
pickle.dump(Bases, fichero_escritura)
fichero_escritura.close()
except:
Bases.update({database: {"mode": mode, "encoding": encoding}})
# Actualizamos el archivo binario de los registros de bases de datos
fichero_escritura = open("BD_register", "wb")
pickle.dump(Bases, fichero_escritura)
fichero_escritura.close()
return val
def obtenerContenidoTabla(database, table, estructura):
val = []
if estructura == 0:
val = avl_mode.extractTable(database, table)
elif estructura == 1:
val = b_mode.extractTable(database, table)
elif estructura == 2:
val = bplus_mode.extractTable(database, table)
elif estructura == 3:
val = dict_mode.extractTable(database, table)
elif estructura == 4:
val = isam_mode.extractTable(database, table.lower())
elif estructura == 5:
val = json_mode.extractTable(database, table)
elif estructura == 6:
val = hash_mode.extractTable(database, table)
if val == []:
return ""
contenido = ""
for i in range(len(val)):
contenido += str(val[i])
return contenido
def obtenerBase(database, estructura):
val = []
if estructura == 0:
val = avl_mode.showDatabases()
elif estructura == 1:
val = b_mode.showDatabases()
elif estructura == 2:
val = bplus_mode.showDatabases()
elif estructura == 3:
val = dict_mode.showDatabases()
elif estructura == 4:
val = isam_mode.showDatabases()
elif estructura == 5:
val = json_mode.showDatabases()
elif estructura == 6:
val = hash_mode.showDatabases()
if val == []:
return val
else:
for i in range(len(val)):
if val[i].lower() == database.lower():
return estructura
return []
def dropDatabase(database):
mode = None
for i in range(7):
mode = obtenerBase(database, i)
if mode == []:
continue
else:
if mode == 0:
mode = "avl"
elif mode == 1:
mode = "b"
elif mode == 2:
mode = "bplus"
elif mode == 3:
mode = "dict"
elif mode == 4:
mode = "isam"
elif mode == 5:
mode = "json"
elif mode == 6:
mode = "hash"
break
if mode == None:
return 2
if mode == "avl":
# Grupo 16
val = avl_mode.dropDatabase(database)
elif mode == "b":
# Grupo 17
val = b_mode.dropDatabase(database)
elif mode == "bplus":
# Grupo 18
val = bplus_mode.dropDatabase(database)
elif mode == "dict":
# Auxiliar
val = dict_mode.dropDatabase(database)
elif mode == "isam":
# Grupo 14
val = isam_mode.dropDatabase(database)
elif mode == "json":
# Ingeniero
val = json_mode.dropDatabase(database)
elif mode == "hash":
# Grupo 15
val = hash_mode.dropDatabase(database)
else:
val = 3
if val == 0:
global Bases
global Tablas
try:
# Leemos el archivo binario de los registros de bases de datos
fichero_lectura = open("BD_register", "rb")
Bases = pickle.load(fichero_lectura)
Bases.pop(database)
# Actualizamos el archivo binario de los registros de bases de datos
fichero_escritura = open("BD_register", "wb")
pickle.dump(Bases, fichero_escritura)
fichero_escritura.close()
try:
# Leemos el archivo binario de los registros de tablas
fichero_lectura = open("TB_register", "rb")
Tablas = pickle.load(fichero_lectura)
try:
Tablas.pop(database)
except:
""""""
# Actualizamos el archivo binario de los registros de tablas
fichero_escritura = open("TB_register", "wb")
pickle.dump(Tablas, fichero_escritura)
fichero_escritura.close()
except:
try:
Tablas.pop(database)
except:
""""""
# Actualizamos el archivo binario de los registros de tablas
fichero_escritura = open("TB_register", "wb")
pickle.dump(Tablas, fichero_escritura)
fichero_escritura.close()
except:
Bases.pop(database)
# Actualizamos el archivo binario de los registros de bases de datos
fichero_escritura = open("BD_register", "wb")
pickle.dump(Bases, fichero_escritura)
fichero_escritura.close()
try:
# Leemos el archivo binario de los registros de tablas
fichero_lectura = open("TB_register", "rb")
Tablas = pickle.load(fichero_lectura)
try:
Tablas.pop(database)
except:
""""""
# Actualizamos el archivo binario de los registros de tablas
fichero_escritura = open("TB_register", "wb")
pickle.dump(Tablas, fichero_escritura)
fichero_escritura.close()
except:
try:
Tablas.pop(database)
except:
""""""
# Actualizamos el archivo binario de los registros de tablas
fichero_escritura = open("TB_register", "wb")
pickle.dump(Tablas, fichero_escritura)
fichero_escritura.close()
return val
def createTable(database, table, numColumns):
mode = None
for i in range(7):
mode = obtenerBase(database, i)
if mode == []:
continue
else:
if mode == 0:
mode = "avl"
elif mode == 1:
mode = "b"
elif mode == 2:
mode = "bplus"
elif mode == 3:
mode = "dict"
elif mode == 4:
mode = "isam"
elif mode == 5:
mode = "json"
elif mode == 6:
mode = "hash"
break
if mode == None:
return 2
if mode == "avl":
# Grupo 16
val = avl_mode.createTable(database, table, numColumns)
elif mode == "b":
# Grupo 17
val = b_mode.createTable(database, table, numColumns)
elif mode == "bplus":
# Grupo 18
val = bplus_mode.createTable(database, table, numColumns)
elif mode == "dict":
# Auxiliar
val = dict_mode.createTable(database, table, numColumns)
elif mode == "isam":
# Grupo 14
val = isam_mode.createTable(database, table, numColumns)
elif mode == "json":
# Ingeniero
val = json_mode.createTable(database, table, numColumns)
elif mode == "hash":
# Grupo 15
val = hash_mode.createTable(database, table, numColumns)
else:
val = 3
if val == 0:
global Tablas
try:
# Leemos el archivo binario de los registros de bases de datos
lectura = open("TB_register", "rb")
Tablas = pickle.load(lectura)
try:
Tablas[database].update({table: {"PK": None, "FK": None}})
except:
Tablas.update({database: {table: {"PK": None, "FK": None}}})
# Actualizamos el archivo binario de los registros de bases de datos
escritura = open("TB_register", "wb")
pickle.dump(Tablas, escritura)
escritura.close()
except:
try:
Tablas[database].update({table: {"PK": None, "FK": None}})
except:
Tablas.update({database: {table: {"PK": None, "FK": None}}})
# Actualizamos el archivo binario de los registros de bases de datos
fichero_escritura = open("TB_register", "wb")
pickle.dump(Tablas, fichero_escritura)
fichero_escritura.close()
return val