def EAltRenameDatabase():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
EDD.alterDatabase(listaMemoria[0][0], listaMemoria[0][1])
print("Base de datos Renombrada Exitosamente")
listaMemoria.pop(0)
def procesar_alterdb(query,ts):
if store.alterDatabase(query.id_original,query.id_alter) == 0:
print("LA BASE DE DATOS "+str(query.id_original)+" HA SIDO ALTERADA")
# ----------------------------------------------------------------------------------------------------------------
elif store.alterDatabase(query.id_original,query.id_alter) == 3:
print("LA BASE DE DATOS "+str(query.id_alter)+" YA EXISTE")
# ----------------------------------------------------------------------------------------------------------------
elif store.alterDatabase(query.id_original,query.id_alter) == 2:
print("LA BASE DE DATOS "+str(query.id_original)+" NO EXISTE")
# ----------------------------------------------------------------------------------------------------------------
elif store.alterDatabase(query.id_original,query.id_alter) == 1:
print("ERROR :(")
def ejecutar(self, ts):
if not TRef.databaseExist(self.nombre):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_invalid_schema_name.invalid_schema_name), 0)
if self.accion[0] == 'OWNER':
pass
else:
#Comprobamos que no exista una base de datos con ese nombre
if TRef.databaseExist(self.accion[1]):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_database), 0)
DBMS.alterDatabase(self.nombre, self.accion[1])
TRef.alterDatabase(self.nombre, self.accion[1])
return 0
def ejecutar(self, ts):
if self.accion[0] == 'OWNER':
pass
else:
result = DBMS.alterDatabase(self.nombre, self.accion[2])
return result
return 0
def ejecutar(self, ent):
result = DBMS.alterDatabase(self.id, self.newdb)
if (result == 2):
variables.consola.insert(
INSERT, "ERROR >> En la instrucción Alter Database " +
self.id + ", La base de datos que desea renombrar NO EXISTE\n")
reporteerrores.append(
Lerrores(
"Error Semantico",
"Instrucción Alter Database " + self.id +
", La base de datos que desea renombrar NO EXISTE", '',
''))
return
elif (result == 3):
variables.consola.insert(
INSERT, "ERROR >> En la instrucción Alter Database " +
self.id + ", ya exite una basde de datos con ese nombre\n")
reporteerrores.append(
Lerrores(
"Error Semantico", "Instrucción Alter Database " +
self.id + ", ya exite una basde de datos con ese nombre",
'', ''))
return
elif (result == 0):
ent.renombrarDatabase(self.id, self.newdb)
DBMS.showCollection()
variables.consola.insert(
INSERT, "Base de datos renombrada a : " + self.newdb +
" EXITOSAMENTE\n")
return
def procesar_alterdatabase(instr,ts,tc):
global salida
if isinstance(instr.tipo_id,ExpresionIdentificador) :
global salida
print('OWNER ' + str(instr.tipo_id.id))
elif isinstance(instr.tipo_id, ExpresionComillaSimple) :
print('OWNER ' + str(instr.tipo_id.val))
else:
result = j.alterDatabase(str(instr.id_tabla),str(instr.tipo_id))
if result == 0:
tipo = TC.Tipo(useCurrentDatabase,instr.id_tabla,instr.id_tabla,"",OPCIONES_CONSTRAINT.CHECK,None,None)
tc.actualizarDatabase(tipo,instr.id_tabla,instr.tipo_id)
temp1 = ts.obtener(instr.id_tabla,"")
temp2 = TS.Simbolo(instr.tipo_id,temp1.tipo,temp1.valor,temp1.ambito)
ts.actualizarDB(temp2,temp1.id)
ts.actualizarDBTable(temp1.id,temp2.id)
salida = "\nALTER DATABASE"
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result == 2 :
salida = "\nERROR: database \"" + str(instr.id_tabla) +"\" does not exist \nSQL state: 3D000"
elif result == 3 :
salida = "\nERROR: database \"" + str(instr.tipo_id) +"\" alredy exists\nSQL state: 42P04"
def AlterDatabase(nodo, tablaSimbolos):
global consola
if nodo.rename:
b = jBase.alterDatabase(nodo.id.valor, nodo.idnuevo)
if b == 0:
base = tablaSimbolos.renameBase(nodo.id.valor, nodo.idnuevo)
if base:
for fk in listaFK:
if fk.idbase == nodo.id.valor:
fk.idbase = nodo.idnuevo
for cons in listaConstraint:
if cons.idbase == nodo.id.valor:
cons.idbase = nodo.idnuevo
consola += "La base se renombró con éxito " + nodo.idnuevo + " \n"
else:
consola += "Error no se pudo renombrar la base " + nodo.id.valor + " en la tabla de simbolos \n"
elif b == 2:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"La base de datos " + nodo.id.valor + " no existe"))
elif b == 3:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"La base de datos ya existe " + nodo.idnuevo))
elif b == 1:
listaSemanticos.append(
Error.ErrorS("Error Semantico", "Error en la operacion."))
def execute(self, environment):
if not isinstance(self.newName,str):
return {'Error': 'El nombre indicado de la base de datos no es una cadena.', 'Fila':self.row, 'Columna': self.column }
if not isinstance(self.oldName,str):
return {'Error': 'El nombre indicado de la base de datos no es una cadena.', 'Fila':self.row, 'Columna': self.column }
result = 4
result = admin.alterDatabase(self.oldName, self.newName) #<---------------------------
if result == 0:
#Se cambio correctamente el nombre a la base de datos.
db_name = environment.getActualDataBase()
database = environment.readDataBase(db_name)
database.setName(self.newName)
return 'Se cambio el nombre de:' + self.oldName + ' a : '+self.newName
elif result == 1:
#Error al crear
return {'Error':'Ocurrió un error en el storage manager. No se pudo cambiar el nombre de :' + self.oldName + ' a: '+self.newName, 'Fila':self.row, 'Columna':self.column}
elif result == 2:
#Base de datos:oldName no existe
return {'Error':'No existe la base de datos con el nombre: ' + self.oldName, 'Fila':self.row, 'Columna':self.column}
elif result == 3:
#Base de datos:oldName no existe
return {'Error':'Ya existe una base de datos con el nombre: ' + self.newName, 'Fila':self.row, 'Columna':self.column}
else:
return {'Error': "Error desconocido en el storage manager.", 'Fila': self.row, 'Columna': self.column}
def updateDatabase(self, databaseOld: str, databaseNew: str, line, column):
"""
Method to update the name of a database in type checker
:param databaseOld: The old name of the database
:param databaseNew: The new name of the database
:param line: The instruction line
:param column: The instruction column
:return: Returns nothing
"""
dbStatement = jsonMode.alterDatabase(databaseOld, databaseNew)
if dbStatement == 0:
database = self.searchDatabase(databaseOld)
database.name = databaseNew
self.writeFile()
print('Database updated successfully')
elif dbStatement == 1:
desc = f": Can't update database {databaseOld}"
ErrorController().addExecutionError(34, 'Execution', desc, line,
column)
elif dbStatement == 2:
desc = f": Database {databaseOld} does not exist"
ErrorController().addExecutionError(35, 'Execution', desc, line,
column)
elif dbStatement == 3:
desc = f": Database {databaseNew} already exists"
ErrorController().addExecutionError(30, 'Execution', desc, line,
column)
def alterDB(self, nodo):
databaseOld = ''
databaseNew = ''
owner = ''
rename = 0
for hijos in nodo.hijos:
databaseNew = hijos.valor
if hijos.etiqueta == 'RENAME TO':
rename = 1
else:
owner = hijos.valor
if nodo.valor != '':
databaseOld = nodo.valor
query_result = jsonMode.alterDatabase(databaseOld, databaseNew)
if rename == 1:
if query_result == 0:
if databaseOld in self.ts:
self.ts[databaseNew] = self.ts[databaseOld]
del self.ts[databaseOld]
self.output.append('La base de datos \"' + databaseOld +
'\" ha sido renombrada a \"' + databaseNew +
'\".')
elif query_result == 1:
self.errors.append(
Error('XX000', EType.SEMANTICO, 'internal_error',
nodo.linea))
elif query_result == 2: # Base de datos inexistente
self.errors.append(
Error('-----', EType.SEMANTICO, 'database_non_exist',
nodo.linea))
elif query_result == 3: # Base de datos existente
self.errors.append(
Error('42P04', EType.SEMANTICO, 'duplicate_database',
nodo.linea))
#self.output.append(query_result)
else:
if query_result == 0:
self.ts[databaseOld].owner = owner
self.output.append('La base de datos \"' + databaseOld +
'\" ha cambiado de propietario a \"' +
owner + '\".')
elif query_result == 1:
self.errors.append(
Error('XX000', EType.SEMANTICO, 'internal_error',
nodo.linea))
elif query_result == 2: # Base de datos inexistente
self.errors.append(
Error('-----', EType.SEMANTICO, 'database_non_exist',
nodo.linea))
elif query_result == 3: # Base de datos existente
self.errors.append(
Error('42P04', EType.SEMANTICO, 'duplicate_database',
nodo.linea))
def execute(self, environment):
if self.option == "RENAME":
valor = jsonMode.alterDatabase(self.name, self.newname)
if valor == 2:
return "La base de datos no existe"
if valor == 3:
return "El nuevo nombre para la base de datos existe"
if valor == 1:
return "Hubo un problema en la ejecucion de la sentencia"
if valor == 0:
return "Instruccion ejecutada con exito"
def updateDatabase(self, databaseOld: str, databaseNew: str):
dbStatement = jsonMode.alterDatabase(databaseOld, databaseNew)
if dbStatement == 0:
database = self.searchDatabase(databaseOld)
database.name = databaseNew
self.writeFile()
print('Database updated successfully')
elif dbStatement == 1:
print(f"Can't update database '{databaseOld}'")
elif dbStatement == 2:
print("Database doesn't exist")
elif dbStatement == 3:
print(f"Database '{databaseNew}' already exists")
def alterDatabase(self, databaseOld: str, databaseNew: str, line: int):
# 0 -> operación exitosa
# 1 -> error en la operación
# 2 -> databaseOld no existente
# 3 -> databaseNew existente
query_result = jsonMode.alterDatabase(databaseOld, databaseNew)
if query_result == 0:
self.consola.append(
Codigos().successful_completion('ALTER DATABASE'))
self.type_checker[databaseNew] = self.type_checker.pop(databaseOld)
self.tabla_simbolos.simbolos[
databaseNew] = self.tabla_simbolos.simbolos.pop(databaseOld)
self.saveTypeChecker()
elif query_result == 1:
self.addError(Codigos().database_internal_error(databaseOld), line)
elif query_result == 2:
self.addError(Codigos().database_undefined_object(databaseOld),
line)
else:
self.addError(Codigos().database_duplicate_database(databaseNew),
line)
def cmd_alterDatabase(self, databaseOld, databaseNew):
if existeBase(databaseOld) == 1:
self.tabla.modificarTS_Base(databaseOld, databaseNew)
EDDResp.alterdatabase(condb.alterDatabase(databaseOld,
databaseNew))
# JSON Mode Test File
# Released under MIT License
# Copyright (c) 2020 TytusDb Team
from storageManager import jsonMode as j
# create db1 and db2, return two 0's and show return list
print(j.createDatabase("db1"))
print(j.createDatabase("db2"))
print(j.showDatabases())
# try create db1 and db2, return error value 2 and show return list
print(j.createDatabase("db1"))
print(j.createDatabase("db2"))
print(j.showDatabases())
# rename db1 to db3, return 0 and show return list
print(j.alterDatabase("db1", "db3"))
print(j.showDatabases())
# rename db2 to db1, return 0 and show return list
print(j.alterDatabase("db2", "db1"))
print(j.showDatabases())
# drop db3 and db1, return two 0's
print(j.dropDatabase("db3"))
print(j.dropDatabase("db1"))
# show empty-list of databases
print(j.showDatabases())
# License: Released under MIT License
# Notice: Copyright (c) 2020 TytusDB Team
# Developer: Luis Espino
from storageManager import jsonMode as j
# assume no data exist or execute the next drop function
j.dropAll()
# 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']
# File: JSON Mode Test File for EDD
# License: Released under MIT License
# Notice: Copyright (c) 2020 TytusDB Team
# Developer: Luis Espino
from storageManager import jsonMode as j
# assume no data exist or execute the next optional drop function
j.dropAll()
# test Databases CRUD
print(j.createDatabase('b1')) # 0
print(j.createDatabase('b1')) # 2
print(j.createDatabase('b4')) # 0
print(j.createDatabase('b5')) # 0
print(j.createDatabase(0)) # 1
print(j.alterDatabase('b5', 'b1')) # 3
print(j.alterDatabase('b5', 'b2')) # 0
print(j.dropDatabase('b4')) # 0
print(j.showDatabases()) # ['b1','b2']
def ejecutar(self, ent):
DBMS.alterDatabase(self.id, self.newdb)
DBMS.showCollection()
