Funções mais Usadas no SQL
Tags: beginners, sql, mysql, braziliandevs
Published: 2022-03-03 21:08:31

## Tabela de Conteúdos

- [Manipulação de Strings](#manipulação-de-strings)
- [`IF` e `CASE`](#if-e-case)
- [Funções Matemáticas](#funções-matemáticas)
- [Funções de Agregação](#funções-de-agregação)
- [`GROUP BY` e `HAVING`](#group-by-e-having)
- [Links Úteis]()

---

## Manipulação de Strings

### O que é?

São funções nativas do MySQL responsáveis pela manipulação de strings.

### O que faz?

Como dito em sua definição, essas funções nos permitem manipular strings, permitindo a normalização e formatação dos dados.

### Sintaxe

Cada função lida com a _string_ de uma forma, porém a base é sempre a mesma, primeiro temos o `SELECT` e logo em seguida a função desejada, sendo que a _string_ a ser manipulada deve ser passada como argumento.

``` sql
SELECT <função>(<string>);
```

#### Upper Case `UCASE`

Para colocarmos toda a string em caixa alta utilizamos a função __`UCASE`__.

``` sql
SELECT UCASE(<string>);
```

#### Lower Case `LCASE`

Para colocarmos toda a string em caixa baixa utilizamos a função __`LCASE`__.
``` sql
SELECT LCASE(<string>);
```

#### Replace `REPLACE`

Podemos substituir determinada string utilizando a função __`REPLACE`__.

``` sql
SELECT REPLACE(<string>, <parte a ser substituída>, <string substituta>);
```

#### Left `LEFT`

Podemos selecionar um caractere específico utilizando o comando __`LEFT`__. Nesse caso será contado os caracteres da esquerda para a direita.

``` sql
SELECT LEFT(<string>, <número do caractere>);
```

#### Right `RIGHT`

Podemos selecionar um caractere específico utilizando o comando __`RIGHT`__. Nesse caso será contado os caracteres da direita para a esquerda.

``` sql
SELECT RIGHT(<string>, <número do caractere>);
```

#### Length `CHAR_LENGTH`

Conseguimos descobrir o tamanho de uma string através da função __`CHAR_LENGTH`__.

``` sql
SELECT CHAR_LENGTH(<string>);
```

#### Substring `SUBSTRING`

É possível extrair uma substring a partir do comando __`SUBSTRING`__, esse que é extremamente similar ao método __`.slice()`__.

_*O índice de término é opcional_

``` sql
SELECT SUBSTRING(<string>, <índice de início>, <quantidade a ser extraída>);
```

<br />

<small>[Voltar ao topo](#tabela-de-conteúdos)</small>

___

## If e Case

### O que são?

São comandos de controle de fluxo, ou em outras palavras, são __comandos condicionais__, onde determinada ação será tomada a depender se a condição estabelecida foi atendida ou não.

### Sintaxe

#### `IF`

O comando __`IF`__ funciona no MySQL de forma similar a condicional __`if`__ de outras linguagens, como JS e Python. A maior diferença é que no MySQL definimos as ações a serem tomadas dentro dos parênteses.

Dessa forma o primeiro parâmetro a ser passado no __`IF`__ é a condição, o segundo parâmetro é a ação a ser tomada caso a condição seja verdadeira e o terceiro parâmetro é a ação caso a condição seja falsa.

``` sql
SELECT IF(<condição>, <ação se verdadeiro>, <ação se falso>)
FROM <DB>.<tabela>;
```
``` sql
SELECT IF(idade >= 18, 'Maior de idade', 'Menor de idade')
FROM mydb.pessoas;
```

#### `CASE`

O comando __`CASE`__ funciona de forma similar a estrutura __`switch/case`__ de outras linguagens, sendo possível atribuir a ação caso a caso, assim como definir uma ação default.

Para criarmos condições usando o comando __`CASE`__, utilizamos o comando __`WHEN/THEN`__ e para definirmos nossa ação default, utilizamos o comando __`ELSE`__.

Sendo possível ainda renomear a coluna que irá demonstrar esses resultados, para isso utilizamos o comando __`END AS`__, seguido do nome que desejamos dar à coluna.

``` sql
SELECT <coluna>,
  CASE
    WHEN <condição> THEN <ação>
    ELSE <ação default>
  END AS <nome da coluna>
FROM <DB>.<tabela>;
```
``` sql
SELECT idade,
  CASE
    WHEN idade < 18 THEN 'Menor de idade',
    WHEN idade >= 18 AND idade <= 60 THEN 'Maior de idade',
    ELSE 'Senior'
  END AS 'idade_pessoas'
FROM mydb.pessoas;
```

<br />

<small>[Voltar ao topo](#tabela-de-conteúdos)</small>

___

## Funções Matemáticas

### O que são?

São funções nativas do MySQL que permitem a execução de cálculos matemáticos simples como: soma, subtração, divisão, multiplicação, exponenciação e raiz quadrada.

### Sintaxe
Podemos realizar operações matemáticas atribuindo diretamente um valor ou designando colunas que possuam valores do tipo numérico.

#### Operações simples

Todas as operações listadas abaixo seguem a mesma sintaxe: número, operação e número.

- __Soma__: `+`
- __Subtração__: `-`
- __Multiplicação__: `*`
- __Divisão__: `/`
- __Divisão inteira__: `DIV`
- __Módulo__: `MOD`

``` sql
SELECT <número> <operação> <número>;
```
``` sql
SELECT 4 + 5;
```


#### Operações de funções*

Já as operações que serão listadas a seguir funcionam como funções, ou seja, precisamos passar os valores como parâmetros.

- __Exponenciação__: `POW();`
- __Raiz quadrada__: `SQRT();`

``` sql
SELECT <operação>(<número>, <número>);
```
``` sql
SELECT POW(2, 3);  -- 2³ = 8
```

#### Operações de arredondamento

Ainda podemos arredondar valores utilizando as funções listadas a seguir. Lembrando que por serem funções, precisamos passar os valores a serem arredondados como parâmetro.

- __Arredondamento variável__: `ROUND();`
- __Arredondamento para cima__: `CEIL();`
- __Arredondamento para baixo__: `FLOOR();`

``` sql
SELECT <operação>(<número>, <limite de casas decimais>);
```
``` sql
SELECT ROUND(423.786, 2);  -- 423.79
```

<br />

<small>[Voltar ao topo](#tabela-de-conteúdos)</small>

___

## Funções de Agregação

### O que são?
São funções que realizam certos cálculos que são feitos frequentemente como média, menor valor, maior valor, somatória e quantidade de linhas.

### Quais são?

- __Média__: `AVG();`
- __Menor valor__: `MIN();`
- __Maior valor__: `MAX();`
- __Somatória__: `SUM();`
- __Quantidade__: `COUNT();`

### Sintaxe
Todas as funções de agregação funcionam de maneira similar, basta definirmos a função que desejamos e passar a coluna/valor que será usada para o cálculo como parâmetro.

``` sql
SELECT <função>(<coluna>) FROM <DB>.<tabela>;
```
``` sql
SELECT AVG(age) FROM mydb.people;
```

<br />

<small>[Voltar ao topo](#tabela-de-conteúdos)</small>

___

## Group By e Having

### O que são?
Ambos são comandos para agrupar valores, sendo que o __`GROUP BY`__ irá agrupar somente baseado na coluna passada, enquanto o __`HAVING`__ possibilita a criação de um filtro para o agrupamento.

### Sintaxe

#### Group By
O comando __`GROUP BY`__ deve ser colocado após a definição de qual tabela iremos receber os dados, seguido de qual coluna desejamos agrupar.

``` sql
SELECT * FROM <DB>.<tabela>
GROUP BY <coluna>;
```
``` sql
SELECT * FROM sakila.actor
GROUP BY first_name;
```

#### Having
O comando __`HAVING`__ é definido após o agrupamento realizado com o __`GROUP BY`__, sendo seguido de uma condicional que realizará o filtro.

``` sql
SELECT * FROM <DB>.<tabela>
GROUP BY <coluna>
HAVING <condição>;
```
``` sql
SELECT role, AVG(salary) AS 'average_salary' FROM myDB.employees
GROUP BY role
HAVING 'average_salary' > 3000;
```
No exemplo acima estamos filtrando todos os cargos que tem a média salaria maior que 3000 (três mil).

<br />

<small>[Voltar ao topo](#tabela-de-conteúdos)</small>

---

## Links Úteis

- [W3Schools - MySQL Functions](https://www.w3schools.com/mysql/mysql_ref_functions.asp)

<br />

<small>[Voltar ao topo](#tabela-de-conteúdos)</small>