sexta-feira, 27 de março de 2026

ORACLE PL/SQL- Tipos de JOIN (Explicação Simples)

 ## Tipos de JOIN


Vou explicar usando duas tabelas como exemplo:

- **CLIENTES** (id, nome)

- **PEDIDOS** (id, cliente_id, valor)


### 1. **INNER JOIN** (ou só JOIN)

**Retorna apenas os registros que têm correspondência em AMBAS as tabelas.**

```sql

SELECT * FROM CLIENTES c

INNER JOIN PEDIDOS p ON c.id = p.cliente_id;

**Resultado:** Só clientes que fizeram pedidos. Clientes sem pedido NÃO aparecem.

Cliente com pedido   → aparece

Cliente sem pedido   → não aparece


### 2. **LEFT JOIN** (ou LEFT OUTER JOIN)

**Retorna TODOS os registros da tabela da ESQUERDA + correspondências da direita.**

```sql

SELECT * FROM CLIENTES c

LEFT JOIN PEDIDOS p ON c.id = p.cliente_id;

**Resultado:** Todos os clientes. Quem não tem pedido fica com NULL nos campos de pedido.

Cliente com pedido   → aparece com dados do pedido

Cliente sem pedido   → aparece com NULL nos campos do pedido


### 3. **RIGHT JOIN** (ou RIGHT OUTER JOIN)

**Retorna TODOS os registros da tabela da DIREITA + correspondências da esquerda.**

```sql

SELECT * FROM CLIENTES c

RIGHT JOIN PEDIDOS p ON c.id = p.cliente_id;

**Resultado:** Todos os pedidos. Pedidos sem cliente (raro) aparecem com NULL nos campos de cliente.

Pedido com cliente   → aparece com dados do cliente

Pedido sem cliente   → aparece com NULL nos campos do cliente


### 4. **FULL JOIN** (ou FULL OUTER JOIN)

**Retorna TODOS os registros de AMBAS as tabelas.**

```sql

SELECT * FROM CLIENTES c

FULL JOIN PEDIDOS p ON c.id = p.cliente_id;

**Resultado:** Tudo. Clientes sem pedido e pedidos sem cliente aparecem com NULLs.

Clientes com e sem pedido → todos aparecem

Pedidos com e sem cliente → todos aparecem


### 5. **CROSS JOIN**

**Produto cartesiano: cada linha da primeira combina com TODAS da segunda.**

```sql

SELECT * FROM CLIENTES

CROSS JOIN PEDIDOS;

**Resultado:** Se 10 clientes e 100 pedidos → 1.000 registros (cada cliente com cada pedido)


### 6. **SELF JOIN**

**JOIN da tabela com ela mesma.** Útil para relações hierárquicas.

```sql

SELECT e.nome AS empregado, g.nome AS gerente

FROM FUNCIONARIOS e

LEFT JOIN FUNCIONARIOS g ON e.gerente_id = g.id;


## Resumo Visual

| Tipo                    | Esquerda                                       | Direita |

| **INNER**       | ✅ só correspondentes                 | ✅ só correspondentes |

| **LEFT**          | ✅ todos                                      | ✅ só correspondentes |

| **RIGHT**       | ✅ só correspondentes                 | ✅ todos |

| **FULL**         | ✅ todos                                       | ✅ todos |


## Exemplo com diagrama mental

Tabela A          Tabela B

┌─────┐          ┌─────┐

│ 1           │          │ 2           │

│ 2           │          │ 3           │

│ 3           │          │ 4           │

│ 5           │          │             │

└─────┘          └─────┘


INNER JOIN: [2, 3]        (o que tem nos dois)

LEFT JOIN:  [1, 2, 3, 5]  (tudo de A)

RIGHT JOIN: [2, 3, 4]     (tudo de B)

FULL JOIN:  [1, 2, 3, 4, 5] (tudo de ambos)

```


## Dica prática

- **INNER JOIN**: quando só importam registros relacionados

- **LEFT JOIN**: quando não quer perder os registros da tabela principal (mais comum)

- **FULL JOIN**: quando precisa ver tudo de ambos os lados

- **RIGHT JOIN**: raro, dá pra substituir por LEFT trocando ordem das tabelas

ORACLE PL/SQL - Diferença entre NOT LIKE e <>

 ## Diferença entre NOT LIKE e <>


São operadores completamente diferentes com propósitos distintos:


### **LIKE / NOT LIKE**

- Usado para **comparação de padrões** com strings

- Permite uso de curingas: `%` (qualquer sequência) e `_` (um caractere)

- Funciona **apenas com dados do tipo texto** (VARCHAR2, CHAR, etc.)


```sql

-- Exemplos com NOT LIKE

WHERE nome NOT LIKE 'João%'     -- Não começa com "João"

WHERE nome NOT LIKE '%Silva%'   -- Não contém "Silva"

WHERE nome NOT LIKE '_____'     -- Não tem exatamente 5 caracteres

```


### **<> (ou !=)**

- Usado para **desigualdade exata**

- Compara valores completos

- Funciona com **qualquer tipo de dado** (números, datas, textos)


```sql

-- Exemplos com <>

WHERE id <> 10                  -- id diferente de 10

WHERE nome <> 'João'            -- nome exatamente diferente de 'João'

WHERE data <> SYSDATE           -- data diferente de hoje

```


## Principais diferenças:


CARACTERÍSTICAS             NOT LIKE                                   <> 

 **Propósito**                            Comparação de padrão                 Desigualdade exata

 **Curingas**                             Sim (%, _)                                     Não

 **Tipo de dado**                      Apenas texto                                   Qualquer tipo 

 **NULL**                                 Retorna NULL                               Retorna NULL

 **Performance**                       Geralmente mais lento |                 Geralmente mais rápido 


## Comportamento com NULL:

**Ambos retornam NULL quando comparados com NULL:**

```sql

-- Se campo é NULL:

WHERE campo NOT LIKE '%valor%'  -- NULL (não retorna)

WHERE campo <> 'valor'          -- NULL (não retorna)


-- Para incluir NULLs, é necessário tratar:

WHERE (campo IS NULL OR campo NOT LIKE '%valor%')

```


## Exemplo prático com seu caso:


```sql

-- NOT LIKE: exclui apenas padrões específicos

WHERE PAR_X_OPERADORPARC NOT LIKE 'PARCERIA - 05'  

-- Exclui: 'PARCERIA - 05', 'PARCERIA - 05 algo', 'XPARCERIA - 05X'


-- <>: exclui apenas o valor exato

WHERE PAR_X_OPERADORPARC <> 'PARCERIA - 05'

-- Exclui APENAS: 'PARCERIA - 05' (exato, sem espaços extras)


-- Se o campo tem espaços, <> falha:

-- 'PARCERIA - 05 ' (com espaço) NÃO será excluído com <>

-- Mas será excluído com NOT LIKE 'PARCERIA - 05' (depende do padrão)

```


## Para seu cenário específico:

Se o problema é espaços em branco, considere:

```sql

-- NOT LIKE com tratamento de espaços

AND TRIM(PAR_X_OPERADORPARC) NOT LIKE 'PARCERIA - 05'


-- Ou com <> tratando espaços

AND TRIM(PAR_X_OPERADORPARC) <> 'PARCERIA - 05'

```

**Resumo:** Use `NOT LIKE` quando precisa de busca por padrão com curingas. Use `<>` para comparar valores exatos e em campos não-texto.

terça-feira, 24 de fevereiro de 2026

Visual Studio - Remover o WeatherForecast

 Se você está lendo este post, é porque você ao executar sua API, se deparou com WeatherForecast. Este é apenas um template de exemplo. São apenas dois passos para remover este template.


1 — Deletar os arquivos de exemplo

No Solution Explorer, delete:

WeatherForecast.cs (na raiz do projeto)

Controllers/WeatherForecastController.cs

Clique com botão direito em cada um → Excluir


2 — Verificar o Program.cs

Confirme que não há nenhuma referência ao WeatherForecast no seu Program.cs. O seu atual já está limpo, então não deve ter nada para remover.


Espero ter ajudado e até a próxima


segunda-feira, 23 de fevereiro de 2026

CRIAR UMA API RESTful NO VISUAL STUDIO 2022

Opção Recomendada: ASP.NET Core Web API (API Web do ASP.NET Core)


A forma mais direta é criar um projeto já configurado para API REST. Veja o passo a passo:

1. Abra o Visual Studio 2022

2. Clique em "Criar um novo projeto"

3. Pesquise por "ASP.NET Core Web API"

4. Escolha o template e clique em Avançar

5. Configure o nome e local do projeto

6. Na próxima tela, selecione: 

    o .NET 8 (LTS mais recente)

    o Marque "Use controllers" se quiser o padrão MVC, ou deixe desmarcado para usar Minimal APIs

    o Marque "Enable OpenAPI support" para ter o Swagger já configurado


Esse template já vem com tudo pronto: controller de exemplo, Swagger, configurações de CORS, etc.


Projeto Vazio com C# — Vale a pena?

Tecnicamente é possível, mas não recomendo para quem está começando ou quer agilidade. Você teria que configurar manualmente o middleware, injeção de dependência, roteamento, etc. Dá mais trabalho sem nenhum ganho real.


O que você ganha com o template Web API

Com o projeto gerado, você já tem uma estrutura como:

Controllers/ → onde ficam seus endpoints

Program.cs → configuração da aplicação

appsettings.json → configurações como connection string

Swagger disponível em /swagger ao rodar o projeto


Dica importante

Se for uma API mais simples ou moderna, o Visual Studio 2022 também oferece o template de Minimal API, que é mais enxuto e sem controllers, tudo em Program.cs. Para projetos maiores e em equipe, prefira a abordagem com Controllers.

Quer que eu te ajude com os próximos passos, como criar um CRUD completo ou conectar a um banco de dados?


ASP.NET CORE API WEB (Native AOT)

O Native AOT compila o projeto diretamente para código nativo, o que traz inicialização mais rápida e menor uso de memória. Porém tem limitações importantes:

Não suporta reflection (o que quebra muitas libs populares como Entity Framework, AutoMapper, Newtonsoft.Json, etc.)

Mais restrito e complexo de configurar

Indicado para cenários muito específicos de alta performance, como microsserviços em containers


Resumindo API Web do ASP.NET  x Core Native AOT


API Web do ASP.NET    

             

Facilidade                                 ✅ Alta

Compatibilidade com libs         ✅ Total

Performance de startup             Normal

Recomendado para iniciantes   ✅ Sim


Core Native AOT


Facilidade                                  ❌ Complexo

Compatibilidade com libs         ⚠️ Limitada

Performance de startup              Muito alta

Recomendado para iniciantes   ❌ Não


Facilidade ✅ Alta ❌ Complexo

Compatibilidade com libs ✅ Total ⚠️ Limitada

Performance de startup Normal Muito alta

Recomendado para iniciantes ✅ Sim ❌ Não


terça-feira, 17 de fevereiro de 2026

ANDROID STUDIO - OBTER SHA1 UTILIZANDO POWERSHELL

No Android Studio, abra o Terminal. Para acessar o Terminal (View > Tool Windows > Terminal).

Em seguida digite: & "C:\Program Files\Android\Android Studio\jbr\bin\keytool.exe" -list -v -alias androiddebugkey -keystore "$env:USERPROFILE\.android\debug.keystore" -storepass android -keypass android


O certificado SHA1 será exibido.


Espero ter ajudado e até a próxima.