def alterTable(database: str, tableOld: str, tableNew: str) -> int:
"""Renames a table in a database
Parameters:\n
database (str): name of the database
tableOld (str): name of the target table
tableNew (str): new name of the table
Returns:\n
0: successful operation
1: an error ocurred
2: non-existent database
3: non-existent target table
4: new table name occupied
"""
bd = _database(database)
if bd:
tb = _table(database, tableOld)
if tb:
mode = tb["modo"]
val = -1
if mode == "avl":
val = avl.alterTable(database, tableOld, tableNew)
elif mode == "b":
val = b.alterTable(database, tableOld, tableNew)
elif mode == "bplus":
val = bplus.alterTable(database, tableOld, tableNew)
elif mode == "hash":
val = hash.alterTable(database, tableOld, tableNew)
elif mode == "isam":
val = isam.alterTable(database, tableOld, tableNew)
elif mode == "json":
val = json.alterTable(database, tableOld, tableNew)
elif mode == "dict":
val = dict.alterTable(database, tableOld, tableNew)
if val == 0:
_table(database, tableOld)["nombre"]=tableNew
_Guardar()
return val
else:
return 3
else:
return 2
def alterTable(database, tableOld, tableNew):
if searchInMode(tableOld) != None:
currentMode = searchInMode(tableOld)
if currentMode == 'avl':
avlList.append(tableNew)
return avl.alterTable(database, tableOld, tableNew)
elif currentMode == 'b':
bList.append(tableNew)
return b.alterTable(database, tableOld, tableNew)
elif currentMode == 'bplus':
bplusList.append(tableNew)
return bplus.alterTable(database, tableOld, tableNew)
elif currentMode == 'dict':
dictList.append(tableNew)
return DM.alterTable(database, tableOld, tableNew)
elif currentMode == 'isam':
isamList.append(tableNew)
return isam.alterTable(database, tableOld, tableNew)
elif currentMode == 'json':
jsonList.append(tableNew)
return j.alterTable(database, tableOld, tableNew)
elif currentMode == 'hash':
hashList.append(tableNew)
return Hash.alterTable(database, tableOld, tableNew)
else:
return 2
def delete(database, table, columns):
if searchInMode(database) != None:
currentMode = searchInMode(database)
if currentMode == 'avl':
# avlList.append(tableNew)
return avl.delete(database, table, columns)
elif currentMode == 'b':
# bList.append(tableNew)
return b.delete(database, table, columns)
elif currentMode == 'bplus':
# bplusList.append(tableNew)
return bplus.delete(database, table, columns)
elif currentMode == 'dict':
# dictList.append(tableNew)
return DM.delete(database, table, columns)
elif currentMode == 'isam':
# isamList.append(tableNew)
return isam.delete(database, table, columns)
elif currentMode == 'json':
# jsonList.append(tableNew)
return j.delete(database, table, columns)
elif currentMode == 'hash':
# hashList.append(tableNew)
return Hash.delete(database, table, columns)
else:
return 2
def createTable(database, table, numbercolumns):
if searchInMode(database) != None:
currentMode = searchInMode(database)
if currentMode == 'avl':
avlList.append(table)
return avl.createTable(database, table, numbercolumns)
elif currentMode == 'b':
bList.append(table)
return b.createTable(database, table, numbercolumns)
elif currentMode == 'bplus':
bplusList.append(table)
return bplus.createTable(database, table, numbercolumns)
elif currentMode == 'dict':
dictList.append(table)
return DM.createTable(database, table, numbercolumns)
elif currentMode == 'isam':
isamList.append(table)
return isam.createTable(database, table, numbercolumns)
elif currentMode == 'json':
jsonList.append(table)
return j.createTable(database, table, numbercolumns)
elif currentMode == 'hash':
hashList.append(table)
return Hash.createTable(database, table, numbercolumns)
else:
return 2
def extractTable(database, table):
if searchInMode(database) != None:
currentMode = searchInMode(database)
if currentMode == 'avl':
# avlList.append(tableNew)
return avl.extractTable(database, table)
elif currentMode == 'b':
# bList.append(tableNew)
#registros = b.extractTable(database, table) -> [reg,reg2,regi]
return b.extractTable(database, table)
elif currentMode == 'bplus':
# bplusList.append(tableNew)
return bplus.extractTable(database, table)
elif currentMode == 'dict':
# dictList.append(tableNew)
return DM.extractTable(database, table)
elif currentMode == 'isam':
# isamList.append(tableNew)
return isam.extractTable(database, table)
elif currentMode == 'json':
# jsonList.append(tableNew)
return j.extractTable(database, table)
elif currentMode == 'hash':
# hashList.append(tableNew)
return Hash.extractTable(database, table)
else:
return 2
def alterAddPK(database, table, columns):
dbs = databases.find_all(database)
if dbs == []:
return 2
for db in dbs:
if db.mode == "avl":
result = avlMode.alterAddPK(database, table, columns)
elif db.mode == "b":
result = BMode.alterAddPK(database, table, columns)
elif db.mode == "bplus":
result = BPlusMode.alterAddPK(database, table, columns)
elif db.mode == "dict":
result = DictMode.alterAddPK(database, table, columns)
elif db.mode == "isam":
result = ISAMMode.alterAddPK(database, table, columns)
elif db.mode == "json":
result = jsonMode.alterAddPK(database, table, columns)
elif db.mode == "hash":
result = HashMode.alterAddPK(database, table, columns)
if result != 3:
if result == 0:
db.tables.search(table).pk += columns
for x in range(5):
try:
Serializable.commit(databases, "lista_bases_de_datos")
return result
except:
break
return 1
break
return result
def createDatabase(database: str, mode: str, encoding: str):
if verify_string(database):
if exist(database): return 2
if encoding.lower().strip() is "ascii" or encoding.lower().strip() is "iso-8859-1" \
or encoding.lower().strip() is "utf8":
status = -1
if mode.lower().strip() is "avl":
status = avl.createDatabase(database)
elif mode.lower().strip() is "b":
status = b.createDatabase(database)
elif mode.lower().strip() is "bplus":
status = bPlus.createDatabase(database)
elif mode.lower().strip() is "dict":
status = diccionario.createDatabase(database)
elif mode.lower().strip() is "isam":
status = isam.createDatabase(database)
elif mode.lower().strip() is "json":
status = json.createDatabase(database)
elif mode.lower().strip() is "hash":
status = hash.createDatabase(database)
else:
return 3
if status == 0:
save_mode(database, mode, encoding)
return status
else:
return 4
else:
return 1
def extractRangeTable(database: str, table: str, columnNumber: int, lower: any,
upper: any) -> list:
dbs = databases.find_all(database)
if dbs == []:
return None
if databases.find_table(database, table) == None:
return None
registers = []
for db in dbs:
if db.tables.search(table) == None:
continue
if db.mode == "avl":
registers = avlMode.extractRangeTable(database, table,
columnNumber, lower, upper)
elif db.mode == "b":
registers = BMode.extractRangeTable(database, table, columnNumber,
lower, upper)
elif db.mode == "bplus":
registers = BPlusMode.extractRangeTable(database, table,
columnNumber, lower, upper)
elif db.mode == "dict":
registers = DictMode.extractRangeTable(database, table,
columnNumber, lower, upper)
elif db.mode == "isam":
registers = ISAMMode.extractRangeTable(database, table,
columnNumber, lower, upper)
elif db.mode == "json":
registers = jsonMode.extractRangeTable(database, table,
columnNumber, lower, upper)
elif db.mode == "hash":
registers = HashMode.extractRangeTable(database, table,
columnNumber, lower, upper)
return registers
def alterTable(database, tableOld, tableNew):
dbs = databases.find_all(database)
if dbs == []:
return 2
for db in dbs:
if db.mode == "avl":
result = avlMode.alterTable(database, tableOld, tableNew)
elif db.mode == "b":
result = BMode.alterTable(database, tableOld, tableNew)
elif db.mode == "bplus":
result = BPlusMode.alterTable(database, tableOld, tableNew)
elif db.mode == "dict":
result = DictMode.alterTable(database, tableOld, tableNew)
elif db.mode == "isam":
result = ISAMMode.alterTable(database, tableOld, tableNew)
elif db.mode == "json":
result = jsonMode.alterTable(database, tableOld, tableNew)
elif db.mode == "hash":
result = HashMode.alterTable(database, tableOld, tableNew)
if result != 3:
if result == 0:
db.tables.search(tableOld).name = tableNew
for x in range(5):
try:
Serializable.commit(databases, "lista_bases_de_datos")
return result
except:
continue
return 1
break
return result
def insert(database: str, table: str, register: list):
dbs = databases.find_all(database)
if dbs == []:
return 2
for x in register:
if type(x) == str and not verify_encoding(x, dbs[0].encoding):
return 6
for db in dbs:
if db.mode == "avl":
result = avlMode.insert(database, table, register)
elif db.mode == "b":
result = BMode.insert(database, table, register)
elif db.mode == "bplus":
result = BPlusMode.insert(database, table, register)
elif db.mode == "dict":
result = DictMode.insert(database, table, register)
elif db.mode == "isam":
result = ISAMMode.insert(database, table, register)
elif db.mode == "json":
result = jsonMode.insert(database, table, register)
elif db.mode == "hash":
result = HashMode.insert(database, table, register)
if result != 3:
break
return result
def delete(database: str, table: str, columns: list):
dbs = databases.find_all(database)
if dbs == []:
return 2
if databases.find_table(database, table) == None:
return 3
result = 1
for db in dbs:
if db.tables.search(table) == None:
continue
if db.mode == "avl":
result = avlMode.delete(database, table, columns)
elif db.mode == "b":
result = BMode.delete(database, table, columns)
elif db.mode == "bplus":
result = BPlusMode.delete(database, table, columns)
elif db.mode == "dict":
result = DictMode.delete(database, table, columns)
elif db.mode == "isam":
result = ISAMMode.delete(database, table, columns)
elif db.mode == "json":
result = jsonMode.delete(database, table, columns)
elif db.mode == "hash":
result = HashMode.delete(database, table, columns)
return result
def update(database, table, register, columns):
dbs = databases.find_all(database)
if dbs == []:
return 2
if databases.find_table(database, table) == None:
return 3
for x in register.values():
if type(x) == str and not verify_encoding(x, dbs[0].encoding):
return 5
result = 1
for db in dbs:
if db.tables.search(table) == None:
continue
if db.mode == "avl":
result = avlMode.update(database, table, register, columns)
elif db.mode == "b":
result = BMode.update(database, table, register, columns)
elif db.mode == "bplus":
result = BPlusMode.update(database, table, register, columns)
elif db.mode == "dict":
result = DictMode.update(database, table, register, columns)
elif db.mode == "isam":
result = ISAMMode.update(database, table, register, columns)
elif db.mode == "json":
result = jsonMode.update(database, table, register, columns)
elif db.mode == "hash":
result = HashMode.update(database, table, register, columns)
return result
def extractRow(database, table, columns):
dbs = databases.find_all(database)
if dbs == []:
return []
if databases.find_table(database, table) == None:
return []
result = []
for db in dbs:
if db.tables.search(table) == None:
continue
if db.mode == "avl":
result = avlMode.extractRow(database, table, columns)
elif db.mode == "b":
result = BMode.extractRow(database, table, columns)
elif db.mode == "bplus":
result = BPlusMode.extractRow(database, table, columns)
elif db.mode == "dict":
result = DictMode.extractRow(database, table, columns)
elif db.mode == "isam":
result = ISAMMode.extractRow(database, table, columns)
elif db.mode == "json":
result = jsonMode.extractRow(database, table, columns)
elif db.mode == "hash":
result = HashMode.extractRow(database, table, columns)
return result
def insert(database, table, register):
if saveModo_bandera is False:
Block.activar_SaveModo(register)
#print("validacion correcta")
if searchInMode(database) != None:
currentMode = searchInMode(database)
if currentMode == 'avl':
# avlList.append(tableNew)
return avl.insert(database, table, register)
elif currentMode == 'b':
# bList.append(tableNew)
return b.insert(database, table, register)
elif currentMode == 'bplus':
# bplusList.append(tableNew)
return bplus.insert(database, table, register)
elif currentMode == 'dict':
# dictList.append(tableNew)
return DM.insert(database, table, register)
elif currentMode == 'isam':
# isamList.append(tableNew)
return isam.insert(database, table, register)
elif currentMode == 'json':
# jsonList.append(tableNew)
return j.insert(database, table, register)
elif currentMode == 'hash':
# hashList.append(tableNew)
return Hash.insert(database, table, register)
else:
return 2
def extractRangeTable(database: str, table: str, columnNumber: int, lower: any,
upper: any) -> list:
db = databases.search(database)
if db == None:
return None
if db.mode == "avl":
result = avlMode.extractRangeTable(database, table, columnNumber,
lower, upper)
elif db.mode == "b":
result = BMode.extractRangeTable(database, table, columnNumber, lower,
upper)
elif db.mode == "bplus":
result = BPlusMode.extractRangeTable(database, table, columnNumber,
lower, upper)
elif db.mode == "dict":
result = DictMode.extractRangeTable(database, table, columnNumber,
lower, upper)
elif db.mode == "isam":
result = ISAMMode.extractRangeTable(database, table, columnNumber,
lower, upper)
elif db.mode == "json":
result = jsonMode.extractRangeTable(database, table, columnNumber,
lower, upper)
elif db.mode == "hash":
result = HashMode.extractRangeTable(database, table, columnNumber,
lower, upper)
return result
def alterDatabase(databaseOld: str, databaseNew: str) -> int:
if re.search(DB_NAME_PATTERN, databaseOld) and re.search(
DB_NAME_PATTERN, databaseNew):
if databases.search(databaseNew) != None:
return 3
dbs = databases.find_all(databaseOld)
if dbs == []:
return 2
for db in dbs:
if db.mode == "avl":
code = avlMode.alterDatabase(databaseOld, databaseNew)
elif db.mode == "b":
code = BMode.alterDatabase(databaseOld, databaseNew)
elif db.mode == "bplus":
code = BPlusMode.alterDatabase(databaseOld, databaseNew)
elif db.mode == "dict":
code = DictMode.alterDatabase(databaseOld, databaseNew)
elif db.mode == "isam":
code = ISAMMode.alterDatabase(databaseOld, databaseNew)
elif db.mode == "json":
code = jsonMode.alterDatabase(databaseOld, databaseNew)
elif db.mode == "hash":
code = HashMode.alterDatabase(databaseOld, databaseNew)
if code == 0:
db.name = databaseNew
try:
Serializable.commit(databases, "lista_bases_de_datos")
return 0
except:
db.name = databaseOld
return 1
else:
return 1
def __drop_table_sp(database, table, mode):
dbs = databases.find_all(database)
if dbs == []:
return 2
if databases.find_table(database, table) == None:
return 3
for db in dbs:
if db.mode == mode == "avl":
result = avlMode.dropTable(database, table)
elif db.mode == mode == "b":
result = BMode.dropTable(database, table)
elif db.mode == mode == "bplus":
result = BPlusMode.dropTable(database, table)
elif db.mode == mode == "dict":
result = DictMode.dropTable(database, table)
elif db.mode == mode == "isam":
result = ISAMMode.dropTable(database, table)
elif db.mode == mode == "json":
result = jsonMode.dropTable(database, table)
elif db.mode == mode == "hash":
result = HashMode.dropTable(database, table)
else:
continue
if result != 3:
if result == 0:
db.tables.delete(table)
for x in range(5):
try:
Serializable.commit(databases, "lista_bases_de_datos")
return result
except:
break
return 1
break
return result
def dropDatabase(database: str) -> int:
if re.search(DB_NAME_PATTERN, database):
dbs = databases.find_all(database)
if dbs == []:
return 2
for db in dbs:
if db.mode == "avl":
code = avlMode.dropDatabase(database)
elif db.mode == "b":
code = BMode.dropDatabase(database)
elif db.mode == "bplus":
code = BPlusMode.dropDatabase(database)
elif db.mode == "dict":
code = DictMode.dropDatabase(database)
elif db.mode == "isam":
code = ISAMMode.dropDatabase(database)
elif db.mode == "json":
code = jsonMode.dropDatabase(database)
elif db.mode == "hash":
code = HashMode.dropDatabase(database)
if code == 0:
databases.delete(db.name)
for x in range(5):
try:
Serializable.commit(databases, "lista_bases_de_datos")
return 0
except:
continue
return 1
else:
return 1
def alterAddFK(database: str, table: str, references: dict) -> int:
bd = _Buscar(database)
if bd:
mode = bd[1]
val = -1
if mode == "avl":
val = avl.alterAddFK(database, table, references)
elif mode == "b":
val = b.alterAddFK(database, table, references)
elif mode == "bplus":
val = bplus.alterAddFK(database, table, references)
elif mode == "hash":
val = hash.alterAddFK(database, table, references)
elif mode == "isam":
val = isam.alterAddFK(database, table, references)
elif mode == "json":
val = json.alterAddFK(database, table, references)
elif mode == "dict":
val = dict.alterAddFK(database, table, references)
return val
else:
return 2
def createTable(database: str, table: str, numberColumns: int) -> int:
db = databases.search(database)
if db == None:
return 2
if table in showTables(database):
return 3
if db.mode == "avl":
result = avlMode.createTable(database, table, numberColumns)
elif db.mode == "b":
result = BMode.createTable(database, table, numberColumns)
elif db.mode == "bplus":
result = BPlusMode.createTable(database, table, numberColumns)
elif db.mode == "dict":
result = DictMode.createTable(database, table, numberColumns)
elif db.mode == "isam":
result = ISAMMode.createTable(database, table, numberColumns)
elif db.mode == "json":
result = jsonMode.createTable(database, table, numberColumns)
elif db.mode == "hash":
result = HashMode.createTable(database, table, numberColumns)
if result == 0:
if db.tables.create(table, numberColumns) == 0:
for x in range(5):
try:
Serializable.commit(databases, "lista_bases_de_datos")
return result
except:
continue
return 1
return result
def createdatabase(db, modo, cod):
if not modo in modos:
return 3
if not cod in encoding:
return 4
if buscar(db) == None:
if modo == "avl":
tmp = avl.createDatabase(db)
elif modo == "b":
tmp = b.createDatabase(db)
elif modo == "bplus":
tmp = bplus.createDatabase(db)
elif modo == "hash":
tmp = hash.createDatabase(db)
elif modo == "isam":
tmp = isam.createDatabase(db)
elif modo == "json":
tmp = json.createDatabase(db)
elif modo == "dict":
tmp = dict.createDatabase(db)
else:
return 2
if tmp == 0:
lista_db.append([db, modo, cod])
return 0
else:
return 1
def alterDropColumn(database: str, table: str, columnNumber: int) -> int:
dbs = databases.find_all(database)
if dbs == []:
return 2
for db in dbs:
if db.mode == "avl":
result = avlMode.alterDropColumn(database, table, columnNumber)
elif db.mode == "b":
result = BMode.alterDropColumn(database, table, columnNumber)
elif db.mode == "bplus":
result = BPlusMode.alterDropColumn(database, table, columnNumber)
elif db.mode == "dict":
result = DictMode.alterDropColumn(database, table, columnNumber)
elif db.mode == "isam":
result = ISAMMode.alterDropColumn(database, table, columnNumber)
elif db.mode == "json":
result = jsonMode.alterDropColumn(database, table, columnNumber)
elif db.mode == "hash":
result = HashMode.alterDropColumn(database, table, columnNumber)
if result != 3:
if result == 0:
db.search(table).columns -= 1
for x in range(5):
try:
Serializable.commit(databases, "lista_bases_de_datos")
return result
except:
break
return 1
break
return result
def alterDropColumn(database, table, columnNumber):
if searchInMode(database) != None:
currentMode = searchInMode(database)
if currentMode == 'avl':
# avlList.append(tableNew)
return avl.alterDropColumn(database, table, columnNumber)
elif currentMode == 'b':
# bList.append(tableNew)
return b.alterDropColumn(database, table, columnNumber)
elif currentMode == 'bplus':
# bplusList.append(tableNew)
return bplus.alterDropColumn(database, table, columnNumber)
elif currentMode == 'dict':
# dictList.append(tableNew)
return DM.alterDropColumn(database, table, columnNumber)
elif currentMode == 'isam':
# isamList.append(tableNew)
return isam.alterDropColumn(database, table, columnNumber)
elif currentMode == 'json':
# jsonList.append(tableNew)
return j.alterDropColumn(database, table, columnNumber)
elif currentMode == 'hash':
# hashList.append(tableNew)
return Hash.alterDropColumn(database, table, columnNumber)
else:
return 2
def __insert_sp(database: str, table: str, register: list, mode: str):
dbs = databases.find_all(database)
if dbs == []:
return 2
tb = databases.find_table(database, table)
if tb == None:
return 3
if len(register) != tb.columns:
return 5
if mode not in MODES:
return 6
for db in dbs:
if db.mode != mode:
continue
if db.mode == "avl":
result = avlMode.insert(database, table, register)
elif db.mode == "b":
result = BMode.insert(database, table, register)
elif db.mode == "bplus":
result = BPlusMode.insert(database, table, register)
elif db.mode == "dict":
result = DictMode.insert(database, table, register)
elif db.mode == "isam":
result = ISAMMode.insert(database, table, register)
elif db.mode == "json":
result = jsonMode.insert(database, table, register)
elif db.mode == "hash":
result = HashMode.insert(database, table, register)
else:
continue
if result != 3:
break
return result
def extractRangeTable(database, table, columnNumber, lower, upper):
if searchInMode(database) != None:
currentMode = searchInMode(database)
if currentMode == 'avl':
# avlList.append(tableNew)
return avl.extractRangeTable(database, table, columnNumber, lower, upper)
elif currentMode == 'b':
# bList.append(tableNew)
return b.extractRangeTable(database, table, columnNumber, lower, upper)
elif currentMode == 'bplus':
# bplusList.append(tableNew)
return bplus.extractRangeTable(database, table, columnNumber, lower, upper)
elif currentMode == 'dict':
# dictList.append(tableNew)
return DM.extractRangeTable(database, table, columnNumber, lower, upper)
elif currentMode == 'isam':
# isamList.append(tableNew)
return isam.extractRangeTable(database, table, columnNumber, lower, upper)
elif currentMode == 'json':
# jsonList.append(tableNew)
return j.extractRangeTable(database, table, lower, upper)
elif currentMode == 'hash':
# hashList.append(tableNew)
return Hash.extractRangeTable(database, table, columnNumber, lower, upper)
else:
return 2
def loadCSV(file: str, database: str, table: str) -> list:
try:
result = []
dbs = databases.find_all(database)
for db in dbs:
tb = db.tables.search(table)
if tb == None:
continue
if db.mode == "avl":
result = avlMode.loadCSV(file, database, table)
elif db.mode == "b":
result = BMode.loadCSV(file, database, table)
elif db.mode == "bplus":
result = BPlusMode.loadCSV(file, database, table)
elif db.mode == "dict":
result = DictMode.loadCSV(file, database, table)
elif db.mode == "isam":
result = ISAMMode.loadCSV(file, database, table)
elif db.mode == "json":
result = jsonMode.loadCSV(file, database, table)
elif db.mode == "hash":
result = HashMode.loadCSV(file, database, table)
return result
except:
return []
def insert(database, table, register):
if searchInMode(database) != None:
currentMode = searchInMode(database)
if currentMode == 'avl':
# avlList.append(tableNew)
return avl.insert(database, table, register)
elif currentMode == 'b':
# bList.append(tableNew)
return b.insert(database, table, register)
elif currentMode == 'bplus':
# bplusList.append(tableNew)
return bplus.insert(database, table, register)
elif currentMode == 'dict':
# dictList.append(tableNew)
return DM.insert(database, table, register)
elif currentMode == 'isam':
# isamList.append(tableNew)
return isam.insert(database, table, register)
elif currentMode == 'json':
# jsonList.append(tableNew)
return j.insert(database, table, register)
elif currentMode == 'hash':
# hashList.append(tableNew)
return Hash.insert(database, table, register)
else:
return 2
def extractTable(database, table):
dbs = databases.find_all(database)
if dbs == []:
return None
if databases.find_table(database, table) == None:
return None
result = []
for db in dbs:
tb = db.tables.search(table)
if tb != None:
if db.mode == "avl":
result = avlMode.extractTable(database, table)
elif db.mode == "b":
result = BMode.extractTable(database, table)
elif db.mode == "bplus":
result = BPlusMode.extractTable(database, table)
elif db.mode == "dict":
result = DictMode.extractTable(database, table)
elif db.mode == "isam":
result = ISAMMode.extractTable(database, table)
elif db.mode == "json":
result = jsonMode.extractTable(database, table)
elif db.mode == "hash":
result = HashMode.extractTable(database, table)
else:
continue
return result
def truncate(database, table):
if searchInMode(database) != None:
currentMode = searchInMode(database)
if currentMode == 'avl':
# avlList.append(tableNew)
return avl.truncate(database, table)
elif currentMode == 'b':
# bList.append(tableNew)
return b.truncate(database, table)
elif currentMode == 'bplus':
# bplusList.append(tableNew)
return bplus.truncate(database, table)
elif currentMode == 'dict':
# dictList.append(tableNew)
return DM.truncate(database, table)
elif currentMode == 'isam':
# isamList.append(tableNew)
return isam.truncate(database, table)
elif currentMode == 'json':
# jsonList.append(tableNew)
return j.truncate(database, table)
elif currentMode == 'hash':
# hashList.append(tableNew)
return Hash.truncate(database, table)
else:
return 2
def _createTable(database, table, numberColumns, mode):
val = -1
if mode == "avl":
val = avl.createTable(database, table, numberColumns)
elif mode == "b":
val = b.createTable(database, table, numberColumns)
elif mode == "bplus":
val = bplus.createTable(database, table, numberColumns)
elif mode == "hash":
val = hash.createTable(database, table, numberColumns)
elif mode == "isam":
val = isam.createTable(database, table, numberColumns)
elif mode == "json":
val = json.createTable(database, table, numberColumns)
elif mode == "dict":
val = dict.createTable(database, table, numberColumns)
if val == 0:
_database(database)["tablas"].append({"nombre": table, "modo":mode, "columnas": numberColumns, "pk": []})
_Guardar()
return val
