OCA ORACLE DATABASE
SQL EXPERT EXAM
(Exam 1Z0-047)
SQL Oracle: Funções
andreviniciusnascimento@[Link]
2012
Conteúdo
Introdução a Funções
Tipos de Funções
Características
Funções
Caracteres
Numéricas
Datas
Conversão
Outras
Introdução
Funções representam um mecanismo
poderoso da linguagem SQL.
As funções podem ser utilizadas para:
Executar Cálculos
Modificar itens de dados individuais
Manipular a saída para um grupo de linhas
Formatar Datas e Números
Efetuar a conversão de Tipos de Dados
Tipos de Funções
Existem dois tipos de funções
Single-row
Multiple-row
Single-Row
Operam em uma única linha e retornam um
resultado por linha.
Mutliple-Row
Podem operar em um grupo de linhas para fornecer um
resultado por grupo. Conhecidas como funções de
agregação ou agrupamento.
Tipos de Funções
Esse módulo cobrirá, principalmente, as
seguintes funções (single-row):
Caracteres
Numéricas
Data
Conversão
De uso geral
Características
As funções (single-row) apresentam as
seguintes características:
Manipulam itens de dados
Aceitam argumentos e retornam um valor
Retornam um resultado por linha
Podem modificar o tipo de dado
Podem ser aninhadas
Aceitam argumentos que podem ser uma coluna
ou uma expressão
Cadeias de Caracteres
Funções que atuam em cadeias de caracteres
aceitam cadeias de caracteres como entrada
e podem retornar cadeias de caracteres ou
valores numéricos.
Essas funções podem ser dividades em:
Case-manipulation functions (Funções que
manipulam case).
Character-manipulation functions (Funções que
manipulam caracteres).
Cadeias de Caracteres
Case-manipulation functions (Funções que
manipulam case).
LOWER
Converte para minúsculas
UPPER
Converte para maiúsculas
INITCAP
Converte a primeira letra de cada palavra para
maiúscula, e o restante para minúscula.
Cadeias de Caracteres
SQL> SELECT MATRICULA, NOME, CARGO FROM TB_FUNCIONARIO;
MATRICULA NOME CARGO
---------- ------------------------ ----------
1 joao ricardo dos santos GERENTE
2 ROBERTO Silva JUNIOR ANALISTA
SQL> SELECT MATRICULA, UPPER(NOME) AS NOME,
LOWER(CARGO) AS CARGO FROM TB_FUNCIONARIO;
MATRICULA NOME CARGO
---------- ------------------------ ----------
1 JOAO RICARDO DOS SANTOS gerente
2 ROBERTO SILVA JUNIOR analista
Cadeias de Caracteres
SQL> SELECT MATRICULA, INITCAP(NOME) FROM
TB_FUNCIONARIO;
MATRICULA INITCAP(NOME)
---------- --------------------------------------------
1 Joao Ricardo Dos Santos
2 Roberto Silva Junior
Cadeias de Caracteres
CONCAT
CONCAT(char1, char2).
Retorna char1 concatenado com char2.
Essa função é equivalente ao operador de
concatenação ( || ).
SQL> SELECT CONCAT(CONCAT(NOME, ' é '), CARGO) AS
FUNCAO FROM TB_FUNCIONARIO;
FUNCAO
------------------------------------------------
JOAO RICARDO DOS SANTOS é GERENTE
ROBERTO SILVA JUNIOR é ANALISTA
Cadeias de Caracteres
SUBSTR
SUBSTR(char, position, [substring_length])
Retorna uma parte da cadeia de caracteres char,
começando pelo caractere na posição position e
com tamanho igual a substring_length.
SQL> SELECT SUBSTR(NOME, 1, 10) FROM
TB_FUNCIONARIO;
SUBSTR(NOME,1,10)
----------------------------------------
JOAO RICAR
ROBERTO SI
Cadeias de Caracteres
SQL> SELECT SUBSTR(NOME, 5) FROM TB_FUNCIONARIO;
SUBSTR(NOME,5)
------------------------------------------------
RICARDO DOS SANTOS
RTO SILVA JUNIOR
SQL> SELECT SUBSTR(NOME, -10, 3) FROM TB_FUNCIONARIO;
SUBSTR(NOME,
------------
DOS
LVA
Cadeias de Caracteres
LENGTH
LENGTH (CHAR)
Retorna o número de caracteres da cadeia de
caracteres passada como parâmetro.
SQL> SELECT LENGTH(NOME) FROM TB_FUNCIONARIO;
LENGTH(NOME)
------------
23
20
Cadeias de Caracteres
INSTR
INSTR(string, substring, [position [,occurrence]])
Retorna a posição inicial da substring dentro da
string.
Se position é especificado, indica a posição na
string que a busca pela substring deve começar.
Se occurrence é especificado, a busca só termina
após ser encontrada a ocorrência de número
occurrence.
Cadeias de Caracteres
NOME
------------------------
JOAO RICARDO DOS SANTOS
ROBERTO SILVA JUNIOR
SQL> SELECT INSTR(NOME, 'DOS') FROM
TB_FUNCIONARIO;
INSTR(NOME,'DOS')
-----------------
14
0
Cadeias de Caracteres
SQL> SELECT INSTR(NOME, 'DOS', 15) FROM
TB_FUNCIONARIO;
INSTR(NOME,'DOS',15)
--------------------
0
0
Cadeias de Caracteres
NOME
------------------------
JOAO RICARDO DOS SANTOS
ROBERTO SILVA JUNIOR
SQL> SELECT INSTR(NOME, 'A', 1, 2) FROM
TB_FUNCIONARIO;
INSTR(NOME,'A',1,2)
-------------------
9
0
Cadeias de Caracteres
LPAD
LPAD(expr1, n, [expr2])
Retorna a expr1, com tamanho n, preenchida à
esquerda com os caracteres da expr2.
Se expr2 não for especificada, o padrão é um
espaço em branco simples.
Cadeias de Caracteres
SQL> SELECT LPAD(MATRICULA, 10, '0') FROM
TB_FUNCIONARIO;
LPAD(MATRICULA,10,'0')
----------------------------------------
0000000001
0000000002
Cadeias de Caracteres
RPAD
RPAD(expr1, n, [expr2])
Retorna a expr1, com tamanho n, preenchida à
direita com os caracteres da expr2.
Se expr2 não for especificada, o padrão é um
espaço em branco simples.
Cadeias de Caracteres
SQL> SELECT CARGO, RPAD(' ', SALARIO/100/3, '*')
SALARIO FROM TB_FUNCIONARIO;
CARGO SALARIO
----------- --------------------
GERENTE *********
ANALISTA *****
PROGRAMADOR *
Cadeias de Caracteres
TRIM
Remove caracteres do inicio ou fim de uma cadeia
de caracteres.
SQL> SELECT TRIM(' RICARDO AMARAL') FROM DUAL;
TRIM('RICARDOA
--------------
RICARDO AMARAL
Cadeias de Caracteres
SQL> SELECT TRIM(' RICARDO AMARAL') FROM DUAL;
TRIM('RICARDOA
--------------
RICARDO AMARAL
SQL> SELECT TRIM(LEADING '*' FROM '***RICARDO
AMARAL***') FROM DUAL;
TRIM(LEADING'*'FR
-----------------
RICARDO AMARAL***
Cadeias de Caracteres
SQL> SELECT TRIM(TRAILING '*' FROM '***RICARDO
AMARAL***') FROM DUAL;
TRIM(TRAILING'*'F
-----------------
***RICARDO AMARAL
SQL> SELECT TRIM(BOTH '*' FROM '***RICARDO
AMARAL***') FROM DUAL;
TRIM(BOTH'*'FR
--------------
RICARDO AMARAL
Cadeias de Caracteres
SQL> SELECT TRIM('*' FROM '***RICARDO AMARAL***')
FROM DUAL;
TRIM('*'FROM'*
--------------
RICARDO AMARAL
Cadeias de Caracteres
REPLACE
REPLACE(char, search_string, replace_string)
Retorna char com todas as ocorrências de
search_string substituidas por replace_string.
Se replace_string é omitida ou null, todas as
ocorrências de search_string são removidas.
Se search_string é null, REPLACE retorna char.
Cadeias de Caracteres
SQL> SELECT REPLACE ('ARACAJU/SERGIPE', '/', '-')
FROM DUAL;
REPLACE('ARACAJ
---------------
ARACAJU-SERGIPE
Funções Numéricas
ROUND
TRUNC
REMAINDER
MOD
ROUND
ROUND (column | expression, n)
Efetua o arredondamento da coluna, expressão ou
valor para n casas decimais.
Se n é omitido, é arredondado sem casas
decimais.
Se n é negativo, números à esquerda do ponto
decimal são arredondados.
ROUND
SQL> SELECT ROUND(123.678, 2) FROM DUAL;
ROUND(123.678,2)
----------------
123,68
SQL> SELECT ROUND(123.674, 2) FROM DUAL;
ROUND(123.674,2)
----------------
123,67
ROUND
SQL> SELECT ROUND(123.675,2) FROM DUAL;
ROUND(123.675,2)
----------------
123,68
SQL> SELECT ROUND(123.675) FROM DUAL;
ROUND(123.675)
--------------
124
ROUND
SQL> SELECT ROUND(123.678, -2) FROM DUAL;
ROUND(123.678,-2)
-----------------
100
SQL> SELECT ROUND(123.678, -1) FROM DUAL;
ROUND(123.678,-1)
-----------------
120
SQL> SELECT ROUND(125.678, -1) FROM DUAL;
ROUND(125.678,-1)
-----------------
130
TRUNC
TRUNC (column | expression, n)
Efetua o truncamento da coluna, expressão ou
valor para n casas decimais.
Se n é omitido, o padrão é zero.
TRUNC
SQL> SELECT TRUNC(123.988,2) FROM DUAL;
TRUNC(123.988,2)
----------------
123,98
SQL> SELECT TRUNC(123.8999) FROM DUAL;
TRUNC(123.8999)
---------------
123
TRUNC
SQL> SELECT TRUNC(123.999, -2) FROM DUAL;
TRUNC(123.999,-2)
-----------------
100
SQL> SELECT TRUNC(125.678, -1) FROM DUAL;
TRUNC(125.678,-1)
-----------------
120
REMAINDER
REMAINDER (n2, n1)
Identifica o múltiplo de n2 que é mais próximo a
n1, e retorna a diferença entre os dois valores.
Existe uma diferença no algoritmo em relação à
função MOD. REMAINDER utiliza a função ROUND
e MOD utiliza a função FLOOR.
REMAINDER
SQL> SELECT REMAINDER(9,3) FROM DUAL;
REMAINDER(9,3)
--------------
0
SQL> SELECT REMAINDER(10,3) FROM DUAL;
REMAINDER(10,3)
---------------
1
SQL> SELECT REMAINDER(11,3) FROM DUAL;
REMAINDER(11,3)
---------------
-1
MOD
MOD(n1, n2)
Identifica o múltiplo de n2 que é mais próximo a
n1, e retorna a diferença entre os dois valores.
Existe uma diferença no algoritmo em relação à
função REMAINDER. REMAINDER utiliza a função
ROUND e MOD utiliza a função FLOOR.
MOD
SQL> SELECT MOD(9,3) FROM DUAL;
MOD(9,3)
----------
0
SQL> SELECT MOD(10,3) FROM DUAL;
MOD(10,3)
----------
1
SQL> SELECT MOD(11,3) FROM DUAL;
MOD(11,3)
----------
2
Funções de Data
SYSDATE
ROUND (date)
TRUNC (date)
NEXT_DAY
LAST_DAY
ADD_MONTHS
MONTHS_BETWEEN
SYSDATE
Retorna a data e hora atual do sistema em
que o servidor de banco de dados reside.
Retorna um valor do tipo DATE
O Formato do Retorno depende do parâmetro
NLS_DATE_FORMAT
SYSDATE
SQL> ALTER SESSION SET NLS_DATE_FORMAT =
'DD/MM/YYYY';
Sessão alterada.
SQL> SELECT SYSDATE FROM DUAL;
SYSDATE
----------
13/01/2012
SYSDATE
SQL> ALTER SESSION SET NLS_DATE_FORMAT =
'DD/MM/YYYY HH24:MI:SS';
Sessão alterada.
SQL> SELECT SYSDATE FROM DUAL;
SYSDATE
-------------------
13/01/2012 17:18:54
ROUND(date)
ROUND (date, fmt)
Retorna um valor do tipo Date que representa um
arredondamento da data passada como
parâmetro.
O Arredondamento é realizado em função do
formato passado como parâmetro.
A ausência do formato, efetua o arredondamento
para o dia mais próximo.
ROUND (date)
SQL> SELECT ROUND(TO_DATE('15-01-2012','DD-MM-
YYYY'),'MM') FROM DUAL;
ROUND(TO_DATE('15-0
-------------------
01/01/2012 00:00:00
SQL> SELECT ROUND(TO_DATE('16-01-2012','DD-MM-
YYYY'),'MM') FROM DUAL;
ROUND(TO_DATE('16-0
-------------------
01/02/2012 00:00:00
ROUND (date)
SQL> SELECT ROUND(TO_DATE('01-07-2012','DD-MM-
YYYY'),'YEAR') FROM DUAL;
ROUND(TO_DATE('01-0
-------------------
01/01/2013 00:00:00
SQL> SELECT ROUND(TO_DATE('30-06-2012','DD-MM-
YYYY'),'YEAR') FROM DUAL;
ROUND(TO_DATE('30-0
-------------------
01/01/2012 00:00:00
ROUND (date)
SELECT ROUND(TO_DATE('15-01-2012 12:00:00','DD-
MM-YYYY HH24:MI:SS'),'DD') FROM DUAL;
ROUND(TO_DATE('15-0
-------------------
16/01/2012 00:00:00
SELECT ROUND(TO_DATE('15-01-2012 11:59:59','DD-
MM-YYYY HH24:MI:SS'),'DD') FROM DUAL;
ROUND(TO_DATE('15-0
-------------------
15/01/2012 00:00:00
TRUNC (date)
TRUNC (date, fmt)
Retorna um valor do tipo Date que representa um
truncamento da data passada como parâmetro.
O truncamento é realizado em função do formato
passado como parâmetro.
Quando o formato não é especificado, o padrão é
DD (dia).
TRUNC (date)
SELECT TRUNC(TO_DATE('15-01-2012 12:00:00','DD-
MM-YYYY HH24:MI:SS'),'DD')FROM DUAL;
TRUNC(TO_DATE('15-0
-------------------
15/01/2012 00:00:00
SELECT TRUNC(TO_DATE('15-01-2012 11:59:59','DD-
MM-YYYY HH24:MI:SS'),'DD')FROM DUAL;
TRUNC(TO_DATE('15-0
-------------------
15/01/2012 00:00:00
TRUNC (date)
SELECT TRUNC(TO_DATE('01-07-2012','DD-MM-
YYYY'),'YEAR') FROM DUAL;
TRUNC(TO_DATE('01-0
-------------------
01/01/2012 00:00:00
SELECT TRUNC(TO_DATE('15-01-2012 12:30:00','DD-
MM-YYYY HH24:MI:SS'),'HH') FROM DUAL;
TRUNC(TO_DATE('15-0
-------------------
15/01/2012 12:00:00
NEXT_DAY
NEXT_DAY (date, char)
Retorna a data do próximo dia da semana
especificado por char, depois da data passada
como parâmetro.
SQL> SELECT NEXT_DAY(SYSDATE, 'SEGUNDA') FROM
DUAL;
NEXT_DAY(SYSDATE,'S
-------------------
16/01/2012 21:23:37
LAST_DAY
LAST_DAY (date)
Retorna a data do último dia do mês que contém
a data passada como parâmetro.
SQL> SELECT LAST_DAY(SYSDATE) FROM DUAL;
LAST_DAY(SYSDATE)
-------------------
30/09/2012 21:28:44
ADD_MONTHS
ADD_MONTHS (date, integer)
Retorna a data passada com parâmetro mais o
número de meses especificado pelo parâmetro
integer.
SQL> SELECT ADD_MONTHS(SYSDATE,1) FROM DUAL;
ADD_MONTHS(SYSDATE,
-------------------
10/02/2012 21:36:53
ADD_MONTHS
SQL> SELECT ADD_MONTHS(TO_DATE('31/01/2012',
'DD/MM/YYYY'),1) FROM DUAL;
ADD_MONTHS(TO_DATE(
-------------------
29/02/2012 00:00:00
MONTHS_BETWEEN
MONTHS_BETWEEN (date1, date2)
Retorna o número de meses entre as datas date1
e date2.
Se date1 é posterior a date2, o valor é positivo.
Se date2 é posterior a date1, o valor é negativo.
MONTHS_BETWEEN
SELECT MONTHS_BETWEEN
(TO_DATE('02-02-1995','MM-DD-YYYY'),
TO_DATE('01-01-1995','MM-DD-YYYY') ) "Meses“
FROM DUAL;
Months
----------
1.03225806
Funções de Conversão
As funções de conversão convertem o tipo de
dado de uma expressão para outro tipo de
dado. Em alguns casos, o formato da
expressão também é modificado.
As funções de conversão não são necessárias
em todas as situações. Algumas conversões
são implícitas. No entanto, é uma boa prática
efetuar conversões explícitas.
Funções de Conversão
Existem inúmeras funções de conversão.
As mais utilizadas são:
TO_CHAR
TO_NUMBER
TO_DATE
TO_CHAR
TO_CHAR
A função TO_CHAR converte vários tipos de dados
para Cadeia de Caracteres.
Existe três sobrecargas da função TO_CHAR:
TO_CHAR (char)
TO_CHAR (number, format_model, nls_params)
TO_CHAR (date, format_model, nls_params)
TO_CHAR (char)
TO_CHAR (char)
Trasforma o parâmetro em VARCHAR2.
O parâmetro pode ser do tipo NCHAR,
NVARCHAR2, CLOB ou NLOB.
SELECT TO_CHAR(‘Joao Ricardo') FROM DUAL;
TO_CHAR(‘Joao Ricardo')
----------------
Joao Ricardo
TO_CHAR (number)
TO_CHAR (number, format_model,
nls_params)
Transforma um valor numérico em uma cadeia de
caracteres.
Pode ser informado um formato a ser seguido.
Pode ser informado um conjunto de configurações
para valores numéricos: caracter de decimal,
caracter de grupo, simbolo monetário, etc.
TO_CHAR (number)
SQL> SELECT TO_CHAR(SALARIO, 'L99G999D00') FROM
TB_FUNCIONARIO;
TO_CHAR(SALARIO,'L99
--------------------
R$3.000,00
R$2.000,00
R$800,00
R$2.800,56
R$2.800,56
TO_CHAR (number)
SQL> SELECT TO_CHAR(12848800.00,'9.9EEEE') FROM
DUAL;
TO_CHAR(1
---------
1.3E+07
TO_CHAR (date)
TO_CHAR (date, format_model, nls_params)
Formata uma data em uma saída específica de
acordo com o formato passado como parâmetro.
TO_CHAR (date)
SQL> SELECT TO_CHAR(SYSDATE, 'DD-MM-YYYY') FROM
DUAL;
TO_CHAR(SY
----------
15-01-2012
SQL> SELECT TO_CHAR(SYSDATE, 'DD-MM-YY') FROM
DUAL;
TO_CHAR(
--------
15-01-12
TO_CHAR (date)
SQL> SELECT TO_CHAR(SYSDATE, 'DD/MM/YYYY') FROM
DUAL;
TO_CHAR(SY
----------
15/01/2012
SQL> SELECT TO_CHAR(SYSDATE, 'DD/MM/YYYY
HH:MI:SS') FROM DUAL;
TO_CHAR(SYSDATE,'DD
-------------------
15/01/2012 06:35:43
TO_CHAR (date)
SQL> SELECT TO_CHAR(SYSDATE, 'DD "de" MONTH "de"
YYYY HH24:MI:SS') FROM DUAL;
TO_CHAR(SYSDATE,'DD"DE"MONTH"DE"YYYYHH24:MI:SS')
-------------------------------------------------
15 de JANEIRO de 2012 18:42:51
SQL> SELECT TO_CHAR(SYSDATE, 'YYYYMMDD') FROM
DUAL;
TO_CHAR(
--------
20120115
TO_NUMBER
TO_NUMBER (expr [, fmt [,nls_params]])
Converte uma expressão em um valor numérico.
Pode utilizar o formato fmt para indicar o formato
a ser interpretado.
Pode utilizar parâmetros para ajudar na
interpretação da expressão.
TO_NUMBER
SQL> SELECT TO_NUMBER('R$2.000,67') FROM DUAL
*
ERRO na linha 1:
ORA-01722: número inválido
SQL> SELECT TO_NUMBER('R$2.000,67', 'L99G999D00')
FROM DUAL;
TO_NUMBER('R$2.000,67','L99G999D00')
------------------------------------
2000,67
TO_NUMBER
SQL> SELECT TO_NUMBER('7784.89') FROM DUAL;
SELECT TO_NUMBER('7784.89') FROM DUAL
*
ERRO na linha 1:
ORA-01722: n·mero invßlido
SQL> SELECT TO_NUMBER('7784.89', '9999.00') FROM
DUAL;
TO_NUMBER('7784.89','9999.00')
------------------------------
7784,89
TO_NUMBER
SQL> SELECT TO_NUMBER('7784.89',
'9999D00','nls_numeric_characters = ''.,'' ') F
ROM DUAL;
TO_NUMBER('7784.89','9999D00','NLS_NUMERIC_CHARAC
TERS=''.,''')
-------------------------------------------------
7784,89
TO_DATE
TO_DATE (char [,fmt [,nls_params]])
Converte uma cadeia de caracteres em uma data.
Pode ser utilizado um formato para indicar o
formato a ser interpretado
Pode utilizar parâmetros de interpretação
adicionais.
TO_DATE
SQL> SELECT TO_DATE('13/01/2012','DD/MM/YYYY') FROM
DUAL;
TO_DATE('13/01/2012
-------------------
13/01/2012 00:00:00
SQL> SELECT TO_DATE('13/01/12','DD/MM/YY') FROM DUAL;
TO_DATE('13/01/12',
-------------------
13/01/2012 00:00:00
TO_DATE
SQL> SELECT TO_DATE('20120123','YYYYMMDD') FROM
DUAL;
TO_DATE('20120123',
-------------------
23/01/2012 00:00:00
SQL> SELECT TO_DATE('12-01-2012 23:50:00','DD-MM-
YYYY HH24:MI:SS') FROM DUAL;
TO_DATE('12-01-2012
-------------------
12/01/2012 23:50:00
Funções de uso geral
NVL
NVL2
NULLIF
COALESCE
DECODE
CASE
NVL
NVL (expr1, expr2)
Se expr1 é nulo, então NVL retorna expr2.
Se expr1 não é nulo, então NVL retorna expr1.
NVL
SQL> SELECT MATRICULA, SALARIO FROM
TB_FUNCIONARIO;
MATRICULA SALARIO
---------- ----------
1 3000
2 2000
3 800
4
NVL
SQL> SELECT MATRICULA, NVL(SALARIO,0) FROM
TB_FUNCIONARIO;
MATRICULA NVL(SALARIO,0)
---------- --------------
1 3000
2 2000
3 800
4 0
NVL
SQL> SELECT MATRICULA,
LPAD(RTRIM(NVL(TO_CHAR(SALARIO, '9999D00'),
'0,00')),10,
' ') SALARIO FROM TB_FUNCIONARIO;
MATRICULA SALARIO
---------- --------------------------------------
1 3000,00
2 2000,00
3 800,00
4 0,00
NVL2
NVL2 (expr1, expr2, expr3)
Se expr1 não é nulo, retorna expr2.
Se expr1 é nulo, retorna expr3.
NVL2
SQL> SELECT MATRICULA, SALARIO, COMISSAO FROM
TB_FUNCIONARIO
2 WHERE SALARIO IS NOT NULL;
MATRICULA SALARIO COMISSAO
---------- ---------- ----------
1 3000 ,2
2 2000 ,1
3 800
NVL2
SQL> SELECT MATRICULA, NVL2(COMISSAO,
SALARIO*(1+COMISSAO), SALARIO) AS SALARIO_
TOTAL FROM TB_FUNCIONARIO WHERE SALARIO IS NOT
NULL;
MATRICULA SALARIO_TOTAL
---------- -------------
1 3600
2 2200
3 800
NULLIF
NULLIF (expr1, expr2)
Compara expr1 com expr2.
Se expr1 for igual a expr2, retorna nulo.
Se expr1 for diferente de expr2, retorna expr1.
É equivalente a:
CASE WHEN expr1 = expr2 THEN NULL ELSE expr1
END
COALESCE
COALESCE (expr1, expr2...)
Retorna a primeira expressão não nula da lista de
expressões passada como parâmetro.
DECODE
DECODE
Avalia uma expressão de maneira similar à
avaliação feita por um IF.. THEN.. ELSE.
DECODE
SQL> SELECT MATRICULA, CARGO, SALARIO
2 FROM TB_FUNCIONARIO;
MATRICULA CARGO SALARIO
---------- ----------- ----------
1 GERENTE 3000
2 ANALISTA 2000
3 PROGRAMADOR 800
4 PROGRAMADOR
DECODE
SQL> SELECT MATRICULA,
DECODE(CARGO, 'GERENTE', SALARIO*1.2,
'ANALISTA', SALARIO*1.1,
SALARIO) AS SALARIO
FROM TB_FUNCIONARIO;
MATRICULA SALARIO
---------- ----------
1 3600
2 2200
3 800
4
CASE
CASE
Avalia uma expressão de maneira similar à
avaliação feita por um IF.. THEN.. ELSE.
CASE expr WHEN comparison_expr1 THEN return_expr1
[WHEN comparison_expr2 THEN return_expr2
WHEN comparison_exprn THEN return_exprn
ELSE else_expr]
END
CASE
CASE WHEN media < 5.0 THEN ‘Ruim'
WHEN media < 6.0 THEN ‘Regular'
WHEN media < 8.0 THEN ‘Boa'
ELSE 'Excelente'
END