DATABASE()

Retorna o nome do banco de dados atual:

mysql> SELECT DATABASE();
        -> 'test'

Se nenhum banco de dados estiver selecionado, DATABASE() retorna NULL a partir do MySQL 4.1.1, e uma string vazia em versões anteriores.

USER(), SYSTEM_USER(), SESSION_USER()

Retorna o nome do usuário MySQL e nome de máquina atual:

mysql> SELECT USER();
        -> 'davida@localhost'

O valor indica o nome do usuário que você especificou ao conectar ao servidor e a máquina cliente da qual você se conectou. (Antes do MySQL versão 3.22.11, o valor da função não inclui o nome da máquina cliente.)

Você pode extrair apenas a parte do nome do usuário, desconsiderando se o valor inclui a parte do nome de máquina, desta forma:

mysql> SELECT SUBSTRING_INDEX(USER(),"@",1);
        -> 'davida'

CURRENT_USER()

Retorna o nome do usuário e o nome de máquina com os quais a sessão atual foi autenticada. Este valor corresponde a conta que é usada para acessar seu privilégio de acessos. Ela pode ser diferente do valor de USER().

mysql> SELECT USER();
        -> 'davida@localhost'
mysql> SELECT * FROM mysql.user;
        -> ERROR 1044: Access denied for user: '@localhost' to database 'mysql'
mysql> SELECT CURRENT_USER();
        -> '@localhost'

O exemplo ilustra que embora o cliente tenha especificado um nome de usuário davida (como indicado pelo valor da função USER()), o servidor autenticou o cliente usando uma conta de usuário anônimo (como visto pela parte vazia no nome de usuário do valor CURRENT_USER()). Um modos de isto ocorrer é que não haja uma conta listada na tabela de permissões para davida.

PASSWORD(str), OLD_PASSWORD(str)

Calcula a senha a partir de senha str em texto puro. Está é a função que é utilizada para criptografar a senha do MySQL para armazenamento na coluna Password da tabela de permissões user

mysql> SELECT PASSWORD('badpwd');
        -> '7f84554057dd964b'

A criptografia de PASSWORD() não e reversível.

PASSWORD() não realiza a criptografia da senha da mesa maneira que as senhas Unix são criptografadas. Veja ENCRYPT().

Note: A função PASSWORD() é usada pelo sistema de autentificação no servidor MySQL, você NÃO deve uitlizá-las em suas próprias aplicações. Para este propósito utilize MD5() ou SHA1(). Veja também RFC-2195 para maiores informações sobre o tratamento de senha e autenticação segura em suas aplicações.

ENCRYPT(str[,salt])

Criptografa str utilizando a chamada de sistema crypt() do Unix. O argumento salt deve ser uma string com dois caracteres. (Na versão 3.22.16 do MySQL, salt deve ser maior que dois caracteres.)

mysql> SELECT ENCRYPT("hello");
        -> 'VxuFAJXVARROc'

ENCRYPT() ignora tudo depois dos primeiros 8 caracteres de str, pelo menos em alguns sistemas. Este comportamento é determinado pela implementação da chamada de sistema crypt().

Se crypt() não estiver disponível no seu sistema, ENCRYPT() sempre retorna NULL. Devido a isto recomendamos que você use MD5() ou SHA1() em vez dos existentes em sua plataforma.

ENCODE(str,senha_str)

Criptografa str usando senha_str como a senha. Para descriptografar o resultado, utilize DECODE().

O resultado é uma string binária do mesmo tamanho de str. Se você deseja salvá-la em uma coluna, use uma coluna do tipo BLOB.

DECODE(cript_str,senha_str)

Descriptografa o string criptografada cript_str usando senha_str como a senha. cript_str deve ser uma string retornada de ENCODE().

MD5(string)

Calcula um checksum MD5 de 128 bits para a string. O valor é retornado como um número hexadecimal de 32 digitos que pode, por exemplo, ser usado como uma chave hash:

mysql> SELECT MD5("testing");
        -> 'ae2b1fca515949e5d54fb22b8ed95575'

Este é o "RSA Data Security, Inc. MD5 Message-Digest Algorithm".

SHA1(string), SHA(string)

Calcula um checksum SHA1 de 160 bit para a string, como descrito no RFC 3174 (Algoritmo Hash de Segurança). O valor é retornado como um número hexadecial de 40 digitos, or NULL no caso do argumento ser NULL . Uma das possibilidades para o uso desta função é a chave hash. Você também pode usá-lo como uma função segura de criptografia para armazenar senhas.

mysql> SELECT SHA1("abc");
        -> 'a9993e364706816aba3e25717850c26c9cd0d89d'

SHA1() foi adicionado na versão 4.0.2, e pode ser considerada um equivalente ao MD5() com criptografia mais segura. SHA() é um sinônimo para SHA1().

AES_ENCRYPT(string,string_chave), AES_DECRYPT(string,string_chave)

Estas funções permitem criptografia/descriptografia de dados usando o algoritmo oficial AES (Padrão Avançado de Criptografia), antes conhecido como Rijndael. Criptgrafia com uma chave de 128 bits podem ser usadas, mas você pode extendê-la para 256 bits através da fonte. Nós escolhemos 128 bits porque é muito mais rápido e é bastante seguro.

Os argumentos de entrada podem ser de qualquer tamanho. Se ambos argumentos são NULL, o resultado desta função tam bém será NULL.

Como o AES é um algorítimo de nível de bloco, padding é usado para codificar strings de tamanho ímpares e então a string resultante pode ser calculada como 16*(trunc(tamanho_string/16)+1).

Se AES_DECRYPT() detectar dados inválidos ou padding incorreto, ela retorna NULL. No entanto, é possível para o AES_DECRYPT() retornar um valor não-NULL (possivelmente lixo) se os dados de entrada ou a chave eram inválidos

Você pode usar as funções AES para armazenar dados de forma criptografada modificando as suas consultas:

INSERT INTO t VALUES (1,AES_ENCRYPT('text','password'));

Você pode obter mais segurança não transferindo a chave em suas conexões a cada consulta, o que pode ser conseguido armazenando-o em varáveis do lado do servidor na hora das conexão.

SELECT @password:='my password';
INSERT INTO t VALUES (1,AES_ENCRYPT('text',@password));

AES_ENCRYPT() e AES_DECRYPT() foram adicionados na versão 4.0.2, e podem ser considerados a função de criptografia mais segura atualmente disponível no MySQL.

DES_ENCRYPT(string_para_ciptografar [, (numero_chave | chave_string) ] )

Criptografa a string com a chave dada utilizando o algortimo Triplo-DES.

Note que esta função só funciona se o MySQL tiver sido configurado com suporte a SSL. See Secção 4.4.10, “Usando Conexões Seguras”.

A chave de criptografia utilizada é escolhida da seguinte forma:

O string retornada será uma string binária onde o primeiro caracter será CHAR(128 | número_chave).

O 128 é adicionado para facilitar o reconhecimento da chave de criptografia. Se você usar uma chave string, numéro_chave será 127.

Havendo erro, esta função retorna NULL.

O tamanho da string para o resultado será novo_tamanho= tamanho_orig + (8-(tamanho_orig % 8))+1.

O des-key-file terá o seguinte formato:

numero_chave chave_string_des
numero_chave chave_string_des

Cada numero_chave deve ser um núero na faixa de 0 a 9. As linhas do arquivo podem estar em qualquer ordem. chave_string_des é a string que será usada para criptografar a mensagem. Entre o número e a chave deve haver pelo menos um espaço. A primeira chave é a chave padrão que será utilizada se não for especificada nenhuma chave como argumento para DES_ENCRYPT()

Você pode dizer ao MySQL para ler novos valores de arquivos de chave com o comando FLUSH DES_KEY_FILE. Isto exige o privilégio Reload_priv.

Um benefício de ter um conjunto de chaves padrões é que ele dá a aplicação um modo de verificar a existência de valores criptografados em colunas, sem dar ao usuário final o direito de descriptografar estes valores.

mysql> SELECT endereco_clientes FROM tabela_clientes WHERE
       cartao_credito_criptografado = DES_ENCRYPT("numero_cartao_credito");

DES_DECRYPT(string_para_descriptografar [, chave_string])

Derscritogra uma string criptografada com DES_ENCRYPT().

Note que esta função só funciona se o MySQL tiver sido configurado com suporte SSL. See Secção 4.4.10, “Usando Conexões Seguras”.

Se nenhum argumento chave_string for dado, DES_DECRYPT() examina o primeiro byte da string criptografada para determinar o número de chave DES que foi usado para criptografar a string original, e então lê a chave de des-key-file para descriptografar a mensagem. Para isto funcionar o usuário deve ter o privilégio SUPER.

Se você passar para esta função um argumento chave_string, aquela string é usada como a chave para descriptografar a mensagem.

Se a string_para_descriptografar não se paracer com uma string criptografada, o MySQL retornará a string_para_descriptografar dada.

Havendo erro, esta função retorna NULL.

COMPRESS(string_para_compactar)

Compacta uma string

mysql> SELECT LENGTH(COMPRESS(REPEAT("a",1000)));
  -> 21
1 row in set (0.00 sec)

mysql> SELECT LENGTH(COMPRESS(""));
  -> 0
1 row in set (0.00 sec)

mysql> SELECT LENGTH(COMPRESS("a"));
  -> 13
1 row in set (0.00 sec)

mysql> SELECT LENGTH(COMPRESS(REPEAT("a",16)));
  -> 15
1 row in set (0.00 sec)

COMPRESS() foi adicionado no MySQL 4.1.1. Se exigido, o MySQL tem que ser compilado com uma biblioteca de compactação como zlib. Senão , o valor de retorno é sempre NULL.

O conteúdo da string compactada é armazenada da seguinte forma:

UNCOMPRESS(string_para_descompactar)

Descompacta uma string compactado pela função COMPRESS()

mysql> select UNCOMPRESS(COMPRESS("any string"));
  -> 'any string'
1 row in set (0.00 sec)

UNCOMPRESS() foi adicionado no MySQL 4.1.1 Se exigido, o MySQL tem que ser compilado com uma biblioteca de compactação como zlib. Senão , o valor de retorno é sempre NULL.

UNCOMPRESSED_LENGTH(string_compactada)

Retorna o tamanho da string compactada antes da compactação

mysql> select UNCOMPRESSED_LENGTH(COMPRESS(REPEAT("a",30)));
  -> 30
1 row in set (0.00 sec)

UNCOMPRESSED_LENGTH() foi adicionado no MySQL 4.1.1

LAST_INSERT_ID([expr])

Retorna o último valor gerado automaticamente que tenha sido inserido em um coluna AUTO_INCREMENT.

mysql> SELECT LAST_INSERT_ID();
        -> 195

O último ID que foi gerado e mantido no servidor em uma base por conexão. Isto significa que o valor que a função retona para um dado cliente é o valor AUTO_INCREMENT gerado mais recentemente por aquele cliente. O valor não pode ser afetado pelos outros clientes, mesmo se eles gerarem um valor AUTO_INCREMENT deles mesmos. Este comportamento assegura que você pode recuperar seu próprio ID sem se preocupar com a atividade de outros clientes e sem precisar de locks ou transações.

O valor de LAST_INSERT_ID() não é alterado se você atualizar uma coluna AUTO_INCREMENT de uma linha com um valor não-mágico (Isto é, um valor que não seja NULL e nem 0).

Se você inserir muitos registros ao mesmo tempo com uma instrução insert, LAST_INSERT_ID() retorna o valor da primeira linha inserida. A razão para isto é tornar possível reproduzir facilmente a mesma intrução INSERT em algum outro servidor.

Se expr é dado com um argumento para LAST_INSERT_ID(), então o valor do argumento é retornado pela função e é configurado como o próximo valor para ser retornado pela LAST_INSERT_ID(). Isto pode ser útil para simular sequências:

Primeiro crie a tabela:

mysql> CREATE TABLE sequencia (id INT NOT NULL);
mysql> INSERT INTO sequencia VALUES (0);

Então a tabela pode ser usada para gerar sequência de números como estes:

mysql> UPDATE sequencia SET id=LAST_INSERT_ID(id+1);

Você pode gerar sequências sem chamar LAST_INSERT_ID(), mas a utilidade de se usar a função deste modo é que o valor ID é mantido no servidor como o último valor gerado automaticamente (seguro para multi-usurário). Você pode recuperar a nova ID como você leria qualquer valor AUTO_INCREMENT normal no MySQL. Por exemplo, LAST_INSERT_ID() (sem um argmento) retornará a nova ID. A função mysql_insert_id() da API C também pode ser usada para obter o valor.

Note que como mysql_insert_id() só é atualizado depois de instruções INSERT e UPDATE, você não pode utilizar a função da API C para recuperar o valor para LAST_INSERT_ID(expr) depois de executar outra instrução SQL como SELECT ou SET. See Secção 12.1.3.32, “mysql_insert_id()”.

FORMAT(X,D)

Formata o número X com um format como '#,###,###.##', arredondado para D casas decimais, e retorna o resultado como uma string. Se D é 0, o resultado não terá nehum ponto decimal ou parte fracionária:

mysql> SELECT FORMAT(12332.123456, 4);
        -> '12,332.1235'
mysql> SELECT FORMAT(12332.1,4);
        -> '12,332.1000'
mysql> SELECT FORMAT(12332.2,0);
        -> '12,332'

VERSION()

Retorna uma string indicando a versão do servidro MySQL:

mysql> SELECT VERSION();
        -> '3.23.13-log'

Note que se seu versão finalizar com -log, significa que o log está habilitado.

CONNECTION_ID()

Retorna a identificação (ID da thread) desta conexão. Cada conexão tem seu próprio ID único:

mysql> SELECT CONNECTION_ID();
        -> 23786

GET_LOCK(str,temo_limite)

Tenta conseguir uma trava com o nome dado pela string str, com um tempo limite de timeout segundos. Retorna 1 se o bloqueio foi obtido com sucesso, 0 se o tempo esgotou (por exemplo, porque outro cliente ja bloqueou o nome), ou NULL se uma erro ocorreu (tal como estouro de memória ou a threado tiver sido finalizada com mysqladmin kill). Uma trava é liberada quando você executa RELEASE_LOCK(), executa uma nova GET_LOCK(), ou a thread termina. (tanto de forma normal quanto anormal) Esta função pode ser usada para implementar bloqueio de aplicação ou para simular registros travados. Nomes são bloqueados em uma base ampla do servidor. Se um nome foi bloqueado por um cliente, GET_LOCK() trava qualquer pedido de bloqueio de outro cliente com o mesmo nome. Isto permite que clientes que concordam com um dado nome da trava possam usar a string para realizar travamento de consultas cooperativas:

mysql> SELECT GET_LOCK("lock1",10);
        -> 1
mysql> SELECT IS_FREE_LOCK("lock2");
        -> 1
mysql> SELECT GET_LOCK("lock2",10);
        -> 1
mysql> SELECT RELEASE_LOCK("lock2");
        -> 1
mysql> SELECT RELEASE_LOCK("lock1");
        -> NULL

Note que a segunda chamada de RELEASE_LOCK() retorna NULL porque a trava "lock1" foi liberada automaticamente pela segunda chamada GET_LOCK().

RELEASE_LOCK(str)

Libera a trava nomeada pela string str que foi obtida com GET_LOCK(). Retorna 1 se a trava foi liberada, 0 se a trava não foi bloquada pela thread (caso onde a trava não é liberada), e NULL se o nome da trava não existe. (A trava nunca exitirá se ela nunca for obtida pela chamada de GET_LOCK() ou se ela ja tiver sido liberada).

A instrução DO é conveniente para ser utilizada com RELEASE_LOCK(). See Secção 6.4.10, “Sintaxe DO”.

IS_FREE_LOCK(str)

Verifica se a trava chamada str está livre para ser utilizada (ex. não está bloqueada). Retorna 1 se a trava está liver (ninguém a esta usando), 0 se a trava está em uso, e NULL caso ocorra erro (como argumentos incorretos).

BENCHMARK(cont,expr)

A função BENCHMARK() executa a expressão expr repetidamente cont vezes. Ela pode ser usada para medir a velocidade em que o MySQL processa a expressão. O valor resultante é sempre 0. A intenção é usá-la no clientei mysql, relatando o tempo de execução da consulta:

mysql> SELECT BENCHMARK(1000000,ENCODE("hello","goodbye"));
+----------------------------------------------+
| BENCHMARK(1000000,ENCODE("hello","goodbye")) |
+----------------------------------------------+
|                                            0 |
+----------------------------------------------+
1 row in set (4.74 sec)

O tempo relatado é o tempo decorrido no cliente, não o tempo de CPU no servidor. Pode ser aconselhável executar BENCHMARK() diversas vezes e interpretar o resultado cosiderado o peso da carga da maquina servidora.

INET_NTOA(expr)

Dado um endereço numérico de rede (4 ou 8 bytes), retorna a representacão no formato com pontos do endereço como uma string:

mysql> SELECT INET_NTOA(3520061480);
       ->  "209.207.224.40"

INET_ATON(expr)

Dada a represenação com pontos de um endereço de rede como uma string, retorna um inteiro que representa o valor numérico deste endereço. Endereços podem ter 4 ou 8 bytes de endereçamento:

mysql> SELECT INET_ATON("209.207.224.40");
       ->  3520061480

O número gerado é sempre na ordem de bytes da rede; por exemplo o número acima é calculado como 209*256^3 + 207*256^2 + 224*256 +40.

MASTER_POS_WAIT(nome_log, log_pos [, tempo_limite])

Envia blocos o slave alcançar (ex.: ter lido e aplicado todas as atualizações) a posição específica no log master. Se a informação master não está inicializada, ou se os argumentos estão incorretos, retorna NULL. Se o slave não está em execução, enviará blocos e irá esperar até que ele seja iniciado e vá para (ou passe por) a posição especificada. Se o slave já passou pela posição especificada, retorna imediatamente.

Se tempo_limite (novo na versão 4.0.10) é especificado, irá esperar até que tempo_limite segundos tenham se passado. tempo_limite deve ser maior que 0; zero ou um tempo_limite negativo significa sem tempo_limite. O valor de retorno é o número de eventos de log que ele tem que esperar para obter a posição especificada, NULL no caso de erro, ou -1 se o tempo_limite tiver sido excedido.

O comando é útil para controle de sincronização mo master/slave.

FOUND_ROWS()

Uma instrução SELECT pode incluir uma cláusula LIMIT para restringir o número de linhas que o servidor retorna para um cliente. Em alguns casos, é desejável saber quantas linhas a instrução teria retornado sem o LIMIT, mas sem executar a instrução novamente. Para obter esta contagem de linhas, inclua uma opção SQL_CALC_FOUND_ROWS na instrução SELECT, então chame FOUND_ROWS() loga depois:

mysql> SELECT SQL_CALC_FOUND_ROWS * FROM nome_tabela
       WHERE id > 100 LIMIT 10;
mysql> SELECT FOUND_ROWS();

O segundo SELECT irá retornar um número indicando quantas linhas o primeiro SELECT teria retornado se ele fosse escrito sem a cláusula LIMIT. (Se o instrução SELECT anterior não inclui a opção SQL_CALC_FOUND_ROWS, então FOUND_ROWS() pode retornar um resultado diferente quando LIMIT é usado daquele que não é usado).

Note que se você estiver usando SELECT SQL_CALC_FOUND_ROWS ..., o MySQL tem que calcular quantos registros existem em todo o conjunto de resultados. No entanto, isto é mais rápido que se você não utilizar LIMIT, já que o resultado precisa ser enviado ao cliente.

SQL_CALC_FOUND_ROWS e FOUND_ROWS() podem ser úteis em situações em que você queira restringir o número de registros que uma consulta retorna, mas também determinar o número de linhas em todo o resultado sem executar a consulta novamente. Um exemplo é um script web que apresenta um display paginado contendo links para as páginas que mostram outras seções de um resultado de busca. Usar FOUND_ROWS() lhe permite determinar quantos outras páginas são necessárias para o resto do resultado.

O uso de SQL_CALC_FOUND_ROWS e FOUND_ROWS() é mais complexa para consultas UNION que para instruções SELECT simples, porque LIMIT pode ocorrer em vários lugares em um UNION. Ele pode ser aplicado a instruções SELECT individuais no UNION, ou globais ao resultado UNION como um todo.

A intenção de SQL_CALC_FOUND_ROWS para UNION é que ele deve retornar a contagem das linhas que seriam retornadas sem um LIMIT global. As consições para uso de SQL_CALC_FOUND_ROWS com UNION são:

SQL_CALC_FOUND_ROWS e FOUND_ROWS() estão disponíveis a partir da versão 4.0.0 do MySQL.