Hoje vamos mergulhar nos componentes da linguagem PL/SQL. Em um artigo anterior [Introdução à Arquitetura do PL/SQL] analisamos a arquitetura do PL/SQL

Agora quero que você imagine que estamos construindo uma casa – o PL/SQL seria o nosso conjunto de ferramentas e materiais. Vamos explorar cada peça dessa caixa de ferramentas para entender como podemos criar programas incríveis!

Conjuntos de Caracteres no Oracle

O Oracle usa dois conjuntos de caracteres principais:

Conjunto de caracteres do banco de dados (Database Character Set)
Conjunto de caracteres nacional (National Character Set)

Esses conjuntos são como “alfabetos” que o Oracle usa para armazenar e processar dados. Vamos entender melhor cada um:

1. Conjunto de caracteres do banco de dados

Este é o conjunto principal usado para armazenar a maioria dos dados no banco de dados, incluindo nomes de tabelas, colunas e a maioria dos tipos de dados como VARCHAR2 e CHAR.

Como verificar:

Você pode verificar o conjunto de caracteres do banco de dados usando a seguinte consulta SQL:

SELECT VALUE 
FROM NLS_DATABASE_PARAMETERS 
WHERE PARAMETER = 'NLS_CHARACTERSET';

SELECT VALUE

FROM NLS_DATABASE_PARAMETERS

WHERE PARAMETER = 'NLS_CHARACTERSET';

Exemplo de resultado:

VALUE
----------------
AL32UTF8

VALUE

----------------

AL32UTF8

Neste exemplo, AL32UTF8 é um conjunto de caracteres Unicode que suporta múltiplos idiomas.

2. Conjunto de caracteres nacional

Este conjunto é usado especificamente para tipos de dados NCHAR, NVARCHAR2 e NCLOB. É útil quando você precisa armazenar dados em um conjunto de caracteres diferente do conjunto de caracteres do banco de dados.

Como verificar:

Para verificar o conjunto de caracteres nacional, use esta consulta:

SELECT VALUE 
FROM NLS_DATABASE_PARAMETERS 
WHERE PARAMETER = 'NLS_NCHAR_CHARACTERSET';

SELECT VALUE

FROM NLS_DATABASE_PARAMETERS

WHERE PARAMETER = 'NLS_NCHAR_CHARACTERSET';

Exemplo de resultado:

VALUE
----------------
AL16UTF16

VALUE

----------------

AL16UTF16

AL16UTF16 é outro conjunto de caracteres Unicode, otimizado para dados NCHAR.

Exemplo prático

Vamos ver como isso funciona na prática:

-- Criando uma tabela com colunas usando ambos os conjuntos de caracteres
CREATE TABLE exemplo_caracteres (
    id NUMBER,
    nome VARCHAR2(50),  -- Usa o conjunto de caracteres do banco de dados
    nome_nacional NVARCHAR2(50)  -- Usa o conjunto de caracteres nacional
);

-- Inserindo dados
INSERT INTO exemplo_caracteres VALUES (1, 'João', N'João');
INSERT INTO exemplo_caracteres VALUES (2, '日本', N'日本');

-- Consultando os dados
SELECT * FROM exemplo_caracteres;

-- Criando uma tabela com colunas usando ambos os conjuntos de caracteres

CREATE TABLE exemplo_caracteres (

id NUMBER,

nome VARCHAR2(50), -- Usa o conjunto de caracteres do banco de dados

nome_nacional NVARCHAR2(50) -- Usa o conjunto de caracteres nacional

);

-- Inserindo dados

INSERT INTO exemplo_caracteres VALUES (1, 'João', N'João');

INSERT INTO exemplo_caracteres VALUES (2, '日本', N'日本');

-- Consultando os dados

SELECT * FROM exemplo_caracteres;

Neste exemplo:

A coluna nome usa o conjunto de caracteres do banco de dados.
A coluna nome_nacional usa o conjunto de caracteres nacional.
Note o ‘N' antes da string na inserção para nome_nacional. Isso indica que estamos usando o conjunto de caracteres nacional.

Importância na prática

Suporte a múltiplos idiomas: O conjunto de caracteres correto permite armazenar e processar texto em vários idiomas.
Otimização de espaço: Alguns conjuntos de caracteres são mais eficientes para certos tipos de dados.
Compatibilidade: É crucial para interações com sistemas externos e importação/exportação de dados.
Performance: A escolha do conjunto de caracteres pode afetar o desempenho de consultas e operações de string.

Verificando suporte a caracteres específicos

Para verificar se um caractere específico é suportado, você pode tentar inseri-lo em uma tabela:

-- Criando uma tabela de teste
CREATE TABLE teste_caractere (
    texto VARCHAR2(10)
);

-- Tentando inserir um caractere
INSERT INTO teste_caractere VALUES ('α'); -- Letra grega alpha

-- Verificando se foi inserido corretamente
SELECT * FROM teste_caractere;

-- Criando uma tabela de teste

CREATE TABLE teste_caractere (

texto VARCHAR2(10)

);

-- Tentando inserir um caractere

INSERT INTO teste_caractere VALUES ('α'); -- Letra grega alpha

-- Verificando se foi inserido corretamente

SELECT * FROM teste_caractere;

Se o caractere for exibido corretamente, ele é suportado pelo conjunto de caracteres do seu banco de dados.

Lembre-se, a escolha do conjunto de caracteres é feita na criação do banco de dados e é difícil de mudar depois. Por isso, é importante escolher sabiamente baseado nas necessidades do seu projeto!

Grupos Fundamentais de Caracteres

Nosso alfabeto PL/SQL tem quatro grupos principais:

Letras: A-Z e a-z (como no nosso alfabeto normal)
Dígitos: 0-9 (nossos números de sempre)
Caracteres de espaço em branco: espaço, tab, nova linha, retorno de carro (são os caracteres invisíveis que dão forma ao nosso código)
Caracteres de pontuação: *, +, -, =, etc. (os sinais que usamos para operações especiais)

Esses caracteres são as peças fundamentais com as quais construímos nosso código PL/SQL. Aqui você tem uma lista dos Character Sets recomendados pela Oracle.

Unidades Léxicas do PL/SQL

Agora, vamos juntar essas peças para formar palavras no nosso idioma PL/SQL. Essas “palavras” são chamadas de unidades léxicas. São como os tijolos da nossa casa de código. Temos cinco tipos principais:

Identificadores: São os nomes que damos às nossas “coisas” no código, como variáveis, constantes, procedimentos e funções.
Palavras reservadas: São palavras especiais que o PL/SQL guarda só para ele usar, como BEGIN, END, SELECT. É como se fossem ferramentas que só o mestre de obras pode usar.
Delimitadores: São caracteres especiais que têm significados próprios, como os operadores aritméticos (+, -) e as aspas. Eles são como a argamassa que une nossos tijolos.
Literais: São valores fixos no nosso código, como números (123), textos (“Olá, mundo!”), ou valores booleanos (TRUE/FALSE). São como os móveis que colocamos dentro da nossa casa de código.
Comentários: São notas que deixamos no código para explicar o que ele faz. Podem ser de uma linha (–) ou de várias linhas (/* */). São como as plantas da nossa casa, que explicam como ela foi construída.

Variáveis em PL/SQL

Agora, vamos falar sobre um dos componentes mais importantes: as variáveis. Elas são como caixas onde guardamos informações no nosso programa.

Para criar uma variável, usamos a seguinte estrutura:

<nome_da_variavel> <tipo_de_dado> [atribuição_opcional];

1	<nome_da_variavel> <tipo_de_dado> [atribuição_opcional];

Por exemplo:

v_nome VARCHAR2(50);
v_idade NUMBER;
v_data_nascimento DATE := SYSDATE;

v_nome VARCHAR2(50);

v_idade NUMBER;

v_data_nascimento DATE := SYSDATE;

Regras para Nomes de Variáveis

Devem começar com uma letra
Podem conter letras, números, $, # e _
Não são sensíveis a maiúsculas e minúsculas (v_nome é igual a V_NOME)
Não podem conter espaços ou caracteres especiais (exceto $, # e _)
Não podem ser palavras reservadas do PL/SQL

Exemplos de nomes válidos:

v_aluno_id
nome_completo
SALARIO_TOTAL
apartamento_#

v_aluno_id

nome_completo

SALARIO_TOTAL

apartamento_#

Exemplos de nomes inválidos:

1a_tentativa  -- Não pode começar com número
nome completo -- Não pode conter espaços
select        -- É uma palavra reservada
x+y           -- Não pode conter operadores

1a_tentativa -- Não pode começar com número

nome completo -- Não pode conter espaços

select -- É uma palavra reservada

x+y -- Não pode conter operadores

Palavras Reservadas em PL/SQL

As palavras reservadas são como as regras da casa – não podemos mudá-las ou usá-las para outras coisas. Por exemplo, não podemos criar uma variável chamada “BEGIN” ou “SELECT”, porque o PL/SQL já usa essas palavras para funções específicas.

Se tentarmos usar uma palavra reservada como nome de variável, o PL/SQL vai reclamar! Por exemplo:

DECLARE
   exception VARCHAR2(15);  -- Isso vai dar erro!
BEGIN
   exception := 'Teste';
   DBMS_OUTPUT.PUT_LINE(exception);
END;

DECLARE

exception VARCHAR2(15); -- Isso vai dar erro!

BEGIN

exception := 'Teste';

DBMS_OUTPUT.PUT_LINE(exception);

END;

Este código vai gerar um erro porque “exception” é uma palavra reservada em PL/SQL.

Esse Artigo faz parte do Treinamento DBA Oracle com GRID 21. Curso 100% Prático.
Melhor Preço por Tempo Limitado. Clique Aqui e Teste Sem Risco.
30 Dias de Satisfação Garantida!

Delimitadores em PL/SQL

Os delimitadores são como a pontuação no nosso código. Eles ajudam o PL/SQL a entender onde uma instrução começa e termina, ou como realizar operações. Alguns exemplos importantes:

+, -, *, /: Operadores aritméticos
=, <>, <, >: Operadores de comparação
:=: Operador de atribuição
||: Operador de concatenação de strings

Vejamos um exemplo:

DECLARE
   v_resultado1 NUMBER;
   v_resultado2 NUMBER;
BEGIN
   v_resultado1 := (3 + 47) / 10;
   v_resultado2 := 3 + (47 / 10);
   DBMS_OUTPUT.PUT_LINE('Resultado 1: ' || v_resultado1);
   DBMS_OUTPUT.PUT_LINE('Resultado 2: ' || v_resultado2);
END;

DECLARE

v_resultado1 NUMBER;

v_resultado2 NUMBER;

BEGIN

v_resultado1 := (3 + 47) / 10;

v_resultado2 := 3 + (47 / 10);

DBMS_OUTPUT.PUT_LINE('Resultado 1: ' || v_resultado1);

DBMS_OUTPUT.PUT_LINE('Resultado 2: ' || v_resultado2);

END;

Neste exemplo, os parênteses e os operadores matemáticos são delimitadores que controlam como as operações são realizadas.

Literais em PL/SQL

Literais são valores fixos que colocamos diretamente no nosso código. Eles podem ser:

Strings (texto): Sempre entre aspas simples, como ‘Olá, mundo!'
Números: Escritos diretamente, como 42 ou 3.14
Booleanos: TRUE ou FALSE

Exemplo:

DECLARE
   v_nome VARCHAR2(20);
   v_idade NUMBER;
   v_ativo BOOLEAN;
BEGIN
   v_nome := 'João da Silva';  -- Literal de string
   v_idade := 30;              -- Literal numérico
   v_ativo := TRUE;            -- Literal booleano
   
   DBMS_OUTPUT.PUT_LINE('Nome: ' || v_nome);
   DBMS_OUTPUT.PUT_LINE('Idade: ' || v_idade);
   IF v_ativo THEN
      DBMS_OUTPUT.PUT_LINE('Está ativo');
   END IF;
END;

DECLARE

v_nome VARCHAR2(20);

v_idade NUMBER;

v_ativo BOOLEAN;

BEGIN

v_nome := 'João da Silva'; -- Literal de string

v_idade := 30; -- Literal numérico

v_ativo := TRUE; -- Literal booleano

DBMS_OUTPUT.PUT_LINE('Nome: ' || v_nome);

DBMS_OUTPUT.PUT_LINE('Idade: ' || v_idade);

IF v_ativo THEN

DBMS_OUTPUT.PUT_LINE('Está ativo');

END IF;

END;

Lembre-se: literais de string são sensíveis a maiúsculas e minúsculas, e espaços contam! ‘Maçã' é diferente de ‘maçã' e de ‘Maçã ‘.

Conclusão

Ufa! Chegamos ao fim da nossa aula sobre os componentes da linguagem PL/SQL. Vimos como os caracteres se juntam para formar unidades léxicas, aprendemos sobre variáveis, palavras reservadas, delimitadores e literais. Cada um desses componentes é uma ferramenta poderosa na nossa caixa de construção de programas PL/SQL.

Lembre-se: assim como um bom construtor conhece suas ferramentas, um bom programador PL/SQL domina esses componentes. Com prática, você vai se sentir cada vez mais confortável usando-os para construir programas incríveis!

Conjuntos de Caracteres no Oracle

1. Conjunto de caracteres do banco de dados

Como verificar:

2. Conjunto de caracteres nacional

Como verificar:

Exemplo prático

Importância na prática

Verificando suporte a caracteres específicos

Grupos Fundamentais de Caracteres

Unidades Léxicas do PL/SQL

Variáveis em PL/SQL

Regras para Nomes de Variáveis

Palavras Reservadas em PL/SQL

Esse Artigo faz parte do Treinamento DBA Oracle com GRID 21. Curso 100% Prático. Melhor Preço por Tempo Limitado. Clique Aqui e Teste Sem Risco. 30 Dias de Satisfação Garantida!

Delimitadores em PL/SQL

Literais em PL/SQL

Conclusão

Related Posts

Esse Artigo faz parte do Treinamento DBA Oracle com GRID 21. Curso 100% Prático.
Melhor Preço por Tempo Limitado. Clique Aqui e Teste Sem Risco.
30 Dias de Satisfação Garantida!