Cómo ejecutar SQL sin procesar en SQLAlchemy

SQLAlchemy es una herramienta de SQL creada con Python que proporciona a los desarrolladores una gran cantidad de potentes funciones para diseñar y administrar bases de datos de alto rendimiento.

Exploraremos brevemente cómo usar SQLAlchemy y luego profundizaremos en cómo ejecutar declaraciones SQL sin formato desde la comodidad del lenguaje de dominio Python.

Usando SQLAlchemy

Al igual que con todas las bibliotecas de Python, comience instalando SQLAlchemy. Una vez instalado podemos comenzar la diversión en Python.

A continuación, importe sqlalchemy mismo, luego importe algunos módulos para que podamos acceder fácilmente al motor de base de datos SQLAlchemy:

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy import inspect

Además de create_engine , también estamos importando una serie de módulos adicionales que necesitaremos para crear una nueva tabla. Sin embargo, antes de llegar a eso, asegúrese de que SQLAlchemy se haya instalado, importado y funcione llamando a .__version__ así:

print sqlalchemy.__version__
Out[*]: 1.0.9

Creando una tabla

Usaremos la funcionalidad básica de SQLAlchemy, que es el lenguaje de expresión SQL para crear algunos metadata que contendrá una serie de módulos (u objetos) relacionados que definen nuestro nuevo book tabla de base de datos:

metadata = MetaData()
books = Table('book', metadata,
  Column('id', Integer, primary_key=True),
  Column('title', String),
  Column('primary_author', String),
)

engine = create_engine('sqlite:///bookstore.db')
metadata.create_all(engine)

En la parte superior definimos metadata , luego lo pasamos a la Table() método, donde le damos a nuestra tabla el nombre book . Dentro de esto, definimos cada columna, junto con atributos importantes como tipo de datos y primary_key .

Una vez que nuestras tablas estén definidas y asociadas con nuestros metadata objeto, necesitamos crear un motor de base de datos con el que podamos conectarnos. Esto se logra usando el create_engine función.

engine = create_engine('sqlite:///bookstore.db')

Para nuestro ejemplo, usaremos un SQLite simple base de datos. También puede usar cadenas de conexión para otros motores como MySQL o PostgreSQL. Aquí hay una sintaxis de ejemplo para crear un motor para PostgreSQL:

engine = create_engine('postgresql://user:password@host/database')

Con el motor creado, ahora necesitamos usar .create_all() método de nuestros metadata objeto y pasar el engine conexión a él, lo que automáticamente hará que SQLAlchemy genere nuestra tabla para nosotros, como se ve arriba.

Con eso completo, podemos usar la tabla como mejor nos parezca. En este ejemplo simple, solo usaremos el inspect módulo para ver las columnas y verificar que nuestra tabla se creó con éxito:

inspector = inspect(engine)
inspector.get_columns('book')
Out[*]:
[{'autoincrement': True,
  'default': None,
  'name': u'id',
  'nullable': False,
  'primary_key': 1,
  'type': INTEGER()},
 {'autoincrement': True,
  'default': None,
  'name': u'title',
  'nullable': True,
  'primary_key': 0,
  'type': VARCHAR()},
 {'autoincrement': True,
  'default': None,
  'name': u'primary_author',
  'nullable': True,
  'primary_key': 0,
  'type': VARCHAR()}]

Efectivamente, usando .get_columns() método para nuestro book tabla, vemos que se generaron nuestras tres columnas.

Ejecución de sentencias SQL

Con los conceptos básicos en su lugar, ahora podemos intentar ejecutar SQL sin formato usando SQLAlchemy.

Usando el Módulo de Texto

Un método para ejecutar SQL sin procesar es usar el text módulo, o Textual SQL . La forma más legible de usar text es importar el módulo, luego, después de conectarse al engine , define el text Cadena de sentencia SQL antes de usar .execute para ejecutarlo:

from sqlalchemy.sql import text
with engine.connect() as con:

    data = ( { "id": 1, "title": "The Hobbit", "primary_author": "Tolkien" },
             { "id": 2, "title": "The Silmarillion", "primary_author": "Tolkien" },
    )

    statement = text("""INSERT INTO book(id, title, primary_author) VALUES(:id, :title, :primary_author)""")

    for line in data:
        con.execute(statement, **line)

Aquí estamos insertando dos registros en nuestra base de datos usando un text() declaración definida.

Usando el método de ejecución

El método alternativo es omitir usando text() y pase una cadena SQL sin formato a .execute() método. Por ejemplo, aquí usaremos .execute() para ver los nuevos registros que insertamos arriba:

with engine.connect() as con:

    rs = con.execute('SELECT * FROM book')

    for row in rs:
        print row

Out[*]:
(4, u'The Hobbit', u'Tolkien')
(5, u'The Silmarillion', u'Tolkien')

¡Ahí lo tenemos! Métodos simples y efectivos para ejecutar sentencias SQL sin procesar en SQLAlchemy.