[PostgreSQL] - Tablespaces

Enquanto os esquemas dividem um banco de dados em particionamentos lógicos, o tablespace divide um banco de dados fisicamente. Tablespace no PostgreSQL é uma pasta no sistema de arquivos utilizada para armazenamento físico dos dados e objetos de um banco de dados.

Ao se criar um banco de dados no PostgreSQL são criados dois tablespaces:
- PG_DEFAULT - por padrão, quando não é definido explicitamente um tablespace, os dados e objetos são armazenados no tablespace PG_DEFAULT.
- PG_GLOBAL - armazena objetos globais, visíveis a todos os bancos

Um tablespace pode armazenar dados de diversos bancos de dados, desde que se tenha permissão para acesso aos mesmos. Um banco de dados também pode dividir seus objetos e dados entre vários tablespaces.

Os tablespaces são utilizados para:
- Gerenciamento de espaço de armazenamento de dados - pode-se armazenar bancos grandes em mídia com tamanho apropriado que esteja disponível na rede.
- Melhor desempenho - objetos que sofrem mais acessos podem ser alocados em discos mais rápidos, por exemplo, com ganho substancial de desempenho.

Os principais comandos relacionados são:
- CREATE TABLESPACE - Criação de tablespaces
- DROP TABLESPACE - Exclusão de tablespaces sem conteúdo

Para visualizar a lista de tablespaces do seu servidor PostgreSQL, basta se fazer uma consulta na tabela pg_tablespace.

Exemplo:

1 - Recuperação do identificador de objeto e dos dados dos tablespaces do servidor.

SELECT oid, * FROM pg_tablespace;

2 - Recuperando o Tablespace e o usuário que tem permissão de owner do tablespace

SELECT T.oid, T.spcname, T.spcowner, U.usename
FROM pg_tablespace T, pg_user U
WHERE T.spcowner = U.usesysid;

Fonte:
http://postgresqlbr.blogspot.com.br/2007/06/tablespaces-no-postgresql.html

[PostgreSQL] - Comando SHOW

O PostgreSQL tem dúzias de variáveis de configuração que tem influência no comportamento do banco, em sua segurança e no desempenho. Acompanhar estes parâmetros de forma simples permite melhor controle do funcionamento do servidor.

O Comando SHOW é uma extensão do PostgreSQL que facilita este acompanhamento. Este comando permite que se visualize todos os valores das variáveis de configuração do seu banco de dados. O autovacuum está ativado? Qual é o estilo de data que está sendo utilizado no momento? Perguntas como essa são facilmente respondidas pela utilização deste comando.

Problemas conhecidos:
- Este comando não permite a cláusula WHERE. Desta forma recuperamos todas as dezenas de parâmetros ou apenas parâmetros específicos, um de cada vez.
- O comando não aceita recuperar uma lista de parâmetros definida pelo usuário (SHOW par1, par2,..., parN).
- Testes com os comandos SELECT, UNION e SELECT INTO não funcionaram, isto é, não é possível utilizar o SHOW com estes comandos.

Sintaxe:

SHOW name
SHOW ALL

Exemplos:

1 - Mostrando todos os parâmetros de configuração

SHOW ALL;

2 - Mostrando parâmetros específicos

SHOW array_nulls;
SHOW autovacuum;

[PostgreSQL] - Overview dos Processos e Estrutura

[PostgreSQL] - Movendo Tabelas, Índices para Tablespaces e Domínios para schema

Bom pessoal, segue abaixo uma forma automatizada para movimentação de tabelas, índices e domínios no PostgreSQL:

-- Mover tabelas para Tablespace específica no PostgreSQL:
SELECT 'ALTER TABLE ' || table_schema || '.' || table_name || ' SET TABLESPACE tbs_zeustab;'
    FROM information_schema.tables
    WHERE table_schema = 'public'
    ORDER BY table_name;

-- Mover Índices para Tablespace específica no PostgreSQL:
SELECT 'ALTER INDEX ' || schemaname || '.' || indexname || ' SET TABLESPACE tbs_zeusindx;'
    FROM pg_catalog.pg_indexes
    WHERE schemaname = 'pagila' and tablespace is null
    ORDER BY tablename;

-- Mover Dominios para Schema específico no PostgreSQL:
SELECT 'ALTER DOMAIN ' || domain_schema || '.' || domain_name || ' SET SCHEMA pagila;'
    FROM information_schema.domains
    WHERE domain_schema = 'pagila'
    ORDER BY domain_name;

[Oracle] - Comandos de ARCHIVE LOG no SQL*PLUS

Para verificar se a base de dados está em modo de archive log, use os comandos abaixo para consulta no SQL*PLUS:

archive log list
archive log stop
archive log start
archive log next
archive log all
archive log n

[PostgreSQL] - Efetuando Backup

1) Backup de BD
  # Comando de Backup dos BD
  # -v VERBOSE DA CONEXÃO
  # -o OIDS, ????????? PRECISA REALMENTE  OU SÓ SE TIVER "lo" ??????
  # -b "lo", BLOBS 
  # -i IGNORAR VERSAO
  # -Z1 a Z9 COMPRIME O BACKUP, 0=MENOR, 9=MAIOR COMPRESSAO.
  # -Fc TIPO DE ARQUIVO "c" CUSTOMIZADO PARA ARMAZENAR OS BLOBS
  # -f ARQUIVO DE DESTINO
  # -W SOLICITA SENHA PARA AUTENTICAÇÃO
  pg_dump -h 127.0.0.1 -U postgres -W -v -o -b -i -Z9 -Fc -f "c:\dump\backup_zeus.sql" "zeus" 2> "c:\dump\backup_zeus.log"
  
  # Comando de Backup dos BD
  # --host  INFORMA O HOST/SERVIDOR QUE IRÁ CONECTAR
  # --port  INFORMA A PORTA UTILIZADA PELO HOST/SERVIDOR
  # --username  INFORMA USUÁRIO UTILIZADO PARA O BACKUP
  # --ignore-version  IGNORA VERSAO
  # --verbose  VERBOSE DA CONEXÃO
  # --file     INFORMA LOCAL DE ARMAZENAMENTO DO BACKUP
  # --blobs    INFORMA QUE SERÁ FEITO BACKUP DE OBJETOS BINÁRIOS
  # --format   INFORMA O TIPO DE ARQUIVO PARA ARMAZENAMENTO DO BACKUP "t" COMPACTADO, "p" TEXTO PLANO, "c" CUSTOMIZADO
  pg_dump --host=localhost --port=5432 --username=postgres -W --ignore-version --verbose --file="C:\dump\backup_zeus.sql" --blobs --format=c "zeus" 2> "c:\dump\backup_zeus.log"

2) Backup das Variaveis Globais (Permissoes, Usuarios e Grupos)
  # Comando de Backup das Permissoes, Usuarios e Grupos
  pg_dumpall -g -i -v -h 127.0.0.1 -U postgres -W > "c:\dump\backup_zeus_meta.sql" 2> "c:\dump\backup_zeus_meta.log"

[MySQL] - Habilitando acesso remoto ao servidor

Dica velha que de vez em quando é necessário relembrar, por isso vou deixar registrado aqui para não ter que ficar procurando no google sempre que precisar.

Executar todos os passos abaixo como root:

1 – Edite o arquivo:
/etc/mysql/my.cnf

2 – Altere a seguinte linha:
bind-address = 127.0.0.1
Deixando assim:
bind-address = 0.0.0.0

3 – Reinicie o Mysql
# /etc/init.d/mysql restart

4 – Vamos agora dar GRANT no usuário root, logue no mysql:
# mysql -u root -p

5 – Após se logar, digite o seguinte comando:
GRANT ALL ON *.* TO root@'%' IDENTIFIED BY 'sua_senha';

Dessa forma você libera o acesso ao seu servidor Mysql vindo de qualquer máquina externa, caso queira liberar somente o acesso da sua máquina, é só verificar qual é seu IP e entrar com o comando:

GRANT ALL ON *.* TO root@'192.168.0.2' IDENTIFIED BY 'sua_senha';

6. Após isso, basta dar uma reiniciada novamente no Mysql e realiazar a conexão remota.
# /etc/init.d/mysql restart

====================================================

Caso você queira desfazer o acesso remoto é bem simples também.

1 – Altere a seguinte linha:
bind-address = 0.0.0.0
Deixando assim:
bind-address = 127.0.0.1

2. Logue no Mysql:
# mysql -u root -p

3. Delete todos os privilégios remotos:
DELETE FROM mysql.user WHERE User = 'root' AND Host = '%';
FLUSH PRIVILEGES;

4. Reinicie o Mysql e pronto, não estará mais acessível remotamente.

Fonte:
http://jf.eti.br/habilitando-acesso-remoto-ao-servidor-mysql/

[Oracle] - Alterando Tablespaces de tabelas e índices

A tarefa é trivial, mas não é algo que você faz todo dia. Então resolvi documentar aqui para facilitar a minha vida. Há várias formas diferentes de se rearranjar tablespaces. Com a popularização dos RAIDs, não é mais tão comum ficar dividindo tablespaces através de discos isolados, mas ainda assim, há bons motivos para você criar todos os objetos em apenas um tablespace:

• O backup on-line pode ser feito um tablespace por vez, diminuindo a quantidade de logs gerados durante o backup;
• Você pode transportar tablespaces entre bases (teste e produção por exemplo) sem ter que exportar e importar todos os dados;
• Você pode utilizar diferentes parâmetros de storage, particionamento, etc;
• Fica mais fácil monitorar o crescimento da base com várias aplicações se cada aplicação possuir suas próprias tablespaces;
• Separar índices de tabelas ainda é uma boa política, especialmente porquê os índices podem ser reconstruídos e as tabelas não;
• Objetos especiais como LOBs e dados estáticos são bons candidatos a terem seu próprio tablespace;

Assim sendo, é comum você pegar uma tabela que cresceu muito e alocar um tablespace só para ela e coisas do tipo. Particularmente, quando os desenvolvedores tem a liberdade de criar objetos no ambiente de testes (sim, isso é polêmico e fonte para outra conversa), é comum ter que ajustar os parâmetros de storage antes de colocar os objetos no ambiente de homologação ou produção. Seja qual for o motivo da movimentação, você terá que fazer a migração em 3 etapas:

• Migrar tabelas com o comando:
  
  ALTER TABLE nome_da_tabela MOVE TABLESPACE nome_do_novo_tablespace;

• Migrar índices com o comando:
  
  ALTER INDEX nome_do_indice REBUILD TABLESPACE nome_do_novo_tablespase;

• Migrar LOBs com o comando:
  
  ALTER TABLE nome_da_tabela MOVE LOB(nome_da_coluna_lob) STORE AS (nome_do_novo_tablespace);

Note tabelas que contem LOBs, possuem um índice que aparece na tabela DBA_INDEXES com data_type do tipo LOB. Se você tentar reconstruir estes índices em outro tablespace você terá um erro do tipo: “ORA-02327: cannot create index on expression with datatype LOB”. Por isso é importante a etapa de migração dos LOBs.

Segue aqui um script para fazer isso rapidamente num para todos objetos de um determinado esquema:

SELECT 'ALTER TABLE nome_do_esquema.' || table_name || ' MOVE TABLESPACE nome_do_novo_tablespace;' FROM dba_tables WHERE owner = 'nome_do_esquema'; SELECT 'ALTER INDEX nome_do_esquema.' || index_name || ' REBUILD TABLESPACE nome_do_novo_tablespace;' FROM dba_indexes WHERE owner = 'nome_do_esquema' AND index_type != 'LOB'; SELECT 'ALTER TABLE nome_do_esquema.' || table_name || ' MOVE LOB( ' || COLUMN_NAME || ' ) STORE AS (TABLESPACE nome_do_novo_tablespace);' FROM dba_tab_columns WHERE owner = 'nome_do_esquema' AND data_type LIKE '%LOB';

[PostgreSQL] - Movendo objetos no Postgres

Quando você cria um objeto seja ele uma tabela, visão, função, etc, a não ser que você especifique o contrário, ele vai ser criado no esquema ‘public’, no tablespace ‘pg_default’ e o dono do objeto será o ‘postgres’. Dependendo da aplicação, não há nenhum problema nisso. Sério, existem aplicações que funcionam muito bem com este arranjo padrão. Mas você pode querer organizar melhor os seus objetos em diferentes esquemas, pode querer melhorar a segurança e criar donos diferentes para os objetos e pode também querer armazenar seus objetos em discos ou partições diferentes.

Note no padrão ISO esquema e dono de objeto se confundem. Isto pode ou não ocorrer no PostgreSQL dependendo de como você organizar as coisas. Note que por padrão, a variável ‘search_path’ sempre aponta para ‘$user’, public’. Ou seja, se você criar um esquema com o nome de um usuário, os objetos vão ser sempre procurados neste esquema em primeiro lugar. Se não achar lá, vai procurar no esquema public.

Bom, por algum motivo você resolveu mudar as coisas… você pode se surpreender como é simples mudar um único objeto de lugar. Imagine uma tabela ‘foo’, uma sequência ‘foo_seq’ e uma visão ‘foo_vw’ que vão ser migrados para o esquema ‘bar’, usuário ‘bar’ e tablespace ‘novo_tablespace’:

• Para mudar um objeto de esquema, basta utilizar o SET SCHEMA:
  
  ALTER TABLE foo SET SCHEMA bar;
  ALTER SEQUENCE foo_set SET SCHEMA bar;
  ALTER VIEW foo_vw SET SCHEMA bar;

• Para mudar o dono de um objeto, basta utilizar o OWNER TO
  
  ALTER TABLE foo OWNER TO bar;
  ALTER SEQUENCE foo_seq OWNER TO bar;
  ALTER VIEW foo_vw OWNER TO bar;
• Para mudar o tablespace de um objeto (no caso só se aplica para tabelas e índices, pois os demais objetos são armazenados apenas no catálogo):
  
  ALTER TABLE foo SET TABLESPACE novo_tablespace; ALTER INDEX foo_idx SET TABLESPACE novo_tablespace;

Automatizando

Claro que se você quiser migrar um conjunto enorme de objetos, você vai querer automatizar um pouco este trabalho. Aqui vou demonstrar apenas um exemplo de migração de tabelas, sequências, visões e funções para um novo esquema. Você pode migrar outros objetos como tipos, domínios, agregações, extensões, tabelas externas, operadores e outros bichos avançados do Postgres. Aqui eu coloquei apenas os objetos mais utilizados para não complicar:

-- Script para mover tabelas, sequências, visões e funções do esquema 'PUBLIC' para o esquema 'bar'
 -- Cria o esquema novo
CREATE SCHEMA AUTHORIZATION bar;
 -- Os comandos \t e \o são interpretados apenas pelo psql. 
-- São utilizados para exportar o resultado das consultas abaixo
\t
\o move.sql
SELECT 'ALTER TABLE ' || table_schema || '.' || table_name || ' SET SCHEMA bar;'
    FROM information_schema.tables
    WHERE table_schema = 'public'
    ORDER BY table_name;

SELECT 'ALTER SEQUENCE ' || sequence_schema || '.' || sequence_name || ' SET SCHEMA bar;'
    FROM information_schema.sequences
    WHERE sequence_schema = 'public'
    ORDER BY sequence_name;

SELECT 'ALTER VIEW ' || table_schema || '.' || table_name || ' SET SCHEMA bar;'
    FROM information_schema.views
    WHERE table_schema = 'public'
    ORDER BY table_name;

SELECT 'ALTER FUNCTION ' || n.nspname || '.' || p.proname || ' (' || pg_catalog.pg_get_function_arguments(p.oid) || ') SET SCHEMA bar;'
    FROM 
                  pg_catalog.pg_proc p
        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
    WHERE n.nspname = 'public'
    ORDER BY p.proname;

\o
\t
-- O comando \i é interpretado pelo psql apenas. 
-- Ele é utilizado para executar o script indicado.

\i move.sql

Navegando pelo psql

Os usuários do pgAdmin III muitas vezes ficam perdidos ao utilizarem o psql. Na verdade é mais fácil e rápido do que parece. Utilize os comandos \dn para ver os esquemas existentes na sua base, o \dp para ver as permissões nos objetos e o \db para ver os tablespaces.

Cuidado ao mover objetos grandes para um novo tablespace

Uma observação importante é que ao alterar o esquema e o dono de um objeto, apenas o registro no catálogo do sistema é alterado (mais especificamente na pg_catalog.pg_class). Então esta alteração é bem rápida. Para alterar o tablespace, além de alterar o catálogo, o postgres ainda tem de copiar o objeto fisicamente para o novo tablespace. Então, um objeto grande pode levar um bom tempo para mover.

Fonte:
http://savepoint.blog.br/movendo-objetos-no-postgres/

[PostgreSQL] - Criando Usuários, Tablespaces, Databases e Schemas

-- Criando Usuário no PostgreSQL --
CREATE ROLE zeus LOGIN
  ENCRYPTED PASSWORD 'Teste,.123'
  SUPERUSER INHERIT CREATEDB CREATEROLE REPLICATION;

-- Criando Tablespaces no PostgreSQL --
CREATE TABLESPACE tbs_zeustab OWNER zeus LOCATION 'C:\postgres\zeus\tablespaces\tab';
CREATE TABLESPACE tbs_zeusindx OWNER zeus LOCATION 'C:\postgres\zeus\tablespaces\indx';
CREATE TABLESPACE tbs_zeuslob OWNER zeus LOCATION 'C:\postgres\zeus\tablespaces\lob';

-- Criando Banco de dados vinculando os tablespace de armazenamento do usuário --
-- criando banco de dados com collate 'UTF8'
CREATE DATABASE zeus
       WITH OWNER = zeus
       ENCODING = 'UTF8'
       TABLESPACE = tbs_zeustab
       LC_COLLATE = 'Portuguese_Brazil.1252'
       LC_CTYPE = 'Portuguese_Brazil.1252'
       CONNECTION LIMIT = -1;

-- criando banco de dados com collate 'LATIN5'
CREATE DATABASE dbteste
 WITH OWNER = postgres
       ENCODING = 'LATIN5'
       TABLESPACE = pg_default
       LC_COLLATE = 'C'
       LC_CTYPE = 'C'
       CONNECTION LIMIT = -1;

-- criando banco de dados com collate 'LATIN1'
CREATE DATABASE dbteste1
  WITH OWNER = postgres
       ENCODING = 'LATIN1'
       TABLESPACE = pg_default
       LC_COLLATE = 'C'
       LC_CTYPE = 'C'
       CONNECTION LIMIT = -1;

-- Criando Schemas no PostgreSQL --

-- Schema: sisimobiliaria
-- DROP SCHEMA sisimobiliaria;
CREATE SCHEMA sisimobiliaria
  AUTHORIZATION zeus;
GRANT ALL ON SCHEMA sisimobiliaria TO zeus;

-- Schema: public
-- DROP SCHEMA public;
CREATE SCHEMA public
  AUTHORIZATION zeus;
GRANT ALL ON SCHEMA public TO zeus;
GRANT ALL ON SCHEMA public TO public;
COMMENT ON SCHEMA public
  IS 'standard public schema';        
    
-- Definido os tablespaces:
-- Para definir o tablespace, você deve procurar dois pontos importantes no seu dump ou criação: o ponto imediatamente anterior antes de criar as tabelas e o ponto imediatamente anterior a criação dos índices e constraints.

Antes da criação das tabelas coloque a seguinte linha:
SET default_tablespace = 'tbs_zeustab';

Antes da criação de índices e constraints, coloque a seguinte linha:
SET default_tablespace = 'tbs_zeusindx';

Banco de dados de Exemplo para PostgreSQL:
https://www.dropbox.com/s/qolrw6w0gcnwqdo/bd_exemplo_postgresql.zip

Documentação Oficial do PostgreSQL:
https://www.dropbox.com/s/1xzc3zx4dl2y98b/pgdocptbr800-1.2.pdf.zip

[Oracle] - Verificando sessões utilizadas e matando sessões

-- Verifica usuários que estão conectados no Oracle

SELECT
    S.SID,
    S.SERIAL#,
    S.USERNAME,
    S.MACHINE
  FROM  V$SESSION S

-- Mata Sessões no Oracle

select 'ALTER SYSTEM KILL SESSION '''||sid||','||serial#||''' IMMEDIATE;' as "MataUsuariosConectados"
from v$session
where username is not null
   and username not in ('SYS', 'SYSMAN', 'DBSNMP')
/

[MySQL] - Backup da estrutura e dados separados

-- Backup da estrutura do banco de dados
mysqldump -u root --password=teste -h 127.0.0.1 -n --default-character-set=utf8 --routines --triggers --events -d -v nome_banco > c:\dump\nome_banco_estrutura.sql 2> c:\dump\nome_banco_estrutura.error

-- Backup dos dados do banco de dados
mysqldump -u root --password=teste -h 127.0.0.1 -n -R -c -t -e -v -K nome_banco > c:\dump\nome_banco_dados.sql 2> c:\dump\nome_banco_dados.error

-- Select para validar objetos importados --

SET @nome_do_schema = 'nome_banco';
Select
(select schema_name from information_schema.schemata where schema_name=@nome_do_schema) as "Nome do Banco de dados",
(SELECT Round( Sum( data_length + index_length ) / 1024 / 1024, 3 )
FROM information_schema.tables
WHERE table_schema=@nome_do_schema
GROUP BY table_schema) as "Tamanho do Banco de dados em Mega Bytes",
(select count(*) from information_schema.tables where table_schema=@nome_do_schema and table_type='base table') as "Quant. Tabelas",
(select count(*) from information_schema.statistics where table_schema=@nome_do_schema) as "Quant. Índices",
(select count(*) from information_schema.views where table_schema=@nome_do_schema) as "Quant. Views",
(select count(*) from information_schema.routines where routine_type ='FUNCTION' and routine_schema=@nome_do_schema) as "Quant. Funções",
(select COUNT(*) from information_schema.routines where routine_type ='PROCEDURE' and routine_schema=@nome_do_schema) as "Quant. Procedimentos",
(select count(*) from information_schema.triggers where trigger_schema=@nome_do_schema) as "Quant. Triggers",
(select default_collation_name from information_schema.schemata where schema_name=@nome_do_schema)"Default collation do Banco de dados",
(select default_character_set_name from information_schema.schemata where schema_name=@nome_do_schema)"Default charset do Banco de dados",
(select sum((select count(*) from information_schema.tables where table_schema=@nome_do_schema and table_type='base table')+(select count(*) from information_schema.statistics where table_schema=@nome_do_schema)+(select count(*) from information_schema.views where table_schema=@nome_do_schema)+(select count(*) from information_schema.routines where routine_type ='FUNCTION' and routine_schema=@nome_do_schema)+(select COUNT(*) from information_schema.routines where routine_type ='PROCEDURE' and routine_schema=@nome_do_schema)+(select count(*) from information_schema.triggers where trigger_schema=@nome_do_schema))) as "Total de Objetos do Banco de dados"
LIMIT 0, 1000\G

-- Validando os dados importados --
select a.TABLE_SCHEMA, a.TABLE_TYPE , a.TABLE_NAME, a.TABLE_ROWS from information_schema.tables a where a.table_schema='nome_banco';

Procedure para envio de e-mails no Oracle

Pré-requisitos:

- Serviço de enfileiramento de mensagens SMTP instalado no Windows.
- Caso possua algum firewall ou anti-vírus, verifique se o mesmo não impede envios pela porta 25 (SMTP)

Procedure:

create or replace
procedure email_html (from_name varchar2, to_name varchar2,  subject varchar2, message varchar2) is
/***********************************************************************
Criacao     : Anderson Ayres
Objetivo    : Envia um email em formato HTML
Observacoes :
———————————————————————-
Historico das alteracoes:
———————————————————————-
Alteracao   : 10/03/2010 por Anderson Ayres Bittencourt
Objetivo    : Alteração de método de autenticação no servidor de email.
Observacoes : Os métodos possíveis de autenticação são: (validar qual o cliente utiliza)
UTL_SMTP.COMMAND(conn, ‘STARTTLS’); — comum em Exchange 2010.
UTL_SMTP.COMMAND(conn, ‘AUTH LOGIN’); — comum em Exchange 2007 e o mais utilizado por outros servidores de e-mail.
UTL_SMTP.COMMAND(conn, ‘AUTH NTLM’); — método para autenticação NTLM
UTL_SMTP.COMMAND(conn, ‘AUTH PLAIN’); — pouco utilizado… inseguro.
************************************************************************/v_smtp_server      varchar2(20) := ‘mail.superti.org‘;
v_smtp_server_port number  := 25;
v_directory_name   varchar2(100);
v_file_name        varchar2(100);
v_line             varchar2(1000);
crlf               varchar2(2):= chr(13) || chr(10);
mesg               varchar2(32767);
conn               UTL_SMTP.CONNECTION;
type varchar2_table is table of varchar2(200) index by binary_integer;begin
– Open the SMTP connection …
– ————————
conn:= utl_smtp.open_connection( v_smtp_server, v_smtp_server_port );– Initial handshaking …
– ——————-
utl_smtp.helo( conn, v_smtp_server );UTL_SMTP.COMMAND(conn, ‘AUTH LOGIN’);
UTL_SMTP.COMMAND(conn, UTL_RAW.CAST_TO_VARCHAR2(UTL_ENCODE.BASE64_ENCODE(UTL_RAW.CAST_TO_RAW(‘usuário_smtp‘))));
UTL_SMTP.COMMAND(conn, UTL_RAW.CAST_TO_VARCHAR2(UTL_ENCODE.BASE64_ENCODE(UTL_RAW.CAST_TO_RAW(‘senha‘))));

utl_smtp.mail( conn, ‘remetente‘ );
utl_smtp.rcpt( conn, to_name );

utl_smtp.open_data (conn);

– build the start of the mail message …
– ———————————–
UTL_SMTP.WRITE_RAW_DATA( conn,UTL_RAW.CAST_TO_RAW(‘Mime-Version: 1.0′ || utl_tcp.CRLF));
UTL_SMTP.WRITE_RAW_DATA( conn,UTL_RAW.CAST_TO_RAW(‘Content-Type: Text/html; charset=ISO-8859-1′ || utl_tcp.CRLF));
UTL_SMTP.WRITE_RAW_DATA( conn,UTL_RAW.CAST_TO_RAW(‘From:remetente@superti.org‘ ||utl_tcp.CRLF));
UTL_SMTP.WRITE_RAW_DATA( conn,UTL_RAW.CAST_TO_RAW(‘Date:’         ||  TO_CHAR( SYSDATE, ‘dd Mon yy hh24:mi:ss’ ) || utl_tcp.CRLF));
UTL_SMTP.WRITE_RAW_DATA( conn,UTL_RAW.CAST_TO_RAW(‘To:’         ||  to_name || utl_tcp.CRLF));
UTL_SMTP.WRITE_RAW_DATA( conn,UTL_RAW.CAST_TO_RAW(‘Subject:’     ||  subject || utl_tcp.CRLF));

utl_smtp.write_data(conn,’ ‘ || utl_tcp.CRLF);
utl_smtp.write_raw_data(conn,utl_raw.cast_to_raw(utl_tcp.CRLF||message));
utl_smtp.close_data( conn );
utl_smtp.quit( conn );
end;

Fonte:
http://www.superti.org/?p=17

Oracle – RMAN Configuração e comandos básicos para realizar backups

Partindo do princípio que sua base está ok e com o archivelog corretamente ligado e configurado, segue abaixo algumas sugestões de configuração e alguns comandos básicos para ter seu backup rodando, fazer consultas e limpezas:

A configuração abaixo mantem uma janela de recovery de 2 dias e configura o backup para executar na pasta E:\rman\. (Você pode e deve alterar para o seu local de backup)

#### CONFIGURANDO O RMAN ####

rman target /
CONFIGURE RETENTION POLICY TO RECOVERY WINDOW OF 2 DAYS;
CONFIGURE DEFAULT DEVICE TYPE TO DISK;
CONFIGURE CONTROLFILE AUTOBACKUP ON;
CONFIGURE CHANNEL DEVICE TYPE DISK FORMAT ‘E:\rman\BANCO.SERVER_RMAN_FULL_%s%t.bak’;

* As demais opções vamos deixar default *

#### LISTAR OS BACKUPS FEITOS ####
conectar… rman target….
# list backupset;

#### LISTAR TODAS AS CONFIGURAÇÕES DO RMAN ###
# show all;

#### CUIDADO!! LISTAR OS BACKUPS FEITOS ####
# list backup of database;

#### DELETAR OS BACKUPS ####
# delete backup;

#### LISTAR TODOS OS ARCHIVELOGS ####
# list archivelog all;

#### DELETAR TODOS OS ARCHIVELOGS ####
# delete force noprompt archivelog all;

#### DELETAR TODOS OS ARCHIVELOGS EXPIRADOS ####
# delete force noprompt expired archivelog all;

Fonte:
http://www.superti.org/?p=151

Oracle – Shrink de tabelas dentro da Tablespace (redução)

– Enable row movement.
ALTER TABLE hr.teste ENABLE ROW MOVEMENT;

– Recover space and amend the high water mark (HWM).
ALTER TABLE scott.emp SHRINK SPACE;

– Recover space, but don’t amend the high water mark (HWM).
ALTER TABLE scott.emp SHRINK SPACE COMPACT;

– Recover space for the object and all dependant objects.
ALTER TABLE scott.emp SHRINK SPACE CASCADE;

– Disable row movement.
alter table HR.TESTE disable row movement;

O Select abaixo, efetua a geração dos scripts para redução e realocação do espaço livre nas tabelas:

select t.*,
'ALTER ' || t.segment_type || ' ' || t.segment_name || ' ENABLE ROW MOVEMENT;' as enable_row_mov,
'ALTER ' || t.segment_type || ' ' || t.segment_name || ' SHRINK SPACE CASCADE;' as shrink,
'ALTER ' || t.segment_type || ' ' || t.segment_name || ' DISABLE ROW MOVEMENT;' as disable_row_mov
from (
select segment_name, segment_type, bytes/1024/1024 Size_Mb
from user_segments
where segment_type = 'TABLE'
and not exists(
select 1
from user_tab_columns
where table_name = segment_name
and data_type IN ('LONG', 'LONG RAW'))
order by bytes/1024/1024 DESC ) t;

fonte:
http://www.superti.org/?p=122
http://veduardodba.wordpress.com/2011/12/29/shrink-a-table/

Como limitar o número de registros retornados em uma consulta SQL

Não existe uma instrução SQL padronizada para limitar o número de registros retornados em uma consulta, ou seja, cada fornecedor implementa essa funcionalidade do seu jeito.

Veja um resumo de como fazer isso para alguns fabricantes:

DB2 -- select * from table fetch first 10 rows only 
Informix, InterBase/Firebird, SKIP  -- select first 10 * from table 
Microsoft SQL Server and Access -- select top 10 * from table 
MySQL, PostgreSQL, SQLite, HSQL/H2 -- select * from table limit 10 
Oracle -- select * from table where rownum <= 10




Fonte:http://stackoverflow.com/questions/595123/is-there-an-ansi-sql-alternative-to-the-mysql-limit-keywordhttp://www.macoratti.net/d250102.htmhttp://www.dougboude.com/blog/1/2006/06/Equivalent-of-SQL-TOP-X-in-Oracle.cfm

[MS SQL SERVER] - Exercícios de T-SQL

Execícios sobre Procedimentos Armazenados(Stored Procedures) e Gatilhos(Triggers):

1) Criar a tabela conforme abaixo:

Obs: crie o banco de dados empresa para utilizar este exemplo ( "create database empresa;" )

Create table empregado
( cpf numeric(14) not null primary key,
Nome varchar(40) not null,
Data_nasc datetime,
Sexo char(1),
Endereco varchar(100),
Sarario numeric(12,2),
Numr_dept numeric(5),
Cpf_super numeric(14))

2) Criar um procedimento armazenado que receba como parâmetro todos os dados de um Empregado e efetue a sua inclusão. Este procedimento deverá avaliar se o CPF do Empregado que está sendo inserido já existe. Se isto ocorrer, apresentar uma mensagem de erro e não efetuar a inclusão.

3) Criar um gatilho para verificar nas ocorrências de inclusão e alteração não permitindo que o CPF do supervisor seja o mesmo do supervisionado. Apresentar uma mensagem de erro informando que o Empregado não pode ser supervisor dele mesmo.

4) Criar um gatilho que verifique e não permita a redução do Salario dos Empregados.

Respostas:

Exercicio 2

use empresa;

create procedure inclui_empregado
@cpf numeric (14),
@Nome varchar(40),
@Data_nasc datetime,
@Sexo char(1),
@Endereco varchar(100),
@Salario numeric (12,2),
@Nome_dept numeric (5),
@Cpf_super numeric (14)
as
if exists (select cpf from empregado where cpf = @cpf)
begin
print 'Empregado ja Cadastrado'
end
else
begin
insert into empregado values ( @cpf, @Nome, @Data_nasc, @Sexo, @Endereco,
@Salario, @Nome_dept, @Cpf_super )
print 'Empregado '+ @Nome + ' Incluído com Sucesso!'
end

____________________________________________________________
Exercicio 3

create trigger valida_super on empregado
for insert,update
as
declare 
@cpf numeric(14),
@cpf_super numeric(14)
set @cpf = ( select cpf from inserted )
set @cpf_super = ( select cpf_super from inserted )
if 
(@cpf = @cpf_super)
begin
print 'Empregado não pode ser supervidor dele mesmo'
rollback
end

____________________________________________________________
Exercicio 4

create trigger salario_menor on empregado
for update
as
declare 
@salario_atual numeric(12,2),
@salario_novo numeric(12,2)
set @salario_atual = ( select salario from deleted )
set @salario_novo = ( select salario from inserted )
if 
(@salario_atual > @salario_novo)
begin
print 'Salario Novo não pode ser menor que o Salario Atual'
rollback
end

___________________________________________________________

[MySQL] - Some useful MySQL Flush commands

Some useful MySQL Flush commands

Following are some useful flush commands with their description.

1. flush-hosts: Flush all host information from host cache.
2. flush-tables: Flush all tables.
3. flush-threads: Flush all threads cache.
4. flush-logs: Flush all information logs.
5. flush-privileges: Reload the grant tables (same as reload).
6. flush-status: Clear status variables.

# mysqladmin -u root -p flush-hosts
# mysqladmin -u root -p flush-tables
# mysqladmin -u root -p flush-threads
# mysqladmin -u root -p flush-logs
# mysqladmin -u root -p flush-privileges
# mysqladmin -u root -p flush-status

Fonte:
http://www.askdbexperts.com/2013/02/most-used-mysql-flush-commands.html
http://www.askdbexperts.com/2013/02/most-often-used-mysql-dba-commands.html