Saiba que este documento não poderá ser reproduzido, seja por meio eletrônico ou

mecânico, sem a permissão expressa por escrito da Domínio Sistemas Ltda. Nesse caso,
somente a Domínio Sistemas poderá ter patentes ou pedidos de patentes, marcas
comerciais, direitos autorais ou outros de propriedade intelectual, relacionados aos
assuntos tratados nesse documento. Além disso, o fornecimento desse documento não
lhe concede licença sobre tais patentes, marcas comerciais, direitos autorais ou outros de
propriedade intelectual; exceto nos termos expressamente estipulados em contrato de
licença da Domínio Sistemas. É importante lembrar que as empresas, os nomes de
pessoas e os dados aqui mencionados são fictícios; salvo indicação contrária.
© 1998 2014 Domínio Sistemas Ltda. Todos os direitos reservados.
Sugestões
A Domínio Sistemas busca aumentar a qualidade dos seus produtos
continuamente. Um exemplo disso é esse material, que tem como objetivo aumentar a
produtividade e o desempenho dos usuários de nossos sistemas.
O processo de elaboração desse material passou por freqüentes correções e
testes de qualidade, mas isso não exime o material de erros e possíveis melhorias. Para
que haja melhoras, nós contamos com o seu apoio. Caso você tenha alguma sugestão,
reclamação ou até mesmo encontre algum tipo de erro nesse material, solicitamos que
você entre em contato conosco. Dessa forma, poderemos analisar suas sugestões e
reclamações para corrigir eventuais erros.
Para entrar em contato com o nosso Centro de Treinamento, escreva para
treinamento@dominiosistemas.com.br. Relate, pois, a sua sugestão, reclamação ou o
erro encontrado e sua localização para que possamos fazer as devidas correções. Você
também dispõe do seguinte formulário para enviar-nos suas notações. Basta destacar
essa folha, relatar sua sugestão e/ou reclamação e remeter ao seguinte endereço:
Centro de Treinamento Domínio
Avenida Centenário, 7405
Nossa Senhora da Salete
Criciúma – SC – CEP: 88815-001
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
 Índice
Visão Geral do Curso................................................................................................................07
Descrição..............................................................................................................................07
Objetivos..............................................................................................................................07
1. Introdução..............................................................................................................................06
2. Argumento Seleção................................................................................................................06
3. LEFT OUTER JOIN..............................................................................................................12
4. Sub-consulta……….. ............................................................................................................18
5. IN e NOT IN..........................................................................................................................20
6. EXISTS e NOT EXISTS.......................................................................................................21
7. COUNT..................................................................................................................................23
8. Duas ou mais quebras.............................................................................................................25
9. Funções...................................................................................................................................36
9.1. CumulativeSum()..........................................................................................................37
9.2. Extenso().......................................................................................................................38
9.3. Extenso_Numero() .......................................................................................................39
9.4. Year(), Month() e Day()................................................................................................41
9.5. TrazNomeMes()............................................................................................................45
9.6. Left() e Right()..............................................................................................................46
9.7. Len() e Length()............................................................................................................49
9.8. Trim ()...........................................................................................................................51
9.9. Lower(), Upper() e WordCap .......................................................................................54
9.10. GetRow ()....................................................................................................................57
9.11. Today ().......................................................................................................................58
9.12. List ()...........................................................................................................................59
9.13. Min() e Max ().............................................................................................................62
9.14. IsNull() e Coalesce ()...................................................................................................63
9.15. IF..................................................................................................................................67
9.16. CASE...........................................................................................................................70
10. Destacar Linhas.....................................................................................................................73
Visão Geral do Curso

Descrição

A finalidade do curso Domínio Gerador de Relatórios II é apresentar

aos nossos usuários e técnicos, os seguintes tópicos:
• Criar Seleções, utilizando técnicas como:
o “LEFT OUTER JOIN”;
o “IN” e “NOT IN”;
o “EXISTS” e “NOT EXISTS”;
o “COUNT”.
• Criar Quebras;
• Criar Funções:
o “IF ELSE”;
o Destacar linhas;
o Justifica;
o Extenso;
o Len;
o Left;
o Nome do mês extenso

Objetivos

Ao término desse treinamento, o aluno estará apto a realizar a seguinte função:

• Realizar relatórios complexos com base nos bancos de dados dos aplicativos Domínio.
1 – Introdução

Iniciamos este treinamento lembrando que no treinamento anterior aprendemos

como abrir o Gerador de Relatórios, não só de uma forma. Criamos os relatórios
utilizando somente as guias da tela Definições da Fonte de dados com exceção da guia
SQL.
Neste treinamento faremos
faremos uso da guia SQL na maioria das alterações e criações
realizados na estrutura do relatório se tornando conseqüentemente mais complexa.
Separamos alguns itens que que iremos avaliar no treinamento: “seleção”,
subconsultas, COUNT, LEFT OUTER JOIN, IN e NOT IN, EXISTS e NOT EXISTS,
funções, entre outros.

2 – Argumento “Seleção”

Com o módulo Folha aberto criamos um novo relatório, com o nome “Relação de
Empresas”, classificação “Treinamento”, a qual, nós já temos criada.
 Após abrir a janela
la “Definição da Fonte de
de dados” selecionamos os campos
referente as Empresas:

No primeiro treinamento, vimos na aba argumento apenas o argumento de

Classificação “Argumento”, neste treinamento veremos como é utilizado e para que serve
o argumento de classificação “Seleção”.
“Seleção”
Selecionamos na aba argumentos a classificação “Seleção” , na coluna seguinte
devemos informar o nome da coluna referente ao código da empresa no banco de dados
(bethadba.geempre.codi_emp). Na coluna Texto será o texto apresentado
apresent para o
argumento antes da emissão do relatório. A coluna Obrig. serve para decidir se o
preenchimento do argumento é obrigatório ou não, neste caso colocamos “Não” para
quando deixarmos o argumento em branco(vazio) o relatório emita todas as empresas, as
demais colunas já foram explicadas em treinamento anterior. A tela abaixo demonstra
como deve ficar o argumento criado.
 Veremos como o relatório irá se comportar se deixarmos o argumento em branco:
branco

Outra característica do argumento

argumento “Seleção” é a possibilidade de selecionar as
empresas que deseja emitir no relatório. Para realizar seleção, os números referentes ao
código das empresas devem ser separadas por “,” ou “-“ “ “ quando houver intervalo. No
exemplo abaixo selecionamos as empresas 1,3-5,7-9, 9, ou seja, 1,3,4,5,7,8,9.

Lembrando que não é necessário adicionar nenhuma condição ou relacionamento

(WHERE) no SQL do relatório.
 Dando continuidade ao treinamento, iremos inserir mais um campo no relatório, o
campo Situação.

Utilizando esta coluna, poderemos filtrar as empresas pelas seguintes situações:

“A – Ativa”, “I – Inativa” e “C - Em constituição”. Conforme imagem abaixo, como o campo
é de apenas um caractere, após emissão o relatório será emitido com a apenas a letra
que representa a situação da empresa.

No caso acima, podemos ajustar o campo situação utilizando a tabela de valores e

aumentando o campo para que o mesmo receba a descrição completa da situação.
 Sendo emitido da seguinte forma:

Podemos
odemos também criar um argumento para que o usuário selecione a situação que
deseja emitir no relatório. Para isso devemos inserir um argumento,
argumento, para fazer a seleção
do campo “situação”, conforme abaixo:
 Em seguida, adicionamos a condição referente à Situação. Por enquanto, como o
relatório ainda está muito básico, iremos utilizar a guia Seleção para fazer os
relacionamentos e as condições, conforme imagem a seguir:

Para auxiliar o usuário na hora da emissão, pois nem todos os usuários tem
conhecimento
ecimento que “A” refere-se
refere se à situação Ativas ou “I” e “C” às suas respectivas
situações, podemos inserir no campo texto uma descrição que o auxilie, como mostra o
exemplo abaixo:

Porém, podemos verificar na imagem acima que o tamanho do texto é limitado,

limita não
sendo permitido incluir o texto auxiliar completamente para o usuário. Para isso, temos
um outro comando utilizado na coluna “Valor Inicial” na de Argumentos, conforme abaixo:

Utilizamos primeiramente o nome que será exibido ao usuário no momento

mome da
emissão, em seguida o comando “~t” seguindo do caractere que identifica a opção no
caso a letra “A”, ficando da seguinte forma: Ativa~tA e por último para separar as opções
utilizamos a “/”, conforme demonstra imagem acima. No momento em que o usuário usuár for
emitir o relatório clicando
licando na seta do argumento referente à situação o usuário poderá
escolher a opção desejada sem ter conhecimento à qual caractere a opção se refere.
 Assim terminamos de explicar o argumento de classificação “Seleção”,
“Seleção” suas
vantagens
antagens e também como montar um menu no argumento utilizando o comando “~t”.
“~t”

3 – LEFT OUTER JOIN

O comando LEFT OUTER JOIN significa “Junção Externa à Esquerda”, ou seja, ele
faz a junção da tabela à direita à tabela à esquerda, como exemplo criaremos
criarem um relatório
de dependentes.
- Criamos o relatório;
- Incluímos as colunas “Código da Empresa, Código do Empregado e Nome da
tabela de empregados (Empregados – (foempregados));
- Criamos um argumento para selecionar a empresa;
- Incluímos na aba Seleção
Seleção o relacionamento do código da empresa com o
argumento de empresa.

Ficando a estrutura e emissão do relatório conforme abaixo:

 Agora iremos acrescentar os dependentes:
- Acessamos as Definições de dados do relatório e incluímos as colunas “Código
do Dependente, Nome do Dependente e Data de Nascimento” da tabela de dependentes
(Empregados – Dependentes – (fofilhos)) .

Obs.: Na guia SQL, podemos verificar que os relacionamentos da tabela de

dependentes com a tabela de empregados foi criada
criada automaticamente. Para algumas
tabelas o Gerador de Relatórios cria os relacionamentos automaticamente, para outras
não. Por isso, o usuário deve sempre verificar a guia SQL para verificar se os
relacionamentos estão corretos, caso não estejam, o usuário usuár deve criar os
relacionamentos manualmente.

- Diminuímos os campos referentes aos nomes para ficar com um tamanho

adequado.
 Conforme imagem acima, podemos verificar que o relatório emite apenas os
empregados que possuem dependentes. Os empregados
empregados 1,4,5 entre outros não são
emitidos porque não possuem dependentes. Isso acontece porque os relacionamento da
tabela “empregados” com a tabela “filhos” foi feito “WHERE” principal, ou seja, para o
empregado ser emitido é automaticamente obrigatório ter pelo menos 1 dependente.
Neste caso, como o relatório deve mostrar todos os empregados
independentemente se contém dependente ou não, utilizamos a sintaxe LEFT OUTER
JOIN.
- Adicionamos a sintaxe LEFT OUTER JOIN após a tabela de empregados;
- Deslocamos
mos a tabela “bethadba.fofilhos” após a sintaxe;
- Na linha abaixo deslocamos os relacionamento da tabela “filhos” com a tabela
“empregados” para junto com a tabela “filhos” adicionada a sintaxe “ON” como se fosse o
“WHERE”;
Obs.: Após o “ON” são colocados
colocad os relacionamentos.
Feito as alterações o SQL do relatório deve ficar conforme abaixo:
 Conforme verificamos acima, a esquerda(LEFT) fica a tabela de empregados, ou
seja, à esquerda o relatório irá emitir todos os dados(empregados) e a direita a tabela
t de
filhos, emitindo todos os filhos de todos os empregados que possuem os mesmos.
Vejamos como ficou o relatório:

Como existe o LEFT OUTER JOIN existe também o RIGHT OUTER JOIN que é o
inverso do comando anterior, caso seja inserida no SQL do relatório a mesma irá emitir
todos os empregados da tabela à direita independentemente se há dados na tabela da
esquerda. Ficaria da seguinte forma:

“FROM bethadba.fofilhos RIGHT OUTER JOIN bethadba.foempregados”.

Os relacionamentos continuam iguais apenas

ape são
ão invertidas as tabelas e o relatório
irá emitido conforme imagem anterior. Feito isso finalizamos o relatório.
 Faremos um novo exemplo desta sintaxe para que a mesma seja bem
exemplificada. Portanto iremos criar um relatório que demonstre uma lista de empregados
que tenha uma coluna com a data de demissão, para que caso o empregado esteja
demitido, o mesmo seja demonstrado como demitido. Proceder conforme abaixo:

- Criar um novo relatório de nome: “Empregados

“ – Data demissão” e selecionar a
classificação
ficação criada para o treinamento;
- Adicionamos na Definição de dados as colunas “Código da Empresa, Código do
Empregado e Nome do empregado” da tabela de empregados;
- Adicionamos também a coluna “Data Demissão” da tabela “Rescisões Cálculo”.
- Adicionamos os o argumento empresa na guia “Argumentos” e posteriormente
adicionamos o relacionamento do argumento com a tabela de empregados.
Feito isso, o SQL deve ficar da seguinte forma:
 Após emitimos o relatório:

Analisando a imagem acima,

acima, podemos verificar que só foram emitidos os
empregados demitidos, ou seja, apenas os empregados que possuem dados no campo
“Data Demissão”. Para emitir todos os empregados independentes se estão demitidos ou
não, devemos utilizar o LEFT OUTER JOIN conforme
confor abaixo:
 Após alteração, emitimos o relatório demonstrando todos os empregados.

4 – SUB-CONSULTA

Continuando o treinamento, utilizaremos o mesmo relatório para explicar como

criar sub-consultas:
- Apagamos o LEFT OUTER JOIN deixando apenas a tabela de empregados no
FROM;
- Criamos a sub-consulta
consulta com o nome “data_emissao”, dentro desta sub-consulta
sub é
gerado um novo SELECT.
- No SELECT adicionamos o campo que queremos buscar da tabela de rescisões;
- No FROM a tabela de rescisões;
- No WHERE os relacionamentos de empresa e empregado com a tabela de
empregados.
Ficando da seguinte forma
 Conforme imagem acima o relatório permanece quase o mesmo. As sub-consultas
sub
são responsáveis por realizar busca por um campo
campo desejado, neste caso, a data de
demissão, ou seja, verifica em todos os empregados se os mesmos possuem data de
demissão. Caso existe a mesma é demonstrada para o empregado, caso não exista o
empregado será emitido no relatório normalmente, porém sem dade
dade de demissão. Segue
abaixo relatório emitido:
5 – IN E NOT IN

Iremos utilizar o mesmo relatório para explicar os comandos IN e NOT IN, para o
primeiro exemplo iremos emitir apenas os empregados 2, 3 e 15, por isso adicionamos no
relacionamento
mento do SQL principal o seguinte comando:
“AND bethadba.foempregados.i_empregados IN (2,3,15)”

Onde o comando “IN” faz com que o relatório emita apenas os empregados
informados dentro dos parênteses. Sendo emitido conforme abaixo:

Utilizando o comando “NOT IN” o mesmo tem objetivo inverso, ou seja, faz com
que o relatório emita apenas os empregados que não foram informados dentro dos
parênteses.
“AND bethadba.foempregados.i_empregados IN (2,3)”
 Sendo emitido conforme abaixo:

6 – EXISTS E NOT EXISTS

Utilizaremos o relatório de empregados e dependentes já criado no treinamento

para explicarmos sobre os comandos EXISTS e NOT EXISTS.
- Excluímos todos os campos referente à dependentes;
- Adicionamos no relacionamento o seguinte:
“AND EXISTS (Sub-consulta)”
consulta)”
Fazendo uma consulta que selecione pelo menos 1 dependente, comprovando que
pelo menos 1 empregado possui 1 dependente, ficando da seguinte forma:
 Sendo assim, o relatório irá emitir apenas os empregados que possua pelo menos
1 dependente.

Adicionando o comando “NOT” antes do EXISTS, o relacionamento irá realizar uma

busca inversa, ou seja, só serão emitidos os empregados que não possuem dependentes.
7 – COUNT

O comando “COUNT” é utilizado dentro de uma sub-consulta,

sub onsulta, para explicar o
mesmo, utilizaremos o mesmo relatório do tópico anterior.
- Excluímos o relacionamento com o comando “NOT EXISTS”;
- Adicionamos a sub-consulta
consulta de nome “quant_dep” para fazermos a contagem dos
dependentes de cada funcionário. Conforme
Co imagem abaixo:

- No SELECT em vez de colocarmos o nome do campo que queremos buscar,

temos a opção de e informar qualquer campo da tabela de dependente –
COUNT(fofilhos.i_filhos), podemos informar o número 1 – COUNT(1) ou deixar vazio –
COUNT(). Porém, como padrão utilizamos o “COUNT(1)”.
- No FROM a tabela de dependentes;
- No WHERE os relacionamentos de empresa e empregado com a tabela de
dependentes.
 Ao emitirmos o relatório, o mesmo demonstra a quantidade de dependentes para
cada empregado.

Utilizando o relatório de empresas podemos fazer a contagem de empregados

ativos em cada empresa.
- Adicionamos a sub-consulta
consulta de nome “quant_empregados ” para fazermos a
contagem dos empregados ativos de cada funcionário. Conforme imagem abaixo:
abaixo
 - No FROM a tabela de empregados;
- No WHERE os relacionamentos de empresa com a tabela de dependentes e de
empregados com afastamento diferente de 8, que se refere a “demitido”. Sendo emitido
conforme abaixo:

8 – DUAS OU MAIS QUEBRAS

No primeiro
ro treinamento utilizamos apenas uma quebra, porém podemos utilizar
mais de uma quebra por relatório. Criaremos um novo relatório de nome “Empresas –
Departamentos”.

Criado o relatório devemos configurar da seguinte forma:

- Inserir na aba colunas os campos: Código da Empresa, Nome da Empresa,
Código do Empregado, Nome do Empregado, Código do Departamento na tabela de
Empregados, Código e Nome do Departamento na tabela de Departamento. Conforme a
segui:
 Na aba Argumentos criamos o argumento de classificação “Seleção” utilizando o
código da emprega – (geempre.codi_emp).

Na aba SQL verificamos que os relacionamentos já foram realizados

automaticamente.
 Clicamos em OK e verificamos como ficou a estrutura do relatório:

Sendo emitido
do conforme abaixo:

Podemos verificar na imagem acima que a empresa e o departamento se repetem

inúmeras vezes. Neste relatório iremos criar as quebras de empresa e departamento para
que o relatório fique mais organizado e também para que as informações
informaçõ não se repitam.
Começamos criando a quebra de empresa para separar e organizar os
empregados por empresa.
- Através do menu “Inserir > Quebra” inserimos a quebra por código da empresa.
 Com a quebra por empresa criada, deslocamos os campos referente à empresa
para a banda da “quebra 1” criada anteriormente.
Ajustamos os demais campos para deixa o relatório de forma organizada, ficando
conforme abaixo:

Ao emitir o relatório, podemos verificar que as empresas não se repetem mais,

onde é emitido o nome da empresa e em seguida todos os empregados desta empresa,
fazendo isso para todas as empresa. Vejamos como ficou:
 Até aqui o primeiro treinamento tinha dados os passos de como realizar uma
quebra. Antes de criar a segunda quebra, acessamos o menu “Inserir > Ordenar” e
ordenamos o relatório primeiro por código da empresa e segundo por departamento.
 Iremos criar uma nova quebra, esta por departamento:
- Através do menu “Inserir > Quebra” inserimos a quebra por código do
departamento, conforme imagem abaixo:

Com a quebra por departamento criada, deslocamos os campos referente ao

departamento para a banda da “quebra 2” criada anteriormente.
Ajustamos os demais campos para deixa o relatório de forma organizada, ficando
fic
conforme abaixo:

Para complementar o relatório iremos adicionar o campo “Salário” do empregado

no relatório. Acessamos a Definição da Fonte de Dados e inserimos a coluna “salário”:
 Como o salário é um valor decimal, ajustamos o formato nas propriedades
do objeto, conforme abaixo:
 Ao emitir o relatório, podemos verificar que os departamentos não se repetem
mais, onde é emitido o nome da empresa e em seguida o departamento em azul
conforme ajustamos anteriormente e abaixo todos os empregados
empregados deste departamento.
Vejamos como ficou:

Podemos deixar o relatório mais completo criando campos onde demonstrem o

somatório dos salários por departamento, por empresa e geral.
- Criamos um campo computado no rodapé da 2ª quebra;
 - Dentro do campo computado inserimos a seguinte expressão:
Sum ( foempregados_salario ) for group 2), onde “group 2” representa a quebra 2 e
será somado apenas os salários dentro desta quebra, ou seja, soma os salários por
quebra.
- Clicamos em “Verificar” para
para verificar se a expressão está correta e após clicamos
em “OK”.

Realizamos os mesmos passos para o próximo campo. Criamos um campo

computa e inserimos o mesmo no rodapé da quebra 1, inserindo dentro do mesmo
o mesmo comando citado acima, porém agrupado
agrupa pelo grupo 1, conforme imagem
abaixo.
 Por fim, criamos um 3º campo computado com as mesmas configurações dos
campos anteriores, porém desta vez a expressão: sum (foempregado_salario). Desta
forma será realizado o somatório de todos os salários que
que compõem o relatório. Inserimos
o mesmo no sumário do relatório, tendo assim os 3 campos somatórios na estrutura do
relatório. Inserimos também 3 campos Texto, para identificar a qual quebra o somatório
pertence e deixar a informação mas clara para o usuário
usuário que irá utilizá-lo.
utilizá
 Após alterações realizadas podemos verificar abaixo o resultado final de nosso
relatório de Empresas e Departamentos.
9. FUNÇÕES

Neste tópico iremos dar explicar várias funções que podem deixar
deixar um relatório, mais
completo e organizado. Primeiramente criamos um novo relatório com o nome
“Empregados – Funções”. Em seguida adicionamos pela guia “Colunas” os campos
“Código da empresa, Código do empregado, Nome do empregado e Salário”. Criamos o
argumento “empresa” e adicionamos o relacionamento de empresa na guia “Seleção”
utilizando o argumento “empresa”. Em analise ao SQL, o mesmo deve ficar da seguinte
forma:

Clicando em “Ok” na tela de Definições de dados, podemos verificar como ficou a

estrutura do relatório:
9.1. CUMULATIVESUM()

Tendo criado o relatório, iniciaremos a explicação das funções. Iniciaremos com a

função Cumulativesum(). Inserimos na banda detalhe ao lado do campo salário um campo
computado com a seguinte expressão:
expr cumulativesum( salário ).

Ao emitirmos o relatório, podemos verificar a real funcionalidade desta função. Que

soma o salário os salários a cada linha, acumulando-os.
acumulando
9.2. EXTENSO()

Utilizando o mesmo campo do tópico anterior podemos demonstrar

demonstrar no relatório o
salário por extenso, utilizando a função EXTENSO() da seguinte forma:

Extenso ( salário, 1 , 1000,0,0,0)

Os números após as variáveis são valores padrões utilizados nesta função, por
isso sempre que for usada esta funções os números
números devem permanecer os mesmos.

Após emissão, podemos verificar como é demonstrado o campo computado.

9.3. EXTENSO_NUMERO()

Utilizando o mesmo campo computado, temos também expressão

Extenso_Numero(), que demonstra os números também por extenso, porém sem o valor
de moeda, ou seja, sem os “reais”.

Conforme podemos verificar abaixo:

 Por esta expressão não utilizar “reais” no fim da mesma, podemos utilizá-la
utilizá
também com outros campos, como por exemplo, o código dos empregados, conforme
imagem abaixo.

Ao emitirmos podemos verificar o código por extenso.

9.4 YEAR(), MONTH() E DAY()

Estas expressões são utilizadas quando o usuário quiser mostrar apenas um dos
números de uma data inteira. Ex: year(admissão), mostra apenas o ano da admissão.
Para demonstrar melhor, acessamos a Definição da Fonde de Dados do relatório e
adicionamos através da guia Colunas o campo Admissão(admissão).

Ficando da seguinte forma:

Em seguida adicionamos um campo computado e nas propriedades do campo

c
adicionamos a expressão “year(admissao)”.
Após emissão é demonstrado o ano no campo computado:
Criamos um novo campo computado para demonstrar a expressão MONTH().
Adicionamos a expressão “month(admissao)”.

Criamos um novo campo computado

computado para demonstrar a expressão DAY().
Adicionamos a expressão “day(admissao)”.
 Após emissão, podemos verificar as datas de admissão e os campos computados
separados por cada expressão, year(), month() e Day().
9.5. TRAZNOMEMES()

Esta expressão traz o nome do mês por extenso, a mesma é utilizada com a
função month(). Conforme exemplo abaixo, adicionamos no campo computado referente
ao mês criado anteriormente a expressão “TrazNomeMes(month(admissão))”.

mitido, o relatório é demonstrado com o mês por extenso.

Após emitido,
9.6. LEFT() E RIGHT()

Utilizando o mesmo relatório excluímos os campos computados criados para o

tópico anterior e criamos um novo campo computado. Estas técnicas servem para o
usuário que quer mostrar apenas alguns caracteres de um campo. No exemplo utilizamos
o campo nome acompanhado do número de caracteres a serem mostrados à esquerda,
“LEFT ( nome , 5 )”.

Após emissão podemos ver como ficou o novo campo computado.

 O campo mostrou apenas
penas os 5 primeiros caracteres do texto(Ex: ”Joao “, “Maria”,
“Ronal”, ...).
Mudando o expressão de LEFT para RIGHT e o tamanho 8 é mostrado os 8
últimos caracteres do texto Ex: ”Da Silva “, “S Santos”,” Ra Alves”, ...).

Após emissão podemos ver

ver como ficou o novo campo computado.
 Podemos utilizar estas funções também dentro do SQL. No exemplo abaixo
demonstramos como configurar o relatório para que o mesmo traga apenas os
empregados que terminam com a palavra “Silvestre”.

Adicionamos a condição no relacionamento principal, clicamos em Ok e após

emitimos o relatório. Sendo o emitido o mesmo é possível visualizar quais empregados
terminam com “Silvestre”.
9.7. LEN() E LENGTH ()

Está função serve para contar os caracteres

caracteres de um campo. Utilizando o mesmo
relatório inserimos no campo computado a expressão LEN(nome).

Podemos verificar que na imagem abaixo como ficou o relatório emitido.

 Esta expressão também pode ser utilizada no SQL, porém a mesma deve ser
escrita
rita por completo e não abreviada como utilizamos na expressão. Deve-se
Deve usa
LENGTH().

No SQL criamos o campo tamanho, que se refere ao tamanho do nome, para o

campo utilizamos o “LENGTH(FOEMPREGADOS.NOME)” para contar os caracteres do
nome dos empregados.
9.8. TRIM

Este comando serve para tirar os espaços no começo e no fim do campo. No

exemplo utilizamos o empregado JOAO DA SILVA, colocamos alguns espaços em branco
antes do seu nome e salvamos.

Utilizando o relatório do tópico anterior,

anterior, excluímos os campos computados criados
e emitimos o relatório ficando conforme abaixo. Podemos verificar que o empregado
JOAO ficou com um espaço entre o código e o nome diferente dos demais, isso deve-se
deve
aos espaços inseridos no nome, no cadastro do mesmo.me
 Inserimos um campo computado e adicionando a função TRIM(nome), será
excluído todos os espaços existentes no início e no fim do campo “nome”.

Conforme podemos verificar a seguir, o nome de JOAO voltou a ser mostrado

corretamente na 2ªª linha, junto com o nome dos demais empregados. Nos demais
empregados não vemos diferença entre os nomes porque os mesmos não contém
espaços no início ou fim do campo.
 Esta função também pode ser utilizada no SQL, podemos utilizá-lo
utilizá para
comparativo. No exemplo abaixo inserimos nos relacionamentos a condição
“foempregados.nom = ‘JOAO DA SILVA’.

Como temos espaços no início do nome de JOAO, o relatório ao ser emitido não
encontra dados. Isso acontece pois quando a condição é feita usando
usando “Strings” o campo a
ser encontrado deve estar cadastrado igual a condição feita.

Utilizamos a função TRIM() no nome do empregado na condição.

 Após emissão, o nome é encontrado.

9.9. LOWER(), UPPER E WORDCAP()

WOR

Nestee tópico iremos falar sobre

sobre três funções semelhantes, todas servem para o
tratamento de campo de caracteres.

- LOWER(): Para tornar todos os caracteres minúsculos.

- UPPER():Para
Para tornar todos os caracteres maiúsculos.
- WORDCAP():Para
Para tornar apenas o primeiro caractere de cada
cada palavra maiúsculo
e o restante minúsculo.

Utilizando o relatório do tópico anterior excluímos o campo da 2ª linha e inserimos

um novo computado, no mesmo adicionamos a expressão “lower(nome)”.
 Após emissão o campo computado é demonstrado em minúsculo
minúsculo conforme
expressão criada.

Alteramos o nome do empregado JOAO DA SILVA para “Joao da Silva” e

salvamos.

No mesmo campo computado criado para a função LOWER(), alteramos a

expressão para “UPPER(nome)”.
 Após emissão o campo computado é demonstrado em maiúsculo conforme
expressão alterada.

Alteramos o nome do empregado “Joao da Silva” para JOAO DA SILVA e

salvamos.

No mesmo campo computado criado para a função UPPER(), alteramos a

expressão para “WORDCAP(nome)”.
 Após emissão o campo computado é demonstrado o primeiro caractere em
maiúsculo e os demais em minúsculo, conforme expressão alterada.

9.10. GETROW()

Esta função retornar o número da linha.

Adicionamos em um campo computado a função getrow(). Ao emitirmos o relatório

r
verificamos que o campo computado retornou o número de cada linha.
9.11. TODAY()

Utilizamos esta função para retornar a data atual, ou seja, a data que está
informada no sistema Windows.

Inserimos a mesma em um campo computado e após emissão

emissão podemos verificar a
data atual para os empregados.

,
9.12. LIST()

A função list() serve para trazer mais de um registro em uma linha. Para o exemplo
desta função iremos criar um novo relatório de nome “Exemplo List”.
Adicionamos os campos “codi_emp”
“codi_emp” e “nome_emp” da tabela de
empresas(geempre).

Ficando da seguinte forma:

Após emissão, podemos visualizar a lista de empresas conforme já vimos em

relatórios anteriores.
 Acessamos o SQL e incluímos uma sub-consulta,
sub consulta, colocamos um apelido
ape na tabela
de empregados como “fun” referente a funcionários. Adicionamos o campo conforme
desejamos, neste exemplo o campo “nome”.
“nome”

Ao emitirmos ocorre o erro abaixo:

Isso ocorre porque a sub-consulta

sub consulta está encontrando mais de um registra para
par uma
das linhas do relatório. A sub--consulta
consulta criada está retornando todos os empregados de
cada uma das empresas listadas. Como só é permitido um registro por linha o erro ocorre.
Para resolver esta situação temos como alternativa a função LIST(). Acessamos
Acess o
SQL e incluímos a função List() antes do campo “nome”, dentro da sub-consulta,
sub
conforme imagem abaixo:
 Após emissão, podemos verificar a lista de empregados em uma linha só. O erro
não ocorre novamente, porque a função “list()” busca todos os
os empregados e separa
todos por “,” formando uma string, como se fosse apenas um campo.

Dentro da função list() também podemos incluir outros campos, como o código do
empregado separando os campos por ifem, conforme demonstramos acima. Convertemos
o campo
mpo “i_empregados” para String e adicionamos dentro do list(). Adicionamos também
um filtro por empresa, sendo demonstrados apenas os empregados das empresas 9996,
9997, 9998 e 9999.

Após emissão verificamos como ficou o relatório:

9.13. MIN() E MAX()

Estas funções são utilizadas para pegar o menor e o maior registro do campo
selecionado. No exemplo utilizamos o mesmo campo computado criado no tópico anterior,
e inserimos o max() antes do campo do funcionário, conforme demonstra imagem abaixo.

consulta irá buscar apenas o maior registro, ou seja, o registro máximo de

Esta sub-consulta
empregados para cara empresa. Após emissão podemos verificar o código máximo de
empregados para cada empresa.

Alterando o “max” para “min” a sub-consulta

sub irá buscar
car o menor registro, ou seja, o
registro mínimo de empregados para cara empresa.
 Após emissão podemos verificar o código mínimo de empregados para cada
empresa.

9.14. ISNULL() OU COALESCE()

Utilizamos as funções isnull()

isnull e coalesce() para verificar
ificar quando o campo está
vazio.
Para este tópico criamos um novo relatório, para criação do mesmo inserimos os
campos “Código, Nome e complemento dos empregados”. Adicionamos um filtro de
empresa = 9999 e empregas de 1 à 8, apenas para o relatório não ficar tão grande
quando emitido.

Após, emitimos o relatório para ver como ficou.

 Conforme verificamos acima o relatório possui alguns campos vazios e como são
vazios os mesmos ficam em branco no relatório. Caso o usuário deseja mostra alguma
mensagem
agem como por exemplo “(Sem complemento informado)”, o mesmo pode utilizar as
funções Isnull() e Coalesce().
A função Isnull e Coalesce são utilizadas da mesma
me forme,
e, conforme demonstrado
abaixo:

A função é formada da seguinte forma: Função(Falsa,Verdadeira),

Função(Falsa,Verdadeira), ou seja,
Isnull(bethadba.foempregados.complemento, ‘(Sem
(Sem complemento informado)’);
informado)
Caso o campo esteja vazio, é demonstrado no relatório a condição verdadeira, no
caso a frase determinada, caso contrário é demonstrado o campo com os dados do
mesmo.
Após emitirmos o relatório, podemos verificar como ficou.
ficou

A função Coalesce() é utilizada da mesma forma que a função Isnull().

Isnull
 Adicionamos a função Coalesce()
Coalesce() e após emissão verificamos que a emissão foi
demonstrada da mesma forma em que utilizamos a função Isnull().

Também podemos utilizar ambas as funções na expressão de um campo

computado. Para isso, retornamos
rnamos ao SQL deixamos o campo complemento sem as
funções, conforme abaixo:

Adicionamos um campo computado

computado e incluímos a seguinte expressão:

‘O
O complemento do endereço é: ‘ + complemento

Ficando da seguinte forma:

 Após emissão do relatório, podemos verificar que o mesmo só demonstra os
campos que contem alguma informação no campo complemento. Verificamos também
que o campo que não contém complemento, não é demonstrado nem mesmo a frase ‘O
complemento do endereço é: ‘.

Para utilizar as funções deste tópico em um campo computado o mesmo deve ser
utilizado com a função “IF” que será explicada no próximo tópico. É utilizada da seguinte
forma:: If ( Isnull (complemento), ‘Sem complemento’, complemento),, ou seja, se o
complemento for vazio, mostra a frase ‘Sem complemento’,, caso contrário demonstra
demonstr o
campo.

Depois de emitido, podemos visualizar como ficou o relatório.

9.15. IF

A função “IF” é muito utilizada em relatórios mais avançados,

avançados, a mesma serve para
par
condições verdadeiras
ras e falsas. É utilizada da seguinte forma:
IF ( condição, verdadeira, falsa),
falsa), conforme demonstra imagem abaixo:

Neste exemplo utilizaremos um relatório já criado anteriormente, o relatório

“Empregados – Funções”,, deixando ele apenas com os campos “Código
Código da Empresa,
Código do Empregado, Nome me e Salário”.
Salário . Adicionamos um campo computado e na
expressão do mesmo adicionamos a função “IF”,, conforme imagem a seguir:
 Antes
ntes de emitirmos o relatório vamos na guia formato e selecionamos o formato
númerio - #,##0.00. Esta função faz o seguinte, se o salário for menor que 2000, mostra o
salario + 50, caso contrário mostra apenas o salário sem acrescimo. Depois de emitido,
visualizamos o relatório. O salário de 4000 continuou 4000 e o salário de 1500 somou
mais 50, ficando 1550.

Abaixo explicaremos como é utilizado o “IF” no SQL.

IF – condição
THEN – Verdadeira
ELSE – Falsa
ENDIF para finalizar a função.

Criamos um novo campo de nome novo_salario

novo_salario e adicionamos a mesma função
utilizada no campo computado, porém da forma que deve ser utilizada
lizada no SQL, ficando
conforme abaixo:
 Retornando a estrutura do relatório, verificamos que o novo campo foi adicionado
na estrutura do mesmo. Acessamos as propriedades do campo e alteramos o formato
conforma a seguir:

Após emissão, verificamos que o campo criado no

o campo computado e o campo
criado no SQL emitem as mesmas informações.

.
9.16. CASE

Utilizando o mesmo relatório excluímos os campos criados no tópico anterior e

adicionamos o campo “Estado
Estado Civil”
Civil conforme SQL demonstrado o abaixo:

Após emissão, o relatório é emitido, porém com informações de difícil

interpretação. Isso acontece porque o campo estado civil define o estado civil por apenas
um caractere no banco de dados, ou seja, S para Solteiro,
Solteiro, C para Casado, entre outros.
 Excluímos o campo estado civil da estrutura do relatório e no lugar do mesmo
adicionamos
dicionamos um campo computado com a seguinte expressão:

‘O
O estado civil do empregado é:
é ‘ + estado_civil

Clicamos em Ok e emitimos o relatório, verificamos que o mesmo ainda não está

claro.

Nesta situação, podemos utilizar a função case que permite inclui não apenas um
condição para o campo, mas sim várias. Neste caso, poderíamos utilizar a tabela de
valores explicado
plicado no primeiro treinamento,
treinamento, ou utilizarmos a função case que é formada da
seguinte forma:

CASE – Campo a ser utilizado para a condição

WHEN – Caractere que estáe gravado no campo
THEN – Palavra referente ao caractere
ELSE ‘’– para mostrar vazio
vazio caso nenhum dos caracteres estejam no WHEN
END – para finalizar a função.
 Adicionamos no SQL a função conforme imagem acima e emitimos o relatório.
Conforme imagem abaixo, podemos verificar que agora as informações demonstradas
estão mais claras.

A função Case também pode ser utilizada na expressão de um campo computado

como podemos ver na imagem a seguir, a função é formada da quase mesma forma que
no SQL, porém
rém existem duas alterações, a primeira que ao contrário do SQL, o CASE
vem antes da abrir os parênteses e a segunda é que o END para finalizar a função não é
usado, bastando apenas fechar os parênteses.
 Depois de emitido verificamos que o relatório é emitido corretamente. Assim como
quando campo fora criado no SQL.

10. DESTACAR LINHAS

Neste último tópico iremos

emos explicar como deixar o relatório, mais
mais organizado
or e
bonito. Destacando as linhas em cores diferentes. Para isso devemos proceder da
seguinte forma:

1 – Inserir um objeto retângulo para preencher toda a extensão da linha;

2 – Coloque a cor do fundo no objeto retângulo conforme desejado(Ex: Prata);

3 – Após clicando com o botão direito do mouse no objeto retângulo, selecione

“Enviar para Traz”;

4 – Deixe os campos que ficarão acima do retângulo com a cor transparente;

5 – Na guia “Expressões” nas propriedades do objeto, no campo Visível adicionar a
expressão:
If(mod(getrow(),2
(mod(getrow(),2 = 0,0,1)
 Caso o usuário tenha feito todos os passos corretamente, o relatório será emitido
da seguinte forma, tornando-se
se um relatório mais
mais simples e organizado. Assim,
terminamos o nosso “Treinamento
reinamento II”.
II