Commitou o que não era pra comittar? Dá "Rollback"!

Fala ai, pessoal!

Se você é de TI, com certeza já passou por uma situação como essa:
Atualizando dados de uma tabela em um banco de dados Oracle, você alterou um ou vários campos com o valor errado, ou até mesmo excluiu um ou mais registros e deu COMMIT. E agora?!?! Fedeu?!?! NÃO!!! Você pode recuperar os dados...
Fala ai, pessoal!

Se você é de TI, com certeza já passou por uma situação como essa:
Atualizando dados de uma tabela em um banco de dados Oracle, você alterou um ou vários campos com o valor errado, ou até mesmo excluiu um ou mais registros e deu COMMIT. E agora?!?! Fedeu?!?! NÃO!!! Você pode recuperar os dados através do Oracle Flashback.

Para isso, a tarefa é muito simples. Basta fazer um select na tal tabela, normal mesmo, com os campos e condições que você quer e, no from, após o nome da tabela, colocar "as of timestamp systimestamp - interval 'X' minute", onde esse "X" é o tempo que passou desde a bobagem que você fez até agora.

Por exemplo: Tenho uma tabela CLIENTE na minha base de dados Oracle e vou atualizar os clientes que não fazem compras há mais de 1 mês para Inativos.

Então fiz lá meu update, atualizando o campo STATUS_CLIENTE para "I", depois de fazer um select que retorna os tais clientes que não compraram no último mês. Dei o COMMIT. Alguns desses clientes estavam com o STATUS "A" de Ativo, "D" de Devedor, "V" de VIP.

Daí, chega o meu chefe, 30 minutos depois que eu fiz o update, dizendo que esse update não pode ser feito em clientes VIP e eu... DANÇO? Não! Eu faço o seguinte:

select ID_CLIENTE
from CLIENTE
as of timestamp systimestamp - interval '30' minute
where STATUS_CLIENTE = 'V';

PRONTO! Peguei todo mundo que tava com o campo STATUS_CLIENTE = 'V' 30 minutos atrás.
Com os IDs, eu faço um novo update, passando essa galera, que está com o STATUS = 'I', pra 'V'.

Salvei meu emprego e deixei meu chefe feliz!

PS.: Agradecimentos ao camarada Willian Rodrigues que ajudou nesse post!

Abraço a todos!

Artigo completo (View Full Post)

VB6 & Oracle - Inserindo Dados

O Modelo Cliente/Servidor caracteriza-se por centralizar grande parte dos processos de um sistema de informação no SGBD. Esses processos são programados em forma de UDFs, Procedures e Triggers.
Neste artigo veremos como criar um procedure no Oracle, para em seguida desenvolvermos um aplicativo em VB6 o qual ira chamar a execução da mesma.

Iniciaremos então pelo banco de dados, veja abaixo o código da procedure:

Back-End Script de Banco de Dados

-- Criando a tabela para testar insert apartir de um front-end vb6
CREATE TABLE TESTEGM (
  COD VARCHAR(3),
  DESCRICAO VARCHAR(10)

);

-- Procedimento para insert - exemplo de arquitetura cliente/servidor
CREATE OR REPLACE PROCEDURE PROC_TESTE_GM (
                                   PCOD IN VARCHAR,
                                   PDESCRICAO IN VARCHAR,
                                   PAUX_RETORNO OUT VARCHAR)
AS
 BEGIN
   INSERT INTO TESTEGM
    (COD, DESCRICAO) VALUES    (PCOD, PDESCRICAO);
    COMMIT;
    PAUX_retorno := 'OPERAÇÃO REALIZADA COM SUCESSO!';
 EXCEPTION
   WHEN OTHERS THEN
     PAUX_retorno := SQLERRM || ' INSERT DISTRATO ERRO.' ; -- RETORNA A MENSAGEM COM CÓDIGO E DESCRIÇÃO DO ERRO ORACLE
     ROLLBACK;

END;

Front-end Código do lado Cliente

Neste exemplo, aproveito para demostrar um pouco de modularização. Criei duas funcionalidades, uma que se preocupa com a conexão com o banco, "GetConnectionCRUD". Essa "Sub" retorna um "ADO Command" conectado e configurado como "procedure". Uma segunda rotina, "BuildParams", monta os parâmetros do "ADO Command" (o qual recebe como parâmetro) dinamicamente e atribui valor para os mesmos.

Private Sub BuildParams(ByRef obj As ADODB.Command)
 'Cria o parâmetro de saida no commad
 objInsertCommandAux.Parameters.Append objInsertCommandAux.CreateParameter("PAUX_RETORNO", adBSTR, adParamOutput)
 'Cria os parâmetros de entrada nos commads já passando o valor para eles
 obj.Parameters.Append objInsertCommandAux.CreateParameter("PCOD", adBSTR, adParamInput, , Text1.Text)
 obj.Parameters.Append objInsertCommandAux.CreateParameter("PDESCRICAO", adBSTR, adParamInput, , Text2.Text)

End Sub

Private Function GetConnectionCRUD() As ADODB.Command
 ' Retorna um objeto (um activeX) ja conectado ao banco
 ' Dessa forma podemos de forma coesa, isolada definir uma conexão com o banco
 Dim objCommandAux As New ADODB.Command
 Dim MyConn  As New ADODB.Connection

 MyConn.Open "Provider=MSDAORA;Data Source=desvbancoteste;User ID=sistema;Password=landjah;"
 objCommandAux.ActiveConnection = MyConn
 objCommandAux.CommandType = adCmdStoredProc
 Set GetConnectionCRUD = objCommandAux

End Function

Em seguinda codificaremos no evento OnClick de um botão a execução dos procedimentos, "Caixa Preta", descritos acima.

Dim objInsertCommandAux As New ADODB.Command
Dim AuxRetorno As String
' Para trabalar desconectado do banco ...
Dim rsZN As New ADODB.Recordset

Private Sub Command1_Click()

 Set objInsertCommandAux = GetConnectionCRUD()
 ' Define que o command criado executará proc de Insert
 objInsertCommandAux.CommandText = "PROC_TESTE_GM"

  
 BuildParams objInsertCommandAux

 '*** Executando a stored procedure
 objInsertCommandAux.Execute

 MsgBox (objInsertCommandAux("PAUX_RETORNO"))

 'Destroi o objeto
 Set objInsertCommandAux = Nothing

End Sub

Artigo completo (View Full Post)

“DBMS_SQL package” & “EXECUTE IMMEDIATE” - PL/SQL

“DBMS_SQL package” & “EXECUTE IMMEDIATE”

Aproveitando o gancho deixado pelo comentário do Malta(no post anterior), acho que cabe um exemplo mostrando a aplicação das pls da package “DBMS_SQL” na abordagem de SQL dinâmico no Oracle.

Usando a Package

CREATE OR REPALCE PROCEDURE insert_ZNtable (
    ZN_ID  NUMBER,
    NameZN    VARCHAR2) IS
 ZNcursor_Manipulador     INTEGER;
 DynSQLZn        VARCHAR2(280);
 rows_processed  BINARY_INTEGER;

BEGIN
 DynSQLZn := 'INSERT INTO MyTableZN VALUES (:ZN_ID, :NameZN)';

 -- Ao Abrir o cursor atribui valor para o "Handle" , o cursor ID.
 ZNcursor_Manipulador := dbms_sql.open_cursor;

 -- efetuando o parse
 dbms_sql.parse(ZNcursor_Manipulador, DynSQLZn,
    dbms_sql.native);

 -- fazando o BIND_VARIABLE
 dbms_sql.bind_variable
    (ZNcursor_Manipulador, ':ZN_ID', ZN_ID);
 dbms_sql.bind_variable
    (ZNcursor_Manipulador, ':NameZN', NameZN);

  -- Executando o cursor
  rows_processed :=
  dbms_sql.execute(ZNcursor_Manipulador);

  -- Fechando o cursor
  dbms_sql.close_cursor(ZNcursor_Manipulador);

END;

Usando SQL dinâmico nativo

CREATE PROCEDURE insert_ZNtableExecuteImm(
    ZN_ID  NUMBER,
    NameZN    VARCHAR2) IS
 DynSQLZn    VARCHAR2(280);

BEGIN
 DynSQLZn := 'INSERT INTO MyTableZN VALUES (:ZN_ID, :NameZN)';
 -- parse e execução no mesmo comando
 EXECUTE IMMEDIATE DynSQLZn
   USING ZN_ID, NameZN;

END;

Artigo completo (View Full Post)

SQL - Operador "LIKE" & ESCAPE

Para a utilização do operador “LIKE”, ANSI SQL, usa-se os caracteres coringas ‘_’, ou ‘%’. Veja o exemplo abaixo:

select
*
from (
  select
      column_value col
  from
    table(ts.split_varchar2('Jan,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez', ','))
) q
WHERE col like 'J_n'

Acima, vimos o exemplo do coringa posicional. Ou seja, para posição que o underscore ocupar na substring de busca, no filtro, o compilador irá interpretar que qualquer caractere serve. O nosso filtro busca qualquer string de três caracteres cujo a primeira posição é ocupada pelo “J” e a última pelo “n”, a posição do meio é o coringa, portanto, qualquer caractere serve. Por isso obtivemos como resultado: “Jan” e “Jun”. Vejamos outro exemplo usando o “%”:

select
*
from (
   select column_value col
   from
     table(ts.split_varchar2('Jan,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez', ','))
) q
WHERE col like 'J%'

Recapitulando, o underscore é um coringa posicional. Veja que, se por exemplo, na cláusula “where” o valor para o filtro for modificado para “like '_a_'” o resultado do select vai ser: Jan, Mar, Mai. Retornará todos os meses que possuírem a letra “a” como segundo caractere. Conforme exemplificado abaixo:

select
*
from (
select column_value col
from table(ts.split_varchar2('Jan,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez', ','))
) q
WHERE col like '_a_'

O Problema que muitos desenvolvedores eventualmente enfrentam é quando o caractere coringa é justamente o que ele quer usar como filtro. Por exemplo:

select
*
from (
select column_value col
from table(ts.split_varchar2('Jan,Jan_2008,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez', ','))
) q
WHERE col like '%_%'

Se você tentar encontrar o registro pela presença do caractere “underscore” o resultado do select não será o esperado. Conforme ilustrado abaixo:

Uma solução, é usar a palavra reservada “ESCAPE”. Desta forma você indica ao compilador SQL qual caractere coringa você deseja que ele considere para busca. Exemplo:

select
*
from (
select column_value col
from
  table(ts.split_varchar2('Jan,Jan_2008,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez', ','))
) q
WHERE col like '%@_%' ESCAPE '@'

Para usar corretamente o ESCAPE, você precisa primeiro marcar o coringa com outro caractere o operando do “like”, exemplo: “like '%@_%'”. Em seguida, o operador do ESCAPE identifica o caractere que marcou o coringa. Exemplo: “ESCAPE '@'”.
Agora o resultado do filtro aplicado retornará o que desejamos:

Outro exemplo:

select
*
from (
select column_value col
from table(ts.split_varchar2('Jan,Jan_2008,Fev_%,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez', ','))
) q
WHERE col like '%@_2008' ESCAPE '@'

Se trocarmos o marcador, de “@” para “/” visando tornar nosso exemplo mais claro. Além disso, vamos testar usar como filtro a presença do caractere “%”. Para isso inclui o elemento “Fev%Wanddjah” no conjunto a ser selecionado.

select
*
from (
select column_value col
from table(ts.split_varchar2('Jan,Jan_2008, Fev,Fev%Wanddjah,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez', ','))
) q
WHERE col like '%/%Wanddjah' ESCAPE '/'

Veja o resultado:




Outra opção para solução seria usar expressões regulares:

select
*
from (
select column_value col
from table(ts.split_varchar2('Jan,Jan_2008, Jan\Fev ,Fev,Fev%Wanddjah,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez', ','))
) q
WHERE REGEXP_LIKE(col,'\')

O ESCAPE do expressões regulares é o “\” .O exemplo acima retorna todos os registros. Para escapar o especial do caractere “\” caso você precise do seu valor literal use o próprio, conforme exemplificado abaixo:

select
*
from (
select column_value col
from table(ts.split_varchar2('Jan,Jan_2008, Jan\Fev ,Fev,Fev%Wanddjah,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez', ','))
) q
WHERE REGEXP_LIKE(col,'\\').               

Agora obteremos como retorno apenas: “Jan\Fev”.

O mesmo vale para os demais metacaracteres. Exemplo: “\.”, “\[”, “\]”, “\?”, “\+”, “\{” , “\}”, “\^”, e “\$”.

Artigo completo (View Full Post)

TYPE CURSOR - Retornar um Resultset numa Procedure - Oracle

Retornar um resultset como parâmetro de saída numa procedure em PL/SQL não é algo tão intuitivo como no Interbase ou no MS SQL Server. Portanto, vamos desenvolver um exemplo onde construiremos um procedure em PL/SQL para retornar um resultset. Em seguida vamos implementar um programa em Delphi que vai executar esse procedimento e recuperaremos na interface o resultado do Select.

Para criar a pakcage:
No PL/SQL Developer, no Object Browser, ou somente Browser, selecione a pasta (folder) “Packages” com o botão direito do mouse click em new. Conforme ilustrado abaixo:



Defina o Nome da package:




Note que será criado uma área de declaração como interface da package e outra área para o “body” da package.



Eu vou definir um tipo cursor o qual será usado para um parâmetro de saída da procedure “CalulaMedia”. Nesse parâmetro retornarei o resultset que desejo exibir na aplicação.

Interface da package:


Body da package:



Construindo a interface em Delphi:

Ok, recapitulando: Vamos construir um aplicativo o qual acessará o banco de dados Oracle onde criamos a package “My_Pkg”. A middleware de acesso a dados será OLE_DB, cujos objetos de acesso a dados estão disponibilizados no Delphi na palheta ADO (Activex Data Object). Estou documentando esse exemplo porque não foi nada fácil, nem intuitivo, recuperar um parâmetro do tipo cursor no Delphi. Na nossa primeira tentativa nos deparamos com muitos problemas o maior deles foi justamente com o parâmetro de retorno do tipo cursor no componente “TADOStoredProc”. Constatamos que nesta tecnologia o tipo “ftCursor” quando atribuído a propriedade “DataType” do parâmetro disparava uma exceção informado que os argumentos estavam incorretos.



Constatamos que para fazer funcionar tínhamos que deletar esse parâmetro da lista de parâmetros, deixando somente o parâmetro de input. Ainda referente ao cenário da primeira tentativa, somente obtivemos sucesso com “TADOStoredProc” enquanto a procedure no banco possuía dois parâmetros, um deles era o tipo cursor, parâmetro de saída, o outro era um parâmetro para filtro na cláusula “where” do comando SQL. Vejamos um exemplo:
Duas condições devem ser atendidas – O tipo cursor deve ser o primeiro parâmetro pois o último, de entrada, deve obrigatoriamente ser definido como “default”. Criei para este exemplo uma procedure que efetua um cálculo simples:

PROCEDURE RetCircunferencia(
    ZnCursor OUT ZNCursorType,
    Raio IN NUMBER DEFAULT 0) IS
 vResultado NUMBER;
BEGIN  
  /* Calcula a retificação da circunferência */ 

  vResultado := 2 * (Raio * PI);

  OPEN ZNCursor FOR
  SELECT
    'Retificação da Circuferência' AS Descricao,
    VResultado AS Resultado
  FROM
    Dual;  
END RetCricunferencia;

A constante “PI” declarei na área de declaração de constantes da package “MY_PKG”. Veja o Código da package agora:

create or replace package body MY_Pkg is

  -- Public constant declarations
  ValorAprovacao constant NUMBER  := 6;
  PI CONSTANT NUMBER := 3.1416; -- Constante usada na procedure "RetCricunferencia"

  -- Private variable declarations
  ResultadoAprovacao VARCHAR2(20);
  Media NUMBER;
  -- Function and procedure implementations
  procedure CalculaMedia(
    Nota1 in INTEGER,
    Nota2 in INTEGER,
    Nota3 in INTEGER,
    Nota4 in INTEGER,
    ZnCursor OUT ZNCursorType) IS
  BEGIN
  /* Calcula a média de um aluno */

  Media := (Nota1 + Nota2 + Nota3 + Nota4)/ 4;
  IF (Media >=  ValorAprovacao) THEN
    ResultadoAprovacao := 'Aprovado';
  ELSE
    ResultadoAprovacao := 'Reprovado';
  END IF;

 /* retornando no CURSOR o resultado do aluno */
  open ZnCursor FOR
  SELECT  'Aluno Estação ZN: ' AS Nome,
          ResultadoAprovacao AS ResultadoZN/*,
          Media AS ValorMedia        */
  FROM dual;

end CalculaMedia;


PROCEDURE RetCircunferencia(
    ZnCursor OUT ZNCursorType,
    Raio IN NUMBER DEFAULT 0) IS
 vResultado NUMBER;
BEGIN  
/* Calcula a retificação da circunferência */ 

 vResultado := 2 * (Raio * PI);

OPEN ZnCursor FOR
 SELECT  'Aluno Estação ZN: ' AS Nome,
          ResultadoAprovacao AS ResultadoZN,
          Media AS ValorMedia       
 FROM dual;
  
END RetCircunferencia;

end MY_Pkg;

Inicie uma nova aplicação, no form1 adicione um “ADOConnection”, um TADOStoredProc, um TDataSource, um TDBGRid, um TEdit, um TLabel. Conecte o ADOConnection com o banco aonde vc criou a procedure. No ADOConnection, o menu popup, com o botão direito do mouse selecione build connection. Veja a ilustrção abaixo:



Não esqueça de alterar a propriedade “LoginPrompt” do ADOConnetion para “False”.

Em seguida conecte a ADOStoredProc no ADOConnection (pela propriedade “Connection” do ADOStoredProc). Conecte o DataSource no ADOStoredProc (propriedade DataSet do DataSource), conecte o DBGrid no DataSource (propriedade “DataSource” do DBGrid). Na propriedade “ProcedureName” do ADOStoredProc digite “[eschema].MY_PKG.RetCircunferencia”. Veja na propriedade parameters do ADOStoredProc a lista de parâmetros recuperados da procedure.



Alterei a propriedade Name do Tedit para “EdtRaio”. Adicione um TBitBtn, nomeie de BtnExcRaio,No Evento OnClick digite conforme exemplificado abaixo:

procedure TForm1.BtnExcRaioClick(Sender: TObject);
begin
  with ADOStoredProc1 do
  begin
    Parameters[0].Value := StrtoFloat(EdtRaio.Text);
    Open;
  end;
end;

Ok, tudo parece estar certo, tudo pronto para testarmos, correto? Posso adiantar que se você executar agora vai levar uma exceção bacana na lata.



Pra funcionar ainda temos que, sem razão aparente, deletar o parâmetro “ZNCURSOR” da lista de parâmetros da propriedade “Parameters” do ADOStoredProc.



Para demonstrar o quanto é complicado alcançar o objetivo proposto no início do nosso exmplo (executar um procedure no Oracle e recuperar o valor de um parâmetro tipo cursor), veja que ainda faltam algumas configurações a fazer no ADOStoredProc. Antes garanta que o ADOConnection esteja desconectado (propriedade “Connected = False”):
1° - Altere a propriedade “EnableBCD” do ADOStoredProc para “False”.
2° - Altere a propriedade “DataType” do parâmtro “RAIO” de “ftBCD” para “ftFloat”. Você pode fazer isso na propriedade “Parameters” do ADOStoredProc.

Agora adicione os campos persitentes, no fields Editor do ADOStoredProc. Em seguida execute o programa e teste:





Com um pouco de persistência obtivemos sucesso! Contudo, os problemas não param por aqui. Por exemplo, se você tiver mais de um parâmetro de entra o bicho vai pegar e o bagulho não vai funfar. Justamente, esse é o caso da procedure “CalculaMedia”, de jeito nenhum conseguimos fazer funcionar com o ADOStoredProc. Tentando de várias outras formas conseguimos sucesso trocando o dataset para TADODataSet, só assim funcionou e mesmo assim tivemos que fazer as mesmas alterações quanto ao tipo do parâmetro e deleção o tipo cursor. A única exceção foi a não obrigatoriedade do parâmetro de saída, tipo cursor, na procedure “CalculaMedia” ser o primeiro na declaração.

No próximo artigo daremos continuidade ....

segue o código da package:

create or replace package MY_Pkg is

-- Author  : GMottazn
-- Created : 12/03/2008 09:58:08
-- Purpose :

-- Public type declarations
TYPE ZNCursorType IS REF CURSOR;

-- Public variable declarations
-- ;

-- Public function and procedure declarations
procedure CalculaMedia(
  Nota1 in out NUMBER,
  Nota2 in NUMBER,
  Nota3 in NUMBER,
  Nota4 in NUMBER,
  ValorAprovacao IN NUMBER,
  Media out NUMBER,
  ZnCursor IN OUT ZNCursorType);

end MY_Pkg;
/
create or replace package body MY_Pkg IS

-- Public constant declarations
  ValorAprovacao constant NUMBER  := 6;

-- Private variable declarations
  ResultadoAprovacao VARCHAR2(20);

-- Function and procedure implementations
procedure CalculaMedia(
  Nota1 in out NUMBER,
  Nota2 in NUMBER,
  Nota3 in NUMBER,
  Nota4 in NUMBER,
  ValorAprovacao IN NUMBER,
  Media out NUMBER,
  ZnCursor IN OUT ZNCursorType) is
begin
  Media := (Nota1 + Nota2 + Nota3 + Nota4)/ 4;
  IF (Media >=  ValorAprovacao) THEN
    ResultadoAprovacao := 'Aprovado';
  ELSE
    ResultadoAprovacao := 'Reprovado';
  END IF;
  open ZnCursor FOR
  SELECT  'Aluno Estação ZN: ' AS Nome,
          ResultadoAprovacao AS ResultadoZN
  FROM dual;

end CalculaMedia;


end MY_Pkg;
/

Artigo completo (View Full Post)

TYPE … IS TABLE OF - BULK COLLECT

PL/SQL é um universo, estamos em débito com ela aqui no Estação ....
Por favor, vamos jogar os "goto pula" pra casa do landjah!!! O mundo agradece!! ... e o unverso diz AMÉM!!!

No Oracle (10i ), para persistir em memória um conjunto de registros de uma tabela qualquer para mais adiante usá-los:

Passo 1) Declare um array do tipo RowType da tabela a qual deseja armazenar:

DECLARE

  I INTEGER;

  TYPE My_TIPO_tabela IS TABLE OF <Table name> %ROWTYPE;

  V_TabTemp My_TIPO_tabela;

Passo 2) Parra carregar o vetor “V_TabTemp”:

begin
-- Test statements here
  SELECT *
    BULK COLLECT INTO V_TabTemp
  FROM 
     <table name>
  WHERE 
     <condições>

Passo 3) Imprimindo os dados:

  FOR i IN 1..2
    dbms_output.put_line(' Dado teste' || V_TabTemp.<ColumnName>(i));
  END;

Passo 4) Fazer um insert numa tabela cujo as colunas sejam idênticas as do vetor:

  FORALL I IN 1.. V_TabTemp.COUNT
    INSERT INTO <tableName> VALUES V_TabTemp.(I);

Exemplo:

  DECLARE
    type AVet is table of Clientes%rowtype;
    i integer;
    VetImportaClientes AVet;
  BEGIN
   -- ***** IMPORTAÇÃO dos Clientes
   i := 0;
   select 
     * bulk collect into VetImportaClientes
   from 
     ClientesA
   where 
     ClientesA.Tipo = 'J';

  forall i in 1.. VetImportaClientes.count
    insert into PossiveisClientesB values VetImportaClientes(i)

Artigo completo (View Full Post)

SQL

Structured Query language SQL

É uma linguagem de pesquisa declarativa e de programação para banco de dados relacional. O SQL foi desenvolvido no início da década de 70 nos laboratórios da IBM, no projeto System R, que tinha por objetivo demonstrar a viabilidade da implementação do modelo relacional proposto por E. F. Codd. O nome original da linguagem era SEQUEL, acrônimo para "Structured English Query Language".A linguagem SQL foi desenvolvida pela IBM, visando realizar operações em SGBDs. Ela é subdividida em quatro categorias:

• Linguagem de definição de dados(DDL):
• Linguagem de manipulação de dados(DML)
• Linguagem de controle de dados (DCL)
• Linguagem de controle de Transação(TCL)

DDL Data Defition Language:

• CREATE – Para crier objetos de banco de dados.
• ALTER – Alterar estrutura de objetos no banco de dados.
• DROP – Excluir objetos no Banco de dados.
• TRUNCATE –Exclui todos os registros de uma tabela.
• RENAME – Renomeia objetos de banco de dados

Exemplos:

a) CREATE:

   Create table <Nome_da_tabela> (<Nome_do_campo>  <tipo> <tamanho> <requerido>); 

b) ALTER:

    Alter table <Nome_da_tabela> add <Nome_do_campo>  <tipo> <tamanho> <requerido>;  

c) DROP
Excluindo uma coluna

   Alter table <Nome_da_tabela> drop <Nome_do_campo>
; 

Excluido uma tabela

   Drop table <Nome_da_tabela> 

DML Data Manipulation Language:

• SELECT – Seleciona dados.
• INSERT – Insere dados numa tabela
• UPDATE – Altera registros de uma tabela.
• DELETE – Apaga registros de uma tabela.

Exemplo:

d) Select:

Select  From   Where   

e) Insert:

Insert Into  Values 

f) UpDate:

UpDate  Set =  ;

g) Delete:

Delete from  Where   ;

DCL Data Controul Language:
o GRANT – Concede privilégios a usuários sobre objetos do banco (gives user's access privileges to database)
o REVOKE – Retira privilégios de usuários (withdraw access privileges given with the GRANT command)
Exemplo:
h) Grant:

Grant  on   to   

i) Revoke:

Revoke  on   from   

TCL

Transaction Control Language (TCL) Comandos que gerenciam manipulações através de DML sobre os registros de uma banco de dados. Esse gerenciamento e feito através de controle de transações. (statements are used to manage the changes made by DML statements. It allows statements to be grouped together into logical transactions).
o COMMIT – Confirma operação realizada. Aplica definitivamente, fisicamente a operação realizada.
o SAVEPOINT – Marca pontos onde a transação pode ser efetivada ou não.
o ROLLBACK – Cancela uma operação iniciada pelo START TRANSACTION.
o START TRANSACTION/ BEGIN TRANS – Incia uma transação.
o SET TRANSACTION – Configura uma transação, como nível de isolamento e seguimentos de Rollback.

Um Script de exemplo - Inerbase/ Fire Bird

CREATE DATABASE 'G:\\BancoCurso.gdb'
USER 'SYSDBA' PASSWORD 'masterkey'
PAGE_SIZE 4096;


/******************************************************************************/
/*                                 DOMAIN                                     */
/******************************************************************************/


CREATE DOMAIN MOEDA AS NUMERIC(15,2) DEFAULT 0;
CREATE DOMAIN BOOLEAN AS CHAR(1) DEFAULT 'F' CHECK(VALUE IN ('F','T'));


/******************************************************************************/
/*                                   Tables                                   */
/******************************************************************************/

CREATE TABLE CLIENTES (
ID_CLIENTE  INTEGER NOT NULL,
NOME        VARCHAR(60) NOT NULL,
CPF         CHAR(11) NOT NULL,
ENDERECO    VARCHAR(60) NOT NULL,
BAIRRO      VARCHAR(40) NOT NULL,
CIDADE      VARCHAR(40) NOT NULL,
ESTADO      CHAR(2) NOT NULL,
DATACAD     TIMESTAMP NOT NULL,
STATUS      BOOLEAN
);



CREATE TABLE ITENS (
ID_PEDIDO   INTEGER NOT NULL,
ID_PRODUTO  INTEGER NOT NULL,
QUANTIDADE  INTEGER NOT NULL,
PRECOVENDA      MOEDA NOT NULL
);

CREATE TABLE PEDIDOS (
ID_PEDIDO      INTEGER NOT NULL,
ID_CLIENTE     INTEGER NOT NULL,
DATAPED        TIMESTAMP  NOT NULL
);

CREATE TABLE PRODUTOS (
ID_PRODUTO  INTEGER NOT NULL,
DESCRICAO   VARCHAR(60) NOT NULL,
PRECOCOMPRA       MOEDA  NOT NULL,
QUANTIDADE    INTEGER NOT NULL
);


/******************************************************************************/
/*                                Primary Keys                                */
/******************************************************************************/

ALTER TABLE CLIENTES ADD PRIMARY KEY (ID_CLIENTE);
ALTER TABLE PEDIDOS ADD PRIMARY KEY (ID_PEDIDO);
ALTER TABLE PRODUTOS ADD PRIMARY KEY (ID_PRODUTO);
ALTER TABLE ITENS ADD PRIMARY KEY(ID_PEDIDO, ID_PRODUTO);


/******************************************************************************/
/*                                Foreign Keys                                */
/******************************************************************************/


ALTER TABLE ITENS ADD FOREIGN KEY (ID_PRODUTO) REFERENCES PRODUTOS (ID_PRODUTO);
ALTER TABLE ITENS ADD FOREIGN KEY (ID_PEDIDO) REFERENCES PEDIDOS (ID_PEDIDO);
ALTER TABLE PEDIDOS ADD FOREIGN KEY (ID_CLIENTE) REFERENCES CLIENTES (ID_CLIENTE);



/******************************************************************************/
/*                                 ÍNDICES                                    */
/******************************************************************************/

CREATE INDEX  IDX_NOMECLI  ON CLIENTES(NOME);
CREATE  UNIQUE INDEX  IDX_CPF_CLI  ON CLIENTES(CPF);
CREATE  INDEX  IDX_DATAPED  ON PEDIDOS(DATAPED);
CREATE UNIQUE INDEX  IDX_DESCRICAO_PROD  ON PRODUTOS(DESCRICAO);

/******************************************************************************/
/*                                 VISÕES                                     */
/******************************************************************************/


SET TERM ^ ;
CREATE VIEW  TOTAL_VENDIDO_PRODUTO(Produto, QTDE_vendida,Valor_vendido) AS
SELECT
produtos.descricao, sum(itens.quantidade) ,SUM(itens.quantidade* itens.PRECOVENDA)
FROM
produtos, itens , pedidos
WHERE
produtos.id_produto = ITENS.id_produto AND
itens.id_pedido = pedidos.id_pedido

group BY
produtos.descricao


^

/******************************************************************************/
/*                                 Generators                                 */
/******************************************************************************/

CREATE GENERATOR GEN_ID_CLIENTE;

CREATE GENERATOR GEN_ID_PRODUTO;

/******************************************************************************/
/*                             Stored Procedures                              */
/******************************************************************************/

SET TERM ^ ;

CREATE PROCEDURE CALCULATOTALPEDIDO (
PNUMPEDIDO INTEGER)RETURNS (VSOMA NUMERIC(15,2))
AS
BEGIN
SELECT SUM(QUANTIDADE * PRECOVENDA) FROM ITENS WHERE ID_PEDIDO = :PNUMPEDIDO INTO :VSOMA;
suspend;
END
^


/******************************************************************************/
/*                                  Triggers                                  */
/******************************************************************************/

SET TERM ^ ;

/* Trigger: TRG_INCREMENTA_CLIENTE */
CREATE TRIGGER TRG_INCREMENTA_CLIENTE FOR CLIENTES
ACTIVE BEFORE INSERT POSITION 0
AS
BEGIN
NEW.ID_CLIENTE = GEN_ID(GEN_ID_CLIENTE, 1);
END;
^


/* Trigger: TRG_INCREMENTA_PRODUTO */
CREATE TRIGGER TRG_INCREMENTA_PRODUTO FOR PRODUTOS
ACTIVE BEFORE INSERT POSITION 0
AS
BEGIN
NEW.ID_PRODUTO = GEN_ID(GEN_ID_PRODUTO, 1);
END
^

Artigo completo (View Full Post)

Quer sortear um registro do banco de dados?

Olá a todos.

Neste post algo não muito usual, mas é no mínimo muito legal.

Alguma vez você já precisou fazer uma espécie de 'sorteio' no banco de dados? Tudo bem, eu admito que dificilmente será o caso.

Mas, se você quiser sortear um felizardo dentro do seu banco de dados você não precisa criar um algoritmo que gera um Random(), testa se existe no banco e caso não exista gere Random() de novo <-- sinceramente isso não dá! xD

Vou colocar abaixo como fazer nos diferentes bancos de dados:

MySQL

select [colunas] from [tabela]
order by rand()
limit 1

PostgreSQL:

select [colunas] from [tabela]
order by random()
limit 1

MS SQL Server:

select top 1 [colunas] from [tabela]
order by newid()

IBM DB2

select [colunas] from [tabela]
order by rand()
fetch first 1 rows only

Oracle:

select [colunas] from
( select [colunas] from [tabela]
order by dbms_random.value )
where rownum = 1

Então valeu. Espero que este post ajude em algo. Abraços.

Artigo completo (View Full Post)