STORED PROCEDURE - Procedimentos Armazenados

Ola, Pessoal

#EdsonGouveia

                Boa noite, meu nome é Edson Gouveia, estou aqui para mais uma aula de Linguagem SQL, utilizando o SQL Server, hoje vou mostrar para vocês o uso das STORED PROCEDURE, ou seja, procedure vem da palavra procedimento, procedimento armazenado, elas são implementadas geralmente por DBA, Analistas de sistemas, programadores sobre um alto nível de aprendizado, acontece muito das pessoas se assustarem com esse tipo de recurso muito conhecido da linguagem T-SQL, pelo fato de serem estruturadas e algumas delas muito complexas, mas nessa aula você vera como é TÃO SIMPLES E FÁCIL ESSE TIPO DE ASSUNTO NO MUNDO DA PROGRAMAÇÃO T-SQL (:  

              

              Ela é realizada basicamente por uma sub-rotina ou função, procedimentos manuais idealizados e documentados.

             Uma maneira bem mais simples de realizar consultas, inserts, updates, deletes e selects, entre outros de registros, é utilizando as Stored Procedures, elas armazenam essa rotina, ficam salvas no SGBD de uma forma pre compiladas, aguardando  uma chamada delas caso seja necessário.

1° Primeiramente vamos criar nosso banco de dados:

CREATE DATABASE AulaProcedure;

use AulaProcedure;

2° Vamos criar nossa tabela de cliente:

CREATE TABLE CLIENTE(

ID INT PRIMARY KEY IDENTITY(1,1),

NOME VARCHAR(200),

CPF VARCHAR(20),

IDADE INT

);

3° Criando sua primeira procedure de Inserir: (INSERT)

CREATE PROCEDURE InserirCliente

@nome varchar(200),

@cpf VARCHAR(20),

@idade INT

AS

INSERT INTO cliente (Nome,

CPF,

Idade)

 

VALUES

(@nome,

@cpf,

@idade);

4° Segunda procedure de Editar (UPDATE)

 CREATE PROCEDURE EditarCliente

@id int,

@nome varchar(200),

@cpf VARCHAR(20),

@idade INT

AS

UPDATE cliente SET Nome= @nome, 

  CPF = @cpf, 

  Idade = @idade 

WHERE

ID = @id

5°  Quarta procedure de Select (SELECT)

CREATE PROCEDURE ListarCliente

@id int

AS

SELECT  NOME, 

CPF, 

IDADE 

   

   FROM cliente 

   

   WHERE ID = ISNULL(@id, id);

6° Terceira procedure de Deletar (DELETE)

CREATE PROCEDURE DetelarCliente

@id int

AS

Delete from cliente where ID = @id 

              Para passar os valores para as procedures para serem executadas, só precisa dizer o nome dela e se necessário passar os parâmetros caso ela tiver.

7° Passando OS PARÂMETROS PARA A EXECUÇÃO DAS PROCEDURES.

Inserir Registro - (InserirCliente)

InserirCliente 'Edson Gouveia', '345.787.654-67', 21;

_________________________________________

Alterar Registro - (EditarCliente)

EditarCliente 1, 'Edson Brito', '000.787.654-67', 22;

Passando o primeiro parâmentro o ID para identificar quem sera o registro.

_____________________________

Listar Registro - (ListarCliente)

ListarCliente 1  --Opcional para consulta.

ListarCliente    -- Listar todos, sem parâmetro. 

No listar eu passei o recurso ISNULL, eu posso definir quem eu vou listar ou posso simplesmente listar todos os registros.

_________________________________________

Deletar Registro - (DeletarCliente)

DeletarCliente 1

E para deletar basta dizer quem sera o registro através do ID  no parâmetro e executar.

          

          Viram como é FÁCIL? Eu disse o que? Agora curta bastante ai, faça muitas stored procedures, faça combinações, você pode fazer N combinações, utilizando Inserts,Selects, updates, deletes, todo tipo de DDL e DML que vocês quiser, seguindo sua logica de programação para tal situação que necessite, poderá fazer também cálculos matemáticos utilizando as variáveis do parâmetro ou dos registros. 

   

HAAA SIMM GALERA, Já ia esquecendo para deletar uma procedure use o comando:

 DROP PROCEDURE NomeDaProcedure; 

Para edita-la, basta encontrá-la e clicar em modificar, elas ficam todas localizadas na pasta de Programação/Procedimentos Armazenados no seu banco.

Espero ter ajudado, DEUS abençoe todos vocês.

Sucesso com esse novo aprendizado (: 

Abraços.

Cardinalidade

 Ola, galera

         Muito Bom dia, vou mostrar para vocês o conceito de cardinalidade, eu recebi alguns emails de algumas duvidas, a pedidos resolvi fazer este post, especificando melhor esse conceito de regra de negocio  que representa tipo de restrição de integridade que modela regras de negócio que define a quantidade mínima e máxima de relacionamentos entre uma determinada entidade e outras entidades distintas, através de um determinado relacionamento. A cardinalidade expressa essas quantidades.

Observe bastante como funciona nessa imagem a baixo: 

 Clique na Imagem para Visualizar: 

Cardinalidade visa restringir a quantidade mínima e a quantidade máxima de relacionamentos que uma entidade A mantém com outras entidades B, C, ... (distintas) através de um Relacionamento-Tipo (R).

V1 = Cardinalidade Mínima; e
V2 = Cardinalidade Máxima.

    






        A Cardinalidade Mínima estabelece a menor quantidade de relacionamentos que deve existir entre uma entidade qualquer e outras entidades distintas através de um relacionamento-tipo.

          A Cardinalidade Máxima estabelece a maior quantidade de relacionamentos que deve existir entre uma entidade qualquer e outras entidades distintas através de um relacionamento-tipo.

Ela é modelada num Diagrama de Entidades e Relacionamentos através de um par de valores (V1,V2) onde:

V1 >= 0 e V2 >= 1

  

       "Eu vou tentar ser mais simples possível, para vocês entender melhor, pois muitas pessoas sentem muita dificuldade nesse conceito de regra de negocio , que é muito importante quando o assunto é modelagem de Banco de Dados."  

    Pense na seguinte situação, um CLIENTE possui vários PEDIDOS, onde esses pedidos estão vinculados a vários PRODUTOS, É basicamente assim que os professores fazem para ensinar, já pra facilitar a vida do aluno, e acredite muita gente se "lasca" nesse conceito,  o relacionamento funciona na seguinte forma; 

    Cliente & Pedidos: 1 Cliente pode realizar N(vários) Pedidos, onde esses pedidos só podem está vinculados ate 1 Cliente e no máximo 1 Cliente! 

A regra funciona para a chave estrangeira a tabela de maior cardinalidade! ou seja a de pedidos! 

  

( 1.1     N.N) 

    Pedidos & Produtos: N(vários) Pedidos podem conter N PRODUTOS, onde esses produtos  podem esta vinculados a N Pedidos, a regra define para esse tipo de situação, a criação de uma nova tabela para associar as 2 entidades! Através das chaves estrangeiras! 

( N        N.N      N ) 

Clique na imagem para visualizar! 

         O segredo e você tentar buscar ler, pensa com calma na situação e aplicar a regra de negocio de uma forma correta, fazendo errado, isso pode causar grandes transtornos em um software já em funcionamento! 

Espero que tenha ajudado!

Que Deus abençoe a todos vocês e ate a próxima! 

Criar tabelas e seus tipos de atributos - SQL Server

   Ola, galera

       Olha eu aqui mais uma vez, daqui a pouco vou me arrumar, ver meu timão em campo, nesse poste eu vou tentar  focar no uso de criação de tabelas de registros, Eu já mostrei bastante isso antes, em outros exemplos. Mas aqui vou tentar especificar mais esse recurso do SQL Server, lembrado também que esses postes de banco de dados são a base inicial para depois começar os assuntos de C# na plataforma .Net que futuramente irei começar a postar.

         Nos vamos ver como é tão simples criar uma tabela no SQL Server no Management Studio, antes pense bem no nome da tabela que você ira criar, ela pode conter no máximo ate 128 caracteres, nomes de tabelas devem ser únicos e podem conter símbolos por sua preferencia, sublinhas (_), símbolos de @, sinais de libra # e numerais.

      Os tipos de atributos são basicamente que tipo irar ter cada coluna na tabela, seja ele tipo varchar, datetime, numeric, decimal, integer, char entre outros! esses são os principais mais utilizados!


VARCHAR: é o tipo de letras, bastante utilizado para nomes, ruas, entre outros, e recomendando usar sempre tipo varchar, quando não vai se trabalhar com cálculos.


NUMERIC ou DECIMAL : Como nome já define, e utilizado para valores numéricos quando vai se trabalhar com cálculos, podendo ser definido o tamanho das casas decimais, durante sua criação do tipo do atributo.

INTEGER: Bastante usando em números inteiros quando não vai se trabalhar com casas decimais, como o SQL não trabalha com virgulas. o tipo Integer só é bastante utilizado em atributos de chave Primaria e Estrangeiras e em valores inteiros!


CHAR: Serve para caracteres de tipo de tamanho único, bastante utilizado em siglas, como por exemplo, siglas de estados que no máximo só pode conter ate 2 caracteres, como PE, RJ, SP, isso mantem uma organização dos registros e a integridade da base de dados!

DATETIME: é utilizado em atributos de data e hora!

    Esses são os principais tipos de atributos, bastante utilizado, existe muitos, recomendo que você pesquise mais, Mas esses tipos que acabei de mencionar são ideias para se começar a criar tabelas no SQL Server.

Vamos aos códigos:

--Criar base de dados

CREATE DATABASE Banco;
use Banco;

--Criar Tabela de Clientes
CREATE TABLE Cliente(
ID INTEGER PRIMARY KEY IDENTITY(1,1),
NOME VARCHAR(100) NOT NULL,
EMAIL VARCHAR(50),
NASCIMENTO DATETIME,
);

--Cria tabela de produtos
CREATE TABLE PRODUTO(
ID INTEGER PRIMARY KEY IDENTITY(1,1),
NOME VARCHAR(200),
PRECO DECIMAL(18,2)
);

-- criar tabela de venda, que sera associação de Clientes as suas compras de produtos
CREATE TABLE VENDA (
ID INTEGER PRIMARY KEY IDENTITY(1,1),
idCliente INTEGER NOT NULL REFERENCES Cliente(ID),
idProduto INTEGER NOT NULL REFERENCES PRODUTO(ID),
QUANTIDADE INTEGER NOT NULL
);

-- Inserir clientes
INSERT INTO Cliente (Nome,EMAIL, NASCIMENTO) values('Edson Gouveia', 'edson@cstsolutions.com.br', '09-09-1992') ;
INSERT INTO Cliente (Nome,EMAIL, NASCIMENTO) values('Barbara Isadora', 'edson@cstsolutions.com.br', '14-04-1996') ;
INSERT INTO Cliente (Nome,EMAIL, NASCIMENTO) values('Priscila Luanna', 'edson@cstsolutions.com.br', '01-09-1994') ;

-- Inserir produtos
INSERT INTO PRODUTO (Nome,PRECO) values('Sabão em Pó', 4.45);
INSERT INTO PRODUTO (Nome,PRECO) values('Feijão Turquesa', 5.44);
INSERT INTO PRODUTO (Nome,PRECO) values('Macarão Vitarela', 7.44);

-- inserir vendas
INSERT INTO VENDA (idCliente,idProduto, QUANTIDADE) values(1, 1, 4);
INSERT INTO VENDA (idCliente,idProduto, QUANTIDADE) values(2, 2, 6);
INSERT INTO VENDA (idCliente,idProduto, QUANTIDADE) values(3, 3, 10);


--Criar consulta para ver os registros associados!
SELECT Cliente.Nome , Cliente.NASCIMENTO,
Cliente.EMAIL, PRODUTO.NOME AS PRODUTO, PRODUTO.PRECO, VENDA.IdCliente, VENDA.idProduto from Cliente, PRODUTO, VENDA  WHERE VENDA.idCliente = CLIENTE.ID and VENDA.idProduto = Produto.ID


-- Total de vendas
SELECT SUM(PRECO) as TOTAL_VENDAS  FROM Produto

     
1- Imagem

Clique na imagem para visualizar o código!

     Simples e pratico, a parte de criação da tabela associativa através da chave estrangeira como eu ja tinha ensinado em outro poste, se tiver com duvidas veja a aula anterior e criado os inserts para carrega as tabelas com registros.

2- Imagem
Clique na imagem para visualizar o código!

        Seguindo o padrão de nome da tabela e nome da coluna para criar o SELECT, e dizendo quais tabelas estarão participando dessa consulta, por ultimo ele faz a associação do ID depois do WHERE no comando.

 3- Imagem
Clique na imagem para visualizar o código!

    O ultimo select mostra a soma dos PREÇOS utilizando o recurso do SQL Server, chamando de SUM, ele calcula todos os valores de todos os registros da coluna preço, trazendo o Total de tudo,

4- Imagem

Clique na imagem para visualizar o código!

Espero que tenha Ajudado!

Que Deus abençoe todos vocês e ate a próxima!

Chaves Primárias e Estrangeiras - SQL Server

Ola, galera

       Tudo bom com vocês? acabei de chegar do culto, eita povo maravilhoso,  é engraçado tentar entender como Deus trabalha nas nossas vidas, enfim,  "Caraka " faz nem um dia que fiz a ultima postagem no finalzinho da tarde, já to postando agora de novo, amanha tem jogo, to indo ao Arruda ver o jogo do
Santa x Sport! KKK, Clássico das Multidões, esse jogo já esta ganho para o SANTACRUZ MEU ETERNO AMOR!

Deixando de conversa, vamos ao que interessa:


    Hoje eu vou mostrar para vocês o uso de chaves primarias e estrangeiras na criação de tabelas no SQL Server, Eu já tinha mostrado isso antes em outros exemplos, Mas nesse Poste, vai exclusivo pra esse tipo de recurso que é muito importante na criação de Base de dados

Chave Primária(PK) É a chave candidata que é escolhida pelo projetista do banco de dados como de significado principal para a identificação de entidades dentro de um conjunto de entidades.

Chave Estrangeira(FK) Uma chave estrangeira é chamada quando há o relacionamento entre duas tabelas

      Imagine a seguinte situação, um Cliente tem seu Carro, que precisa ser devidamente cadastrado na base de dados no sistema do estacionamento do Shopping. Como relacionar as 2 entidades?, o Cliente ao seu Carro! para obter as informações necessárias de ambos! 

CREATE DATABASE Banco;

use Banco;

--Criar Tabela de Clientes

CREATE TABLE Cliente(

ID INTEGER PRIMARY KEY IDENTITY(1,1),

NOME VARCHAR(100) NOT NULL,

EMAIL VARCHAR(50)

);

--Criar Tabela de Veiculos 

CREATE TABLE Veiculo(

ID INTEGER PRIMARY KEY IDENTITY(1,1),

PLACA VARCHAR(15) NOT NULL,

MODELO VARCHAR(200),

iDCLIENTE INTEGER NOT NULL REFERENCES CLIENTE(ID)

);

--Insira registros passando a referencia de qual Cliente este veiculo estará associado, através do ID 

INSERT INTO Veiculo (PLACA, MODELO ,iDCLIENTE) VALUES('KKJK-777', 'UNO MILLE', 1);

INSERT INTO Veiculo (PLACA, MODELO ,iDCLIENTE) VALUES('HH9A-877', 'GOL G6', 2);

INSERT INTO Veiculo (PLACA, MODELO ,iDCLIENTE) VALUES('H7GV-676', 'PALIO', 3);

SELECT * FROM Cliente

SELECT * FROM Veiculo

Selecione os registros de veja como funciona a associação! 

SELECT NOME,MODELO FROM Cliente, Veiculo where Veiculo.iDCLIENTE = Cliente.ID

Clique na imagem para visualizar o código! 

   

 

 






       O uso de chaves é muito importante pessoal, para manter a integridade do banco, explore bastante esse recurso,  porque é essencial na parte de criação de base de dados e consultas SQL.



Espero que tenha ajudado!
Que Deus abençoe todos vocês e ate a próxima!

Auto Incremento - SQL Server

Ola, galera

         Sábado, ta um calor aqui na cidade de camaragibe, que ninguém aguenta, sinceramente, enfim  hoje vou mostrar para vocês como utilizar o comando Auto incrementação do ID, no SQL Server, antes de tudo vou explicar um pouco, O porque usar auto incrementação.
Vou falar um pouco também dos comandos Not Null e Primary Key!

 AUTO_INCREMENT pode ser utilizado para automatizar um código que sirva de chave primária de uma tabela.

PRIMARY KEY define a chave primária da tabela, isto é, o campo que serve como chave da tabela e que não pode ser repetido.

NOT NULL define que um determinado campo seja de preenchimento obrigatório.

Após criadas, as tabelas podem ser manipuladas de diversas formas, inserindo, alterando ou excluindo dados. Para isso basta utilizar os comandos básicos da linguagem SQL.

CREATE DATABASE Banco;
use Banco;


--Criar Tabela, com auto incrementação!
CREATE TABLE Cliente(
ID INTEGER PRIMARY KEY IDENTITY(1,1),
NOME VARCHAR(100) NOT NULL,
EMAIL VARCHAR(50)
);

--Inserir Registros;
INSERT INTO Cliente(NOME, EMAIL) VALUES ('Edson Gouveia', 'edson@cstsolutions.com.br');
INSERT INTO Cliente(NOME, EMAIL) VALUES ('Patricia Guedes', 'patty@cstsolutions.com.br');
INSERT INTO Cliente(NOME, EMAIL) VALUES ('Nathalia Almeida', 'natty@cstsolutions.com.br');


--Visualizar Registros, cadastrados;
SELECT NOME,EMAIL FROM Cliente;

      

IDENTITY: Dessa forma no campo ID, utilizando o comando IDENTITY, estamos passando o auto incremento em termo de execução nesse campo, na criação da tabela e quando formos inserir registros não sera necessário declarar esse campo no INSERT, Pois ele estará automaticamente auto incrementando a cada registro inserido! o comando (1,1)  que fica apos o auto incremento, serve para deixar em ordem numérica o ID, mantendo uma organização dos registros!   

NOT NULL, exige que o campo seja obrigatório  a ser cadastrado.

  

PRIMARY KEY: para servir de identificador único da tabela.

    Clique na Imagem e visualize o código! 

Espero que tenha ajudado

Que Deus abençoe todos vocês, sucesso e até a próxima! 

Como usar o LIKE no SQL Server

Ola, Galera

      Para os iniciantes que ta começando, aprendendo os comandos de SQL no SQL Server , Vou mostrar agora, Como aplicar o comando LIKE do SQL, muito utilizado em comandos de buscas nos usos de SELECT.

 Utilizando o SGBD SQL Server, sendo possível também ser aproveitando em outros SGBDs.

-- Abra seu Banco de Dados e digite os comandos a seguir:

--Criando uma base de dados:
  CREATE DATABASE Banco;
  USE Banco


  --Crie a tabela:
CREATE TABLE Cliente(
ID INTEGER PRIMARY KEY Not null identity(1,1),
Nome varchar(100) not null
);



--Faça o Insert de registros na tabela:
INSERT INTO Cliente (Nome) values ( 'Edson Gouveia');
INSERT INTO Cliente (Nome) values ( 'Carlos Japa');
INSERT INTO Cliente (Nome) values ( 'Cleverson Lacerda');


-- Criando Comando LIKE '%'
 SELECT NOME FROM Cliente WHERE NOME LIKE '%' + 'Edson Gouveia' + '%'    



     Simples e rápido, ele utiliza as % para buscar de acordo com os caracteres, de trás pra frente e de frente pra trás do Registro da tabela:

     Teste outros registros, lembrando também que a linguagem SQL e capaz de reconhecer comandos sem obrigatoriedade de letras maiúsculas e minusculas,  Entretanto isso varia bastante em empresas que seguem um padrão, Pra manter uma organização em geral do código:


SELECT NOME FROM Cliente WHERE NOME LIKE '%' + 'Japa' + '%'  
SELECT NOME FROM Cliente WHERE NOME LIKE '%' + 'Cleverson' + '%'  

    Clique na Imagem a baixo!





Espero que tenha ajudado!
Que Deus abençoe todos vocês, Sucesso e até a próxima!

POG: Programação Orientada a Gambiarras

Programação Orientada a Gambiarras, ou somente POG, é uma técnica avançada de desenvolvimento de software que tem como base a utilização de todo tipo de gambiarra, remendo e tudo de pior que um código pode ter. POG se baseia em conceitos como duplicação de código, fluxos redundantes, tarefas desnecessárias e reinvenção de rodas.

Clique na imagem para Visualizar: 

A primeira POG que se tem notícia é datado de 1582 d.C. O nome desta POG hoje é chamada de Ano Bissexto e foi criada pelo Papa Gregório XIII. Esta POG foi aplicada quando descoberto que a Terra leva 365,25 dias para dar uma volta no Sol, porém nosso calendário tem apenas 365 dias, o que leva a uma diferença de 6 horas por ano. Ao invés de corrigir o “sistema” para que não houvesse essa diferença, a solução adotada pelo Papa foi: “A cada quatro anos, é só colocar mais um dia ali”.

Acredita-se que a POG está presente desde os primórdios da criação de software. Alguns até dizem que ela já existia desde a época de cartões perfurados. POG mantém sua evolução ao longo do tempo, onde perdurou com a programação estruturada e atingiu seu ápice com o surgimento da orientação a objetos.

Se você não conhece POG e não está entendendo nada, leia esse artigo para entender melhor.

No meu primeiro post havia mencionado que iria mostrar alguns códigos POG que tenho encontrado durante esses 10 anos que trabalho com desenvolvimento de software. Relutei quase um ano para tocar no assunto, tentando até certo ponto preservar os autores dos códigos POG que encontrei pela frente.

Mas outro dia me deparei com um trecho de código que me serviu de motivação para publicar os exemplos de POG que tenho guardado

Observação importante

Não estou aqui dizendo que sou um programador perfeito, que não cometo erros ou que escrevo o código mais limpo do mundo. Com certeza eu já fiz alguma POG, seja por falta de conhecimento ou por falta de opção. O ponto aqui é aprender com os erros, os seus e os dos outros.

Por outro lado, eu me esforço para aprimorar a qualidade do meu código a cada dia. Isso se dá com a prática do dia-a-dia, trocando experiências com outros desenvolvedores, lendo o código dos outros, fazendo programação pareada e estudando e lendo muito. Também sei que sou detalhista, sistemático e até certo ponto chato em relação à qualidade de código. Um código ruim me incomoda, mesmo que esse código produza o que se espera dele.

Além disso, todo e qualquer código POG que eu venha a publicar aqui foi escrito por desenvolvedores experientes (ou que se diziam experientes). Achar defeitos em código de um programador iniciante ou um estagiário é fácil, publicá-los seria puramente sacanagem.