Variáveis de ambiente no Linux

As variáveis de ambiente são usadas para armazenar valores, que podem ser usados por scripts, executados a partir da shell.
Algumas variáveis de ambiente já fazem parte do sistema. Outras podem ser criadas por você.
No Bash, há 2 tipos de variáveis de ambiente ou (environment variables):

  1. locais — visíveis apenas dentro da shell, na qual foram criadas.
  2. globais — visíveis a todos os processos em execução numa shell.

Você pode usar o comando printenv, para ver quais são e como estão definidas as variáveis globais no seu ambiente atual:
Veja algumas das minhas:


printenv

LS_COLORS=di=7;32:fi=32:ln=4;32:pi=5;32:so=5;32:bd=5;32:cd=5;32:or=5;32:mi=5;32:ex=1;32:*.png=1;4;32:*.jpg=1;4;32
XDG_MENU_PREFIX=gnome-
LANG=pt_BR.UTF-8
GDM_LANG=pt_BR.UTF-8
DISPLAY=:0
COLORTERM=truecolor
USERNAME=justincase
DESKTOP_SESSION=gnome-xorg
WINDOWPATH=2
TERM=xterm-256color
SHELL=/bin/bash
VTE_VERSION=4602
XDG_CURRENT_DESKTOP=GNOME
GDMSESSION=gnome-xorg
GNOME_DESKTOP_SESSION_ID=this-is-deprecated
PATH=/opt/Komodo-Edit-10/bin:/opt/Telegram/Telegram:/usr/local/bin:/usr/bin:/bin:/usr/games
_=/usr/bin/printenv

Para ver apenas uma das variáveis, use o comando echo:


echo $HOME

/home/justincase

Experimente ver outras variáveis no seu sistema.
Depois, experimente criar sua primeira variável de sistema:


meusite="https://elias.praciano.com"

echo $meusite

https://elias.praciano.com

Fique atento: os nomes das variáveis são sensíveis à caixa (case sensitive).
Por isso, $meusite e $MEUSITE são coisas totalmente diferentes.
variáveis de ambiente sistema linux

Como prática recomendada, use sempre as letras minúsculas, para nomear as suas variáveis.
Assim você evita confusão com as variáveis do sistema.

Antes de abordarmos o próximo tópico, vale lembrar que as variáveis declaradas em uma sessão ou dentro de uma janela de um console não terão validade em outra sessão ou console.

Como declarar uma variável global

Para definir uma variável global, é necessário declarar (como você já deve saber) uma variável local.
Depois disto, a exportamos com o comando export:


autor='Elias Praciano'
echo $autor

Elias Praciano

export autor

Note que não se usa o ‘$’ à frente do nome da variável, quando a passamos para o comando export.
O último passo, para tornar uma variável persistente entre as sessões, é editar o arquivo ~/.bashrc.
Inclua, ao final dele, a linha com o comando export:


export autor='Elias Praciano'

Após este procedimento, a variável autor poderá ser sempre invocada no seu sistema, com o valor ‘Elias Praciano” — ou até você mudar o seu valor ou remover a linha do arquivo .bashrc.

Como descartar variáveis de ambiente no Linux

O comando unset pode ser usado para remover variáveis da memória do sistema:


echo $autor

Elias Praciano

unset autor
echo $autor

Remova também as declarações referentes à variável do seu arquivo .bashrc, ou ela ressurgirá na próxima sessão.

Como ajustar o PATH no Linux

Se você precisa definir um caminho para um diretório, no sistema ou dentro do seu próprio HOME, pode fazer isto ajustando a váriavel $PATH da shell
A variável é composta de uma lista de caminhos, separados por 2 pontos, que é consultada pela shell, para buscar arquivos de comandos ou importantes para o sistema.
linux user path
A palavra path, quer dizer ‘caminho’, em inglês. E é disso que a variável trata.
Existe a variável path padrão do sistema e a específica de cada usuário.
A primeira, é estabelecida pelo próprio sistema, durante a instalação do Bash ou pelo administrador.
A segunda pode ser definida livremente por qualquer usuário.
Para verificar o atual valor de seu PATH, use o comando echo:

echo $PATH

Como é possível observar (abaixo), o meu resultado mostra os valores padrão de um sistema recém instalado. Ainda não ajustei a variável para as minhas necessidades.

/usr/local/bin:/usr/bin:/bin:/usr/games

Dentro de um script, é possível usar a seguinte linha de comando:

printf "%s\n", $PATH

O resultado deve ser o mesmo obtido anteriormente.
Se você tem um diretório local, onde você guarda seus próprios scripts ou binários (como jogos, por exemplo), pode adicioná-lo PATH, para não precisar digitar o caminho completo, toda vez que for fazer uso de um deles.
Veja como acrescentar o caminho ‘/home/justincase/bin’ ao PATH de usuário:

# acrescentando o novo valor à variável $PATH:
PATH=$PATH:/home/justincase/bin/

# verificando a nova varável:
echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/games:/home/justincase/bin/

Uma outra forma, que vai dar o mesmo resultado, é acrescentar a variável $HOME ao PATH.
Veja o seu conteúdo:

echo $HOME
/home/justincase

Basta acrescentar o diretório ‘/bin’ ao PATH. Veja:

PATH=$HOME/bin/:$PATH

Como tornar este ajuste permanente

A variável PATH vai ser reiniciada após um reboot do sistema.
Portanto, ela precisa receber seus valores novamente, quando você se reautenticar.
Para tornar o valor, que você quiser, permanente, faça o ajuste da variável dentro do arquivo ‘.profile’ ou ‘.bash_profile’ (você deve ter um dos dois).
No meu sistema (Debian 9), está presente o arquivo ‘.profile’. Este é seu conteúdo:

cat .profile 
# ~/.profile: executed by the command interpreter for login shells.
# This file is not read by bash(1), if ~/.bash_profile or ~/.bash_login
# exists.
# see /usr/share/doc/bash/examples/startup-files for examples.
# the files are located in the bash-doc package.

# the default umask is set in /etc/profile; for setting the umask
# for ssh logins, install and configure the libpam-umask package.
#umask 022

# if running bash
if [ -n "$BASH_VERSION" ]; then
    # include .bashrc if it exists
    if [ -f "$HOME/.bashrc" ]; then
	. "$HOME/.bashrc"
    fi
fi

# set PATH so it includes user's private bin directories
export PATH="$HOME/bin:$HOME/.local/bin:$PATH"

A linha a ser ajustada é a última.
Abra o arquivo com o seu editor de textos favorito:

vi ~/.profile

Em seguida, ajuste a linha do PATH, para o que achar melhor. No meu caso, vai ficar assim:

export PATH="$HOME/bin:$HOME/.local/bin:$PATH"

Grave e feche o arquivo.
Os novos ajustes só terão efeito após se reautenticar no sistema.
Se quiser carregar os novos valores, sem fazer logout/login, entre o seguinte comando, no terminal:

source ~/.profile

ou, caso você tenha alterado o ‘.bash_profile’:

source ~/.bash_profile

E, antes de finalizarmos este tutorial, faça uma verificação:

echo $PATH

Referências

https://www.cyberciti.biz/faq/how-to-add-to-bash-path-permanently-on-linux/.

Por que precisamos usar ./ antes do nome de um script para executá-lo no Linux?

A combinação de um ponto seguido por uma barra é comumente usada para preceder comandos ou scripts no Linux e em outros sistemas operacionais UNIX.
Ainda que esta característica seja um tanto confusa ou chata para novos usuários, ela existe por uma boa razão e pode ser interessante saber qual é esta razão.
O que acontece é que os comandos em sistemas UNIX ou GNU/Linux são do tipo embutidos (memorizados) ou arquivos executáveis.
No primeiro caso, temos comandos como o cd, echo, kill, ls, pwd etc. Estes são parte da shell, em execução — e, portanto, ela é sempre capaz de localizá-los.
Linux tux ninja
No segundo caso, a shell precisa de ajuda para encontrar os comandos dos arquivos executáveis.
Estes arquivos podem ser tanto scripts (programas em Python, Perl, Bash etc.) como programas compilados.
Um programa compilado é um programa cujo código fonte (ou seja, seu código original, legível por humanos) tenha sido convertido em um arquivo executável, em linguagem de máquina e está pronto para rodar de imediato, sem que suas instruções precisem passar por uma interpretação prévia.
Uma shell é um programa que provê uma interface entre o usuário e o sistema — ela pode ser gráfica ou pode ser um terminal, onde você interage com o sistema em modo texto (que nem os hackers nos filmes).
O emulador de terminal ou o console é uma forma de interagir com a shell do seu sistema. A principal função da shell é ler os comandos que são digitados e executá-los.

Um script é um programa curto, escrito em uma linguagem de programação que é lido por um interpretador (Python, Perl, PHP, Bash etc.), que executa suas instruções.

Quando um texto é fornecido na linha de comandos da shell e, você pressiona Enter, esta assume que forneceu um comando.
A partir daí, a shell imediatamente verifica se a primeira string (sequência de caracteres) dada é um dos comandos embutidos dela ou um dos arquivos executáveis (que ficam guardados em diretórios apropriados).
A shell sabe quais são os diretórios de executáveis, por que eles estão armazenados em uma variável de ambiente do sistema, chamada PATH.

A variável de ambiente PATH é escrita em letras maiúsculas.
Em inglês, a palavra quer dizer “caminho”.
Sua função é informar ao sistema onde se encontram os comandos ou programas de que ele precisa.

Se nenhuma destas condições for atendida, a busca continuará nos diretórios listados na variável de ambiente PATH do usuário.
Ao ser encontrado, o comando é executado, desde que não haja qualquer outro problema.
Se não for encontrado, o usuário recebe uma mensagem de erro: “comando não encontrado” ou “command not found“.
Muitos usuários trabalham, na maior parte do tempo, em seus diretórios home e nos seus subdiretórios — por uma questão de conveniência e/ou segurança.
Contudo, o padrão do sistema operacional é não incluir estes diretórios na variável de ambiente PATH.
Portanto, se o usuário criar um script ou compilar um programa dentro de seu próprio diretório e tentar executá-lo, digitando seu nome, ele irá obter uma mensagem de erro.
Este problema pode ser facilmente resolvido com o uso de ‘./’ (um ponto e uma barra) — em inglês, é chamado de dot slash.
Trata-se, meramente, de uma forma abreviada de informar à shell que o caminho absoluto do arquivo que se está tentando executar é o diretório atual (aquele em que o usuário está trabalhando).

O uso de ./ antes de comandos locais é uma questão de segurança

Arquivos comuns, no diretório atual, podem ser acessados com uma referência simples, se acompanhados de um comando. Veja alguns exemplos:

ls Downloads/
cat lshw.log

Não há necessidade de indicar o caminho absoluto do arquivo, neste caso.
Mas, quando há a necessidade de executar alguma coisa fora dos caminhos usuais, o sistema requer que você informe exatamente o que deseja executar.
Este é um mecanismo de segurança.

Vamos supor uma situação em que você seja o administrador do sistema (root) e entra no diretório de algum dos usuários e comete o erro de digitar o comando ‘sl’, em vez de ‘ls’ — um erro comum.
Se houver algum programa malicioso, neste diretório, com este nome, ele simplesmente será ignorado e o sistema informará que não encontrou o comando.


É possível incluir o diretório /home do usuário no PATH. Basta incluir ‘.’ (ponto) na variável de ambiente PATH.
Ao fazer isto, todo os seus programas e scripts passarão a ser executados direto, sem a necessidade de indicar o caminho deles com um ‘./’.
Mas esta prática, obviamente, não é recomendada — ela põe a segurança do seu sistema em risco.
Se você fizer isto, a shell, pela ordem, irá procurar primeiro dentro do seu diretório de trabalho os comandos de execução. O que significa que, se houver um comando ‘ls’ (ou qualquer outro) lá dentro, ele é que será executado.
Se você necessita executar várias vezes seus scripts e está se incomodando com este “obstáculo de segurança”, há maneiras mais inteligentes e seguras de contorná-lo.

Como alterar a variável de ambiente PATH

Uma forma profissional de lidar com esta situação, em segurança, é criar um subdiretório no seu diretório local, para guardar seus scripts e seus programas compilados.
É seguro, então, informar este diretório específico ao PATH.
Você pode ver o conteúdo da variável de ambiente $PATH com o comando echo:

echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games

Portanto, crie um subdiretório, no seu home, chamado ‘bin’, e o inclua no PATH. Assim:

mkdir bin
export PATH=$PATH:$HOME/bin
echo $PATH

Note, ao final da linha, o novo diretório ‘/home/justincase/bin’ foi incluído:

/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/home/justincase/bin

Esta alteração só vale para a sessão atual.
Se você quiser torná-la permanente, inclua a linha export PATH=$PATH:$HOME/bin ao final do arquivo ‘.bashrc’.
Seja cuidadosa(o) e brinque com segurança.

Referências

http://www.linfo.org/dot_slash.html
http://stackoverflow.com/questions/6331075/why-do-you-need-dot-slash-before-script-name-to-run-it-in-bash

Como pesquisar sequências de caracteres dentro de strings, com a função LOCATE, no MySQL

A função LOCATE() do MySQL permite encontrar sequência dentro de uma cadeia de caracteres. Ou seja, a função pode ser usada para identificar uma substring dentro de uma string.
A função LOCATE() recebe dois argumentos: a substring que você deseja encontrar e o texto dentro do qual ela será procurada.
Capa do tutorial - como encontrar sequências de caracteres no MySQL
Se a busca for bem sucedida, a função retorna a posição em que a substring desejada se encontra ou o valor 0 (zero), caso ela não esteja presente.
Opcionalmente, é possível fornecer um terceiro argumento à função — para indicar em que posição, dentro da string principal, a busca deve ter início.

Exemplos de uso da função locate no MySQL

Neste primeiro exemplo, vou mostrar como criar uma variável no MySQL e, em seguida, como efetuar uma busca dentro dela com a função LOCATE().

SET @minhavar="O mysqladmin é um cliente para executar operações administrativas no MySQL. Ele pode ser usado para verificar a configuração do servidor e seu estado atual, além de criar e apagar bancos de dados - entre outras coisas.";
SELECT LOCATE("cliente",@minhavar);
+-----------------------------+
| LOCATE("cliente",@minhavar) |
+-----------------------------+
|                          19 |
+-----------------------------+
1 row in set (0.00 sec)

A busca efetuada é insensível a caixa das letras, ou seja, tanto faz procurar por “cliente” como “ClIEnTE” — para a função LOCATE(), as duas strings são a mesma coisa.

A função LOCATE() era sensível à caixa das letras nas versões do MySQL anteriores a 4.0.0
— MySQL Cookbook by Paul DuBois

O exemplo abaixo mostra como fazer a busca dentro do banco de dados:

SELECT CidadeCliente FROM ClientesCidades WHERE LOCATE('co',CidadeCliente);

O comando, acima, ordena uma pesquisa dentro da tabela ClientesCidades por CidadeCliente, em cujo texto, tenha a substring “co”. Veja o resultado:

+------------------------+
| CidadeCliente          |
+------------------------+
| Girifalco              |
| San Costantino Calabro |
| Rocourt                |
| Beaconsfield           |
| Rachecourt             |
| Vancouver              |
| Lacombe                |
| Port Lincoln           |
| Corroy-le-Grand        |
| Recco                  |
| Coalhurst              |
| San Demetrio Corone    |
| Lakeland County        |
| Beaconsfield           |
| Colonnella             |
+------------------------+
15 rows in set (0.01 sec)

Mysql: tipos de dados

Tipos de dados são uma forma de classificar as informações que serão armazenados no banco de dados e de definir antecipadamente:
Tutorial MySQL Tipos de dados

  • os tipos de valores que podem ser usados;
  • que tamanhos podem ter
  • as operações que podem ser realizadas;
  • seus significados;
  • se podem/serão indexados
  • como devem ser armazenados etc.

Entender os tipos de dados que podem ser armazenados no banco e a que situações se adequam é importante para projetar um banco de dados o mais eficiente possível. Veja, a seguir, alguns dos tipos de dados mais comuns no MySQL, acompanhado de uma breve descrição.

Tipos de dados numéricos no MySQL

O MySQL tem todos os tipos numéricos possíveis, o que inclui exatos, aproximados, inteiros, de ponto fixo, ponto flutuante etc. A lista, abaixo, mostra um resumo dos tipos de dados possíveis no MySQL:

  • TINYINT — número inteiro muito pequeno (tiny);
  • SMALLINT — número inteiro pequeno;
  • MEDIUMINT — número inteiro de tamanho médio;
  • INT — número inteiro de tamanho comum;
  • BIGINT — número inteiro de tamanho grande;
  • DECIMAL — número decimal, de ponto fixo;
  • FLOAT — número de ponto flutuante de precisão simples (32 bits);
  • DOUBLE — número de ponto flutuante de precisão dupla (64 bits);
  • BIT — um campo de um bit.

Tipos de dados em strings

Strings são cadeias de caracteres. No MySQL, uma string pode ter qualquer conteúdo, desde texto simples a dados binários – tais como imagens e arquivos. Cadeias de caracteres podem ser comparadas e ser objeto de buscas.

  • CHAR — uma cadeia de caracteres (string), de tamanho fixo e não-binária;
  • VARCHAR — uma string de tamanho variável e não-binária;
  • BINARY — uma string binária de tamanho fixo;
  • VARBINARY — uma string binária de tamanho variável;
  • BLOB — um BLOB (Binary Large OBject – OBjeto Grande Binário) pequeno;
  • TINYBLOB — um BLOB muito pequeno;
  • MEDIUMBLOB — um BLOB de tamanho médio;
  • LONGBLOB — um BLOB grande;
  • TINYTEXT — uma string não-binária e de tamanho bem reduzido;
  • TEXT — uma string não-binária e pequena;
  • MEDIUMTEXT — uma string de tamanho comum e não-binária;
  • LONGTEXT — uma string não-binária de tamanho grande;
  • ENUM — de acordo com o manual do MySQL, é uma string, com um valor que precisa ser selecionado de uma lista predefinida na criação da tabela;
  • SET — é um objeto que pode ter zero ou mais valores – cada um dos quais precisa ser escolhido de uma lista de valores predeterminados quando da criação da tabela.

Armazenamento de data e hora

Há várias opções para armazenar dados relacionados a data e hora. Se você quiser apenas armazenar o ano referente a um evento, pode usar o tipo YEAR. O tipo TIMESTAMP pode ser usado para acompanhar as mudanças ocorridas em um campo de uma tabela. Veja os tipos e suas descrições:

  • DATE — o valor referente a uma data no formato 'CCYY-MM-DD'. Por exemplo 1985-11-25 (ano-mês-dia). O 'CC' se refere aos dois dígitos do século (Century, em inglês);
  • TIME — um valor horário no formato 'hh:mm:ss' (hora:minutos:segundos);
  • TIMESTAMP — timestamp é uma sequência de caracteres ou informação codificada que identifica uma marca temporal ou um dado momento em que um evento ocorreu. No MySQL, ele tem o formato 'CCYY-MM-DD hh:mm:ss' – neste caso, seguem a padronização ISO 8601;
  • YEAR — armazena um ano no formato 'CCYY' ou 'YY';

Dados espaciais

O MySQL tem suporte a tipos de dados que correspondem às classes OpenGIS. Alguns destes carregam valores geométricos simples:

  • GEOMETRY
  • POINT
  • LINESTRING
  • POLYGON

O GEOMETRY pode armazenar qualquer tipo de valor geométrico. Os outros valores simples (POINT, LINESTRING e POLYGON) têm seus valores restritos aos tipos geométricos a que se referem.
Os outros, que seguem listados, carregam valores relativos a coleções/coletivos:

  • GEOMETRYCOLLECTION
  • MULTILINESTRING
  • MULTIPOINT
  • MULTIPOLYGON

Assim, GEOMETRYCOLLECTION pode armazenar coletâneas de objetos de qualquer tipo. Os outros tipos coletivos (MULTILINESTRING, MULTIPOLYGON e GEOMETRYCOLLECTION) restringem-se a cada forma geométrica particular.