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()