Transações no banco de dados através do ShellScript

Leia isto "em cerca de 12 minutos".

Olá pessoas, vamos falar de shellscript, que é algo que gosto muito. :)

Introdução

Bom, se você é usuário Linux sabe muito bem o que é Shellscript, uma linguagem usuda em vários sistemas operativos, até aqui tudo bem, mas…o que muitos não sabem é dá para fazer transações no banco de dados através da mesma.

  • Você: Sério?
  • Eu: Sério cara.

O que vamos ver neste post é exatamente isso, uma conexão com um banco de dados; criação de um database; e a criação de uma tabela. Não irei abordar um CRUD completo, pois com base na conexão e criação de uma tabela, você já será apto para navegar em sua mente e realizar as demais transações no banco de dados, tendo como requerimento apenas conhecimento de PL/SQL.

Os bancos de dados que irei abordar aqui serão o PostgreSQL e o MySQL, então suponho que você já tenha um dos dois instalados em sua máquina; com as configurações de usuário e senha realizadas; e o serviço iniciado.

Requerimentos

  • PostgreSQL ou Mysql instalado.
  • Conhecimento básico em PL/SQL.
  • Força de vontade :D

PostgreSQL

Preparando ambiente

Por padrão, o PostgreSQL já cria um usuário e uma role com o nome postgres, você pode fazer um teste de conexão com o seguinte comando:

1 $ psql -U postgres

ou

1 $ sudo -u postgres psql

NOTA: O usuário postgres tem permissão de SUPERUSER, então você pode criar outros usuários, databases, tabelas e outros respectivas permissões com ele.

Criando um DATABASE no PostgreSQL

Uma vez que você já está conectado ao psql com usuário postgres, vamos criar um DATABASE onde vamos trabalhar nossas transações:

1 postgres=# CREATE DATABASE my_db;

NOTA: Mais adiante, criamos nossa DATABASE através de uma função em nosso projeto, porém, vale lembrar que o CREATE DATABASE no PostgreSQL não tem opção IF NOT EXISTS e só podemos executar uma única instrução do CREATE DATABASE, não conseguimos executa-lo dentro de um bloco de transação. Com essas informações, foi usado outras técnicas com shellscript para verificar se DATABASE não existe e assim criar o mesmo.

Iniciando projeto

Criando pasta de ambiente do projeto

Vamos criar uma pasta para nosso projeto e entrar na mesma com o comando abaixo:

1 mkdir ~/sh_postgresql; cd $_

Criando arquivo de configuração

Para fins de boas normas de projeto, vamos criar o arquivo config.conf na base do nosso projeto, e armazenar nossas variáveis global.

Conteúdo do arquivo: config.conf

1 DB="my_db"
2 HOST="localhost"
3 PORT="5432"
4 USER="postgres"
5 TABLE="films"

Essas variáveis vão ser responsáveis por qualquer tipo de transação no banco de dados.

Criando bibliotecas para nosso projeto

Sempre que criamos um projeto, é interessante dividir partes do nosso código e fazer essas partes virarem bibliotecas, ou seja, pequenos trechos de código onde podemos importar a qualquer momento. Vamos criar nossas bibliotecas na pasta libs.

Biblioteca create_database.bash

A primeira lib (biblioteca) que vamos criar é a create_database.bash. Essa biblioteca irá conter uma função para criar nossa DATABASE caso ela não exista.

Conteúdo do arquivo: libs/create_database.bash

1 function _create_database () {
2 	psql -h $HOST -p $PORT -U $USER -tc "SELECT 1 FROM pg_database WHERE datname = '$DB'" | grep -q 1 || psql -h $HOST -p $PORT -U $USER -c "CREATE DATABASE $DB"
3 }

Em Criando um DATABASE no PostgreSQL, criamos nosso DATABASE manualmente através do psql, mas caso não criassemos, essa função já seria responsável por criar.

Biblioteca create_table.bash

Outra lib (biblioteca) que vamos criar é a create_table.bash. Essa bibliotea irá conter uma função para criar nossa TABLE. Você pode ser bem mais dinâmico ao criar suas “libs”, como esse é um post para apenas lhe dar uma ideia, vou ser bem direto nessa biblioteca de criação de TABLE.

Conteúdo do arquivo: libs/create_table.bash

 1 function _create_table () {
 2     psql -h $HOST -p $PORT -U $USER -d $DB << EOF
 3 
 4        \c DB
 5         
 6        CREATE TABLE IF NOT EXISTS $TABLE (
 7     		id          char(5) CONSTRAINT firstkey PRIMARY KEY,
 8     		title       varchar(40) NOT NULL,
 9     		did         integer NOT NULL,
10     		date_prod   date,
11     		kind        varchar(10),
12     		len         interval hour to minute
13 	); 
14 EOF
15 }

Criando o programa principal

Vamos agora criar um arquivo chamando setup.bash, nesse arquivo iremos carregar nosso arquivo de configuração (config.conf) e nossas libs. Ele também terá um menu de interação com o usuário.

Conteúdo do arquivo: setup.bash

 1 #!/usr/bin/env bash
 2 
 3 source config.conf
 4 
 5 libs="$(ls ./libs/*.bash)"
 6 for lib in $libs; do
 7     source $lib
 8 done
 9 
10 case $1 in
11     createtb)
12         _create_database
13         _create_table
14     ;;
15     *)
16        printf "Using: $0 { createtb }"
17     ;;
18 esac
19 exit 0
20 }

Estrutura do projeto para PostgreSQL

A árvore do nosso projeto ficou assim:

1 .
2 ├── config.conf
3 ├── libs
4 │   ├── create_database.bash
5 │   └── create_table.bash
6 └── setup.bash

Executando nosso programa

Depois de ter criado todos arquivos, chegou a hora de fazer nosso programa ser executado. Para isso faça:

1 chmod +x setup.bash
2 bash setup.bash createtb

Se tudo ocorreu bem, a tabela ($DB) já foi criada no banco de dados. Você pode executar os comandos abaixo e verificar:

1 source config.conf && psql -h $HOST -p $PORT -U $USER -d $DB

Dentro do psql, execute o comando \dt para listar as TABLES desse DATABASE:

1 my_db=# \dt
2             Lista de relações
3  Esquema | Nome  |  Tipo  |   Dono   
4 ---------+-------+--------+----------
5  public  | films | tabela | postgres
6 (1 registro)

MySQL

Preparando ambiente

Antes de começar, precisamos verificar se temos acesso a conexão com o MySQL. Se você instalou e configurou normalmente, você pode executar o comando abaixo para logar informando a senha do MySQL configurada:

1 $ mysql -u root -p

Se você se conectou, já podemos prosseguir com os passos seguintes.

Iniciando projeto

Criando pasta de ambiente do projeto

Vamos criar uma pasta para nosso projeto de MySQL e entrar na mesma com o comando abaixo:

1 mkdir ~/sh_mysql; cd $_

Criando arquivo de configuração

Como fizemos no projeto para o PostgreSQL, vamos criar p arquivo config.conf na base do nosso projeto.

Conteúdo do arquivo: config.conf

1 DB="my_db"
2 HOST="localhost"
3 PORT="3306"
4 USER="root"
5 PASSWORD=""
6 TABLE="cartoons"

Criando bibliotecas para nosso projeto

Vamos repetir o mesmo conceito que fizemos para o PostgreSQL, criando nossas bibliotecas na pasta libs do projeto.

Biblioteca create_database.bash

Diferente do PostgreSQL, o MySQL contem uma opção de IF NOT EXISTS para criação de DATABASES, com isso não precisamos fazer a verificação via shellscript como fizemos com o projeto do PostgreSQL. Com a própria instrução SQL do MySQL, podemos fazer essa checagem.

Conteúdo do arquivo: libs/create_database.bash

1 function _create_database () {
2     mysql --host=$HOST --port=$PORT --user=$USER --password=$PASSWORD << EOF
3         CREATE DATABASE IF NOT EXISTS \`$DB\`;
4 EOF
5 }

Biblioteca create_table.bash

Diferentemente do PostgreSQL também, com o MySQL você deve criar delimitadores para executar várias instruções SQL. Você define um delimitador com a palavra reservada DELIMITER e logo em seguida o delimitador que você quer. Aqui estou usando o $$.

Conteúdo do arquivo: libs/create_table.bash

 1 function _create_table () {
 2     mysql --host=$HOST --port=$PORT --user=$USER --password=$PASSWORD << EOF
 3        
 4         DELIMITER $$
 5 
 6         USE \`$DB\` $$
 7 
 8         CREATE TABLE IF NOT EXISTS \`$TABLE\`  (
 9             id        INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
10             title     VARCHAR(40) NOT NULL,
11             did       INTEGER NOT NULL,
12             date      TIMESTAMP,
13             kind      VARCHAR(10),
14             designer  VARCHAR(30),
15             
16         )$$ 
17 EOF
18 }

Criando o programa principal

Vamos carregar todas nossas bibliotecas no setup.bash e o arquivo de configuração config.conf. Na mesma ideia que fizemos no projeto do PostgreSQLm vamos fazer para o MySQL mais uma vez.

Conteúdo do arquivo: setup.bash

 1 #!/usr/bin/env bash
 2 
 3 source config.conf
 4 
 5 libs="$(ls ./libs/*.bash)"
 6 for lib in $libs; do
 7     source $lib
 8 done
 9 
10 case $1 in
11     createtb)
12         _create_database
13         _create_table
14     ;;
15     *)
16        printf "Using: $0 { createtb }"
17     ;;
18 esac
19 exit 0
20 }

Estrutura do projeto para MySQL

A árvore do nosso projeto ficou assim:

1 .
2 ├── config.conf
3 ├── libs
4 │   ├── create_database.bash
5 │   └── create_table.bash
6 └── setup.bash

Executando nosso programa

1 chmod +x setup.bash
2 bash setup.bash createtb

Execute os comandos abaixo e verificar:

1 source config.conf && mysql --host=$HOST --port=$PORT --user=$DB_USER --password=$DB_PASSWD

Dentro do console do mysql, execute o comando abaixo para listar o DATABASE criado:

 1 MySQL [(none)]> show databases;
 2 +--------------------+
 3 | Database           |
 4 +--------------------+
 5 | information_schema |
 6 | my_db              |
 7 | mysql              |
 8 | performance_schema |
 9 +--------------------+
10 3 rows in set (0.001 sec)

Conclusão

Como dito, foi um simples post para você tenha uma noção do que podemos fazer com shellscript. Tanto os passos para PostgreSQL e para MySQL, existem trechos de código praticamente idênticos, mudando uma coisinha ou outra. Porém, apesar de realizarmos transações no banco de dados com shellscript, não recomendo você tentar criar um sistema dessa maneira. Existem diversas linguagens de programação onde temos milhares de vantagens para realizar tudo que fizemos aqui.

Espero que você tenha aprendido algo com esse post. Eu fico por aqui, até a próxima.

jektify © 2019  +

Música

A Palavra

"Quem é fiel nas coisas pequenas também será nas grandes; e quem é desonesto nas coisas pequenas também será nas grandes."
(Lucas 16:10 NTLH)

Deixe seu comentário