Introdução ao banco de dados MySQL

  Vamos ao primeiro contato com o banco de dados MySQL. Depois desta introdução sobre as funcionalidades básicas do banco de dados, vamos unir com Shell Script nas futuras publicações.
  Para saber se o banco de dados já está instalado, digite:

dpkg -l mysql*

  Eu estou usando a versão 5.1.49-1ubuntu8.1
  Caso não esteja instalado, digite:

apt-get install mysql-server

  Para se autenticar, utilize o comando:

mysql -u user -p password

  Substitua o nome do user e a senha password pela combinação que autentica no sistema.
  Antes de sair digitando comando, entenda conceitos essenciais:

• database: conjunto de tabelas.
• table: depois de determinada a database a ser usada, é a vez de criar a tabela contendo os nomes das variáveis dispostas em colunas. Cada variável tem um tipo: varchar, int, time etc. Mais detalhes veja Data Types.

  Para os comandos a seguir, mostro anotações que fiz sobre meu estudo sobre C++. A medida que via informações da mais alta importância, fui armazenando num banco de dados.

  Para listar as databases:

show databases;

  Para criar uma database:

create database deitel;

  Para utilizar a database:

use deitel;

  Para listar as tabelas existentes na database, digite:

show tables;

  Para criar a tabela com 3 variáves sendo página, seção e texto:

create table livro ( pagina INT, secao INT, texto TEXT);

  Se quiser que a cada linha o contador incremente o número do registro, observe o tipo AUTO_INCREMENT e PRIMARY KEY que são usadas para a variável id.

create table livro ( id int AUTO_INCREMENT, pagina varchar(5), secao varchar(8), texto TEXT, PRIMARY KEY (id));

  Para o caso que um valor não poder aceito como vazio, digite o nome da variável, o tipo e a palavra NOT NULL.
  Exemplo:

create table livro ( id int AUTO_INCREMENT, pagina varchar(5) NOT NULL, secao varchar(8), texto TEXT, PRIMARY KEY (id));

  O comando a seguir descreve o nome, o tipo, se é permitido ou não preencher um valor e informações adicionais.

describe livro;

  Para inserir valores na tabela, observe:

insert into livro (pagina, secao, texto) values ('78', '3.9', 'A série Dive-Into mostra como compilar múltiplos arquivos.');

  Para alterar um dado, a sintaxe é:
update nome_da_tabela set Nome_da_variável='NOVO VALOR' where id='numero_unico';
  Exemplificando:

update livro set secao='4.6' where id=4;

  Caso queria descartar uma tabela, o comando é:

drop table nome_da_tabela;

  Exemplificando:

drop table livro;

  Com estes comandos já é possível criar databases e tabelas que atendam necessidades elementares. Na próxima publicação utilizaremos o Shell Script para manipular o MySQL.

Configuração da minha rede de computadores

  Após várias tentativas finalmente cheguei na configuração de rede que atende exatamente o que preciso.
  Listando os elementos da rede:

• modem ADSL
• hub
• roteador wireless
• 2 computadores com windows
• 1 computador com Linux
• 1 impressora

  O modem ADSL deve ser o servidor DHCP para que os computadores entendam quem é o gateway da rede. Se puder o roteador wireless como servidor DHCP, não comunicação com a internet porque este dispositivo não tem interface com as redes externas.
  A função do hub é bem conhecida: é o distribuidor de pontos.
  O roteador wireless tem um recurso interessante que é um servidor de impressão. Basta conectar a interface USB da impressora com o roteador e instalar os drivers que a comunicação acontece sem transtornos. Desta forma, qualquer computador envia para fila de impressão sem depender de outro computador ligado.
  As duas estações windows recebem um IP que é negociado com servidor DHCP. Um ponto interessante chama-se "Expires In" que diz por quanto tempo o servidor DHCP reserva um IP para aquela máquina. Se o tempo expirar, outro computador pode receber o IP que estava com outra máquina.
  Apenas uma máquina tem um IP fixo e fora da faixa do servidor DHCP por razões óbvias: não conflitar com um IP que tem um intervalo reservado. A utilidade de um IP fixo é poder direcionar serviços. Lembrando que para estabelecer uma comunicação é preciso um IP e uma porta. Desta forma, quando uma solicitação vem de fora da minha rede, o roteador analisa qual a porta procurada e se este número estiver listado na configuração, faz o redirecionamento para meu computador. Perfeito quando se esquece um arquivo em casa e a conexão remota economiza tempo!
  Enfim, apresento o diagrama. A figura foi elaborada com o software dia e através do export foi convertida para jpg.

Análise dos números da Quina

  Não há dúvida que programação e matemática combinam para fazer análises das mais variadas formas.
  Este script executa as seguintes etapas:

• baixa um arquivo compactado contendo todos os jogos realizados pela quina
• apaga os arquivos textos criados para evitar que fique poluindo seu diretório
• remove as tags html para que fiquem somente os cinco números sorteados
• organiza os números de colunas para linhas
• ordena em ordem crescente os números sorteados
• calcula a soma da primeira coluna a quinta coluna individualmente
• a soma de cada coluna é divida pelo número de jogos para obter a média aritmética
• exibe os 5 números sorteados com maior frequência

  Copie e execute! Boa análise!
  E se você for premiado com ajuda deste script, aceito doações! :)

#!/bin/bash

# by Murilo Fujita
# v1.1 Exibe os 5 numeros sorteados com maior frequencia
# v1.0 Extrai os numeros sorteados, ordena em ordem crescente, soma cada coluna e divide pela quantidade de jogo

#read -p "Entre com jogo " inicio

wget http://www1.caixa.gov.br/loterias/_arquivos/loterias/D_quina.zip
unzip D_quina.zip

rm -f D_quina.zip
rm -f T7.GIF
rm -f quina1.txt
rm -f quina2.txt
rm -f quina3.txt
rm -f quina4.txt
rm -f quina5.txt
rm -f quina6.txt
rm -f quina7.txt
echo Limpando HTML

sed '/html/d' D_QUINA.HTM | sed '/table/d' | sed '/body/d' | sed '/tr/d' | sed '/,/d' | sed '/SIM/d' | sed '/N/d' | sed 's/<td>//' | sed 's/<\/td>//' > quina1.txt
linhas1=`wc -l quina1.txt | awk '{printf "%s\n",$1}'`

#rm -f D_QUINA.HTM

echo Extraindo numeros sorteados

seq=7
while [ $seq -le $linhas1 ]
  do
   head -n $seq quina1.txt | tail -n 5
   let seq=$seq+10
  done >> quina2.txt

echo Formatando numeros em colunas

linha2=`wc -l quina2.txt | awk '{printf "%s\n",$1}'`
seq2=5
while [ $seq2 -le $linha2 ]
  do
   head -n $seq2 quina2.txt | tail -n 5 | paste -s -d" "
   let seq2=$seq2+5
  done >> quina3.txt

tr -d '\r' < quina3.txt > quina4.txt


echo Organizando os números sorteados em ordem crescente

total_jogos=`sed '/^$/d' quina4.txt | wc -l`
mv -v D_QUINA.HTM D_QUINA$total_jogos.HTM
for i in `seq $inicio 1 $total_jogos`
  do
   head -n $i quina4.txt | tail -n 1 | tr " " "\n" | sort -n | paste -s -d" " >> quina5.txt
  done

s1=`cut -f1 -d" " quina5.txt | paste -s -d"+" | bc`
s2=`cut -f2 -d" " quina5.txt | paste -s -d"+" | bc`
s3=`cut -f3 -d" " quina5.txt | paste -s -d"+" | bc`
s4=`cut -f4 -d" " quina5.txt | paste -s -d"+" | bc`
s5=`cut -f5 -d" " quina5.txt | paste -s -d"+" | bc`
echo Soma de todos os numeros
echo $s1 $s2 $s3 $s4 $s5

#let jogos_processados=$total_jogos-$inicio

# linhas5=`wc -l /home/murilo/programas/quina5.txt | cut -f1 -d" "`
media1=`echo $s1/$total_jogos | bc` #jogos_processados total_jogos
media2=`echo $s2/$total_jogos | bc`
media3=`echo $s3/$total_jogos | bc`
media4=`echo $s4/$total_jogos | bc`
media5=`echo $s5/$total_jogos | bc`
echo Media dos numeros sorteados nos $total_jogos jogos realizados
echo $media1 $media2 $media3 $media4 $media5

printf "\n"
echo Exibindo a frequencia do numero sorteado
sleep .5
  for i in `seq 9`;
   do
    printf "0$i `grep 0$i quina2.txt | wc -l` "
   done
  printf "10 `grep 10 quina2.txt | wc -l` "
  printf "\n"

inicio=11
fim=20
while [ $inicio -le 80 ]
do
  for i in `seq $inicio 1 $fim`;
   do
    printf "$i `grep $i quina2.txt | wc -l` "
   done
  printf "\n"
  let inicio=$inicio+10
  let fim=$fim+10
done


for i in `seq 9`; do printf "0$i `grep 0$i quina2.txt | wc -l`\n" ; done >> quina6.txt
for i in `seq 10 1 80`; do printf "$i `grep $i quina2.txt | wc -l`\n" ; done >> quina6.txt
awk '{printf "%s %3s\n",$2, $1}' quina6.txt | sort -n | tail -n 5 > quina7.txt

printf "\n"
echo Os numeros mais sorteados sao

for i in `seq 5`
  do
   head -n $i quina7.txt | tail -n 1 | awk '{printf "%s %3s\n",$2, $1}'
  done

   Caso queria baixar diretamente o código, salve este link.

Espiral de Arquimedes

  Depois de ver a Espiral de Arquimedes , quis entender a matemática que gera a figura. Até chegar no resultado, usei C++, Shell Script e gnuplot.
  Uma vez lido sobre o assunto no link, é preciso entender como converter de coordenadas cartesianas para polares. O assunto foi estendido para realizar uma figura 3D.
  A parte que utiliza C++ é composta de três arquivos: uma classe, a definição da classe e o programa-cliente (main).

A classe

  Apenas uma função que não retorna nada (void) com o nome de Polar e não recebe nenhum parâmetro.

cat espiral.h

#ifndef ESPIRAL_H
#define ESPIRAL_H

class espiral {
public:
  void Polar();
private:

};
#endif /* ESPIRAL_H */

Definição da classe

  Os includes chamam a biblioteca matemática cmath , iostream para imprimir e mudar de linha (cout e endl) e a biblioteca criada espiral.h .
  void espiral::Polar(). É necessário a palavra espiral e duas vezes :: para que o compilador saiba em qual classe foi feita sua declaração.
  Na função há a declaração da constante pi e algumas variáveis. O laço for gera a quantidade de pontos desejada e foi decidido 10 voltas (3600 pontos). Traduzindo o que x e y armazenam, é

x = raio * cos θ
y = raio * sen θ

  É preciso converter de radianos para graus!
  A variável z é incrementada de 0.001 em 0.001.
  O cout << gera a saída para as variáveis.

cat espiral.cpp

#include< cmath >
#include< iostream >
using std::cout;
using std::endl;
#include "espiral.h"

int espiral::Polar()
{
  const double pi=3.141592;
  const int pontos=3600;
  double x[pontos],y[pontos];
  double z, r=1;

  z=0;
  for (int teta=0; teta < pontos; teta++)
  {
    x[teta]=static_cast(r*cos(teta*pi/180));
    y[teta]=static_cast(r*sin(teta*pi/180));
    z+=0.001;
    r+=.1;

    cout << x[teta] << " " << y[teta] << " " << z << endl;
  }

main

  O programa-cliente que ao ser executado é responsável por chamar os métodos em uma determinada ordem.
  espiral é a classe e myespiral é o objeto criado. O software só pode manipular o objeto e por isso cada classe tem seu objeto.
  Assim, o que é visto em seguida é o objeto myespiral chamando o método Polar.

cat main.cpp

#include <cstdlib>
#include "espiral.h"
using namespace std;
int main(int argc, char** argv) {
  espiral myespiral;
  myespiral.Polar();
  return 0;
}

  Agora que os arquivos estão prontos, uma instrução precisa ser passada ao compilador para saber como juntar os códigos-fontes e gerar o código-objeto (a linguagem de máquina). Assim:

$ g++ espiral.cpp main.cpp -o arquimedes.out -ansi

  Ao executar o binário, redirecione para um arquivo-texto:

$ ./arquimedes.out > plot.txt

  A participação do shell script foi a de apontar valores extremos dos eixos X e Y.

$ cat xy.sh

#!/bin/bash
menorX=`cat plot.txt | awk '{printf "%s\n",$1}' | sort -n | head -n 1`
maiorX=`cat plot.txt | awk '{printf "%s\n",$1}' | sort -nr | head -n 1`
menorY=`cat plot.txt | awk '{printf "%s\n",$2}' | sort -n | head -n 1`
maiorY=`cat plot.txt | awk '{printf "%s\n",$2}' | sort -nr | head -n 1`
echo ">X" $menorX
echo "<X" $maiorX
echo ">Y" $maiorY
echo "<Y" $menorY

  Executando o script xy.sh para a massa de dados plot.txt , o resultado foi:
>X -343.048
<X 361
>Y 334.049
<Y -352.046

  Este resultado servirá para entrar com os limites do gráfico (instruções xrange e yrange).
  Finalmente, para gerar a figura, chame o gnuplot:

  $ gnuplot
   G N U P L O T
   Version 4.4 patchlevel 0
   last modified March 2010
   System: Linux 2.6.35-30-generic
  
   Copyright (C) 1986-1993, 1998, 2004, 2007-2010
   Thomas Williams, Colin Kelley and many others
  
   gnuplot home:     http://www.gnuplot.info
   faq, bugs, etc:   type "help seeking-assistance"
   immediate help:   type "help"
   plot window:      hit 'h'
  
  Terminal type set to 'wxt'
  gnuplot> 

Entre com as seguintes instruções no prompt do gnuplot:

  gnuplot> set xrange[-400:400]
  gnuplot> set yrange[-400:400]
  gnuplot> set ticslevel 0
  gnuplot> splot "plot.txt" u 1:2:3 with lines

  Caso queira apenas um figura 2D, remova a variável z da linha cout << x[teta] << " " << y[teta] << " " << z << endl; para que imprima x e y. Os passos seguintes são os mesmo: direcionar a saída para plot.txt e com um comando no gnuplot, o gráfico é gerado:

gnuplot> plot [-400:400][-400:400] "plot.txt" with lines

  Os gráficos feitos pelo gnuplot permitem ser rotacionados. Use o ponteiro do mouse para visualizar milhares de ângulos!
  O resultado pode ser visto na figura abaixo.

Renomeando diretórios e arquivos recursivamente

  Depois de fazer um certo curso, fui ver a documentação que recebi e os nomes dos arquivos estavam em letras maiúsculas e espaços. Resolvi organizar de forma que estejam com letras minúsculas e sem espaço.
  Primeiro tratei dos nomes dos diretórios e subdiretórios. Observe que o comando find find -type d encontra os diretórios a partir de onde foi dado o comando.
Nota: o comando ls -l mostra os detalhes. Se o primeiro caracter é d, é um diretório. Se for um - é um arquivo comum.
  Tudo que é encontrado é redirecionado para o arquivo /tmp/files_diretorios.txt através do caracter >.
  Em seguida, a variável total_diretorios armazena a quantidade de diretórios. Essa informação é passada para o laço for que avança linha por linha através da combinação de head e tail. A variável Maiuscula guarda o nome original do arquivo buscando dentro do arquivo /tmp/files_diretorios.txt enquanto que minuscula armazena o mesmo nome, porém trocando de maiúscula para minúscula através do comando tr. Uma vez obtido o nome original e o nome personalizado, o comando mv renomeia o que está na primeira variável para a segunda. Extremamente importante as aspas porque os nomes dos arquivos geralmente possuem espaços.   Para remover o espaço, a saída do comando echo é a entrada do comando sed que interpreta 's/ //g' para substituir espaços por nada de forma global (observe a letra g).
  Terminado o tratamento para os diretórios, é a vez de levantar os arquivos comuns. O comando find -type f > /tmp/files_arquivos.txt busca todos arquivos e armazena no arquivo /tmp/files_arquivos.txt (reforçando, o levantamento é feito a partir de onde foi dado o comando).

#!/bin/bash

find -type d > /tmp/files_diretorios.txt
total_diretorios=`wc -l /tmp/files_diretorios.txt | cut -f1 -d' '`

for i in `seq $total_diretorios`
  do
   Maiuscula=`head -n $i /tmp/files_diretorios.txt | tail -n 1`
   minuscula=`head -n $i /tmp/files_diretorios.txt | tail -n 1 | tr A-Z a-z`
   mv -v "$Maiuscula" "$minuscula"
   sem_espaco=`echo $minuscula | sed 's/ //g'`
   mv -v "$minuscula" "$sem_espaco"
  done

find -type f > /tmp/files_arquivos.txt
total_arquivos=`wc -l /tmp/files_arquivos.txt | cut -f1 -d' '`

for i in `seq $total_arquivos`
  do
   Maiuscula=`head -n $i /tmp/files_arquivos.txt | tail -n 1`
   minuscula=`head -n $i /tmp/files_arquivos.txt | tail -n 1 | tr A-Z a-z`
   mv -v "$Maiuscula" "$minuscula"
   sem_espaco=`echo $minuscula | sed 's/ //g'`
   mv -v "$minuscula" "$sem_espaco"
  done

  Para um demonstração, digitei o comando abaixo dentro do diretório /tmp e veja a quantidade de diretórios e arquivos para organizar:

$ wc -l file*
377 files_arquivos.txt
56 files_diretorios.txt
433 total
  Para saber quanto tempo levou a execução do script, usa-se o comando time seguido no nome do seu script. Eu dei o nome de organiza.sh.

time ./organiza.sh

  E a resposta foi:

0m6.396s

  Apenas 6 segundos e 396 milésimos de segundo!

  Aproveitando a oportunidade, gostaria de introduzir o uso de funções. O conceito é simples. Se em outra parte do código realiza a mesma tarefa, este bloco de instruções pode ser atribuído um nome e delimitado por chaves ({}). A função deve ser codificada antes da função chamada. O código abaixo mostra uma versão enxuta usando funções. Uma diferença é que o armazenamento das informações vão para o arquivo /tmp/files.txt em vez de separar em dois arquivos. Não há problema porque primeiro trata de todos os diretórios e só então começa o processo de alterar os nomes de arquivos.

#!/bin/bash

tratamento()
{
   Maiuscula=`head -n $i /tmp/files.txt | tail -n 1`
   minuscula=`head -n $i /tmp/files.txt | tail -n 1 | tr A-Z a-z`
   mv -v "$Maiuscula" "$minuscula"
   sem_espaco=`echo $minuscula | sed 's/ //g'`
   mv -v "$minuscula" "$sem_espaco"
}

find -type d > /tmp/files.txt
total_diretorios=`wc -l /tmp/files.txt | cut -f1 -d' '`

for i in `seq $total_diretorios`
  do
   tratamento
  done

find -type f > /tmp/files.txt
total_arquivos=`wc -l /tmp/files.txt | cut -f1 -d' '`

for i in `seq $total_arquivos`
  do
   tratamento
  done

  Seja visualizar no modo texto ou no modo gráfico (usando nautilus, por exemplo), eu gosto que os arquivos sigam um padrão. Por isso, nada melhor do que um pouco de script para fazer um serviço trabalhoso em poucos segundos!
  Foi uma boa oportunidade para mostrar funções que é comum às linguagens de programação. Entendendo o conceito, é fortemente recomendado o seu uso, pois garante que as tarefas serão executadas todas da mesma forma.

Automatização de download do servidor FTP

  Uma das rotinas em uma empresa que trabalhei era conferir os dados de arquivos-texto e fazer uma contagem da produção. Então por que não automatizar já que é uma rotina?
  Este script conecta em um servidor FTP e realiza algumas instruções. Primeiro, o comando ftp -ivnp ip conecta ao servidor FTP (substitua ip pelo endereço ip). O símbolo << (here-document) diz qual é a palavra que ao encontrar novamente, encerrará as atividades. A linha seguinte inicia com user e é obrigatória. As duas palavras seguintes devem ser o nome de usuário e senha para efetuar a autenticação.
  Em seguida o comando cd acessa diretório1 e o mget faz download de múltiplos arquivos. Caso queria apenas um arquivo, use apenas get. Se for para entrar em outro diretório, use cd ../ para subir um nível e entrar no diretorio2. Por fim, ao encontrar fimftp, o script finaliza suas ações.
  Uma vez que os arquivos foram trazidos, faça o tratamento que for necessário: ter uma cópia em determinado diretório, fazer uma contagem com as informações dentro do arquivo etc.

#!/bin/bash


ftp -ivnp ip << fimftp
user usuario senha

cd diretorio1
mget arquivo1 arquivo2
cd ../diretorio2
mget outro_arquivo
fimftp



  Este é excelente exemplo para mostrar a utilidade do Shell Script. Tudo que for repetitivo pode ser automatizado. Cito como vantagens a garantia que a tarefa não será esquecida (salvo se a conexão cair) e o ganho de tempo. O crontab pode ser usado para disparar o script de acordo com a sua necessidade.

Backup seletivo

  Um dos serviços que funciona na minha máquina é o backup. Através deste script é feita uma compactação dos arquivos importantes combinado com o crontab, responsável por agendar certas tarefas de acordo com a sua programação.
  O primeiro comando, o cp copia meus favoritos para dentro do diretório text. Foi decidido que o nome do arquivo contém a data do dia do backup. Como não é incremental, posso recuperar arquivo com até 30 dias. Os nomes dos arquivos são backup_01.tar.gz, backup_02.tar.gz e assim por diante.
  Abaixo do comando tar estão os diretório e nomes de arquivos (indicados pela extensão ou mesmo por "*") que devem ser compactados. É importante usar o backslash (\) no final de cada linha para que o tar entenda que a instrução não acabou na primeira linha.
  Por fim, é feita uma verificação se o HD externo está montado no sistema operacional. O comando df serve para listar partições e dispositivos montados. Caso a resposta do if seja igual a 0 (zero), ou seja, verdadeiro, o cp copia para um diretório específico do HD externo. Caso negativo, responde que não está montado.
  Recomendo uma lida na man page do comando date para entender como obter determinados valores como mes, ano, hora, minuto entre muitas outras. Talvez criar 30 arquivos seja incômodo demais dependendo do volume que cada compactação ocupe. Então pode usar, por exemplo, um para cada dia da semana gerando apenas 7 arquivos.

#!/bin/bash

# copy my bookmarks from firefox to text directory
cp -v `ls -1tr ~/.mozilla/firefox/s9fan4kw.default/bookmarkbackups/*.json | tail -n 1` ~/text/bookmark.html

data=`date +%d`

tar cvfz /dados/backup/backup_$data.tar.gz \
~/documents/geocities/*.html \
~/documents/geocities/*.txt \
~/programas/* \
~/text/* \
~/documents/*.ldif \
~/documents/CV*


df -h /media/FUJITA250/
if [ `echo $?` = 0 ]
  then
   cp -v /dados/backup/backup_$data.tar.gz /media/FUJITA250/backup/
  else
   echo not mounted
fi

  Não deixe para o seu backup para amanhã. Saiba automatizá-lo para evitar momentos desagradáveis depois da perda.

Sequência cronológica para jpg e mpg

   Para o mesmo caso de juntar fotos e vídeos de uma mesma viagem, é preciso colocar ordem nas suas recordações. Resumindo em 3 etapas o que este script faz, temos:

• renomear de maiúscula para minúscula
  
• mostrar a data original para cada foto e vídeo através do exiftool
  
• renomear usando 2 dígitos para numerar (01.jpg, 02.jpg, ..., 10.mpg, ..., 99.jpg)
  

Os arquivos THM que acompanham os vídeos devem estar juntos, pois ao iniciar a gravação de vídeo, é registrado no THM a data do vídeo.    Os três primeiros for e a utilização das variáveis ano, mes, dia, hora, min, seg já foram comentados em Numerando arquivos de forma cronológica .    A variável total mais uma vez se encarrega de obter a quantidade de arquivos a minupular.    Ambos os laços for fazem o mesmo serviço, apenas para renomear os arquivos com um ou dois dígitos. Dentro do loop é verificado se o arquivo tem extensão JPG ou THM. De acordo com o arquivo fotos.txt, o if> seleciona entre as duas opções qual deve ser renomeado.

#/bin/bash

for M in *.JPG
  do
   m=$(echo $M | tr A-Z a-z)
   mv -v $M $m
  done

for M in *.THM
  do
   m=$(echo $M | tr A-Z a-z)
   mv -v $M $m
  done

for M in *.MPG
  do
   m=$(echo $M | tr A-Z a-z)
   mv -v $M $m
  done


ls -1 *.jpg *.thm | {
  while read arq; do
  ano=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 18-21`
  mes=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 22-23`
  dia=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 24-25`
  hora=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 26-27`
  min=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 28-29`
  seg=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 30-31`
  echo "$arq" $ano$mes$dia$hora$min$seg
  done
} | tee -a fotos.txt

cat fotos.txt | awk '{printf "%s %4s\n",$2,$1}' | sort -n > fotos2.txt

total=`ls *.jpg *.thm | wc -l`
echo *********************
echo Handling $total files
echo *********************
sleep 400

for i in `seq 9`
  do
  arq=`head -n $i fotos2.txt | tail -n 1 | cut -c 25-`
  if [ "$arq" = jpg ]
   then
    foto=`head -n $i fotos2.txt | tail -n 1 | cut -c 16-23`
    mv -v "$foto".jpg "0$i.jpg"
  fi
  if [ "$arq" = thm ]
   then
    video=`head -n $i fotos2.txt | tail -n 1 | cut -c 16-23`
    mv -v "$video".mpg "0$i.mpg"
  fi
  done

for i in `seq 10 1 $total`
  do
   arq=`head -n $i fotos2.txt | tail -n 1 | cut -c 25-`
   if [ "$arq" = jpg ]
    then
     foto=`head -n $i fotos2.txt | tail -n 1 | cut -c 16-23`
     mv -v "$foto".jpg "$i.jpg"
   fi
   if [ "$arq" = thm ]
    then
     video=`head -n $i fotos2.txt | tail -n 1 | cut -c 16-23`
     mv -v "$video".mpg "$i.mpg"
   fi
  done

   Script indicado para quem quer organizar rigorosamente a sequência dos acontecimentos tanto em fotos como em vídeos.    Adicionalmente, esta é uma ideia para mostrar o poder do BASH para organizar de acordo com os seus critérios.

Renomeando arquivos para o padrão Unix

Muitas vezes recebo arquivos que vem com espaços e parenteses e não é muito conveniente tratá-los no shell. Então eu prefiro eliminar esses caracteres. É o serviço do script abaixo.
Para executar, proceda assim:

./script nome_arquivo

para que o script saiba qual arquivo deve renomear.

Então, a primeira providência é uma checagem se foi passado o argumento através da condição if [ $# != 1 ].
Estando tudo bem, o script começa a renomear. O nome do arquivo fica armazenado na variável $1 e passa a transferir novos valores para as variáveis seguinte que foram usados nomes bem intuitivos.
De com_espaco passa o novo valor para sem_espaco.
sem_espaco para minuscula através do comando tr.
De minuscula para dash que substitui a sequência "_-_" por "-" através do sed.
Do dash para abre_parenteses e em seguida para fecha_parenteses que em ambos os casos usam o sed para substituir os caracteres.




#!/bin/bash
# remove spaces, uppercase to lowercase, replace " - " for "-", replace "(" for "-" and replace ")"for ""

# If file name isn't given show message
if [ $# != 1 ]
  then
   echo "Argumento: nome_de_arquivo"
   exit 1
fi

# grab the file name
com_espaco=`ls -1 "$1"`
# change space for underline
sem_espaco=`ls -1 "$1" | sed 's/ /_/g'`
#echo "$sem_espaco"
mv -v "$com_espaco" "$sem_espaco"
minuscula=$(echo "$sem_espaco" | tr A-Z a-z)
# change upper for lowercase
mv -v "$sem_espaco" "$minuscula"
# change _-_ for -
dash=`echo "$minuscula" | sed 's/_-_/-/'`
mv -v "$minuscula" "$dash"

ls "$dash" | grep "("
if [ $? -eq 0 ]
  then
   abre_parenteses=`ls "$dash" | sed 's/(/-/g'`
   mv -v "$dash" "$abre_parenteses"
fi

ls "$abre_parenteses" | grep ")"
if [ $? -eq 0 ]
  then
   fecha_parenteses=`ls "$abre_parenteses" | sed 's/)//g'`
   mv -v "$abre_parenteses" "$fecha_parenteses"
fi


Podemos automatizar este trabalho se forem muitos arquivos. Se for para os arquivos do mesmo diretório, há uma forma bem simples. Digite a linha de comando no seu terminal:


$ ls -1 | { while read arq; do ./script "$arq"; done; }


Apacerá uma mensagem de erro caso o nome de arquivo não tenha parênteses, mas garanto que no fim tudo estará devidamente renomeado.
É mais ágil quando é dado um duplo clique numa palavra e o terminal seleciona inteira facilitando o trabalho de copiar e colar.

Numerando arquivos de forma cronológica

Desenvolvi este script para organizar a reunião de fotos de mais de uma máquina digital. Desta forma, independente como as câmera registram o nome de arquivo, as fotos são renomeadas de acordo com a sequência cronológica.
Primeiro, os nomes são renomeados para maiúsculas como foi no post Renomear de maiúscula para minúscula e com sequência numérica .

O comando ls -1 *.jpg trata de colunar todos os arquivos com essa extensão e a cada linha que avança, as variáveis ano, mes, dia, hora, mim, seg recebem seus respectivos valores e o comando tee -a faz duas tarefas:

• exibe a saída na tela
  
• armazena a saída no arquivo foto.txt
  

Como extrair a informação através do exiftool demanda processamento e dependendo da quantidade parece travado, exibir as mensagens mostra que o programa está executando. O passo seguinte é contar a quantidade de arquivos jpg e armazenar na variável total. Essa informação é usada no laço for para ser o critério de parada. Neste exemplo, fiz para mais de 100 fotos para que todos os nomes de arquivos fiquem com três dígitos (001.jpg, 002.jpg, .., 010.jpg, ..., 100.jpg, ...). Fica a seu critério a quantidade de dígitos. Caso opte por não preencher com 0s (zeros), use o exemplo sem dígitos.

#/bin/bash

for M in *.JPG
  do
    m=$(echo $M | tr A-Z a-z)
    mv -v $M $m
done

ls -1 *.jpg | {
  while read arq; do
    ano=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 18-21`
    mes=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 22-23`
    dia=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 24-25`
    hora=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 26-27`
    min=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 28-29`
    seg=`exiftool "$arq" | grep Original | sed 's/://g' | sed 's/ //g' | cut -c 30-31`
    echo "$arq" $ano$mes$dia$hora$min$seg
done
} | tee -a fotos.txt

cat fotos.txt | awk '{printf "%s %4s\n",$2,$1}' | sort -n > fotos2.txt

total=`ls *.jpg | wc -l`

for i in `seq 9`
  do
    file=`head -n $i fotos2.txt | tail -n 1 | cut -f2 -d ' '`
    mv -v $file 00$i.jpg
  done

for i in `seq 10 1 99`
  do
    file=`head -n $i fotos2.txt | tail -n 1 | cut -f2 -d ' '`
    mv -v $file 0$i.jpg
  done

for i in `seq 100 1 $total`
  do
    file=`head -n $i fotos2.txt | tail -n 1 | cut -f2 -d ' '`
    mv -v $file $i.jpg
  done

Recomendo esta automatição de renomear arquivos de acordo com o data e hora quando várias pessoas participaram da mesma viagem, por exemplo. Assim, a visualização não será exibida em dias alternados. Para encerrar, dois cuidados:

• Garantir a câmera de todos estejam com a data e hora correta. Não precisam estar sincronizadas, apenas corretas.
  
• Difícil acontecer, mas caso exista um arquivo que até foi tirada no mesmo segundo, uma das fotos será sobreescrita.
  

Renomeando arquivos com sequência numérica a partir de um valor

O objetivo deste código-fonte é renomear arquivos com uma sequência numérica iniciando a partir de um determinado número. Neste exemplo, começa com o número 196. Executando no diretório que contém os arquivos *.jpg (observe que obedece o critério que está na linha com a variável nome), os novos nomes de arquivos tornam-se:

pag196.jpg, pag197.jpg, pag198.jpg, ...

até o último arquivo jpg que for encontrado.
A variável total conta os arquivos jpg para entregar ao laço for o critério de parada.
A variável nome armazena o nome do arquivo através do laço for que coloca os nomes em uma coluna e vai avançando linha a linha.
O comando mv renomeia cada arquivo.
O comando let incrementa a variável j.


#!/bin/bash

total=`ls *.jpg | wc -l`
j=196;

for i in `seq $total`
 do
   nome=`ls -1 *.jpg | head -n $i | tail -n 1`
   mv -v $nome pag$j.jpg
   let j++;
 done



Uma aplicação recomendada deste script como pode ser visto pelo novo nome de arquivo pag_NUMERO_.jpg é organizar de acordo com as páginas digitalizadas. Ler o documento no formato digital torna extremamente fácil localizar no livro digitalizado bastando apenas ver o nome do arquivo.

Alterando a permissão de todos os diretórios e subdiretórios

Alterando para 744 todos os subdiretórios a partir do script executado

  Seguindo a ideia de tratar arquivos dentro de um diretório, vamos abranger para uma execução recursiva. Em outras palavras, independente da quantidade de diretório e subdiretórios a partir do ponto que este script é executado, todos os diretórios e suas ramificações são tratados.

  Por exemplo, modificar a permissão de todos os diretórios e subdiretórios. Para cada path (caminho) encontrado, uma sintaxe do Shell Script destaca na cor azul.

#!/bin/bash

quantidade=`ls -R | grep './' | wc -l`

printf "\n       Mudando as permissoes de cada diretorios \n"
for i in `seq $quantidade`
  do
    dir=`ls -R1 | grep './' | sed 's/.\///' | sed 's/://' | head -n $i | tail -n 1`
    echo -e '\033[34;40;1m' "$dir" '\033[m'
    chmod -R 744 "$dir" 
    
    if [ $? == 0 ]
      then
      echo ok
    fi
done

  A variável quantidade informa o total de diretório e subdiretórios e o laço for faz a passagem por cada um deles.

  A sintaxe referido no início do texto é a que aparece na linha echo -e listando em highlighting (destaque).

  Finalmente, a permissão é modificada para o octal 744 alcançando o nosso propósito.

  Apenas para termos um feedback, uma mensagem contendo ok é exibida a cada alteração realizada com sucesso.

  Faço uma advertência quanto à segurança. Determinados diretórios tem seus números octais configurados para restringir acessos. Certifique-se que a alteração recursiva não violará algum diretório que exija maior segurança!