def eliminar(cls, persona):
with CursorDelPoll() as cursor:
logger.debug(cursor.mogrify(cls.__ELIMINAR))
logger.debug(f'Person a eliminar: {persona}')
valores = (persona.get_id_persona(),)
cursor.execute(cls.__ELIMINAR,valores)
return cursor.rowcount
def actualizar(cls, persona):
with CursorDelPoll() as cursor:
logger.debug(cursor.mogrify(cls.__ACTUALIZAR))
logger.debug(f'Person a actualizar: {persona}')
valores = (persona.get_nombre(), persona.get_apellido(), persona.get_email(),persona.get_id_persona())
cursor.execute(cls.__ACTUALIZAR,valores)
return cursor.rowcount
def insertar(cls, persona):
with CursorDelPoll() as cursor:
logger.debug(cursor.mogrify(cls.__INSERTAR))
logger.debug(f'Person a insertar: {persona}')
valores = (persona.get_nombre(), persona.get_apellido(), persona.get_email())
cursor.execute(cls.__INSERTAR,valores)
return cursor.rowcount
def seleccionar(cls):
with CursorDelPoll() as cursor:
logger.debug(cursor.mogrify(cls.__SELECCIONAR))
cursor.execute(cls.__SELECCIONAR)
registros = cursor.fetchall()
personas = []
for registro in registros:
persona = Persona(registro[3], registro[0], registro[1], registro[2])
personas.append(persona)
return personas
def obtenerCursor(cls):
if cls.__cursor is None:
try:
cls.__cursor = cls.obtenerConexion().cursor()
logger.debug(f'Se abrio el cursor con exito: {cls.__cursor}')
return cls.__cursor
except Exception as e:
logger.error(f'Error al obtener el cursor: {e}')
sys.exit()
else:
return cls.__cursor
def seleccionar(cls):
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__SELECCIONAR))
cursor.execute(cls.__SELECCIONAR)
registros = cursor.fetchall()
personas = []
for registro in registros:
persona = Persona(registro[3], registro[0], registro[1],
registro[2])
personas.append(persona)
Conexion.cerrar()
return personas
def cerrar(cls):
if cls.__cursor is not None:
try:
cls.__cursor.close()
except Exception as e:
logger.error(f'Error al cerrar el cursor: {e}')
if cls.__conexion is not None:
try:
cls.__conexion.close()
except Exception as e:
logger.error(f'Error al cerrar la conexion: {e}')
logger.debug(f'Se han cerrado los objetos de Cursor y conexion')
def obtenerConexion(cls):
if cls.__conexion is None:
try:
cls.__conexion = db.connect(host=cls.__HOST,
user=cls.__USER,
password=cls.__PASSWORD,
port=cls.__DB_PORT,
database=cls.__DATABASE)
logger.debug(f'Conexion existosa: {cls.__conexion}')
return cls.__conexion
except Exception as e:
logger.error(f'Error al conectar a la base de datos: {e}')
sys.exit()
else:
return cls.__conexion
def eliminar(cls, persona):
try:
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__ELIMINAR))
logger.debug(f'Person a eliminar: {persona}')
valores = (persona.get_id_persona(), )
cursor.execute(cls.__ELIMINAR, valores)
conexion.commit()
return cursor.rowcount
except Exception as e:
conexion.rollback()
logger.error(f'Error al eliminar una persona: {e}')
finally:
Conexion.cerrar()
def actualizar(cls, persona):
try:
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__ACTUALIZAR))
logger.debug(f'Person a actualizar: {persona}')
valores = (persona.get_nombre(), persona.get_apellido(),
persona.get_email(), persona.get_id_persona())
cursor.execute(cls.__ACTUALIZAR, valores)
conexion.commit()
return cursor.rowcount
except Exception as e:
conexion.rollback()
logger.error(f'Error al actualizar una persona: {e}')
finally:
Conexion.cerrar()
def obtenerPool(cls):
if cls.__POOL is None:
try:
cls.__POOL = pool.SimpleConnectionPool(cls.__MIN_CON,
cls.__MAx_CON,
host=cls.__HOST,
user=cls.__USER,
password=cls.__PASSWORD,
port=cls.__DB_PORT,
database=cls.__DATABASE)
logger.debug(f'Creacion de pool exitosa: {cls.__POOL}')
return cls.__POOL
except Exception as e:
logger.error(f'Error al crear el pool de conexiones: {e}')
sys.exit()
else:
return cls.__POOL
def __exit__(self, exception_type, exception_value, exception_traceback):
logger.debug(f'se ejecuta el metodo __exit__()')
if exception_value:
self.__conn.rollback()
logger.debug(f'Ocurrio una excepcion: {eception_value}')
else:
self.__conn.commit()
logger.debug(f'Commit de la transaccion')
#cerramos el cursor
self.__cursor.close()
#regresara la conexion al pool
Conexion.liberarConexion(self.__conn)
valores = (persona.get_nombre(), persona.get_apellido(), persona.get_email(),persona.get_id_persona())
cursor.execute(cls.__ACTUALIZAR,valores)
return cursor.rowcount
@classmethod
def eliminar(cls, persona):
with CursorDelPoll() as cursor:
logger.debug(cursor.mogrify(cls.__ELIMINAR))
logger.debug(f'Person a eliminar: {persona}')
valores = (persona.get_id_persona(),)
cursor.execute(cls.__ELIMINAR,valores)
return cursor.rowcount
if __name__ == '__main__':
personas = PersonaDao.seleccionar()
for persona in personas:
logger.debug(persona)
# persona = Persona(nombre='javier',apellido='perez',email='*****@*****.**')
# num_registro = PersonaDao.insertar(persona)
# logger.debug(f'Registros insertados: {num_registro}')
# persona = Persona(12,'fernando','gonzalez','*****@*****.**')
# num_reg = PersonaDao.actualizar(persona)
# logger.debug(f'Registros actualizados: {num_reg}')
# persona = Persona(id_persona=13)
# num_reg = PersonaDao.eliminar(persona)
# logger.debug(f'Registros actualizados: {num_reg}')
self.__cursor = None
#inicio de with
def __enter__(self):
logger.debug('Inicio de with metodo __enter__')
self.__conn = Conexion.obtenerConexion()
self.__cursor = self.__conn.cursor()
return self.__cursor
#fin de with
def __exit__(self, exception_type, exception_value, exception_traceback):
logger.debug(f'se ejecuta el metodo __exit__()')
if exception_value:
self.__conn.rollback()
logger.debug(f'Ocurrio una excepcion: {eception_value}')
else:
self.__conn.commit()
logger.debug(f'Commit de la transaccion')
#cerramos el cursor
self.__cursor.close()
#regresara la conexion al pool
Conexion.liberarConexion(self.__conn)
if __name__ == '__main__':
with CursorDelPoll() as cursor:
cursor.execute('SELECT * FROM persona')
logger.debug('Listado de persona')
logger.debug(cursor.fetchall())
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__ELIMINAR))
logger.debug(f'Person a eliminar: {persona}')
valores = (persona.get_id_persona(), )
cursor.execute(cls.__ELIMINAR, valores)
conexion.commit()
return cursor.rowcount
except Exception as e:
conexion.rollback()
logger.error(f'Error al eliminar una persona: {e}')
finally:
Conexion.cerrar()
if __name__ == '__main__':
# personas = PersonaDao.seleccionar()
# for persona in personas:
# logger.debug(persona)
# persona = Persona(nombre='javier',apellido='perez',email='*****@*****.**')
# num_registro = PersonaDao.insertar(persona)
# logger.debug(f'Registros insertados: {num_registro}')
# persona = Persona(12,'fernando','gonzalez','*****@*****.**')
# num_reg = PersonaDao.actualizar(persona)
# logger.debug(f'Registros actualizados: {num_reg}')
persona = Persona(id_persona=13)
num_reg = PersonaDao.eliminar(persona)
logger.debug(f'Registros actualizados: {num_reg}')
def cerrarConexiones(cls):
# cerrar pool y todas sus conexiones
cls.obtenerPool().closeall()
logger.debug(f'Cerramos el pool: {cls.__POOL}')
def liberarConexion(cls,conexion):
# regresar el objeto al pool
cls.obtenerPool().putconn(conexion)
logger.debug(f'regresamos la conexion al pool: conexion')
logger.debug(f'estado del pool: {cls.__POOL}')
def obtenerConexion(cls):
# obtener una conexion de tipo pool
conexion = cls.obtenerPool().getconn()
logger.debug(f'Conexion obtenida del pool: {conexion}')
return conexion
def get_apellido(self):
return self.__apellido
def set_apellido(self, apellido):
self.__apellido = apellido
def get_email(self):
return self.__email
def set_email(self, email):
self.__email = email
def __str__(self):
return (f'Id: {self.__id_persona}, '
f'Nombre: {self.__nombre}, '
f'Apellido: {self.__apellido}, '
f'Email: {self.__email}')
if __name__ == '__main__':
persona = Persona(1, 'fran', 'mauriz', '*****@*****.**')
logger.debug(persona)
#simulando un objeto a insertat de tipo persona
persona2 = Persona(nombre="esther",
apellido='Jaime',
email='*****@*****.**')
logger.debug(persona2)
#simular el caso de eliminar el objeto de tipo persona
persona3 = Persona(id_persona=3)
logger.debug(persona3)
def __enter__(self):
logger.debug('Inicio de with metodo __enter__')
self.__conn = Conexion.obtenerConexion()
self.__cursor = self.__conn.cursor()
return self.__cursor
