Student SQL

START, STOP, RESTART PostgreSQL via CMD

2013-07-02T13:58:00.000-07:00

Pra aqueles que tiverem algum problema com a inicialização ou finalização do serviço do PostgreSQL, aqui vai os comandos para iniciar (START) e parar (STOP) o servidor de banco de dados.

Para iniciar (START) o servidor de banco de dados, execute os seguintes passos:

1- Aperte Windows
2- Se for windows 7 ou superior digite cmd e aperte Enter.
Se não, vá em Executar e digite cmd e aperte Enter.
3- Após aberto o Prompt de comando do Windows - Navegue até a pasta BIN do PostgreSQL
Ex.: CD C:/Program Files/PostgreSQL/9.2/bin
4- Na pasta bin digite o seguinte comando
pg_ctl -D "c:/Program Files/PostgreSQL/9.2/data" start

Obs.: Note que o -D tem que ser maiúsculo para que o comando seja executado perfeitamente.

Para parar o servidor o procedimento é o mesmo, trocando somente a ultima palavra START por STOP.

Agora para se fazer um desligamento com segurança, sem que seja fechada todas as conexões, digite a opção -s depois do comando. Ex.:

pg_ctl -D "c:/Program Files/PostgreSQL/9.2/data" stop -s

Podemos fazer a reinicialização do servidor com o mesmo comando, mudando a palavra stop por RESTART, o que desliga o servidor e reinicia o mesmo.

pg_ctl -D "c:/Program Files/PostgreSQL/9.2/data" restart -s

Criando um SBDD - PostgreSQL - DBLINK

2013-02-15T18:43:00.000-08:00

Olá galera,

vamos falar sobre Sistemas de Banco de Dados Distribuídos usando as funções de interligação de banco de dados DBLINK no PostgreSQL 9.2.

Nessa postagem, vamos ver:

- Criação de dois bancos de dados BD_A e BD_B

- Inserção da função DBLINK nos dois BD

- Interligação dos BD

- Inserção de registros para testes usando DBLINK

- Consulta em um banco de dados usando DBLINK

Bom, inicialmente vamos falar um pouco sobre banco de dados distribuídos para entender o que será desenvolvido nessa postagem e qual a funcionalidade de um sistema distribuído. Um BDD ou banco de dados distribuídos, é todo o sistema que distribua responsabilidades de gerenciamento dos dados, mas mantém uma visão global como se o sistema fosse um simples sistema de banco de dados centralizado. A distribuição dos dados pode ser feita horizontalmente quando queremos dividir grupos de registros utilizando algum critério para isso, Ex.: Salário > 6000, Idade > 65, entre outros critérios de distribuição que podem ser utilizados.

Além da distribuição horizontal, podemos em um BDD dividir as relações ou tabelas verticalmente, nessa divisão a tabela é que é dividida, e as relações mantém um identificador de união das partes que será utilizado posteriormente para a recuperação da tabela original. Um exemplo,

Uma tabela Cliente(id_cliente, nome, rua, numero, bairro, cidade, estado, ddd, telefone)

Podemos dividi-la assim:

CLIENTE(id_cliente, nome)

CLIENTE(id_cliente, rua, numero, bairro, cidade, estado)

CLIENTE(id_cliente, ddd, telefone)

Na sequencia, podemos recuperar ela utilizando o identificador chave id_cliente para juntar as partes utilizando o comando de junção no SQL JOIN, sobre JOIN.

Exemplo

SELECT C1.ID_CLIENTE, C1.NOME, C2.RUA, C2.NUMERO, C2.BAIRRO, C2.CIDADE, C2.ESTADO, C3.DDD, C3.TELEFONE

FROM CLIENTE C1, CLIENTE C2, CLIENTE C3

WHERE C1.ID_CLIENTE = C2.ID_CLIENTE

AND C3.ID_CLIENTE = C2.ID_CLIENTE;

Esse comando recupera a tabela original juntando as partes delas, claro que esse conhecimento das partes e de como está distribuída a tabela são essenciais.

Esse comando acima precisa das funções DBLINK e das conexões com cada uma das bases de dados que armazene cada uma das tabelas. Mas não será o foco dessa postagem. Caso queiram postem comentários que eu crio um post específico para esse tema sobre fragmentação de dados.

Bom vamos ao o que foi proposto,

- Agora que sabemos mais ou menos o que é um banco de dados distribuído, vamos criar dois bancos de dados, vamos criar na mesma máquina para exemplificar o funcionamento. Vai perceber claramente que o desenvolvimento para bancos de dados distribuídos realmente não vai mudar nada além do protocolo de identificação o IP.

Abra o PostgreSQL

Conecte-se a algum servidor e estabeleça os seguintes comandos, claro para quem não sabe como criar um banco de dados no postgres, segue o link Criando um Banco de Dados

CREATE DATABASE BD_A

ENCODING 'WIN 1252'

CONNECTION LIMIT 10;

Depois, vamos criar outro banco de dados para exemplificar os testes.

CREATE DATABASE BD_B

ENCODING 'WIN 1252'

CONNECTION LIMIT 10;

-- Bom, a primeira etapa está concluída, vamos agora compilar funções DBLINK dentro dos dois bancos de dados

Segue o link das funções DBLINK, copie o código e rode ele no seu postgres no SQL Editor.

Funções DBLINK

Você terá que executar as funções nos dois bancos de dados, para que os dois possam fazer inserção e alterações nos dados além de consultas.

--Agora, vamos interligar os bancos de dados

Para conectar ao outro banco de dados, utilizamos a função DBLINK_CONNECT que tem a seguinte sintaxe

Primeiramente vamos criar a conexão do banco de dados A com o B, então claro rode este comando no banco de dados A.

Coloque em password a senha do seu usuario claro, o que você estiver utilizando para executar os testes

SELECT DBLINK_CONNECT('conexao_bd_a_bd_b',

'hostaddr = 127.0.0.1

port = 5432

user = postgres

password = senha_do_user

dbname = BD_B');

No banco de dados B execute

SELECT DBLINK_CONNECT('conexao_bd_b_bd_a',

'hostaddr = 127.0.0.1

port = 5432

user = postgres

password = senha_do_user

dbname = BD_A');

--Bom agora, criamos duas conexões, vamos agora criar uma tabela claro, não temos tabelas ainda, já que eu não as criei antes de fazer as conexões e não só por isso, já que estamos falando sobre banco de dados distribuídos, vamos então criar nossas tabelas já utilizando as funções DBLINK_EXEC.

--No banco de dados A

SELECT DBLINK_EXEC('conexao_bd_a_bd_b', 'CREATE TABLE TB_TESTE(ID INTEGER, NOME VARCHAR)');

--Agora conectado no banco de dados B

SELECT DBLINK_EXEC('conexao_bd_b_bd_a', 'CREATE TABLE TB_TESTE(ID INTEGER, NOME VARCHAR)');

Pronto, criamos a mesma tabela nos dois bancos de dados.

--Vamos fazer a inserção de um registro agora

--No banco de dados A

SELECT DBLINK_EXEC('conexap_bd_a_bd_b', 'INSERT INTO TB_TESTE(ID, NOME) VALUES

(''1'', ''INSERÇÃO BD A NO B'')');

--Agora, no banco de dados B

SELECT DBLINK_EXEC('conexap_bd_b_bd_a', 'INSERT INTO TB_TESTE(ID, NOME) VALUES

(''1'', ''INSERÇÃO BD B NO A'')');

--Pronto, se tudo ocorreu bem, agora inserimos dois registros, um em cada banco de dados, vamos então fazer a consulta para terminar este post, eu estou com sono já =z

--Para fazer a consulta utilizamos o comando DBLINK, vamos ver como funciona na pratica

SELECT DBLINK('conexao_bd_a_bd_b', 'SELECT * FROM TB_TESTE') TB_AUXILIAR(ID INTEGER, NOME VARCHAR);

--No banco de dados B

SELECT DBLINK('conexao_bd_b_bd_a', 'SELECT * FROM TB_TESTE') TB_AUXILIAR(ID INTEGER, NOME VARCHAR);

--E pronto, realizado nossos testes, desenvolvido algum conhecimento sobre banco de dados distribuídos, espero que ajudem em alguma coisa.

Abraço

Funções DBLINK - PostgreSQL

2013-02-15T18:21:00.001-08:00

-- Adjust this setting to control where the objects get created.
SET search_path = public;

-- dblink_connect now restricts non-superusers to password
-- authenticated connections
CREATE OR REPLACE FUNCTION dblink_connect (text)
RETURNS text
AS '$libdir/dblink','dblink_connect'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_connect (text, text)
RETURNS text
AS '$libdir/dblink','dblink_connect'
LANGUAGE C STRICT;

-- dblink_connect_u allows non-superusers to use
-- non-password authenticated connections, but initially
-- privileges are revoked from public
CREATE OR REPLACE FUNCTION dblink_connect_u (text)
RETURNS text
AS '$libdir/dblink','dblink_connect'
LANGUAGE C STRICT SECURITY DEFINER;

CREATE OR REPLACE FUNCTION dblink_connect_u (text, text)
RETURNS text
AS '$libdir/dblink','dblink_connect'
LANGUAGE C STRICT SECURITY DEFINER;

REVOKE ALL ON FUNCTION dblink_connect_u (text) FROM public;
REVOKE ALL ON FUNCTION dblink_connect_u (text, text) FROM public;

CREATE OR REPLACE FUNCTION dblink_disconnect ()
RETURNS text
AS '$libdir/dblink','dblink_disconnect'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_disconnect (text)
RETURNS text
AS '$libdir/dblink','dblink_disconnect'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_open (text, text)
RETURNS text
AS '$libdir/dblink','dblink_open'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_open (text, text, boolean)
RETURNS text
AS '$libdir/dblink','dblink_open'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_open (text, text, text)
RETURNS text
AS '$libdir/dblink','dblink_open'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_open (text, text, text, boolean)
RETURNS text
AS '$libdir/dblink','dblink_open'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_fetch (text, int)
RETURNS setof record
AS '$libdir/dblink','dblink_fetch'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_fetch (text, int, boolean)
RETURNS setof record
AS '$libdir/dblink','dblink_fetch'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_fetch (text, text, int)
RETURNS setof record
AS '$libdir/dblink','dblink_fetch'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_fetch (text, text, int, boolean)
RETURNS setof record
AS '$libdir/dblink','dblink_fetch'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_close (text)
RETURNS text
AS '$libdir/dblink','dblink_close'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_close (text, boolean)
RETURNS text
AS '$libdir/dblink','dblink_close'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_close (text, text)
RETURNS text
AS '$libdir/dblink','dblink_close'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_close (text, text, boolean)
RETURNS text
AS '$libdir/dblink','dblink_close'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink (text, text)
RETURNS setof record
AS '$libdir/dblink','dblink_record'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink (text, text, boolean)
RETURNS setof record
AS '$libdir/dblink','dblink_record'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink (text)
RETURNS setof record
AS '$libdir/dblink','dblink_record'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink (text, boolean)
RETURNS setof record
AS '$libdir/dblink','dblink_record'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_exec (text, text)
RETURNS text
AS '$libdir/dblink','dblink_exec'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_exec (text, text, boolean)
RETURNS text
AS '$libdir/dblink','dblink_exec'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_exec (text)
RETURNS text
AS '$libdir/dblink','dblink_exec'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_exec (text,boolean)
RETURNS text
AS '$libdir/dblink','dblink_exec'
LANGUAGE C STRICT;

CREATE TYPE dblink_pkey_results AS (position int, colname text);

CREATE OR REPLACE FUNCTION dblink_get_pkey (text)
RETURNS setof dblink_pkey_results
AS '$libdir/dblink','dblink_get_pkey'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_build_sql_insert (text, int2vector, int, _text, _text)
RETURNS text
AS '$libdir/dblink','dblink_build_sql_insert'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_build_sql_delete (text, int2vector, int, _text)
RETURNS text
AS '$libdir/dblink','dblink_build_sql_delete'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_build_sql_update (text, int2vector, int, _text, _text)
RETURNS text
AS '$libdir/dblink','dblink_build_sql_update'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_current_query ()
RETURNS text
AS '$libdir/dblink','dblink_current_query'
LANGUAGE C;

CREATE OR REPLACE FUNCTION dblink_send_query(text, text)
RETURNS int4
AS '$libdir/dblink', 'dblink_send_query'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_is_busy(text)
RETURNS int4
AS '$libdir/dblink', 'dblink_is_busy'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_get_result(text)
RETURNS SETOF record
AS '$libdir/dblink', 'dblink_get_result'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_get_result(text, bool)
RETURNS SETOF record
AS '$libdir/dblink', 'dblink_get_result'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_get_connections()
RETURNS text[]
AS '$libdir/dblink', 'dblink_get_connections'
LANGUAGE C;

CREATE OR REPLACE FUNCTION dblink_cancel_query(text)
RETURNS text
AS '$libdir/dblink', 'dblink_cancel_query'
LANGUAGE C STRICT;

CREATE OR REPLACE FUNCTION dblink_error_message(text)
RETURNS text
AS '$libdir/dblink', 'dblink_error_message'
LANGUAGE C STRICT;

Agradecimento - 12-02-2013 - 15 mil acesso

2013-02-12T10:42:00.001-08:00

Olá Pessoal, para todos os visitantes deste blog, eu gostaria de agradecer pois é por causa de cada visita que surgem as motivações para continuar postando conhecimentos aqui na rede.

Eu sou estudante do curso superior de Tecnologia em Banco de Dados pela FATEC Mococa, e tenho muito prazer de poder compartilhar cada um de nossos aprendizados com todos, desde uma simples consulta a uma tabela em um banco de dados centralizado até a grandes consultas avançadas com junção de tabelas em banco de dados diferentes distribuídos por localidades. Aqui é postado conhecimentos que se interligado a outros conhecimentos também aqui postados dão um grande conhecimento de como resolver determinados problemas cotidianos.
A ideia deste projeto de expor os conhecimentos aqui, é acima de tudo uma iniciativa de contribuir de alguma maneira para o desenvolvimento do aprendizado, acima de tudo o aprendizado.
Como não tenho tanto para quem dizer sobre banco de dados, pois falar sobre banco de dados é algo que não é tão agradável assim para qualquer um, então eu resolvo postar aqui na internet para que de alguma forma possa ser compreendido, lido, seja importante em algum sentido à alguém.

E é com grande felicidade que agradeço a cada visita a este blog, afinal, não teria sentido nada sem a presença de cada um que passou por aqui.

Tudo tem um fim,
mas a capacidade de aprender não.

Gande abraço!
Que Deus abençoe a vida de cada um de vocês!

SQL - Group by and Having - PostgreSQL

2013-02-12T09:57:00.000-08:00

Olá Pessoal,
em relatórios complexos sempre utilizaremos a clausula GROUP BY para realizar o agrupamento de informações. Sendo assim, vamos então exemplificar o funcionamento desse grande comando do SQL.

Para nosso exemplo, vamos utilizar as seguintes tabelas

TB_CLIENTE
id_cliente INTEGER PRIMARY KEY,
nome VARCHAR NOT NULL,
cpf VARCHAR(14) NOT NULL UNIQUE

TB_PRODUTOS
id_produto INTEGER PRIMARY KEY,
ds_produto VARCHAR NOT NULL,
preco_produto NUMERIC(10,2)

TB_COMPRAS
id_compra INTEGER NOT NULL,
id_cliente INTEGER NOT NULL,
dt_compra DATE NOT NULL,
id_produto INTEGER FOREIGN KEY REFERENCES TB_PRODUTOS

suponha que os seguintes dados estão armazenados

tb_cliente
1, NOME 1, 333.333.333-33
2, NOME 2, 444.444.444-44
3, NOME 3, 555.555.555-55

tb_produtos
1, PRODUTO 1, 2.00
2, PRODUTO 2, 3.50
3, PRODUTO 3, 6.99

tb_compras
1, 1, 12-02-2013, 1
2, 2, 12-02-2013, 2
3, 3, 12-02-2013, 3
4, 3, 11-02-2013, 3
5, 2, 11-02-2013, 2
6, 1, 11-02-2013, 1
7, 1, 10-02-2013, 2
8, 2, 17-01-2013, 3
9, 3, 12-12-2012, 3

Um pouco complexo de se analisar assim, mas, para um bom entendedor não será matéria difícil.

Vamos lá aos exemplos de agrupamento.
Ex. 1 Suponha que precisemos agrupar a quantidade de compras de cada cliente.

Para a realização deste procedimento, será necessário fazer o agrupamento das vendas por código de cliente, assim, o número de vendas por clientes será contado pela função COUNT

Ex.: SELECT id_cliente, COUNT(id_cliente)
FROM TB_COMPRAS
GROUP BY id_cliente;

Pronto! Esta seria a solução para o nosso problema inicialmente proposto.

Vamos a um segundo exemplo,
Ex 2 Suponha que precisemos saber o número de compras de cada cliente por dia

Nesse caso, será necessário fazer o agrupamento das vendas por dia e assim, contar quantas vendas por dia cada cliente fez.

Ex.: SELECT id_cliente, dt_compra, count(id_cliente)
FROM TB_COMPRAS
GROUP BY dt_compra, id_cliente;

Pronto! Mais uma resolução de um de nossos problemas.

Acho que com essas utilizações podemos utilizar nosso auto conhecimento para imaginar quais outras oportunidades de utilização.

Vamos neste post, deixar assim como GROUP BY vamos seguir a diante falar um pouco do que é o HAVING.

O HAVING é para o GROUP BY o que o WHERE é para o SELECT, assim para os entendedores, não será necessário falar muito sobre o mesmo.

A utilização do HAVING só poderá ser realizada em conjunto com a função de agrupamento GROUP BY, em nenhuma outra ocasião será utilizado o comando HAVING.

Espero que seja útil.
Abraço

GREATEST and LEAST - Oracle 11g

2013-01-05T07:27:00.001-08:00

Saudações Pessoal,
vamos falar sobre essas outras duas funções importantes do Oracle que será umamão na roda quando houver a necessidade de verificar o maior e ou o menor valor de uma lista.

A função GREATEST retorna o maior valor em uma lista, mas não confunda com a função MAX,
ela retornará o maior valor de uma lista especificada na consulta.

Ex.:
SELECT GREATEST(1, 2, 3, 4, 5, 11, 20)
FROM DUAL;

Retornará o valor 20 dessa lista.

A função LEAST é contrária a função GREATEST e por tanto, retornará o menor valor de uma lista, mas não confunda com a função MIN.

Ex.:

SELECT LEAST(1, 2, 3, 4, 5, 11, 20)
FROM DUAL;

Retornará o valor 1, pois é o menor na lista especificada.
Bom pessoal, é isso ai.
Abraço

SQRT Oracle 11g

2013-01-05T07:18:00.001-08:00

Olá Pessoal,
O SGBD Oracle 11g possui inúmeros metodos com inúmeras utilizações, uma delas é a obtenção da raiz quadrada de um determinado valor usando a função SQRT.
Para selecionarmos valores e automaticamente obter sua raiz quadrada precisamos somente passar o valor a função SQRT para que o valor seja obtido.
Exemplo:

Selecionar a raiz quadrada do salario de cada funcionário da empresa.

SELECT SQRT(salario)
FROM tb_funcionarios
WHERE fg_ativo = 1;

A utilização dessa função segue da mesma maneira.

Download NetBeans 7.2.1

2013-01-02T19:28:00.001-08:00

Faça o download da IDE aqui mesmo do blog,
Clique aqui para fazer o download..

Descrição do download
NetBeans 7.2.1 Instalador para Windows/Português (Brasil) (pt_BR)
netbeans-7.2.1-ml-windows.exe (239.9 MB)

Vamos começar a desenvolver postagens sobre desenvolvimento de software, usando essa ferramenta.
Até mais

Download PostgreSQL 9.2.2 - Links

2013-01-02T19:19:00.002-08:00

CONSTRAINTS PRIMARY AND FOREIGN KEY - ORACLE

2012-12-27T13:49:00.001-08:00

Olá pessoal, vamos falar um pouco sobre contraints no oracle 11g, criando ela na tabela, ou adicionando ela após a tabela criada.

Inicialmente vamos iniciar uma demonstração de como inserir uma constraint foreign key, ou uma restrição de chave estrangeira, na criação da tabela. Vamos ao exemplo:

--Criando uma tabela modelo.

CREATE TABLE TB_MODELO(

id_modelo INTEGER,

CONSTRAINT PK_TB_MODELO PRIMARY KEY (id_modelo)

);

--Criando agora uma tabela com a restrição de chave estrangeira.

CREATE TABLE TB_TESTE(

id_teste INTEGER PRIMARY KEY,

id_modelo INTEGER,

CONSTRAINT FK_TB_MODELO FOREIGN KEY(id_modelo) REFERENCES TB_MODELO(id_modelo)

);

Observe que eu utilizei a restrição de chave primária na criação da primeira tabela através de uma criação por comando, assim eu posso nomear minha restrição, e consequentemente ter maior controle e conhecimento posterior. Na criação da segunda tabela, a tabela onde eu crio a restrição de chave estrangeira, eu não utilizei a criação de restrição através de um comando explicito, isso faz com que o SGBD escolha qual o nome de restrição deverá ser utilizado na chave primária, ficando assim mais complicado pra encontrar a restrição posteriormente.

Observe também que eu nomeio a restrição de chave estrangeira como FK_TB_MODELO, assim sei que a restrição de chave estrangeira tem esse nome, e posso desativa-la ou mesmo exclui-la através de sua identificação.

Podemos nomear tanto a chave primária quanto a chave estrangeira, pra isso vamos fazer apenas assim:

CREATE TABLE TB_CHAVES_NOMEADAS(

id_chaves INTEGER,

id_modelo INTEGER,

id_teste INTEGER,

CONSTRAINT PK_CHAVES PRIMARY KEY(id_chaves),

CONTRAINT FK_MODELO FOREIGN KEY(id_modelo) REFERENCES TB_MODELO(id_modelo),

CONTRAINT FK_TESTE FOREIGN KEY(id_teste) REFERENCES TB_TESTE(id_teste)

);

Bom, muito bem, agora vamos mostrar como faríamos pra inserir a restrição caso a mesma não tenha sido criada.

Uma tabela sem restrição primeiramente precisa ser criada pra demonstrações,

CREATE TABLE TB_SEM_RESTRICOES(

id_sem_restricoes INTEGER

);

Nesse caso a tabela não tem chave primária e assim, os registros podem se repetir e causar conflito de informações e inconsistência de dados. Então, vamos adicionar a restrição de chave primária, o que fará com que os registros sejam exclusivos.

ALTER TABLE TB_SEM_RESTRICOES

ADD CONTRAINT PK_TB_SEM_RESTRICOES PRIMARY KEY(id_sem_restricoes);

Bom, é isso ai, assim podemos ter uma base de como trabalhar com restrições de chave primária e estrangeira no oracle.

Bom, como adicionamos uma restrição a tabela que chama-se TB_SEM_RESTRICOES alguma coisa ta errada não é? rs, alteramos o nome da tabela e também da restrição pra fechar o post.

RENAME TABLE TB_SEM_RESTRICOES TO TB_COM_RESTRICAO;

ALTER TABLE TB_COM_RESTRICAO RENAME CONSTRAINT PK_TB_SEM_RESTRICOES TO PK_TB_COM_RESTRICOES;

Enfim, terminamos nosso post.

Abraço (:

Banco de Dados Orientado a Objetos - PostgreSQL

2012-11-28T19:32:00.000-08:00

Bom pessoal, vamos falar um pouco sobre banco de dados orientado a objetos e fazer algumas demonstrações de utilizações nesta postagem.

Um banco de dados Orientado a Objetos é um banco de dados onde os dados são armazenados em forma de objetos, estruturas de dados compostas que podem ser definidas da maneira que se adeque as necessidades. Podemos criar objetos compostos por vários atributos e armazena-los como um tipo de objeto.

Para entendermos um pouco melhor e na prática, vamos criar um banco de dados para desenvolver nosso entendimento.

Cria um banco de dados chamado BDOO.

CREATE DATABASE "BDOO"
CONNECTION LIMIT 1
ENCODING 'LATIN1'
TEMPLATE = TEMPLATE0;

Vamos criar uma tabela teste que irá servir para testar os comandos, mas antes disso, vamos começar a criar os objetos tão falados de banco de dados orientados a objetos.

Cria um objeto que armazena o primeiro nome e o sobrenome, e será nomeado de NOME.

CREATE TYPE NOME AS (
primeiro_nome VARCHAR(20),
sobrenome VARCHAR(20)
);

Vamos criar um tipo de objeto chamado de ENDERECO, com os campos de um endereço.

CREATE TYPE ENDERECO AS (
rua VARCHAR(40),
numero INTEGER,
bairro VARCHAR(40),
cep VARCHAR(10),
cidade VARCHAR(40),
estado CHAR(2),
pais VARCHAR(40)
);

Vamos agora criar um tipo de objeto chamado de TELEFONE.

CREATE TYPE TELEFONE AS (
ddi CHAR(3),
ddd CHAR(3),
telefone VARCHAR(20)
);

Vamos então criar um tipo de objeto CLIENTE que contém os tipos criados a cima.

CREATE TYPE CLIENTE AS (
nm_cliente NOME,
end ENDERECO,
tel TELEFONE
);

Bom, muito bem, todos os tipos de objetos necessário para estudarmos os comandos dessa postagem estão criados, agora vamos criar uma tabela e começar a aprender um pouco sobre manipulação de dados em um banco de dados orientado a objeto.

Cria uma tabela chamada de TB_CLIENTE com o tipo de objeto cliente que contém todos os tipos que criamos e um campo chamado de fg_ativo que controlará se o cliente está ativo.

CREATE TABLE TB_CLIENTE(
client CLIENTE,
fg_ativo INTEGER
);

Agora, vamos entender que a nossa tabela TB_CLIENTE contém um objeto do tipo cliente, que contém os tipos NOME, ENDERECO e TELEFONE, então vamos começar a inserir um dado para entendermos de que maneira a criação dos tipos de objetos contribuem na estruturação de uma tabela.

Insere um registro na tabela TB_CLIENTE.

INSERT INTO TB_CLIENTE (
cliente.nome.primeiro_nome,
cliente.nome.sobrenome,
cliente.endereco.rua,
cliente.endereco.numero,
cliente.endereco.bairro,
cliente.endereco.cep,
cliente.endereco.cidade,
cliente.endereco.estado,
cliente.endereco.pais,
cliente.telefone.ddi,
cliente.telefone.ddd,
cliente.telefone.telefone,
fg_ativo) VALUES
('Nome',
'Sobrenome',
'Minha Rua',
100,
'Meu Bairro',
'13700-000',
'Minha cidade',
'SP', 'Brasil',
'55',
'19',
'0000-0000',
1);

Pronto, inserimos nosso primeiro registro na tabela, vamos começar a fazer consultas agora em um banco de dados orientado a objeto.

Consultar somente o nome e sobrenome dos clientes.

SELECT (TB_CLIENTE).client.nome.primeiro_nome,
(TB_CLIENTE).client.nome.sobrenome
FROM TB_CLIENTE
WHERE fg_ativo = 1;

Ok, agora vamos consultar o nome e a cidade de um cliente.

SELECT (TB_CLIENTE).client.nome.primeiro_nome,
(TB_CLIENTE).client.endereco.cidade
FROM TB_CLIENTE
WHERE fg_ativo = 1;

Vamos agora recuperar os dados dos clientes por completo para finalizar essa postagem.

SELECT (TB_CLIENTE).client.nome.*,
(TB_CLIENTE).client.endereco.*,
(TB_CLIENTE).client.telefone.*
FROM TB_CLIENTE
WHERE fg_ativo = 1;

Poderiamos escrever todos os campos e recuperar os mesmos dados do comando acima, por tanto, espero que tenha sido útil essa postagem pra demonstrar como utilizar banco de dados orientado a objeto e como manipular dados nesses tipos de banco de dados.

Qualquer dúvida sinta-se a vontade para postar seu comentário.
Abraço.

Função NVL2 Oracle 11g

2012-09-30T10:39:00.001-07:00

Olá, a função:

NVL2(x, 'valor não nulo', 'valor_nulo')

serve para retornar strings de substituição para valores nulos e não nulos.

Um exemplo de NVL2 seria, verificar uma lista de telefones dos clientes, alguns clientes não possuem telefone celular por tanto será trocado por uma mensagem.

Exemplo

SELECT NVL2(nro_celular, 'Têm celular', 'Não Têm celular')
FROM clientes;

Espero que entendam a utilização dessa função com esse simples exemplo.
Abraço!

Variáveis Oracle - ACCEPT, &, DEFINE E UNDEFINE

2012-09-30T10:31:00.002-07:00

Utilizando variáveis numa Query Oracle

SELECT &VAR_1, &VAR2
FROM &TABELA
WHERE &CONDICAO;

O & força a inserção de valores para os campos que o contém,
a utilização de variáveis pode ser permanente, para isso o comando de declaração de variaveis permanente seria

DEFINE v_minha_variavel = 1;

ai na query ficaria

select *
from clientes
where id_cliente = v_minha_variavel;

UNDIFINE v_minha_variavel;

Podemos utilizar uma mensagem na obtenção dos valores, para isso o comando seria

ACCEPT v_nome_variavel NUMBER FORMAT 99 PROMPT 'Digite o ID do cliente:';

E então a consulta ficaria assim

select *
from clientes
where id_cliente = v_nome_variavel;

Função REPLACE Oracle - SQL

2012-09-30T10:28:00.002-07:00

Função REPLACE(x, variável_de_busca, variável_de_substituicao)

Função replace é muito utilizada para gerar relatórios, a função replace não altera os valores reais na tabela, somente altera os valores na consulta.

Um exemplo, procurar o sobrenome Thomaz e substituir por "é da família'

SELECT REPLACE(sobrenome_cliente, 'Thomaz', 'é da família')
FROM clientes;

é isso ai

EQUIJOIN Oracle 11g - SQL 86 - 92 (WHERE and JOIN)

2012-09-25T15:28:00.001-07:00

Olá Pessoal, vamos falar um pouco sobre junções de igualdade EQUIJOINS utilizando o Oracle 11g.
As junções de igualdade ou como comumente conhecidas EQUIJOINS são utilizadas para unir tuplas com igualdade em alguma das colunas.

Vamos verificar o código de junção de igualdade SQL 86 utilizando WHERE

SELECT c.id_cliente, c.nome, co.data_compra
FROM clientes c, compras co
WHERE c.id_cliente = co.id_cliente;

A mesma consulta pode ser escrita utilizando SQL 92 e o comando INNER JOIN ON

SELECT c.id_cliente, c.nome, co.data_compra
FROM clientes c
INNER JOIN compras co ON (c.id_cliente = co.id_cliente);

A mesma consulta poderia ser escritas utilizando outros tipos de junção mas não é o foco desta postagem.
Abraço!

Operador MONTHS_BETWEEN - Oracle 11g - SQL

2012-09-24T17:43:00.000-07:00

Olá Pessoal,

vamos conhecer um pouco sobre algumas funções dessa poderosa ferramenta de gerenciamento de banco de dados o Oracle 11g.

Vamos a um exemplo simples, a função MONTHS_BETWEEN como o próprio nome traduzido ao português diz, é utilizada para verificar os meses entre uma determinada data e outra.

A função MONTHS_BETWEEN(x, y) também recebe dois parâmetros, data x e data y, a função verifica a quantidade de meses existentes entre as duas datas.

Exemplo:

Verificar a quantidade de meses de cadastro de um determinado cliente.

Para isso vamos utilizar a data atual e a data de cadastro do cliente.

Vamos a consulta:

SELECT MONTHS_BETWEEN(CURRENT_DATE, data_cadastro) as "Meses de cadastro"

FROM clientes;

A função irá retornar a quantidade de meses entre as duas datas e assim, demonstrará a quantidade de meses de cadastro de cada cliente na tabela.

Após a função MONTHS_BETWEEN foi utilizado um AS que serve pra apelidar o campo de consulta para Meses de cadastro.

Bom galera, é isso ai.

Abraços!

Função NVL Oracle 11g - SQL

2012-09-24T17:32:00.001-07:00

Olá galera,
este blog tem o objetivo de expor alguns métodos específicos de determinados SGBD, nesse post, vamos falar um pouco sobre a função NVL do Oracle.

A função NVL é utilizada quando queremos imprimir uma mensagem em determinadas linhas em que o campo especificado for nulo.
No exemplo a seguir, vamos exemplificar a função NVL para aqueles telefones que forem nulos,
os campos ao invés de ficarem em branco, serão demonstrados com a seguinte mensagem: "Telefone Nulo".

Vamos ao exemplo, a sintaxe desse comando é tranquilamente simples, a função NVL recebe dois parâmetros, NVL(x, y) o x no caso, é o campo que verificaremos valores nulos, o campo y será o valor que será atribuído caso o campo especificado em x seja realmente nulo.

No nosso exemplo a consulta ficaria da seguinte maneira:

SELECT NVL(telefone, "Telefone Nulo")
FROM clientes;

Bom galera, o exemplo da função pode ser aplicado a qualquer tipo de consulta que envolva valores nulos.
Espero ter ajudado.

Abraço!

Função que retorna múltiplos valores - PostgreSQL - PLPGSQL

2012-09-18T15:56:00.004-07:00

Saudações Pessoal,

Vamos falar um pouco mais sobre funções utilizando a linguagem de programação de banco de dados PLPGSQL do PostgreSQL.
Vamos dar um exemplo de uma função que retorna TODOS valores de uma tabela clientes.
O comando SETOF nome_tabela serve para especificar o tipo de retorno da função, no caso esse exemplo abaixo serve para listar tipos de objetos clientes.

CREATE OR REPLACE FUNCTION FN_CLIENTES(CODCLIENTE INTEGER) RETURNS SETOF CLIENTES AS
$$
BEGIN
RETURN QUERY SELECT * FROM CLIENTES;
END;
$$
LANGUAGE PLPGSQL;

Desas maneira, poderão ser retornados todos os campos de uma determinada tabela.
Para dropar uma função, o comando é DROP FUNCTION nome_função(tipo);

Erro, serviço não está escutando. - PostgreSQL 9.0

2012-09-18T06:47:00.002-07:00

Simplesmente podemo corrigir esse problema na versão 9.0 com um simples clique com o botão esquerdo em cima do servidor no PgAdmin 3 e START SERVICE.
Ou se necessário for, pode STOP SERVICE, caso queria.

Simples assim.

DKLINK CONNECT, DBLINK DISCONNECT E DBLINK EXEC - PostgreSQL

2012-09-18T06:40:00.002-07:00

Saudações Pessoal,
Aprendemos um pouco sobre dblink em alguns posts anteriores e nesse, iremos aprender a executar comandos dcl, dml, e ddl através das funções DBLINK_EXEC().

Vamos entender pra que serve, a função dblink_exe() é responsável por efetuar comandos na base de dados remota, comandos que surjam algum efeito permanente.

Vamos exemplificar
* Inserir registros em uma tabela de um banco de dados remoto.

Sintaxe básica
SELECT dblink_exec('nome_da_conexao', 'comando_sql');

--Criando uma conexão
dblink_connect('Conexao_SP',
'hostaddr = 127.0.0.1
port = 5432
user = postgres
password = senha
dbname = BANCO_SP');

Uma vez criada a conexão, deverá fecha-la se necessitar restabelece-la.
O comando que finaliza uma conexão é o dblink_disconnect('nome_da_conexão');
--Comando Insert Into

SELECT dblink_exec('Conexao-SP', 'INSERT INTO clientes (codcliente, nome, datacadastro) VALUES (1, ''Marcelo'',''18-09-2012'');');

Função UPPER and LOWER - Oracle

2012-09-17T17:02:00.000-07:00

Olá galera, pra quem quer saber pra que ser e como funciona, a função UPPER serve para tornar maiúscula toda a string que lhe for passada como parametro Ex: UPPER(nome)
A função LOWER funciona de maneira idêntica a função UPPER, porém torna minúsculas as palavras. Ex: LOWER(nome)

Exemplificando na prática:

SELECT LOWER(nome)
FROM clientes;

SELECT UPPER(nome)
FROM clientes;

Operador IN - SQL - Oracle - PostgreSQL

2012-09-17T16:57:00.003-07:00

O Operador IN no oracle assim como em vários outros SGBDs, como PostgreSQL, SQL SERVER entre outros,funciona da seguinte maneira:

Os campos que estiverem dentro da condição IN serão retornados na consulta, o operador IN serve como um tipo de vetor de verificação, todos os valores dentro de IN serão verificados na clausula SQL.

Exemplo:
Verificar todos os alunos cuja a média deles sejam 10, 9 e 8.

SELECT nome
FROM alunos
WHERE media IN (10, 9, 8);

Este comando serve também para verificar Strings:

SELECT *
FROM clientes
WHERE estado IN ('RJ', 'SP');

DBLINK Função de Seleção - PostgreSQL

2012-09-17T16:48:00.001-07:00

Olá Pessoal,
inicialmente eu apresentei a função de conexão com outro banco de dados, agora, vamos aprender a função de seleção em um banco de dados remoto.

A função DBLINK serve para consultar dados em banco de dados remoto, a sua utilização é simples, basta ter uma conexão estabelecida, e especificar o comando de seleção que deseja, seguido por uma tabela virtual que será responsável por receber os dados resultantes da consulta.

Exemplo:
Vamos fazer uma consulta em uma tabela clientes, que está em um banco de dados remoto.

Inicialmente, estabelecemos a conexão:

SELECT DBLINK_CONNECT('conexao',
'hostaddr = 127.0.0.1 port = 5432 user = postgres password = senha dbname = BANCO_REMOTO);

Após a conexão estabelecida, podemos então consultar nossa tabela com o comando DBLINK.
Suponha que a tabela clientes tenha os campos(codcliente, nome, cidade, estado).
Para realizar a consulta, teríamos a seguinte sintaxe:

SELECT DBLINK('conexao', 'SELECT * FROM CLIENTES') TB_VIRTUAL(codcliente integer,
nome varchar(50), cidade varchar(50), estado char(2));

Obs.: O número de campos da tabela virtual deve ser precisamente o mesmo número de campos que será retornado da consulta.

Bom galera é isso ai, Abraço!

Função PL/pgSQL - PostgreSQL - Function

2012-09-12T22:27:00.001-07:00

Vamos dar exemplos de como utilizar funções no PostgreSQL.
Primeiro, uma função é demonstrada para que possamos entender algumas funcionalidades.

Os comandos SQL estão em negrito, em verde, os comentários, os demais são objetos e operadores.

Tabela Clientes

--Esta função faz a replicação dos campos de uma tabela cliente para outra tabela bkpcliente

create or replace function fn_replica returns void as
$$/*inicia o bloco da função*/
declare /*contém as declarações da função*/

contador integer;/*é utilizado para incrementar de 1 ao número de clientes*/
client integer;/*utilizada para carregar a quantidade de clientes que o loop deverá percorrer*/

begin /*inicia o procedimento*/

select count(*) /* seleciona o quantidade total de clientes no caso */
into client
from clientes;

contador = 1;/*inicia o contador em 1*/

loop/*inicia o laço de repetição*/

insert into bkpclientes(codcliente, nome, endereco,bairro, cep, cidade,estado, datacadastro)
values
  (contador,/*codcliente*/
  (select nome from clientes where codcliente = contador),/*nome*/
  (select endereco from clientes where codcliente = contador),/*endereço*/
  (select bairro from clientes where codcliente = contador),/*bairro*/
  (select cep from clientes where codcliente = contador),/*cep*/
  (select cidade from clientes where codcliente = contador),/*cidade*/
   (select estado from clientes where codcliente = contador),/*estado*/
   (select datacadastro from clientes where codcliente = contador)/*datacadastro*/
);/*finaliza o insert*/

raise notice 'Cliente Nº % inserido.', contador;/*imprime uma mensagem de confirmação*/
exit when contador = client;/*limita o loop quando o contador atingir o nº de clientes*/
contador := contador+1;/*incrementa o contador*/

end loop;/*finaliza o laço de repetição*/

end;/*encerra o procedimento*/

$$/*termina o bloco da função*/

language plpgsql;

Mensagem de Resultado das inserções.

Tabela Bkpclientes

Bom, é isso ai, pra quem queria conhecer alguma coisa de function no PostgreSQL ou relembrar, espero ter ajudado.

Operador ALL - SQL - Oracle 11g

2012-09-11T21:01:00.000-07:00

O operador ALL verifica se o valor especificado é igual a todos os valores dentro do operador all

Exemplo:

SELECT NM_CLIENTE, ESTADO

FROM CIDADES

WHERE ESTADO <> ALL ('SP', 'RJ');

Este comando ira recuperar todas as tuplas que contenham estado diferente de SP e RJ.

SELECT *

FROM PRODUTOS

WHERE PRECO_CUSTO <> ALL (1.99, 2.99, 10.00);

Retorna todas tuplas diferentes de todos esses valores, 1.99, 2.99, e 10.00.