def loadCSV(file: str, database: str, table: str) -> list:
try:
b.dicDB[database][table][0] = serializar.rollback(database + "-" +
table + "-B")
except:
pass
r = b.loadCSV(file, database, table)
try:
serializar.commit(b.dicDB[database][table][0],
database + "-" + table + "-B")
b.dicDB[database][table][0] = bt.arbolB(b.grade)
serializar.commit(b, "BDD")
except:
pass
return r
def insert(database: str, table: str, register: list) -> int:
try:
b.dicDB[database][table][0] = serializar.rollback(database + "-" +
table + "-B")
except:
pass
r = b.insert(database, table, register)
try:
serializar.commit(b.dicDB[database][table][0],
database + "-" + table + "-B")
b.dicDB[database][table][0] = bt.arbolB(b.grade)
serializar.commit(b, "BDD")
except:
pass
return r
def delete(database: str, table: str, columns: list) -> int:
try:
b.dicDB[database][table][0] = serializar.rollback(database + "-" +
table + "-B")
except:
pass
r = b.delete(database, table, columns)
try:
serializar.commit(b.dicDB[database][table][0],
database + "-" + table + "-B")
b.dicDB[database][table][0] = bt.arbolB(b.grade)
serializar.commit(b, "BDD")
except:
pass
return r
def truncate(database: str, table: str) -> int:
try:
b.dicDB[database][table][0] = serializar.rollback(database + "-" +
table + "-B")
except:
pass
r = b.truncate(database, table)
try:
serializar.commit(b.dicDB[database][table][0],
database + "-" + table + "-B")
b.dicDB[database][table][0] = bt.arbolB(b.grade)
serializar.commit(b, "BDD")
except:
pass
return r
def alterAddColumn(self, database, table, default):
if self.identify(database) and self.identify(table):
if self.searchDB(database):
if self.searchTB(database, table):
try:
self.dicDB[database][table][1] += 1
self.dicDB[database][table][0].agregarValor(default)
serializar.commit(self.dicDB[database][table][0],
database + "-" + table + "-B")
return 0
except:
return 1
return 3
return 2
return 1
def __create_database_sp(database: str, mode: str, encoding: str) -> int:
if encoding not in VALID_ENCODING:
return 4
dbs = databases.find_all(database)
if dbs != None:
for db in dbs:
if db.name == database and db.mode == mode:
# Ya existe esta base de datos alternativa
return 0
if mode == "avl":
code = avlMode.createDatabase(database)
elif mode == "b":
code = BMode.createDatabase(database)
elif mode == "bplus":
code = BPlusMode.createDatabase(database)
elif mode == "dict":
code = DictMode.createDatabase(database)
elif mode == "isam":
code = ISAMMode.createDatabase(database)
elif mode == "json":
code = jsonMode.createDatabase(database)
elif mode == "hash":
code = HashMode.createDatabase(database)
else:
return 3
if code == 0:
databases.create(database, mode, encoding)
try:
for i in range(5):
try:
Serializable.commit(databases, "lista_bases_de_datos")
except:
continue
except:
code_drop = dropDatabase(database)
if code_drop == 0:
databases.delete(database)
return 1
else:
for i in range(4):
code_drop = dropDatabase(database)
if code_drop == 0:
databases.delete(database)
break
return 1
return code
def createDatabase(database: str, mode: str, encoding: str) -> int:
if encoding not in VALID_ENCODING:
return 4
if databases.search(database) != None:
return 2
if mode == "avl":
code = avlMode.createDatabase(database)
elif mode == "b":
code = BMode.createDatabase(database)
elif mode == "bplus":
code = BPlusMode.createDatabase(database)
elif mode == "dict":
code = DictMode.createDatabase(database)
elif mode == "isam":
code = ISAMMode.createDatabase(database)
elif mode == "json":
code = jsonMode.createDatabase(database)
elif mode == "hash":
code = HashMode.createDatabase(database)
else:
return 3
if code == 0:
databases.create(database, mode, encoding)
databases.search(database).main_db = True
try:
for i in range(5):
try:
Serializable.commit(databases, "lista_bases_de_datos")
except:
continue
except:
code_drop = dropDatabase(database)
if code_drop == 0:
databases.delete(database)
return 1
else:
for i in range(4):
code_drop = dropDatabase(database)
if code_drop == 0:
databases.delete(database)
break
return 1
return code
def alterDropColumn(self, database, table, columnNumber):
if self.searchDB(database):
if self.searchTB(database, table):
if columnNumber >= 0 and columnNumber < self.dicDB[database][
table][1]:
if self.dicDB[database][table][1] > 1:
try:
columnNumber = int(columnNumber)
if self.dicDB[database][table][2] != None:
if columnNumber not in self.dicDB[database][
table][2]:
self.dicDB[database][table][1] -= 1
self.dicDB[database][table][
0].eliminarValor(columnNumber)
pk = []
for i in self.dicDB[database][table][2]:
if i < columnNumber:
pk.append(i)
else:
pk.append(i - 1)
self.dicDB[database][table][2] = pk
serializar.commit(
self.dicDB[database][table][0],
database + "-" + table + "-B")
return 0
return 4
else:
self.dicDB[database][table][1] -= 1
self.dicDB[database][table][0].eliminarValor(
columnNumber)
serializar.commit(
self.dicDB[database][table][0],
database + "-" + table + "-B")
return 0
except:
return 1
return 4
return 5
return 3
return 2
def update(self, database, table, register, columns):
if self.searchDB(database):
if self.searchTB(database, table):
try:
columns[0] = columns[0]
if self.dicDB[database][table][2] != None:
pk = ""
for i in columns:
pk += str(i) + "_"
pk = pk[:-1]
if pk in self.dicDB[database][table][0].Keys():
tupla = self.extractRow(database, table, columns)
for key, value in register.items():
tupla[key] = value
self.dicDB[database][table][0].update(tupla, pk)
self.updateTree(database, table)
serializar.commit(self.dicDB[database][table][0],
database + "-" + table + "-B")
return 0
return 4
else:
pk = ""
for i in columns:
pk += str(i) + "_"
pk = pk[:-1]
if pk in self.dicDB[database][table][0].Keys():
tupla = self.extractRow(database, table, columns)
for key, value in register.items():
tupla[key] = value
self.dicDB[database][table][0].update(tupla, pk)
self.updateTree(database, table)
serializar.commit(self.dicDB[database][table][0],
database + "-" + table + "-B")
return 0
return 4
except:
return 1
return 3
return 2
def __alter_add_pk_sp(database: str, table: str, columns: list,
mode: str) -> int:
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:
continue
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)
else:
continue
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:
continue
return 1
break
return result
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:
continue
if db.mode == "avl":
result = avlMode.dropTable(database, table)
elif db.mode == "b":
result = BMode.dropTable(database, table)
elif db.mode == "bplus":
result = BPlusMode.dropTable(database, table)
elif db.mode == "dict":
result = DictMode.dropTable(database, table)
elif db.mode == "isam":
result = ISAMMode.dropTable(database, table)
elif db.mode == "json":
result = jsonMode.dropTable(database, table)
elif db.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:
continue
return 1
break
return result
def __drop_database_sp(database: str, mode: str) -> int:
if re.search(DB_NAME_PATTERN, database):
dbs = databases.find_all(database)
if dbs == []:
return 2
if mode not in MODES:
return 4
for db in dbs:
if db.mode != mode:
continue
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)
else:
continue
if code == 0:
databases.delete_sp(db.name, db.mode)
for x in range(5):
try:
Serializable.commit(databases, "lista_bases_de_datos")
return 0
except:
continue
return 1
else:
return 1
def __create_table_sp(database: str, table: str, numberColumns: int,
mode: str) -> int:
dbs = databases.find_all(database)
if dbs == []:
return 2
if mode not in MODES:
return 4
for db in dbs:
if db.mode != mode:
continue
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)
else:
continue
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 alterTable(database: str, tableOld: str, tableNew: str) -> int:
r = b.alterTable(database, tableOld, tableNew)
serializar.commit(b, "BDD")
return r
def createTable(database: str, table: str, numberColumns: int) -> int:
r = b.createTable(database, table, numberColumns)
serializar.commit(b, "BDD")
return r
def dropDatabase(database: str) -> int:
r = b.dropDatabase(database)
serializar.commit(b, "BDD")
return r
def alterDatabase(databaseOld, databaseNew) -> int:
r = b.alterDatabase(databaseOld, databaseNew)
serializar.commit(b, "BDD")
return r
def createDatabase(database: str) -> int:
r = b.createDatabase(database)
serializar.commit(b, "BDD")
return r
def dropTable(database: str, table: str) -> int:
r = b.dropTable(database, table)
serializar.commit(b, "BDD")
return r
MODES = ['avl', 'b', 'bplus', 'dict', 'isam', 'json', 'hash']
HEX_SYMBOLS = [
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E",
"F"
]
VALID_ENCODING = ["utf8", "iso-8859-1", "ascii"]
DB_NAME_PATTERN = "^[a-zA-Z][a-zA-Z0-9#@$_]*"
# Obteniendo la lista general de bases de datos a partir del binario almacenado
# Si no existe el binario, se crea una nueva lista de bases de datos y se almacena
# el binario
try:
databases = Serializable.rollback("lista_bases_de_datos")
except FileNotFoundError:
databases = DBList()
Serializable.commit(databases, "lista_bases_de_datos")
# Descripción:
# Crea una nueva base de datos
# Parámetros:
# database:str - El nombre de la nueva base de datos
# mode:str - El modo de almacenamiento a utilizar en la base de datos
# encoding:str - La codificación utilizada por la base de datos
# Valores de Retorno:
# 0 - Operación exitosa
# 1 - Error en la operación
# 2 - Base de datos existente
# 3 - Modo incorrecto
# 4 - Codificación incorrecta
def createDatabase(database: str, mode: str, encoding: str) -> int:
# File: B Mode Package
# License: Released under MIT License
# Notice: Copyright (c) 2020 TytusDB Team
from storage.b import DataBase as db
from storage.b import Serializable as serializar
from storage.b import Estructura_ArbolB as bt
b = db.DB()
try:
b = serializar.rollback("BDD")
except:
serializar.commit(b, "BDD")
#---------------------FUNCIONES BASES DE DATOS----------------------#
def createDatabase(database: str) -> int:
r = b.createDatabase(database)
serializar.commit(b, "BDD")
return r
def showDatabases() -> list:
return b.showDatabases()
def alterDatabase(databaseOld, databaseNew) -> int:
r = b.alterDatabase(databaseOld, databaseNew)
serializar.commit(b, "BDD")
