Uma breve introdução à alquimia SQL

Sunil Kumar Traço — Publicado em 30 de julho de 2022 e modificado pela última vez em 1º de
agosto de 2022
Iniciante Engenharia de Dados .SQL

Este artigo foi publicado como parte do Data Science Blogathon.

Introdução

Os dados estruturados com os quais geralmente lidamos são armazenados em

um formato tabular em bancos de dados relacionais. E os dados armazenados
nesses bancos de dados podem ser acessados por uma linguagem de consulta
chamada "sequel" ou SQL. E é uma linguagem poderosa. Mas, é uma dor para
escrever códigos SQL brutos quando dezenas de bancos de dados usam um
tipo diferente de SQL; torna-se ainda mais difícil migrar para outros bancos de
dados à medida que suas sintaxes variam. Mas e se houver uma ferramenta
que mascare todas essas complicações e nos permita escrever código pythonic
puro para nos comunicarmos com bancos de dados de back-end? Bem, é aqui
que a Alquimia SQL entra em cena.

Portanto, neste artigo, discutiremos como podemos aproveitar o poder da

Alquimia SQL para interagir com bancos de dados de back-end sem escrever
nenhum código SQL diretamente. Mas antes disso, vamos nos familiarizar
com a Alquimia SQL.
O que é a Alquimia SQL

Então, SQL Alchemy é um kit de ferramentas de banco de dados escrito em

Python para Python. A API consiste principalmente de duas partes distintas,
uma é o núcleo de Alquimia e a outra é a Alquimia ORM. O ORM é
construído em cima do núcleo deAlquimia. Assim, a maioria das operações do
núcleo também é aplicável ao ORM. Então, o que são esses corese ORMs?

O Alchemy Core forma a base do kit de ferramentas. O núcleo fornece uma

camada de abstração em diferentes implementações e comportamentos
DBAPI. A SQLAlchemy Expression Language apresenta um sistema de
representação de estruturas e expressões de banco de dados relacional usando
construções Python

A outra parte do SQLAlchemy é seu ORM ou Object Relationship Mapper. O

mapeamento objeto-relacional é o conceito de escrever consultas SQL
complicadas usando um paradigma orientado a objetos. Então, de fato,
pretendemos escrever consultas SQL em nossa linguagem preferida. O ORM
de Alquimia é um caso de uso aplicado da linguagem de expressão de
alquimia.

Saiba | Escrever | Ganhar

Participe e torne-se parte de mais de 800 autores de ciência de dadosRegistre-se agora

Neste artigo, lançaremos alguma luz sobre a expressão linguagem.

Requisitos de instalação
Antes de entrarmos na parte de codificação, precisamos instalar os requisitos.
Primeiro, instale a própria biblioteca SQL Alchemy. Uma simples instrução
pip deve ser suficiente para isso.

pip install sqlalchemy

Em seguida, precisaremos instalar o DBAPI do nosso dialeto de banco de

dados de back-end. SQL tem muitos dialetos como qualquer linguagem
humana. Por exemplo, o mandarim e o cantonês são dialetos da língua
chinesa. Normalmente, os RDBMS fornecidos por diferentes organizações
podem diferir ligeiramente em termos de sintaxes. Oracle, MySQL, SQLite,
PostgreSQL e MS SQL são chamados de dialetos SQL. Portanto, de acordo
com o banco de dados que você usa, instale o DBAPI apropriado. Usaremos o
SQLite para este artigo. Vamos ver como configurá-lo.

Primeiro, precisamos criar um mecanismo para especificar DBAPI.

import sqlalchemy as sa
engine = sa.create_engine('sqlite:///D:/baseball.db') #Create
baseball.sqlite

SQLite lida com os arquivos locais, de modo que o URL difere de outros
dialetos.

Vamos ver como podemos criar um mecanismo para o dialeto MySQL.

engine =
sa.create_engine('mysql+mysqldb://root:password@localhost/databa
se name')

No código acima, a primeira parte menciona o dialeto e a barra dupla DBAPI

seguida pelo nome de usuário, senha, nome do servidor e, no final, o nome do
banco de dados. O resto dos dialetos seguem o mesmo padrão mencionado
acima. Apenas certifique-se de baixar DBAPI compatível para o seu banco de
dados. Ele pressupõe que a API padrão para esse back-end esteja disponível
no sistema se você não tiver mencionado a DBAPI. Abaixo está o trecho de
código para fazer uma conexão com um banco de dados.

engine = sa.create_engine('sqlite:///D:/student.db')
connection = engine.connect()

Ainda não estabelecemos uma conexão com o banco de dados. Uma conexão
real com o banco de dados é feita quando fornecemos uma consulta ao banco
de dados. Outra coisa importante é que eu não tenho nenhum banco de dados
chamado aluno no meu sistema. Portanto, se você passar um nome de banco
de dados junto com seu caminho, o SQLite criará um novo banco de dados
nesse local.

Criando uma tabela

Agora, veremos como podemos criar um banco de dados e tabelas com a

ajuda da Alquimia SQL. Criaremos uma tabela simples chamada alunos com
ID como chave primária e duas colunas e endereços do tipo string.

from sqlalchemy import Table, Column, Integer, String, MetaData,

ForeignKey
metadata_obj = MetaData()
users = Table('student', metadata_obj,
Column('id', Integer, primary_key=True),
Column('name', String),
Column('address', String),
)
O objeto de metadados armazena os detalhes do esquema da tabela. Vamos
agora inserir uma linha na tabela.

ins = users.insert().values(name='Rakesh',
address='Bhubaneswar')
result = connection.execute(ins)

Da mesma forma, podemos inserir várias linhas na tabela também.

ins = users.insert()
connection.execute(ins, [{"id": 2, "name":"Sonu", "address":
"Chennai"},
{"id": 3, "name":"Dibya", "address":
"Kurukshetra"},
{"id": 4, "name":"Rahul", "address":
"Indore"}])

Vamos ver isso em nossa tabela de dados.

query = sa.select([users])
Result = connection.execute(query)
ResultSet = Result.fetchall()
print(ResultSet[:])
Output: [(1, 'Rakesh', 'Bhubaneswar'), (2, 'Sonu', 'Chennai'),
(3, 'Dibya', 'Kurukshetra'), (4, 'Rahul', 'Indore')]

Atualizar e excluir

Atualizar e Excluir são operações DML usadas para atualizar e excluir

entradas específicas na tabela que atendem a determinadas condições.

Atualização

query = sa.update(users).values(adress =
'Bengaluru').where(users.c.name == 'Rakesh)
res = conn.execute(query)
query2 = sa.select([users])
res = conn.execute(query2)
res.fetchall()

Excluir

query = sa.delete(users).where( users.c.id == 1)

res = conn.execute(query)
query2 = sa.select([users])
res = conn.execute(query2)

Consultando a partir da tabela

Vamos ver como podemos executar consultas SQL regulares no Alchemy.

Para isso, usaremos um banco de dados diferente.

e
ngine = sa.create_engine('sqlite:///D:/baseball.db', echo =
False)
connection = engine.connect()
metadata = sa.MetaData()
baseball = sa.Table('allstarfull', metadata, autoload=True,
autoload_with=engine)

Colunas da tabela

baseball.columns.keys()
output: ['index',
'playerID',
'yearID',
'gameNum',
'gameID',
'teamID',
 'lgID',
'GP',
'startingPos']

Vamos ver como a tabela de dados se parece

query = sa.select([baseball])
result = connection.execute(query)
result.fetchmany(5)
output:[(0, 'gomezle01', 1933, 0, 'ALS193307060', 'NYA', 'AL',
1.0, 1.0),
(1, 'ferreri01', 1933, 0, 'ALS193307060', 'BOS', 'AL', 1.0,
2.0),
(2, 'gehrilo01', 1933, 0, 'ALS193307060', 'NYA', 'AL', 1.0,
3.0),
(3, 'gehrich01', 1933, 0, 'ALS193307060', 'DET', 'AL', 1.0,
4.0),
(4, 'dykesji01', 1933, 0, 'ALS193307060', 'CHA', 'AL', 1.0,
5.0)]

Para tornar a tabela melhor e mais compreensível, podemos convertê-la em

um quadro de dados

import pandas as pd
df = pd.DataFrame(result.fetchmany(5), columns=result.keys())
print(df)
**fetchmany() e fetchall() são as funções usadas para recuperar um número
específico de elementos da tabela. Podemos limitar o número de linhas
importadas passando um argumento em fetchmany(n).

Onde Cláusula

Consultaremos detalhes dos quatro primeiros jogadores com ID de equipe

NYA (New York Yankees) e ID de ano após 2000.

query =
sa.select([baseball]).where(sa.and_((baseball.columns.teamID=='N
YA'), baseball.columns.yearID>2000))

result = connection.execute(query)

df = pd.DataFrame(result.fetchmany(5), columns=result.keys())

df

Encomendar por e agrupar por

Agrupar por e Ordenar por são dois comandos SQL necessários. Vamos ver
como podemos realizar essas operações usando a Alquimia.

query = sa.select( baseball.c.teamID,

sa.func.count(baseball.c.playerID).label('NoOfPlayers'))
.group_by(baseball.c.teamID)
result = connection.execute(query)
df = pd.DataFrame(result.fetchmany(5), columns=result.keys())
df

Como você pode observar, usamos uma função agregada junto com GROUP
BY. A função label funciona como "AS" no SQL para especificar o alias de
uma coluna. Da mesma forma, também podemos usar a ordem por comando.

query = sa.select( baseball.c.teamID,

sa.func.count(baseball.c.playerID).label('NoOfPlayers'))

.group_by(baseball.c.teamID)

.order_by(sa.desc('NoOfPlayers'))
result = connection.execute(query)
df = pd.DataFrame(result.fetchmany(5), columns=result.keys())
df
No código acima, Order by foi usado com a função descendente no alias da
coluna agregada.

Ingresso no SQL

Normalmente, temos que trabalhar com várias tabelas, e consultar dados delas
requer a adesão. Usaremos um método de junção interna.

Para isso, usaremos duas tabelas separadas dos dados do Chinook.

engine = sa.create_engine('sqlite:///E:/Chinook.sqlite', echo =

False)
conn = engine.connect()
metadata = sa.MetaData()
artist = sa.Table('Artist', metadata, autoload=True,
autoload_with=engine)
album = sa.Table('Album', metadata, autoload=True,
autoload_with=engine)

A tabela do artista tem o nome dos artistas e seus IDs. Enquanto a tabela de
álbuns tiver IDs de artista, o nome do álbum e suas IDs. Então, vamos juntar
essas duas tabelas na coluna Id do artista.

query = sa.select([album, artist.c.Name])

j = album.join(artist, album.c.ArtistId == artist.c.ArtistId )
stmt = query.select_from(j)
res = conn.execute(stmt)
dt = pd.DataFrame(res.fetchmany(5), columns=res.keys())
dt
O equivalente SQL do código acima é

str(stmt)
output: 'SELECT "Album"."AlbumId", "Album"."Title",
"Album"."ArtistId", "Artist"."Name" nFROM "Album" JOIN "Artist"
ON "Album"."ArtistId" = "Artist"."ArtistId"'

Prós e contras da alquimia SQL

Agora, vamos discutir algumas vantagens e desvantagens da Alquimia SQL.

Profissionais

 A alquimia dá abstração ao banco de dados de back-end. Assim, um

desenvolvedor médio não precisa se preocupar com instruções SQL.
 A transição para outros bancos de dados se torna mais fácil.
 As consultas são otimizadas e podem funcionar melhor do que o SQL se
você mesmo o escreveu, a menos que seja um veterano do SQL.

Contras

 Pode haver casos em que a Alquimia pode se tornar ineficiente. Portanto,

conhecer SQL é sempre desejado.
 Saber o que está acontecendo sob o capô muitas vezes dá uma vantagem.
Portanto, não é um substituto completo para o SQL.

Conclusão

Ao longo do artigo, passamos por diferentes conceitos sobre a Alquimia SQL.

Aprendemos o quê e o porquê da alquimia. Neste artigo, nós raspamos a
superfície da linguagem de expressão. Alguns pontos-chave do nosso artigo
  Primeiro, aprendemos a nos conectar a bancos de dados em diferentes
dialetos SQL.
 Aprendemos a criar uma nova tabela do zero e importar tabelas
existentes.
 Aprendi a usar operações SQL básicas como consultar, agregar, ingressar,
atualizar e excluir, etc.
 Finalmente, discutiu os prós e contras da Alquimia em breve.

Então, foi isso. Obrigado por ler.

A mídia mostrada neste artigo não é de propriedade da Analytics Vidhya

e é usada a critério do Autor.
Relacionado

Engenharia de Dados: Bancos de Dados SQL vs. NoSQL

Bancos de dados SQL vs NoSQL – um conceito-chave que todo engenheiro de dados deve saber
SQL para Ciência de Dados: Um Guia para Iniciantes!

blogathon.SQLalquimia sql

Duração: Dez 12
Índice

 Introdução
 O que é a Alquimia SQL
 Requisitos de instalação
 Criando uma tabela
 Atualizar e excluir
 Consultando a partir da tabela
 Encomendar por e agrupar por
 Ingresso no SQL
 Prós e contras da alquimia SQL
 Conclusão

Sobre o Autor
Sunil Kumar Traço

Nossos Principais Autores









 
ver mais
BaixarAnalytics Vidhya App para o blog / artigo mais recente

Post AnteriorPipeline ETL com Google DataFlow e Apache Beam

Próximo PostExplicação passo a passo para a previsão de séries temporais
Deixar uma respostaSeu endereço de e-mail não será publicado. Os campos
obrigatórios estão marcados com *
 Notifique-me de comentários de acompanhamento por e-mail.

Notifique-me de novas postagens por e-mail.

Enviar
Principais recursos

Tutorial Python: Trabalhando com arquivo CSV para Ciência de Dados

Harika Bonthu - 21 DE AGOSTO DE 2021

Noções básicas sobre a floresta aleatória

Sruthi E R - JUN 17, 2021

Noções básicas sobre o algoritmo SVM (Support Vector Machine) a partir de exemplos
(juntamente com o código)

Raio de Sol - 13 DE SETEMBRO, 2017

6 Passos Fáceis para Aprender Algoritmo Bayes Ingênuo com códigos..

Raio de Sol - 11 DE SETEMBRO, 2017

Baixar Aplicativo

 Análise Vidhya

Quem somosNossa EquipeCarreirasEntre em contato conosco

 Cientistas de dados

BlogueHackathonDiscussõesCandidate-se a Empregos

 Empresas

Pós EmpregosTreinamentosContratação de HackathonsPublicidade

 Visite-nos

© Direitos autorais 2013-2022 Analytics Vidhya.

Política de privacidade Termos de Uso Política de Reembolso
Usamos cookies nos sites da Analytics Vidhya para