Conéctate a una base de datos de Oracle con Python
Tags: database, datascience, python, tutorial
Published: 2021-02-08 23:12:02

Este es un tutorial muy sencillo con los primeros pasos para lograr una conexión a una base de datos de Oracle con unos pocos scripts en Python.

Comencemos.

## Crea una conexión con Python

Te puedes conectar a una base de datos de Oracle usando `cx_Oracle` de dos diferentes maneras: de manera autónoma (dudosa traducción de `standalone`) o con una conexión agrupada (pooled connection en ingles).

Las conexiones autónomas son útiles cuando la aplicación necesita que un solo usuario inicie sesión en la base de datos mientras que la conexión agrupada es critica para el desempeño cuando la aplicación se conecta y desconecta de la base de datos con frecuencia.

El primer paso para conectarse es crear un modulo `config.py` para guardar la configuración de nuestra base de datos:

```py
username = 'user'
password = '<password>'
dsn = 'localhost/pdborcl'
port = 1512
encoding = 'UTF-8'
```

En este modulo, `dsn` tiene dos partes: el servidor(`localhost`) y la base de datos conectable (`pdborcl`).

Si la base de datos Oracle está en `example.com`, tienes que usar el siguiente `dsn`:

```py
dsn = 'example.com/pdborcl'
```

## Crea conexiones autónomas
Para crear una conexion autonoma, usamos el metodo `cx_Oracle.connect()` o `cx_Oracle.Connection()`.

El siguiente script `connect.py` muestra como crear una conexion a una base de datos Oracle:

```py
import cx_Oracle
import config

connection = None
try:
    connection = cx_Oracle.connect(
        config.username,
        config.password,
        config.dsn,
        encoding=config.encoding)

    # imprime la version de la base de datos
    print(connection.version)

except cx_Oracle.Error as error:
    print(error)

finally:
    # release the connection
    if connection:
    connection.close()
```

## Crea conexiones agrupadas

La conexión agrupada de `cx_Oracle` le permite a las aplicaciones crear y mantener un grupo de conexiones a la base de datos.

Internamente, `cx_Oracle` implementa una conexión en grupo usando la tecnología de sesiones en grupo de Oracle. En general, cada conexión en un grupo de `cx_Oracle` corresponde a una sesión en la base de datos.

Para crear una conexión agrupada, se usa el método `cx_Oracle.SessionPool()`. El siguiente script `connect_pool.py` ilustra como crear este tipo de conexión:

```py
import cx_Oracle
import config

# crea la sesion en grupo
pool = cx_Oracle.SessionPool(
    config.username,
    config.password,
    config.database,
    min=100,
    max=100,
    increment=0,
    encoding=config.encoding)

# consigue una conexion del grupo
connection = pool.acquire()

# usa la conexion
print('Using the connection')

# libera la conexion del grupo
pool.release(connection)

# cierra el grupo
pool.close()
```

En caso de que se supere el número máximo de sesiones en el grupo, cuando se llame al método `acquire()` este producirá un error "ORA-24459: `OCISessionGet()` timed out waiting for pool to create new connections". 

Una solución podría ser llamar al siguiente argumento:

```py
getmode = cx_Oracle.SPOOL_ATTRVAL_WAIT to the cx_Oracle.SessionPool()
```
Que logrará prevenir la excepción, pero causará que la sesión espere a que haya una conexión disponible.

Por esta razón es una practica recomendada crear un grupo con un número fijo de conexiones (es decir, que `min` y `max` tengan el mismo valor y que `increment` sea igual a cero).

# Conclusión

Quizás en otra ocasión repasemos como realizar queries en una base de datos Oracle, pero por el momento creo que este artículo es un buen comienzo.

Espero que mi aporte te haya sido de utilidad, y ¡hasta la proxima!