def insertar(cls, persona):
with Conexion.obtenerConexion():
with Conexion.obtenerCursor() as cursor:
valores = (persona.nombre, persona.apellido, persona.email)
cursor.execute(cls._INSERTAR, valores)
log.debug(f'Persona insertada: {persona}')
return cursor.rowcount
def eliminar(cls, persona):
with Conexion.obtenerConexion():
with Conexion.obtenerCursor() as cursor:
valores = (persona.id_persona, )
cursor.execute(cls._ELIMINAR, valores)
log.debug(f'Objeto eliminado: {persona}')
return cursor.rowcount
def actualizar(cls, persona):
with Conexion.obtenerConexion():
with Conexion.obtenerCursor() as cursor:
valores = (persona.nombre, persona.apellido, persona.email,
persona.id_persona)
cursor.execute(cls._ACTUALIZAR, valores)
log.debug(f'Persona actualizada: {persona}')
return cursor.rowcount
def seleccionar(cls):
try:
Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(f'Datos: {cursor.mogrify(cls.__SELECCIONAR)}')
cursor.execute(cls.__SELECCIONAR)
datos = cursor.fetchall()
logger.debug(datos)
except Exception as e:
logger.error(f'Error de consulta: {e}')
sys.exit()
finally:
Conexion.cerrar()
def insertar(self, persona):
try:
Conexion.obtenerConexion()
cursor = Conexion.obtenerConexion()
logger.debug(f'Datos: {cursor.mogrify(cls.__INSERTAR)}')
datos = (persona[0], persona[1], persona[2])
cursor.execute(cls.__INSERTAR, datos)
logger.debug(f'Conexión exitosa')
except Exception as e:
logger.error(f'Error de consulta: {e}')
sys.exit()
finally:
conexion.commit()
Conexion.cerrar()
def seleccionar(cls):
with Conexion.obtenerConexion() as conexion:
with conexion.cursor() as cursor:
cursor.execute(cls._SELECCIONAR)
registros = cursor.fetchall()
personas = []
for registro in registros:
persona = Persona(registro[0], registro[1], registro[2],
registro[3])
personas.append(persona)
return personas
def insertar(cls, persona):
try:
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__INSERTAR))
logger.debug(f'Persona a insertar: {persona}')
valores = (persona.get_nombre(), persona.get_apellido(), persona.get_email())
cursor.execute(cls.__INSERTAR, valores)
conexion.commit()
return cursor.rowcount
except Exception as e:
conexion.rollback()
logger.error(f'Excepción al insertar persona: {e}')
finally:
Conexion.cerrar()
def eliminar(cls, persona):
try:
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__ELIMINAR))
logger.debug(f'Persona 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'Excepcion al eliminar')
finally:
Conexion.cerrar()
def actualizar(cls, persona):
try:
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__ACTUALIZAR))
logger.debug(f'Persona a actualizar: {persona}')
valores_persona = (persona.get_nombre(), persona.get_apellido(),
persona.get_email(), persona.get_id_persona())
cursor.execute(cls.__ACTUALIZAR, valores_persona)
conexion.commit()
except Exception as e:
conexion.rollback()
logger.error(f'Excepcion al actualizar persona {e}')
finally:
Conexion.cerrar()
def eliminar(cls, persona):
#El try bloque le permite probar un bloque de código en busca de errores.
try:
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__ELIMINAR))
logger.debug(f'Persona a eliminar: {persona}')
valores = (persona.get_id_persona(), )
cursor.execute(cls.__ELIMINAR, valores)
conexion.commit()
return cursor.rowcount
#El except bloque le permite manejar el error.
except Exception as e:
conexion.rollback()
logger.error(f'Excepción al eliminar persona:{e}')
#El finally bloque le permite ejecutar código, independientemente del resultado de los bloques try y except.
finally:
Conexion.cerrar()
def eliminar(cls, persona):
try:
# necesito obtener el conexion para guardar en la BD
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(
cursor.mogrify(cls.__ELIMINAR)
) # manda a imprimir el query q se va a ejecutar pero en la base de datos
logger.debug(f'Persona a eliminar: {persona}')
valores = (persona.get_id_persona(), ) #valores a insertar
cursor.execute(cls.__ELIMINAR, valores)
conexion.commit()
return cursor.rowcount
except Exception as e:
conexion.rollback()
logger.error(f'Error al insertar una persona :{e}')
finally:
Conexion.cerrar()
# if __name__ == "__main__":
# probar el select
# personas = PersonaDao.seleccionar()
# for persona in personas:
# logger.debug(persona)
# logger.debug(persona.get_id_persona())
# Insertar el registro
# persona = Persona(nombre ='Pedro', apellido='Najera', email='*****@*****.**')
# personas_insertadas = PersonaDao.insertar(persona)
# logger.debug(f'Registros Insertados: {personas_insertadas}')
# Actualizar registros
# persona = Persona(id_persona = 1, nombre ='Juan', apellido='Perez', email='*****@*****.**')
# personas_modificadas = PersonaDao.actualizar(persona)
# logger.debug(f'Registros actualizados: {personas_modificadas}')
# Eliminar registro
# persona = Persona(id_persona = 20)
# personas_eliminadas = PersonaDao.eliminar(persona)
# logger.debug(f'Registros Eliminados: {personas_eliminadas}')
def insertar(cls, persona):
try:
# necesito obtener el conexion para guardar en la BD
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(
cursor.mogrify(cls.__INSERTAR)
) # manda a imprimir el query q se va a ejecutar pero en la base de datos
logger.debug(f'Persona a insertar: {persona}')
valores = (persona.get_nombre(), persona.get_apellido(),
persona.get_email()) #valores a insertar
cursor.execute(cls.__INSERTAR, valores)
conexion.commit()
return cursor.rowcount
except Exception as e:
conexion.rollback()
logger.error(f'Error al insertar una persona :{e}')
finally:
Conexion.cerrar()
def eliminar(cls, Persona):
try:
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__ELIMINAR))
logger.debug(f'Persona a eliminar: {Persona}')
# los valores los obtenemos accediendo al objeto, ya que se pasa un objeto de Persona
valores = (Persona.get_id_persona(), )
cursor.execute(cls.__ELIMINAR, valores)
# grabar en bd
conexion.commit()
# cantidad de registros afectados
return cursor.rowcount
except Exception as e:
conexion.rollback()
logger.error(f'Error al eliminar persona: {e}')
finally:
Conexion.cerrarConexion()
def insertar(cls, Persona):
try:
conexion = Conexion.obtenerConexion()
cursor = Conexion.obtenerCursor()
logger.debug(cursor.mogrify(cls.__INSERTAR))
logger.debug(f'Persona a insertar: {Persona}')
# los valores los obtenemos accediendo al objeto, ya que se pasa un objeto de Persona
valores = (Persona.get_nombre(), Persona.get_apellido(),
Persona.get_email())
cursor.execute(cls.__INSERTAR, valores)
# grabar en bd
conexion.commit()
# cantidad de registros afectados
return cursor.rowcount
except Exception as e:
conexion.rollback()
logger.error(f'Error al insertar persona: {e}')
finally:
Conexion.cerrarConexion()
def __enter__(self):
logger.debug('Inicio de __enter__')
self.__conn = Conexion.obtenerConexion()
self.__cursor = self.__conn.cursor()
return self.__cursor
def __enter__(self):
self.__conn = Conexion.obtenerConexion()
self.__cursor = self.__conn.cursor()
logger.debug(f'Inicio de with método __enter__()')
return self.__cursor
def __enter__(self):
log.debug('Incio del método with __enter__')
self._conexion = Conexion.obtenerConexion()
self._cursor = self._conexion.cursor()
return self._cursor
def __enter__(self):
logger.debug('Inicio de with metodo __enter__')
self.__conn = Conexion.obtenerConexion()
self.__cursor = self.__conn.cursor() # asignamos el cursor retornado de la conexion del pool
return self.__cursor
def __enter__(self):
logger.debug(f'Inicio de with metodo _enter__ {self.__conn}')
self.__conn = Conexion.obtenerConexion()
self.__cursor = self.__conn.cursor()
return self.__cursor
