Como executar SQL bruto no SQLAlchemy

SQLAlchemy é uma ferramenta SQL construída com Python que fornece aos desenvolvedores uma abundância de recursos poderosos para projetar e gerenciar bancos de dados de alto desempenho.

Exploraremos brevemente como usar o SQLAlchemy e, em seguida, nos aprofundaremos em como executar instruções SQL brutas de dentro do conforto da linguagem de domínio Python.

Usando SQLAlchemy

Tal como acontece com todas as bibliotecas Python, comece instalando SQLAlchemy. Uma vez instalado, podemos começar a diversão em Python.

Em seguida, importe sqlalchemy em si, importe alguns módulos para que possamos acessar facilmente o mecanismo de banco de dados SQLAlchemy:

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

Além de create_engine , também estamos importando vários módulos adicionais que precisaremos para criar uma nova tabela. Antes de chegarmos a isso, verifique se o SQLAlchemy foi instalado, importado e está funcionando chamando .__version__ igual a:

print sqlalchemy.__version__
Out[*]: 1.0.9

Criando uma tabela

Usaremos a funcionalidade básica do SQLAlchemy, que é a SQL Expression Language para criar alguns metadata que conterá vários módulos (ou objetos) relacionados que definem nosso novo book tabela de banco de dados:

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)

No topo definimos metadata , então passamos isso para a Table() método, onde damos à nossa tabela o nome book . Dentro disso, definimos cada coluna, juntamente com atributos importantes como tipo de dados e primary_key .

Uma vez que nossas tabelas são definidas e associadas aos nossos metadata objeto, precisamos criar um mecanismo de banco de dados com o qual podemos nos conectar. Isso é feito usando o create_engine função.

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

Para nosso exemplo, usaremos um simples SQLite base de dados. Você também pode usar strings de conexão para outros mecanismos, como MySQL ou PostgreSQL. Aqui está um exemplo de sintaxe para criar um mecanismo para PostgreSQL:

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

Com o mecanismo criado, agora precisamos usar o .create_all() método de nossos metadata objeto e passe o engine conexão a ele, o que fará com que o SQLAlchemy gere automaticamente nossa tabela para nós, como visto acima.

Com isso completo, podemos usar a tabela como acharmos melhor. Neste exemplo simples, usaremos apenas o comando inspect módulo para visualizar as colunas e verificar se nossa tabela foi criada com sucesso:

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

Com certeza, usando o .get_columns() método para nosso book tabela, vemos que nossas três colunas foram geradas.

Executando instruções SQL

Com o básico no lugar, agora podemos tentar executar algum SQL bruto usando SQLAlchemy.

Usando o módulo de texto

Um método para executar SQL bruto é usar o text módulo ou Textual SQL . A maneira mais legível de usar text é importar o módulo, então depois de conectar ao engine , defina o text String de instrução SQL antes de usar .execute para executá-lo:

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)

Aqui estamos inserindo dois registros em nosso banco de dados usando um text() -declaração definida.

Usando o método execute

O método alternativo é pular usando text() e passe uma string SQL bruta para o .execute() método. Por exemplo, aqui usaremos .execute() para visualizar os novos registros que inserimos acima:

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

Aí temos! Métodos simples e eficazes para executar instruções SQL brutas no SQLAlchemy.