Categoria Tudo

  • Início   /  
  • Arquivo por categoria "Tudo"

JOIN’s SQL – Vamos aprender ?

Olá pessoal, vamos dar continuidade a nossa trilha do SQL. Dessa vez vamos aprender a relacionar tabelas no momento das consultas.

Para isso vamos utilizar a cláusula JOIN e suas cláusulas conjuntas.

Temos algumas variações da cláusula JOIN. Agora vamos entender cada uma delas.

INNER JOIN  ou JOIN

A cláusula INNER JOIN ou somente JOIN, é utilizada para cruzarmos registro trazendo apenas aqueles que existirem em ambas as tabelas.

SELECT Func.NomeFuncionario

      ,Carg.DescCargo

FROM FUNCIONARIO Func

INNER JOIN CARGO Carg  
  ON Carg.Cod = Func.CodCargo

Neste exemplo a consulta retornará todos os registros que contemplem ambos os lados da consulta, ou seja todos os funcionários que possuam cargos.

 

LEFT JOIN

A cláusula LEFT JOIN, é utilizada para cruzarmos registro trazendo todos os da tabela declarada a esquerda e aqueles que existirem em ambas as tabelas.

SELECT Func.NomeFuncionario
      ,Carg.DescCargo
FROM FUNCIONARIO Func
LEFT JOIN CARGO Carg  
  ON Carg.Cod = Func.CodCargo

Neste exemplo a consulta retornará todos os funcionários que tenham cargo e também os que não possuírem, neste caso as informações de cargo virão como NULL.

 

RIGHT JOIN

A cláusula RIGHT JOIN, é utilizada para cruzarmos registro trazendo todos os da tabela declarada a direita e aqueles que existirem em ambas as tabelas.

SELECT Func.NomeFuncionario

      ,Carg.DescCargo

FROM FUNCIONARIO Func

RIGHT JOIN CARGO Carg  

  ON Carg.Cod = Func.CodCargo

Neste exemplo a consulta retornará todos os cargos que tenham funcionários  e também os que não possuírem, neste caso as informações de funcionário virão como NULL.

 

FULL JOIN

A cláusula FULL JOIN, é utilizada para cruzarmos registro trazendo os registros de ambas as tabelas, possuindo cruzamento ou não.

SELECT Func.NomeFuncionario

      ,Carg.DescCargo

FROM FUNCIONARIO Func

FULL JOIN CARGO Carg  

  ON Carg.Cod = Func.CodCargo

Neste exemplo a consulta retornará todos os registros de ambas as tabelas, para as que não possuírem relacionamento, as informação não contempladas virão como NULL.

 

CROSS JOIN

A cláusula CROSS JOIN, realiza o cruzamento de todos os registro da primeira tabela com todos os registros da segunda tabela.

Está cláusula deve ser utilizado com cuidado, pois pode gerar lentidão no seu processamento dependendo do volume de registros.

SELECT Func.NomeFuncionario

      ,Carg.DescCargo

FROM FUNCIONARIO Func

CROSS JOIN CARGO Carg

No caso a cima, a consulta retornara um cruzamento desconsiderando a chave, e vai cruzar todos os registros de funcionário com os registros de cargo.

Por exemplo

NomeFuncionario DescCargo
Paulo Analista
Paulo Gerente
Paulo Diretor
Maria Analista
Maria Gerente
Maria Diretor
Pedro Analista
Pedro Gerente
Pedro Diretor

 

Pontos muito importantes !!!

  • É sempre muito importante, para termos uma query que desempenhe bem, montarmos a cláusula ON seguindo um índice existente na tabela que será consultada.
  • Também é muito importante deixar as condições relativas a uma tabela sempre dentro do ON da mesma tabela e não no WHERE. No WHERE deixamos as condições da tabela principal.
  • Definirmos os campos que queremos que a consulta retorne, nunca deixar * no SELECT, isso impacta muito na performance do retorno.
  • Utilizar FULL JOIN e CROSS JOIN com prudência, pois os mesmos impactam na performance das consultas.

 

 

Espero que ajude muito a todos.

Até a próxima!!!

Tecnologia e a Pandemia

 

 

Já parou pra pensar o quanto nossas vidas estão mudando neste período de pandemia?

Como todas as grandes crises que ocorreram na história da humanidade, as pessoas foram obrigadas a superar as dificuldades que ocorreram devido aos problemas, fazendo com que evoluíssemos com isso.

Infelizmente o ser humano evolui muito mais rápido em momentos de dificuldade, então com isso temos que olhar o que podemos levar de bom desse momento de dor e dificuldades.

Sei que pra muitas pessoas esse é o pior momento já enfrentado na vida, seja pela perda de um ente querido ou por problemas financeiros.

Com esses problemas estamos sendo obrigados a sair de nossa zona de conforto e nos reinventarmos em diversos setores.

Aos que tinham restaurante, foram obrigados a vender por aplicativos para não fechar as portas.

Aos que tinhas lojas, foram obrigados a vender pela internet.

Aos que trabalhavam em escritórios a implantação do Home Office foi inevitável.

Quem imaginou que conseguiríamos reduzir o transito e a poluição de grandes metrópoles? Ou que teriam mais tempo para convivermos com nossos familiares?

Que resolveríamos a maioria de nossos problemas pelo computador, celular ou tablet?

Diversas das atitudes e formas de nos reinventarmos durante este momento, só esta sendo possíveis pelo avanço tecnológico que tivemos nos últimos anos.

Tenho certeza que a forma de trabalhar e de viver vai ser muito diferente quando isso tudo acabar. Resta saber se estaremos preparados para as mudanças que estão acontecendo.

Uma coisa é certa, a tecnologia vai estar cada vez mais presente em tudo que fazemos e mudando a forma que estamos acostumados a realizar nossas tarefas.

E você… O que espera da tecnologia para os próximos anos ?

 

Até a próxima!!!

 

Modelo Entidade Relacionamento-SQL

Fala pessoal…

Hoje vamos dar continuidade em nossa trilha do SQL, e aprender uma parte conceitual muito importante para aperfeiçoarmos nossa logica na hora de estruturar um banco de dados e ate mesmo um sistema.

Esta etapa é muito importante para testarmos nossa ideia de criação de um banco de dados, suas tabelas, colunas e relacionamentos.

Hoje vamos falar sobre o Modelo Entidade Relacionamento e sobre o Diagrama Entidade Relacionamento ou simplesmente MER e DER.

MER

O Modelo Entidade Relacionamento é uma forma lógica de pensarmos na estrutura de um banco de dados e assim definir suas Entidades(tabelas), Relacionamentos (chaves) e Atributos(campos).

Como é uma parte bem conceitual, a ideia do MER é pensarmos em nosso sistema de forma estruturada. Por exemplo, vamos imaginar que estamos montando um banco de dados de uma loja de de departamento que quer vender via e-commerce .

Entidades

Então começamos a pensar nas nossas entidades principais que não dependem de outras entidades para existir, vamos definir algumas:

  • Fornecedor
  • Produto
  • Cliente
  • Departamento

Essas entidades são conhecidas como Entidades Fortes. Elas podem existir por si só e não dependem de outras para definir sua importância.

Em seguida vamos pensar em algumas entidades que necessitam das anteriores para existir, como por exemplo:

  • Usuário
  • Pedido de Venda
  • Pedido de Compra
  • Categoria

Essas entidades são conhecidas como Entidades Fracas, pois dependem de outras entidades para existir.

Também temos algumas entidades que existem para realizar a interligação entre as entidades. Elas são chamadas de Entidades Associativas, veja:

  • Usuário do Cliente
  • Itens do Pedido de Venda
  • Itens do Pedido de Compra
  • Produtos do Fornecedor
  • Produtos da Categoria
  • Categorias do Departamento

A ideia dessas entidades é que elas não possuem uma chave primaria própria mas sim a junção de outras chaves primarias para criar seus registos únicos, como por exemplo:

Itens do Pedido de Venda -> Código do Pedido + Código do Produto .

Relacionamentos

Agora que definimos as entidades, é necessário definirmos os relacionamentos entre elas, para isso temos três formas de relacionamentos.

  • Relacionamento 1 para 1 – No relacionamento 1:1, definimos que sempre sera um registro de uma entidade vai se relacionar com apenas um registro de outra entidade. Por exemplo, um cliente pode ter apenas um usuário cadastrado para acessar o sistema.
  • Relacionamento 1 para muitos – No relacionamento 1:n, definimos que um registro de uma entidade poderá ter vários registros de outra entidade. Por exemplo, um cliente pode ter vários pedidos de venda, porem um pedido de venda não pode pertencer a vários cliente.
  • Relacionamento muitos para muitos – No relacionamento n:n, definimos ambas entidades podem ter mais de um relacionamento entre elas. Por exemplo, um pedido de venda pode ter vários produtos e um produto pode pertencer a vários pedidos de vendas.

Atributos

Agora vamos entender os atributos.

Os atributos são as características e informações que cada entidade possui. Eles podem ser de alguns tipos diferente:

  • Atributos Nominativos – são aqueles que identificam um objeto da classe, como por exemplo o CPF de um cliente, o nome do cliente, ou até mesmo o código do cliente dentro do sistema.
  • Atributos Descritivos – são aqueles que descrevem alguma informação do objeto, como por exemplo, data de nascimento do cliente, o nome do cliente também pode ser um atributo descritivo, endereço, etc…
  • Atributos Referenciais – são atributos que realizam a ligação entre entidades, como por exemplo o código do cliente dentro do pedido de venda, o código do produto dentro do pedido de venda, o código da categoria dentro do produto, etc…

Além dessa divisões também podemos classificar os atributos como simples ou compostos.

Os atributos simples são aqueles que uma única informação os define, como por exemplo a data de nascimento do cliente, ou a descrição do produto.

Já os atributos compostos são aqueles que necessitam de mais de um atributo para possuírem a informação completa, como por exemplo o endereço, que necessita do atributo logradouro + complemento + bairro + cidade + estado + CEP.

Agora que entendemos o Modelo Entidade Relacionamento, podemos ver que é muito difícil desenhar todo um banco de dados somente com o MER, e por isso temos o DER que é o Diagrama Entidade Relacionamento.

DER

O Diagrama Entidade Relacionamento é a forma gráfica de representar o MER, ele se baseia em uma representação por diagramas, onde possui um nível de abstração muito maior que o MER.

Temos algumas formas de criar o nosso DER. Dois modelos muito conhecidos são:

Notação Peter Chen

Peter Chen é um cientista da computação nascido em Taiwan e Professor de ciência da computação na Louisiana State University, conhecido como criador do modelo entidade relacionamento.[1]

Consiste em uma notação que utiliza entidades (retângulos), relacionamentos (losangos), atributos (elipses) e linhas de conexão (linhas) que indicam a cardinalidade de uma entidade em um relacionamento.

A mesma é representada como o exemplo abaixo:

Notação James Martin

James Martin foi um britânico consultor e autor sobre Tecnologia da Informação, conhecido por seu trabalho em engenharia de tecnologia da informação.

Sua notação consiste na utilização de entidades (caixas), com seus atributos representados diretamente dentro da Entidade, e os relacionamentos são feitos através de linhas que representam a cardinalidade.

Esta notação exibe as informações de uma forma mais enxuta e fácil de visualizar.

Vamos montar nosso exemplo utilizado o DER do do próprio Microsoft SQL Server.

É isso pessoal, espero que ajude muito quando precisarem a estruturar um novo banco de dados.

Até a próxima!!!

Consultas SQL – Vamos aprender!!!

Fala pessoal, tudo bem ?

Dando continuidade nos nossos artigos referente ao conhecimento do SQL, vamos ver hoje um pouco de uma parte da linguagem SQL chamada de DQL (Data Query Language ou Linguagem de Consulta de Dados).

Essa parte da linguagem trata especificamente de comandos utilizados para realizar consultas no banco de dados.

Estrutura Básica.

A estrutura básica deste comando é a seguinte:

SELECT [campo1],[campo2],[campo3] FROM [Tabela] WHERE [condicao1] = [valorCondicao]

Olhando bem essa estrutura, vemos que a mesma é composta pela clausula SELECT, que é utilizada para definirmos os campos que queremos retornar em nossa consulta ao lado, lembrando que caso necessitemos trazer todos os campos, podemos utilizar o operador coringa *, porém o mesmos deve ser utilizado com cautela, pois em uma consulta com muitos registros e colunas, pode acabar gerando lentidões desnecessárias.

Na sequência utilizamos a clausula FROM, que definirá a tabela que gostaríamos de buscar os registros.

Depois temos a clausula opcional (mas que podemos quase sempre considerar indispensável), WHERE, a mesma é utilizada para definir os parâmetros de busca de nossa consulta.

Temos mais algumas clausulas que podemos utilizar e veremos mais a frente.

Agora veja um exemplo da utilização deste estrutura.

SELECT IdProduto, DescProduto, Preco 
FROM Produto 
WHERE IdProduto = 1

Neste exemplo, buscamos 3 colunas da nossa tabela Produto onde o IdProduto = 1

Na clausula WHERE temos alguns operadores lógicos e relacionais que podemos utilizar:

Operadores SQL
Operador Descrição Exemplo
= Igual IdProduto = 1
<> ou != Diferente IdProduto <> 1
> Maior que Preco > 1000
>= Maior ou igual que Preco >= 1000
< Menor que Preco < 1000
<= Menor ou igual que Preco <= 1000
IN Está contido IdProduto IN (1,2,3)
NOT IN Não está contido IdProduto NOT IN (2,3)
BETWEEN Intervalo entre IdProduto BETWEEN 1 AND 2
LIKE Parte do registro DescProduto LIKE ‘TV%’
AND Ambas condições verdareiras IdProduto BETWEEN 1 AND 2 AND Preco > 1000
OR Uma condição verdadeira IdProduto BETWEEN 1 AND 2 OR Preco > 1000

Agrupando registros e suas funções.

Também temos alguma funções de agregação que podemos utilizar. Estas função dependem da utilização da clausula GROUP BY que deve ser utilizada após a clausula WHERE.

MAX

Função responsável por retornar o maior valor dentro da busca e do agrupamento solicitado na consulta.

SELECT MAX(Preco) MaiorPreco, IdCategoria
FROM Produto 
WHERE Ativo = 1
GROUP BY IdCategoria

No exemplo acima estamos buscando o maior preço de produto, agrupado pela categoria.

Veja que definimos a clausula GROUP BY com o campo IdCategoria.

MIN

Função responsável por retornar o menor valor dentro da busca e do agrupamento solicitado na consulta.

SELECT MIN(Preco) MenorPreco, IdCategoria
FROM Produto 
WHERE Ativo = 1
GROUP BY IdCategoria

No exemplo acima estamos buscando o menor preço de produto, agrupado pela categoria.

AVG

Função responsável por retornar a média de um valor dentro da busca e do agrupamento solicitado na consulta.

SELECT AVG(Preco) MenorPreco, IdCategoria
FROM Produto 
WHERE Ativo = 1
GROUP BY IdCategoria

No exemplo acima estamos buscando a média do preço de produto, agrupado pela categoria.

SUM

Função responsável por somar valores dentro da busca e do agrupamento solicitado na consulta.

SELECT SUM(Preco) SomaPreco, IdCategoria
FROM Produto 
WHERE Ativo = 1
GROUP BY IdCategoria

No exemplo acima estamos buscando a soma do preço dos produtos, agrupado pela categoria.

COUNT

Função responsável por contar as linhas dentro da consulta.

Esta função possui a seguinte estrutura:
COUNT ( { [ [ ALL | DISTINCT ] coluna1 ] | * } )

Desta forma conseguimos contar uma determinada coluna, e os valores nulos serão desconsiderados na contagem, ou podemos contar uma coluna utilizando a clausula DISTINCT e retornar somente a quantidade de valores diferentes ou então contar todas as linhas da consulta utilizando o operador *.

Veja os exemplos.

SELECT IdCategoria, COUNT(IdCategoria)QtdCateg 
FROM Produto 
WHERE Ativo = 1
GROUP BY IdCategoria


SELECT IdCategoria, COUNT(DISTINCT IdCategoria)QtdCateg 
FROM Produto 
WHERE Ativo = 1
GROUP BY IdCategoria

SELECT  COUNT(*)QtdProdutos 
FROM Produto 
WHERE Ativo = 1

No primeiro exemplo, utilizamos o COUNT com o campo e também utilizamos o GROUP BY para retornar a quantidade de itens dentro de uma categoria.

No segundo exemplo fizemos o mesmo SELECT, porem utilizando o DISTINCT dentro do COUNT, veja que ele trouxe tudo com o valor 1 pois desconsiderou as duplicidades no campo informado. Imagine que neste exemplo você pode desconsiderar, produtos cadastrado com o mesmo código de barras ou desconsiderar qualquer tipo de duplicidade.

No terceiro exemplo contamos todas as linhas da tabela Produto.

Agora que já aprendemos a usar as funções de agregação vamos aprender a filtrar nossa consulta a partir da agregação realiza.

Para isso vamos utilizas a clausula HAVING. Esta clausula tem a mesma função do WHERE, porém ela é especifica para as funções de agregação, isso é necessário porque a clausula WHERE não comporta esse tipo de função.

Vamos aos exemplos.

SELECT SUM(Preco) SomaPreco, IdCategoria
FROM Produto 
WHERE Ativo = 1
GROUP BY IdCategoria
HAVING SUM(Preco) > 1000


SELECT SUM(Preco) SomaPreco, IdCategoria
WHERE Ativo = 1
GROUP BY IdCategoria
HAVING SUM(Preco) < 1000

Nestes exemplos utilizamos a clausula HAVING para filtrar a soma de preço das categorias.

No primeiro caso, buscamos as categorias que possuem a soma do preço maior que 1000.

No segundo caso, buscamos as categorias que possuem a soma do preço menor que 1000.

Ordenando registro.

Por último em nossa apresentação da parte básica do DQL, temos a clausula ORDER BY que é responsável pela ordenação dos registros.

Esta clausula deve ser utilizada ao final da consulta e deve seguir a estrutura abaixo.

ORDER BY [coluna1][ASC|DESC], [coluna2][ASC|DESC]

Neste caso, ASC ou DESC são utilizados para definirmos se a ordenação da coluna será crescente ou decrescente, lembrando que não é necessário utilizar o ASC, pois o mesmo é o default para a ordenação.

Vamos ao exemplo.

SELECT IdProduto, DescProduto, Preco 
FROM Produto 
WHERE Ativo = 1
ORDER BY Preco DESC, DescProduto


SELECT IdProduto, DescProduto, Preco 
FROM Produto 
WHERE Ativo = 1
ORDER BY Preco

No primeiro exemplo definimos que o resultado venha ordenado de forma decrescente pelo preço, e caso tenha produtos com preços iguais os mesmo sejam ordenados de forma crescente pela descrição.

No segundo exemplo o resultado foi ordenado de forma crescente pelo preço.

Bom pessoal, está é a parte básica da estrutura do SELECT e da parte da DQL da Linguagem SQL.

No próximo artigo vamos avançar um pouco mais.

Espero que ajude muito a todos.

Até a próxima!!!

Machine Learning & Inteligencia Artificial

Com certeza você se lembra de alguns filmes icônicos, como a franquia de Exterminador do Futuro, A.I. – Inteligencia Artificial e Eu Robô. Esses filmes vislumbravam alguns conceitos que temos escutado muito ultimamente que são o Machine Learning e a Inteligencia Artificial.

Bom, hoje vemos que isso não é apenas ficção cientifica e já estamos vivendo uma parte destes conceitos em ferramentas de trabalho e até mesmos em nossos aparelhos de celulares com interfaces inteligentes como a Amazon Alexa, o Apple Siri e o Google Assistente.

Mas você sabe realmente o que são esses conceitos?

Machine Learning.

Machine Learning, é em sua tradução literal “Aprendizagem de Máquina”, então é qualquer ação que uma uma máquina consiga aprender a executar, através de sua programação básica. Esse conceito, por muitas vezes acaba sendo diretamente associado a inteligencia artificial, mas temos uma diferença ente eles.

A ideia base de Machine Learning é que um sistema computacional consiga mudar suas operações, levando em conta dados obtidos em outras execuções.

Um exemplo disso, são as informações das assistentes virtuais das empresas como Amazon, Apple e Google, que com base nas informações dos usuários, consegue sugerir produtos, executar tarefas e gravar informações pessoais.

Carros autônomos, tem sido criados por empresas como Google e Tesla e ambas utilizam o conceito de Machine Learning para a aprendizagem destas tarefas.

Outro exemplo interessante, são os sistemas de tradução simultâneas e de pesquisa , que conseguem levar em conta, gírias e jargões regionais para realizar suas ações.

Tudo isso é possível graças ao conceito de Machine Learning.

Inteligencia Artificial.

A ideia de inteligencia artificial é a de imitação da inteligencia humana, onde uma de suas capacidades é a aprendizagem, que seria então o Machine Learning, porém esse é apenas um de seus recursos.

A inteligencia artificial tem como objetivo a simulação da inteligência humana, assim como o raciocínio e o poder de decisão.

Mas acredito que ainda que a ciência consiga atingir os objetivos da inteligência artificial, teremos algumas características da inteligência humana que serão muito difícil de ser reproduzidas, como por exemplo os sentimentos, emoções e empatia.

Os benefícios da inteligência computacional.

Ambas as tecnologias, nos ajudarão em diversas tarefas, e já começamos as ver seus benefícios.

Ações e funções complexas poderão ser resolvidas de forma mais ágeis, e criaram novas oportunidades.

Porém nesse futuro não tão distante, fica cada vez mais óbvio que as pessoas precisaram conhecer sobre tecnologia para exercer suas atividades.

Com esse pensamento, muitas pessoas acreditam que a tecnologia tem substituído e vai substituir muito mais o lugar das pessoas no mercado de trabalho.

Essa é uma perspectiva preocupante, porém abre um novo leque de evolução para os profissionais, onde todos poderão expandir seus conhecimentos e melhorar suas habilidades, sempre adicionando a tecnologia aos estudos.

Temos que levar essa evolução das máquinas como parte da evolução de nossa sociedade, e entender teremos muitos ganhos com isso.

Setores como o de saúde, indústria, ensino, segurança pública, economia e mobilidade urbana mudarão muito nós próximos anos.

Cuidados que precisamos ter.

Uma grande preocupação que precisamos ter é com a privacidade.

Esse ponto não é relativo somente a Inteligência Artificial e a Machine Learning, porém podem ter seu efeitos amplificados com essas tecnologias.

Sabemos que muitas empresas usam essas tecnologias para captar grande quantidade de informações pessoais para melhorar o setor de marketing, porém muitas delas acabam pegando informações de mais, e isso pode acabar incomodando e ferindo nossa privacidade.

Desta forma, temos que tomar muito cuidado com as informações e deixamos disponíveis na internet e em aplicações que utilizamos.

 

Bom com tudo isso, podemos ter certeza que o futuro já chegou, e ainda não tivemos a visita do exterminador do futuro, mas a inteligência artificial já está entre nós.

 

Até a próxima!!!

Insert, Update e Delete… Quer aprender ?

Fala pessoal, tudo bem ?

Você que tem acompanhado os outros artigos em Banco de dados, deve ter visto que já expliquei o que é SQL, o que é e como criamos uma banco de dados e também como criamos tabelas, colunas e chaves.

Agora vamos ver como manipular dados dentro do banco, utilizando a parte da linguagem DML (Data Manipulation Language) ou seja Linguagem de Manipulação de Dados.

Então vamos ver os comando INSERT, UPDATE e DELETE explorando cada um deles e fazendo alguns exemplos juntos… Vamos lá?

Comando INSERT.

Primeiramente vamos começar com o comando de inclusão de dados.

O comando INSERT na verdade é INSERT INTO e a estrutura do mesmo é a seguinte :
INSERT INTO table_name (column1, column2, column3, …)
VALUES (value1, value2, value3, …)

Onde table_name representa o nome da tabela que vamos inserir os dados, column[n] representa as colunas que serão consideradas na inclusão do registro e value[n] representa os dados que serão incluídos nas colunas do registro.

Então vamos para o exemplo.

INSERT INTO Categoria (Descricao)
VALUES ('Eletrônicos'),
       ('Papelaria'),
       ('Vestuário')

No exemplo acima, foi adicionado 3 categorias, na tabela Categoria (criada no artigo Criando tabelas – Microsoft SQL Server).

Como a coluna IdCategoria desta tabela esta com valor auto incremental, a mesma não precisou ser adicionada no comando de inclusão.

Esses são os valores inseridos no banco:

Agora vamos inserir registros na tabela Produto.

INSERT INTO Produto (DescProduto,Preco,Peso,Ativo,IdCategoria,DataCriacao,CodBarras)
VALUES ('TV LCD 50 Polegadas',2500.00,32.54646,1,1,GETDATE(),'')

INSERT INTO Produto (DescProduto,Preco,Peso,Ativo,IdCategoria,DataCriacao,CodBarras)
VALUES ('Caderno Capa dura 50 folhas',3.50,0.150,1,2,GETDATE(),''),
       ('Camiseta M Preta',25.99,.1367,1,3,GETDATE(),'')

Aqui temos dois exemplos, o primeiro está inserindo apenas um registro e o segundo inserindo dois registros.

Note que o valor referente a coluna IdCategoria, deve existir na tabela Categoria. Caso o mesmo não exista ocorrera o erro com a seguinte mensagem:
The INSERT statement conflicted with the FOREIGN KEY constraint “FK_ProdutoCategoria”. The conflict occurred in database “DataBaseName”, table “dbo.Categoria”, column ‘IdCategoria’.

Nos exemplos. utilizamos a função GETDATE(), que retorna a data e hora atual do sistema.
Os registros ficaram da seguinte forma:

Comando UPDATE.

Agora, vamos falar sobre o comando de atualização.

O comando UPDATE tem a seguinte estrutura básica:

UPDATE table_name SET column2 = value2 WHERE column1 = [valor de filtro]

Muito importante nos atentarmos nas condições do WHERE, pois caso as mesmas estejam erradas, podemos acabar alterando registros que não queremos.

Vamos ao exemplo:

UPDATE Produto SET Preco = 2550.00, CodBarras = '7892509106405' WHERE IdProduto = 1

UPDATE Produto SET Preco = 4.00 WHERE IdProduto = 2

Nos exemplos acima, foram realizadas alterações do preço e do código de barras do produto com IdProduto = 1 e alteramos o preço do produto com IdProduto = 2.
Os registros ficaram da seguinte forma:

Comando DELETE.

Por último vamos ver o comando de exclusão de registros.

O comando DELETE tem a seguinte estrutura:

DELETE FROM table_name WHERE column1 = [valor de filtro]

Muito importante nos atentarmos nas condições do WHERE, pois caso as mesmas estejam erradas, podemos acabar deletando registros que não queremos.

Vamos ao exemplo:

DELETE FROM Produto WHERE IdProduto = 3

Veja que o registro foi deletado.

Bom pessoal, esse é o conteúdo de hoje e com ele entendemos um pouco sobre a parte DML da linguagem SQL.

Aguarde o próximo conteúdo sobre banco de dados.

Até a próxima!!!

Programação Orientada a Objetos – ADVPL

Olá pessoal, tudo bem ?

Hoje vou falar um pouco sobre o programação orientada a objetos (POO) dentro da linguagem ADVPL.

O ADVPL é uma linguagem baseada no Clipper, sendo assim, uma linguagem estruturada.

Com a evolução das linguagens, a TOTVS buscou aprimorar sua linguagem, e com o passar do tempo, e trouxe a orientação a objetos para dentro do ADVPL.

Então, como todas as linguagens POO, ela possui Classes, Propriedades, Métodos, Herança, Encapsulamento, Polimorfismo e Abstração.

Vou explicar um pouco de cada parte do conceito de POO na linguagem ADVPL.

Primeiramente vamos começar com a definição da classe.

#INCLUDE 'TOTVS.CH'
/*/-----------------------------------------------------------
{Protheus.doc} ExemploClass
Classe de exemplo ADVPL

Uso: Geral

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
CLASS ExemploClass From LongClassName
  
  // Defina os parâmetros que sua classe deverá possuir
  Data cPropStr
  Data nPropNum
  Data dPropData
  Data oPropObj
  Data aPropArray
  Data lActive
  
  METHOD New() CONSTRUCTOR
  METHOD Activate()
  METHOD Deactivate()
  METHOD Executar()
  // Demais métodos pertinentes a sua classe 
  
ENDCLASS

Nesta primeira primeira parte de definição da classe vamos colocar o nome da classe logo após a palavra reservada CLASS e o nome da classe pai que nossa classe vai herdar após a palavra reservada From.

Como não estamos herdando essa classe de nenhuma classe especifica vamos herdar a classe LongClassName que permite a utilização de nomes longos.

Logo abaixo começamos a definir as propriedades da classe, utilizando a palavra reservada Data, seguido do nome da propriedade.

Logo abaixo vamos definir as assinaturas dos métodos existentes em nossa classe. Repare que definimos um método New que será o construtor da nossa classe, utilizando a palavra reservada CONSTRUCTOR.

E por fim, encerramos a definição da classe utilizando a palavra reservada ENDCLASS.

Com nossa classe definida, começamos a realizar a construção de nossos métodos dentro da classe.

Primeiramente vamos definir o método construtor e  entender sua importância.

/*/-----------------------------------------------------------
{Protheus.doc} New()
Construtor da classe

Uso: ExemploClass

@sample
//ExemploClass():New()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
METHOD New() CLASS ExemploClass

  ::cPropStr      := " "
  ::nPropNum      := 0
  ::dPropData     := Date()
  Self:oPropObj   := NIL
  Self:aPropArray := {}
  Self:lActive    := .F.

Return Self

O método New, é importante para a iniciação base das propriedades da classe, ou seja seus valores default, desta forma vamos garantir a integridade do funcionamento da classe.

Também podemos definir a obrigatoriedade do preenchimento dos parâmetros da classe, obrigando a passagem deles por parâmetro do método. Isso deve ser feito da mesma forma que é feito em uma função comum do ADVPL.

Muito importante que o retorno deste método seja a palavra reservada Self, que representa o objeto da instância da nossa classe.

Ou seja nosso método New tem a função de criar a instância em que iremos trabalhar, possibilitando a utilização de todos os métodos e propriedades existentes em nossa classe.

Note que para manipularmos ou acessarmos propriedades de dentro de nossa classe podemos utilizar a palavra reservada Self ou ::, as duas formas indicam que estamos acessando propriedades ou métodos de nossa classe corrente. Isso só pode ser utilizado dentro do escopo da classe, ou seja, dentro dos métodos da mesma.

 

Outros métodos importantes de utilizamos são os métodos Activate e o Deactivate.

Com o método Activate podemos definir que nossa classe esta pronta para executar determinados métodos e realizar uma pré-validação de suas execução.

E o método Deactivate é importante para realizarmos a destruição dos objetos e informações correntes, já que o ADVPL não destrói essas informações automáticamente, deixando as mesmas em memória até a finalização da thread corrente.

Vamos defini-los :

/*/-----------------------------------------------------------
{Protheus.doc} Activate()
Ativa a classe

Uso: ExemploClass

@sample
//ExemploClass():Activate()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
METHOD Activate() CLASS ExemploClass
  
  If !Empty(::cPropStr) .AND. ::nPropNum > 0
    ::lActive := .T.
  EndIf
Return ::lActive

/*/-----------------------------------------------------------
{Protheus.doc} Deactivate()
Desativa a classe

Uso: ExemploClass

@sample
//ExemploClass():Deactivate()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
METHOD Deactivate() CLASS ExemploClass
    
    If ::oPropObj <> NIL 
        ::oPropObj:DeActivate()  
        FreeObj(::oPropObj)
        ::oPropObj := Nil	
    EndIf
    
    ::lActive := .F.
Return

 

Vamos agora criar um exemplo de métodos de execução:

/*/-----------------------------------------------------------
{Protheus.doc} Executar()
Método exemplo de execução na classe.

Uso: ExemploClass

@sample
//ExemploClass():Executar()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
METHOD Executar() CLASS ExemploClass
  Local cRet := ""
    
  If ::lActive 
     If ::nPropNum > 10 
       cRet := "Data de Execução do método - " + DTOS(dPropData) + "Texto: "+ ::cPropStr
     Else
       cRet := " Propriedade numerica é menor ou igual a 10 "
     EndIf
  Else
    cRet := "A Classe não está ativa"
  EndIf
    
Return cRet

 

No exemplo a seguir vamos aprender a instanciar e executar métodos da classe.

/*/-----------------------------------------------------------
{Protheus.doc} ExecClas()
Utilizando classe de Exemplo 

Uso: ExemploClass

@sample
//U_ExecClas()

@author Paulo Henrique Corrêa Cardoso.
@since 27/07/2020
@version 1.0
-----------------------------------------------------------/*/
User Function ExecClas()
  Local oObjClass  := NIL
  Local cTextoRet  := ""
  
   // Cria instancia da classe 
   oObjClass := ExemploClass():New() 
   
   // Preenche propriedades 
   oObjClass:cPropStr := "Teste 1"
   oObjClass:nPropNum := 20
   
   // Ativa a classe
   oObjClass:Activate()
   
   // Executa métodos
   cTextoRet := oObjClass:Executar() 
   Conout(cTextoRet)
   
   // Desativa e destroi a classe
   oObjClass:Deactivate()
   FreeObj(oObjClass)
   oObjClass := NIL
    
Return

Com essas estruturas podemos definir os métodos que quisermos e compartilhar as propriedades existentes na classe, entre eles.

Tenho certeza que com a utilização da orientação a objetos você vai economizar e reutilizar muitos códigos em seus futuros desenvolvimentos.

 

Espero que gostem…

 

Até a próxima!!!

 

Trabalhando com Webservice Rest ADVPL

Já pensou em integrar suas aplicações com o ERP Protheus ? O Protheus, como vários ERP’s, são sistemas muito completos e que abrange diversas áreas da empresa, porém sabemos que muitos desses ERP’s não tem acompanhado as novas aplicações de mercado, principalmente na área web/mobile. Mas enquanto as grandes desenvolvedoras adequam seus ERP’s para essa nova geração tecnológica, podemos muito bem fazer os grandes e arcaicos ERP’s conversarem com ferramentas mais amigáveis, dessa forma unimos o melhor de cada uma das tecnologias para otimizar os trabalhos. O Protheus contempla algumas formas de realizar integração, como: Webservice SOAP EAI Próprio Webservice Rest Em minha concepção o mais aderente as plataformas existentes no mercado é o webservice Rest que possui sua representação em JSON e por padrão TOTVS já possui sua camada interface e de autenticação bem implementadas. Passos necessários para preparar seu Protheus para funcionar com o Webservice Rest:

Configurar um server de webservice Rest

Para realizar a configuração será necessário adicionarmos alguns itens no arquivo .ini do server Protheus. Sugiro que seja criado um server separado para o Webservice, tanto por questão de performance, como também por questão de manutenção. 
[GENERAL]
MAXSTRINGSIZE=10
 
[HTTPV11]
Enable=1
Sockets=HTTPREST

[HTTPREST]
Port=8080
URIs=HTTPURI
SECURITY=1

[HTTPURI]
URL=/rest
PrepareIn=All
Instances=1,2

[ONSTART]
jobs=HTTPJOB
RefreshRate=30

[HTTPJOB]
MAIN=HTTP_START
ENVIRONMENT=environment
 

Desenvolvendo sua Classe Rest ADVPL

Para começarmos a desenvolver nossa Primeira classe Rest em ADVPL vamos precisar entender um pouco a ideia dos verbos existentes nesta representação:
  • POST – Verbo responsável por realizar inclusões de registros no sistema.
  • PUT – Verbo  responsável por realizar alterações de registros no sistema.
  • GET – Verbo responsável por realizar o retorno de registros do sistema.
  • DELETE – Verbo  responsável por realizar exclusões de registros do sistema.
Definidas as responsabilidades de cada método podemos começar a exemplificar cada um deles. Para isso, primeiro precisamos a construir a estrutura base do nosso fonte ADVPL para nossa classe Rest. 
#Include 'Protheus.ch'
#Include 'RestFul.CH'    //Necessario utilizar a incluide do RESTFUL

/*/-----------------------------------------------------------
{Protheus.doc} WsRstExp()
Dummy function da Classe Rest
Esta função é necessario pois o ADVPL necessita de um function
dentro do fonte 
Uso: WsRstExp

@sample
//U_WsRstExp()

@author Paulo Henrique Corrêa Cardoso.
@since 21/07/2020
@version 1.0
-------------------------------------------------------------/*/
User Function WsRstExp()
Return

/*/-----------------------------------------------------------
{Protheus.doc} WsRstExp()
Definição da Classe, propriedades e assinatura dos métodos
Uso: WsRstExp

@sample
//U_WsRstExp()

@author Paulo Henrique Corrêa Cardoso.
@since 21/07/2020
@version 1.0
-------------------------------------------------------------/*/
WSRESTFUL WsRstExp DESCRIPTION "Serviço REST de exemplo"
    WSDATA param1    As STRING
    WSDATA param2    As STRING Optional

    WSMETHOD GET    DESCRIPTION "Get Exemplo"     WSSYNTAX "/WsRstExp?param1={valueParam1}&param2={valueParam2}"
    WSMETHOD POST   DESCRIPTION "Post Exemplo"    WSSYNTAX "/WsRstExp"
    WSMETHOD PUT    DESCRIPTION "Put Exemplo"     WSSYNTAX "/WsRstExp?param1={valueParam1}&param2={valueParam2}"
    WSMETHOD DELETE DESCRIPTION "Delete Exemplo"  WSSYNTAX "/WsRstExp?param1={valueParam1}&param2={valueParam2}"

END WSRESTFUL
No exemplo acima definimos a classe WsRstExp, na sequencia definimos 2 parâmetros sendo um deles como opicional. Em seguida definimos a assinatura dos 4 métodos que serão utilizados. Na definição da assinatura temos a seguinte estrutura: WSMETHOD <cVerb> [cId] DESCRIPTION <cDescription> [WSSYNTAX <cSintax>] [PATH <cPath>] [TTALK <cTTalkVersion>] Na definição do método temos a seguinte estrutura: WSMETHOD <cVerb> [cId] [QUERYPARAM <QueryParms>] [PATHPARAM <PathParms>] [HEADERPARAM <HeaderParms>] WSRESTFUL <WsRestFul>
Nome Tipo Descrição Obrigatório
cVerb – POST, PUT, GET ou DELETE X
cId Caracter ID para diferenciar e possibilitar a criação de métodos que utilizam verbos http repetidos
cDescription Caracter Descrição do método REST X
cSintax Caracter Sintaxe HTTP da chamada REST. Esta informação é utilizada apenas para documentação do REST.
cPath Caracter Definição do endpoint que irá acionar aquele método.
*Pode conter agrupamento, o nome da classe e os pathparms. (A partir da release 12.1.23 da lib, em jan./2019).
cTTalkVersion Caracter Valor “v1” para sinalizar que o método utiliza o padrão de mensagem de erro do TTALK.
QueryParms – Indica os parâmetros, separados por vírgulas, que este método receberá via QueryString.
O parâmetros indicados aqui devem ser declarados como WSDATA.
PathParms – Indica os parâmetros, separados por vírgulas, que este método receberá via path, ou seja, como parte da URL.
HeaderParms – Indica os parâmetros, separados por vírgulas, que este método receberá via Header na requisição HTTP.
WsRestFul Caracter Indica o nome da classe, do serviço, que o método atual pertence. X
Agora vamos começar a definir os métodos logo abaixo do código anterior: 
/*/-----------------------------------------------------------
{Protheus.doc} GET
Get de Exemplo - Método utilizado para consultas
Uso: WsRstExp
@sample
//GET / WsRstExp
@author Paulo Henrique Corrêa Cardoso.
@since 21/07/2020
@version 1.0
-------------------------------------------------------------/*/
WSMETHOD GET WSRECEIVE param1, param2 WSSERVICE WsRstExp
   Local lRet      := .T.         // Recebe o Retorno 
   Local oJsonRet  := NIL         // Recebe o JSON de Saida
   
    /*
   
  Trecho com a sua codificação
   
   */
  
   // Monta Objeto JSON de retorno
   oJsonRet := NIL
   oJsonRet := JsonObject():new()

   oJsonRet['Propriedade1'] := EncodeUTF8("Retorno 1", "cp1252") 
   oJsonRet['Propriedade2'] := 10 
   oJsonRet['Propriedade3'] := .T.
  
   // Devolve o retorno para o Rest
   ::SetResponse(oJsonRet:toJSON())
   
Return lRet


/*/-----------------------------------------------------------
{Protheus.doc} POST
Post de Exemplo - Método utilizado para inclusões
Uso: WsRstExp
@sample
//POST/ WsRstExp
@author Paulo Henrique Corrêa Cardoso.
@since 21/07/2020
@version 1.0
-------------------------------------------------------------/*/
WSMETHOD POST WSRECEIVE nullparam WSSERVICE WsRstExp
   Local lRet      := .T.         // Recebe o Retorno 
   Local cBody	   := ''          // Recebe o conteudo do Rest
   Local oJson     := NIL         // Recebe o JSON de Entrada
   Local oJsonRet  := NIL         // Recebe o JSON de Saida
   
   // Pega o conteudo JSON da transação Rest
   cBody := ::GetContent()
   ::SetContentType("application/json")

   oJson := JsonObject():new()
   oJson:fromJson(cBody)
  
   /*
   
  Trecho com a sua codificação
   
   */
  
   // Monta Objeto JSON de retorno
   oJsonRet := NIL
   oJsonRet := JsonObject():new()

   oJsonRet['Propriedade1'] := EncodeUTF8("Retorno 1", "cp1252") 
   oJsonRet['Propriedade2'] := 10 
   oJsonRet['Propriedade3'] := .T.
  
   // Devolve o retorno para o Rest
   ::SetResponse(oJsonRet:toJSON())
        
   FreeObj(oJsonRet)
   FreeObj(oJson)

Return lRet

/*/-----------------------------------------------------------
{Protheus.doc} PUT
PUT de Exemplo - Método utilizado para Alterações
Uso: WsRstExp
@sample
//PUT / WsRstExp
@author Paulo Henrique Corrêa Cardoso.
@since 21/07/2020
@version 1.0
-------------------------------------------------------------/*/
WSMETHOD PUT WSRECEIVE param1, param2 WSSERVICE WsRstExp
   Local lRet      := .T.         // Recebe o Retorno 
   Local cBody	   := ''          // Recebe o conteudo do Rest
   Local oJson     := NIL         // Recebe o JSON de Entrada
   Local oJsonRet  := NIL         // Recebe o JSON de Saida
   
   // Pega o conteudo JSON da transação Rest
   cBody := ::GetContent()
   ::SetContentType("application/json")

   oJson := JsonObject():new()
   oJson:fromJson(cBody)
  
   /*
   
  Trecho com a sua codificação
   
   */
  
   // Monta Objeto JSON de retorno
   oJsonRet := NIL
   oJsonRet := JsonObject():new()

   oJsonRet['Propriedade1'] := EncodeUTF8("Retorno 1", "cp1252") 
   oJsonRet['Propriedade2'] := 10 
   oJsonRet['Propriedade3'] := .T.
  
   // Devolve o retorno para o Rest
   ::SetResponse(oJsonRet:toJSON())
        
   FreeObj(oJsonRet)
   FreeObj(oJson)

Return lRet

/*/-----------------------------------------------------------
{Protheus.doc} DELETE 
DELETE de Exemplo - Método utilizado para exclusões
Uso: WsRstExp
@sample
//DELETE  / WsRstExp
@author Paulo Henrique Corrêa Cardoso.
@since 21/07/2020
@version 1.0
-------------------------------------------------------------/*/
WSMETHOD DELETE WSRECEIVE param1, param2 WSSERVICE WsRstExp
   Local lRet      := .T.         // Recebe o Retorno 
   Local cBody	   := ''          // Recebe o conteudo do Rest
   Local oJson     := NIL         // Recebe o JSON de Entrada
   Local oJsonRet  := NIL         // Recebe o JSON de Saida
   
   // Pega o conteudo JSON da transação Rest
   cBody := ::GetContent()
   ::SetContentType("application/json")

   oJson := JsonObject():new()
   oJson:fromJson(cBody)
  
   /*
   
  Trecho com a sua codificação
   
   */
  
   // Monta Objeto JSON de retorno
   oJsonRet := NIL
   oJsonRet := JsonObject():new()

   oJsonRet['Propriedade1'] := EncodeUTF8("Retorno 1", "cp1252") 
   oJsonRet['Propriedade2'] := 10 
   oJsonRet['Propriedade3'] := .T.
  
   // Devolve o retorno para o Rest
   ::SetResponse(oJsonRet:toJSON())
        
   FreeObj(oJsonRet)
   FreeObj(oJson)
 
Return lRet
Nos exemplos acima utilizei a Classe JsonObject para tratar dados do tipo JSON, com a mesma é possivel transformar o JSON para objeto e vice-versa.

Muito importante

Para realizar os retornos para o Webservice Rest, temos dois métodos que precisamos utilizar. Em caso de sucesso e vamos devolver um JSON com conteúdo, utilizamos o método ::SetResponse(“[JSON]”). Em caso de falha utilizamos o método SetRestFault([StatusErro]), EncodeUTF8(“[Mensagem de Erro]”, “cp1252”)). Observação : utilizo a função EncodeUTF8(“Texto”, “cp1252”), para suprimir problemas de acentuação ao utilizar o envio de textos pela WS Rest. Nos casos de falha podemos utilizar a tabela abaixo para definir o StatusErro:
Status HTTP Descrição
422 Exceções de negócio
400 Requisição Mal Formada
401 Requisição Requer Autenticação
403 Requisição Negada
404 Recurso não Encontrado
405 Método não Permitido
408 Tempo esgotado para a requisição
413 Requisição excede o tamanho máximo permitido
415 Tipo de mídia inválida (falta de informar o content-type correto, ver JSON)
429 Requisição excede a quantidade máxima de chamadas permitidas à API
500 Erro de servidor
  Vou deixar aqui a documentação da TOTVS com mais algumas informações importantes sobre toda a estrutura do REST. https://tdn.totvs.com/display/framework/REST+ADVPL https://tdn.totvs.com/pages/viewpage.action?pageId=75269436   É isso pessoal. Espero que ajude muito vocês.  

Até a próxima!!!

Criando tabelas – Microsoft SQL Server

Fala pessoal, tudo bem ?

Hoje eu vou passar um conteúdo para quem esta começando a aprender a linguagem SQL. Vamos aprender a criar tabelas, colunas e chaves, utilizando o banco de dados Microsoft SQL Server.

Vamos aprender comandos de uma parte da linguagem SQL chamada de DDL (Data Definition Language), ou seja, linguagem de definição de dados.

Mas antes de começarmos a criação da nossa tabela, vamos primeiro aprender um pouco sobre a tipagem de dados utilizados na maioria dos bancos.

Os bancos tem alguns tipos de dados específicos, por isso vou citar os principais e deixar um link com todos os tipos disponíveis para o Microsoft SQL Server.

Tipagem de Dados

int – O tipo de dados int é o tipo de dados inteiros, seu intervalo de dados vai de -2.147.483.648 até 2.147.483.647 e ocupa 4 bytes de armazenamento.

decimal – O tipo decimal guarda dados que possuem casas decimais de precisão, ou seja definimos o tamanho exato de quantidade de casas que o numero poderá ter entre números inteiros e casas decimais. Por exemplo, o número 123,45 tem uma precisão de 5 e uma escala de 2, sua definição fica da seguinte forma decimal(5,2).

A precisão máxima padrão do tipo decimal é 38 e o mesmo tem uma ocupação de armazenamento representado pela tabela abaixo:

Precisão Bytes de armazenamento
1 – 9 5
10–19 9
20–28 13
29-38 17

float – O tipo float é um tipo dados numéricos aproximados para uso com dados numéricos de ponto flutuante. Como são aproximados nem todos os valores no intervalo de tipo de dados podem ser representados de maneira exata.

Sua definição fica da seguinte forma : float(n) em que n é o número de bits usado para armazenar a mantissa do número float na notação científica e, portanto, exige a precisão e o tamanho do armazenamento. Se n for especificado, ele precisará ser um valor entre 1 e 53. O valor padrão de n é 53.

O armazenamento é representado pela tabela abaixo:

Valor de n Precisão Bytes de armazenamento
1-24 7 dígitos 4 bytes
25-53 15 dígitos 8 bytes

datetime – Define uma data combinada com uma hora do dia que inclui frações de segundos e se baseia em um período de 24 horas. Exemplo: 2020-07-21 20:32:00.520

Intervalo de datas Janeiro 1, 1753, a dezembro 31, 9999
Intervalo de horas 00:00:00 a 23:59:59.997

Seu tamanho é de 8 bytes.

char – Tipo de dados de caractere de tamanho fixo, ou seja, o valor que será armazenado possuirá o tamanho definido na declaração deste tipo.

Exemplo, ao definir uma coluna da tabela como char(10) e realizar o input da informação ‘ABC’, a mesma será gravada como ‘ABC ‘.

varchar – Tipo de dados de caractere de tamanho variável,ou seja, o valor que será armazenado possuirá o tamanho variável no memento da gravação, sempre respeitando o tamanho limite definido na declaração do tipo.

Exemplo, ao definir uma coluna da tabela como varchar(10) e realizar o input da informação ‘ABC’, a mesma será gravada como ‘ABC’.

bit – É um tipo dado inteiro que pode aceitar um valor 1, 0 ou NULL. Os valores de cadeia de caracteres TRUE e FALSE podem ser convertidos em valores bit: TRUE é convertido em 1 e FALSE é convertido em 0.

Para mais tipos de dados aceitos pelo Microsoft SQL Server, consulte Aqui

Bom, agora que falamos sobre os tipos de dados mais comuns, podemos a começar entrar na definição de comandos para criar uma tabela dentro do banco de dados.

Criando uma tabela.

Primeiramente vamos utilizar o comando CREATE TABLE para criar a tabela, definindo as colunas da mesma.

Veja o exemplo:

CREATE TABLE Produto (
  IdProduto   INT           IDENTITY(1,1) NOT NULL,
  DescProduto VARCHAR(60)                 NOT NULL,
  Preco       DECIMAL(14,2)               NOT NULL,
  Peso        FLOAT                       NOT NULL,
  Ativo       BIT                         NOT NULL,
  IdCategoria INT                         NOT NULL,
  DataCriacao DATETIME                    NOT NULL
)

Veja que ao definir as colunas, foram utilizados exemplos de alguns tipos explicados anteriormente.

A primeira coluna definida, possui duas informações diferentes das demais. A propriedade IDENTITY(1,1) define que a coluna será auto-incrementada, iniciando no valor 1 e acrecendo 1 a cada novo registro.

Lembrando que a propriedade IDENTITY é opcional.

Temos também a propriedade NOT NULL, que define que a coluna não aceitará valores nulos, podemos também utilizar a propriedade NULL para permitindo o caso contrario.

Ao executar esses comandos no Microsoft SQL Server teremos nossa primeira tabela criada.

Alterando uma tabela

Mas e se eu precisar adicionar ou alterar uma coluno dentro de uma tabela existente, como posso fazer?

Para isso entramos nos comandos de alteração de tabela, o ALTER TABLE.

O comando ALTER TABLE tem diversas propriedades, vamos abordar algumas principais que você vai utilizar no dia a dia.

A Primeira é o comanda para adicionar uma nova coluna na tabela. Para isso utilizaremos o comando ADD.

Veja o exemplo:

ALTER TABLE Produto
ADD CodBarras CHAR(13)    NULL,
    Cor       VARCHAR(10) NULL

Neste exemplo adicionamos duas novas colunas em nossa tabela, utilizando os comandos ALTER TABLE + o comando ADD.

Se precisarmos modificar uma coluna existente, utilizaremos o comando ALTER COLUMN, da seguinte forma:

ALTER TABLE Produto
ALTER COLUMN Cor VARCHAR(20) NOT NULL

Veja que neste exemplo alteramos o tamanho e a propriedade NOT NULL da coluna Cor, utilizando os comandos ALTER TABLE + ALTER COLUMN.

Caso precisemos excluir uma coluna, vamos utilizar o comando DROP COLUMN, da seguinte forma:

ALTER TABLE Produto
DROP COLUMN Cor

Veja que a coluna foi excluída com esse comando.

Chaves da tabela.

Agora que aprendemos os comandos básicos para criação de uma tabela, vamos entender um pouco sobre chaves da tabela.

Existem dois tipos de chaves que utilizamos em uma tabela. A Primary Key (chave primaria) e as Foreign Key’s (chaves estrangeiras).

Uma tabela pode ter apenas uma Primary Key, e seu valor não poderá se repetir entre os registros.

A criação dessa chave pode ser feita no momento da criação to campo na tabela, ou posteriormente com um comando especifico.

Veja o comando para adicionar a Primary Key posteriormente a criação da tabela:

ALTER TABLE Produto
ADD CONSTRAINT PK_Produto_IdProduto PRIMARY KEY CLUSTERED (IdProduto)

Onde “PK_Produto_IdProduto” é o nome que definimos pra nossa Primary Key e IdProduto é o campo que fará parte da chave.

Já as Foreign Key’s são chaves de relacionamento com outras tabelas, e servem para garantir a integridade de registros entre as mesmas.

Para esse exemplo vou criar uma tabela de Categoria para a classificação dos Produtos.

CREATE TABLE Categoria(
  IdCategoria  INT          IDENTITY(1,1) NOT NULL,
  Descricao    VARCHAR(100)               NOT NULL, 
  CONSTRAINT PK_Categoria_IdCategoria    PRIMARY KEY CLUSTERED (IdCategoria)
)

Veja que nesse exemplo eu criei a Primary Key no momento da criação da tabela.

Agora vamos criar uma Foreign Key na tabela de Produtos, relacionando o campo IdCatetoria da tabela Produto com o da tabela Categoria.

ALTER TABLE Produto
ADD CONSTRAINT FK_ProdutoCategoria
FOREIGN KEY (IdCategoria) REFERENCES Categoria(IdCategoria)

Onde “FK_ProdutoCategoria” é o nome da Foreign Key , “(IdCatetoria)” é o campo chave de relacionamento da tabela Produto e “Categoria(IdCategoria)” é a referencia com a tabela de Categoria e com o campo Primary Key da mesma.

Dessa forma quando tentar inserir um registro na tabela de Produtos com uma categoria que não exista o banco de dados não permitira a inclusão do registro, da mesma forma que não será permitido excluir uma categoria que esteja vinculada com algum produto.

Excluindo uma tabela.

Para deletar uma tabela, temos o comando DROP TABLE, que deve ser utilizado da seguinte forma:

DROP TABLE Categoria

Bom pessoal, esse foi o conteúdo do Post de hoje.

Espero que ajude muito vocês!!!

Qualquer dúvida, deixe nos comentários.

Até a próxima!!!

Lógica de programação, um conhecimento para a vida.

Vejo muitas pessoas que estão tentando começar trabalhar na área de análise e desenvolvimento de software, sempre com muita dificuldade em escolher a melhor linguagem de programação, ou fazendo diversos cursos de desenvolvimento, mas nunca consegue evoluir na carreira.

Se você acredita que um curso de programação, ou as vezes até mesmo a faculdade de tecnologia vai te ensinar a programar, sinto dizer que será uma decepção… Decepção que vi nos olhos de diversos colegas que fizeram faculdade comigo.

Antes de mais nada, quero te dizer que o principal conhecimento da área de programação não é a linguagem de programação que você vai utilizar…
A principal skill dessa louca profissão é uma palavrinha de 6 letras…”Lógica”.

A lógica é a base pra qualquer linguagem de programação, não importa qual seja, se você tiver o seu raciocínio lógico aguçado, você será capaz de desenvolver em qualquer linguagem de programação.

Muito além disso, a lógica aguçada vai te ajudar em todas as áreas cognitivas da sua vida.

Na minha época de faculdade, vi diversos professores tentando introduzir a programação na cabeça dos alunos, com uma linguagem chamada Portugol, que nada mais é que uma linguagem de programação em português.

Só que muitos desses alunos não conseguiam pensar de forma estruturado o suficiente para conseguirem escrever uma condições básicas para efetuar as tarefas solicitadas. Isso tudo porque faltava o principal para o desenvolvimento, que é a lógica.

O melhor caminho pra aprender a lógica computacional, no meu ponto de vista, é quebrar ao máximo uma tarefa em pequenas sub-tarefas, de forma muito detalhada e bem compreensível.

Vou usar um exemplo bem simples que tive em minhas aulas de lógica na minha época de meu curso técnico.

Como trocar um pneu de um carro.

Você esta em uma estrada e sente o que o pneu do seu veículo furou, o que fazer?

1 – Ligue a seta para encostar na via.

2 – Vire a direção, sentido ao local que você quer estacionar, de uma forma suave.

3 – Vá parando o veículo aos poucos.

4 – Quando o veículo estiver totalmente parado, puxe o freio de mão.

5 – Desligue o veículo.

6 – Saia do veículo e abra o porta-malas.

7 – Retire o triângulo de sinalização e as ferramentas do porta-malas.

8 – Posicione o triângulo de sinalização na pista, com uma boa distância do veículo.

9 – Volte até o veículo, pegue a chave de rodas e solte um parafuso de cada vez do pneu furado.

10 – Posicione o macaco no local correto para retirar o pneu…

…

…

…

Acho que já deu pra você ter ideia de como é, não é mesmo?
Um bom exercício para você que está começando a estudar lógica, é completar esse exemplo da forma mais detalhada possível.

Viu só, a ideia desse exercício é demonstrar cada passo, de forma estruturada.

Temos que imaginar que um computador interpreta exatamente cada comando que passamos de forma literal e não de forma abstrata.

Após fixarmos a ideia de sempre deixar as informações o mais detalhadas possíveis, começamos a empregar o conceitos de decisões.

Se e Senão

Uma das bases da lógica é o conceito de decisão. Esse conceito temos que utilizar pra tudo em nossa vida pois o mesmo nos fará pensar o que vai acontecer, cada caminho que vamos seguir e prever as possíveis situações.

Uma técnica muito boa para visualizarmos esse conceito é a utilização de fluxogramas.

Os fluxogramas, são representações de processos, através de gráficos esquemáticos, onde cada símbolo tem uma função.

Neste exemplo podemos ver a tomada de decisão para uma lâmpada que parou de funcionar.

Muito importante !!!

Antes de começarmos a desenvolver a lógica de qualquer coisa que queremos passar para um programa, ou até mesmo para algum processo que desejamos criar pra qualquer área da vida, é imprescindível entender o problema, todas as suas variáveis e condições de falha e sucesso.

Quando estiver com esse raciocino lógico bem fixado na sua cabeça, você vai perceber que a linguagem de programação vai entrar muito mais fácil no seu dia a dia!

A complexidade da lógica em um vídeo. (Para rir um pouco…)

Espero que esse conteúdo te ajude!!!
E lembre-se, a lógica antes da linguagem…
A lógica é tudo !!!

Até a próxima !!!

Posts recentes

Comentários

Arquivos

Categorias

© PH Cardoso - 2023. Todos os Direitos Reservados