t

-----------------Study or die-------------------------------
/*
Criador: Henrique Francisco da silva
AB: 985452
Descrição: material abaixo retirado com base no estudo nos módulos 1 e 2 da impacta
de sql server e Cursos aleatórios da Udemy
*/
--Criado para estudo focado nas certificações a baixo:
/*
------certificações focada para modelagem de dados ( BI )------

----------------full back end -------------------------

https://www.microsoft.com/pt-br/learning/exam-70-761.aspx
https://www.microsoft.com/pt-br/learning/exam-70-762.aspx

*/
---ESTUDANDO TUDO DES do começo do curso, BEM EXPLICADO -----------------
USE PEDIDOS

--CRIANDO TABELA
CREATE TABLE TABELA_TESTE(
IDCLI INT IDENTITY (1,1) NOT NULL ,
NOME VARCHAR(20) DEFAULT 'SEM NOME' NULL,
)
--SELECT COMUN
SELECT * FROM TABELA_TESTE

---INSERINDO TADOS SEM DEFINIR O NOME DA TABELA

INSERT INTO TABELA_TESTE
VALUES ('IARA'),
('ICARO'),
('PEDRO'),
('INIDIA');

--INSERINDO DADOS DEFININDO O NOME DA TABELA

INSERT INTO TABELA_TESTE
(NOME)
VALUES ('CARLOS'),
('MARIA');

---DELETANDO DA TABELA TESTE

DELETE TABELA_TESTE
WHERE NOME = 'ICARO'

--ALTERANDO A TABELA TESTE, COLOCANDO SALARIO E IDADE

ALTER TABLE TABELA_TESTE ADD
IDADE INT NULL,
SALARIO MONEY NULL;

--CONSULTANDO NOVAMENTE A TABELA_TESTE

SELECT * FROM TABELA_TESTE

--DELETANDO TODOS OS DADOS DA TABELA_TESTE

DELETE TABELA_TESTE
--INSERINDO VALORES PARA IDADE E SALARIO NA TABELA_TESTE
INSERT INTO TABELA_TESTE (NOME,IDADE, SALARIO)
VALUES ('HENRIQUE',23,$1100),
t

('ICARO',20,$1800),
('ISABELE', 29, $3800),
('TAYLOR', 40, $1700),
('BRUNA', 50, $8000);

--CONSULTANDO NOVAMENTE A TABELA_TESTE

SELECT * FROM TABELA_TESTE

--CONSULTANDO A TABELA COM POSSIVEIS ALTERAÇÕES - SIMULAÇÕES

SELECT IDCLI, NOME, IDADE, SALARIO * 2 AS SALARIO

FROM TABELA_TESTE
WHERE SALARIO < 2000.00

--CONSULTANDO NOVAMENTE A TABELA_TESTE PARA VER AS MODIFICAÇÕES - NEM UMA MESMO

SELECT * FROM TABELA_TESTE

--ALTERANDO AS INFORMAÇÕES DAS COLUNAS PERMANENTEMENTE

UPDATE TABELA_TESTE
SET SALARIO = SALARIO * 2
WHERE SALARIO < 2000

--CONSULTANDO PARA VER AS ALTERAÇÕES

SELECT * FROM TABELA_TESTE

--DEPOIS DE MUITO ESTUDO O SEU SALARIO VAI PARAR NAS ALTURA HENRIQUE
UPDATE TABELA_TESTE
SET SALARIO = 5500.00
WHERE NOME = 'HENRIQUE'

--ENCHERGANDO QUEM FOI DEMITIDO OU SAIU DO CUSTO DA TABELA_TESTE

DELETE TABELA_TESTE OUTPUT DELETED.*

WHERE NOME = 'BRUNA'
AND IDCLI = 17

--CONTULTANDO
SELECT * FROM TABELA_TESTE

------------------------DE AGORA EM DIANTE SÓ IREMOS USAR METODOS COM

TRANSAÇÕES----------------------------------------
USE PEDIDOS
SELECT * FROM [DBO].[EMPREGADOS]
BEGIN TRANSACTION
INSERT INTO [DBO].[EMPREGADOS]
VALUES(73,'FERNANDA AMARAM',5,'1994.07.20',1, 11, '2009.07.20', 8000.00, 500.00,
'S', 'LUTA KARATE, CAPOEIRA E É MESTRE EM KRAVMAGAR, SE MECHER COM ELA, O CORO COME,
(ELA JA MATO 9 MÊS PASSADO)', NULL, 70)
ROLLBACK
--COMMIT

-----------
USE PEDIDOS
SELECT * FROM [DBO].[EMPREGADOS]
t

INSERT INTO [DBO].[EMPREGADOS]

VALUES(100,'HENRIQUE FRANCISCO DA SILVA',0,'1994.07.12',80, 80, '1994.07.13',
4000.00, 5000.00, 'N', ' É O MELHOR E MAIS INTELIGENTE FUNCIONARIO QUE A EMPRESA
TEM, SEMPRE ESTUDANDO PARA APRIMORAR SEUS CONHECIMENTOS, COLOCA A CABEÇA A PREMIO
PARA QUAL EMPRESA PAGAR MAIS, SEU LEMA É (A EMPRESA PAGA QUEM ESTUDA E NÃO PARA QUEM
NÃO BUSCA CRESCIMENTO/VAGABUNDO)', NULL, 0)
COMMIT -- SALVANDO ALTERAÇÕES

---------------CRIANDO DUAS TABELAS RELACIONADAS NO BANCO

PEDIDOS-----------------------------------------------------------
-----IREMOS USAR PK E FK

--CRIANDO A TABELA PEDIDOSTABAJARA

BEGIN TRANSACTION --ABRINDO UMA TRANSAÇÃO SEGURA PARA A MODELAGEM DE DADOS

USE PEDIDOS
CREATE TABLE PRODUTOSTABAJARA (
IDPRODUTO INT NOT NULL UNIQUE,
NOMEPRODUTO VARCHAR(MAX) NOT NULL,
SABORPRODUTO VARCHAR(MAX) NOT NULL,
VALORPRODUTO SMALLMONEY NOT NULL,
CONSTRAINT PK_PEDIDOSTABAJARA_IDPRODUTO PRIMARY KEY (IDPRODUTO)
)

--DROP TABLE PRODUTOSTABAJARA

--INSERINDO DADOS NA TABELA PEDIDOSTABAJARA
INSERT INTO PRODUTOSTABAJARA (IDPRODUTO, NOMEPRODUTO, SABORPRODUTO, VALORPRODUTO)
VALUES (1, 'BISCOITO','CHOCOLATE', 2.00),
(2,'BISCOITO','MORANGO', 1.50),
(3,'BISCOITO','UVA', 3.00),
(4,'BISCOITO','LIMÃO', 2.40),
(5,'BISCOITO','AMORA', 2.10)

---CRIANDO A TABELA CLIENTESTABAJARA

CREATE TABLE CLIENTESTABAJARA (
IDCLI INT IDENTITY (1,1) NOT NULL,
NOMECLI VARCHAR(MAX) NOT NULL,
IDPRODUTO INT NOT NULL,
QUANTIDADE INT NOT NULL,
CONFIRMA_PAGAMENTO VARCHAR(MAX) NOT NULL DEFAULT 'NÃO',
DATAPEDIDO DATETIME NOT NULL,
CONSTRAINT FK_CLIENTESTABAJARA_IDPRODUTO FOREIGN KEY(IDPRODUTO)
REFERENCES PRODUTOSTABAJARA(IDPRODUTO)
)

--INSERINDO PEDIDOS NA TABELA CLIENTESTABAJARA

INSERT INTO CLIENTESTABAJARA (NOMECLI, IDPRODUTO, QUANTIDADE, CONFIRMA_PAGAMENTO,
DATAPEDIDO)
VALUES ('ARLINDO', 3, 9, 'SIM', '2017.10.20'),
('GARILANA', 1, 2, '', '2017.11.10'),
('ARLINDO',4,70, 'SIM', '2017.10.01'),
('GABRIELA',5,50, 'SIM', '2017.09.01'),
('CARLA',2,10, '', '2017.07.01')
t

COMMIT --SALVAR ALTERAÇÕES

ROLLBACK -- NÃO SALVAR ALTERAÇÕES

---------------------------CONULTAR NAS TABELAS

SELECT CLI.NOMECLI AS 'NOME',

CLI.QUANTIDADE AS QUANTIDADE,
CLI.DATAPEDIDO AS 'DATA DO PEDIDO',
PRO.NOMEPRODUTO AS 'PRODUTO',
PRO.SABORPRODUTO AS 'SABOR DO PRODUTO',
PRO.VALORPRODUTO AS 'VALOR DA UNIDADE',
PRO.VALORPRODUTO * CLI.QUANTIDADE AS 'VALOR TOTAL',
CASE CLI.CONFIRMA_PAGAMENTO
WHEN 'SIM' THEN 'PAGAMENTO REALIZADO'
WHEN '' THEN 'PAGAMENTO NÃO REALIZADO'
END AS 'CINFORMAÇÃO DE PAGAMENTO'

FROM CLIENTESTABAJARA AS CLI JOIN

PRODUTOSTABAJARA AS PRO
ON CLI.IDPRODUTO = PRO.IDPRODUTO

---------------------------BRINCANDO COM QUAISQUER TABELAS PARA MAIS ESTUDO -

REFORÇANDO OQUE EU ESQUECI-------------------------------------------
--CRIANDO TABELA TEMPORARIA EMPREGADOS
USE PEDIDOS
SELECT CODFUN AS 'CÓDIGO DO FUNCIONARIO', NOME, DATA_NASCIMENTO, DATA_ADMISSAO,
SALARIO, OBS INTO TRABALHADORES_LOUCOS --CRIANDO TABELA SÓ COM OQUE QUERO
FROM [DBO].[EMPREGADOS]

INSERT INTO TRABALHADORES_LOUCOS ([CÓDIGO DO FUNCIONARIO], NOME, DATA_NASCIMENTO,

DATA_ADMISSAO, SALARIO, OBS)
VALUES(107, 'JAILSON', '1972.03.08', '2014.12.15', 2500.00, 'UM FUNCIONARIO
MUITO DEDICADO, TRABALHA DIA E NOITE, E NUNCA IRÁ PARAR DE TRABALHAR. SEU LEMA É:
FÉRIAS PRAQUE?')
------------------
DELETE TRABALHADORES_LOUCOS
WHERE [CÓDIGO DO FUNCIONARIO] = '105'

BEGIN TRANSACTION
USE PEDIDOS
SELECT TTE.[CÓDIGO DO FUNCIONARIO],
TTE.NOME,
TTE.DATA_ADMISSAO,
TTE.OBS,
DATEDIFF(YEAR, TTE.DATA_ADMISSAO, GETDATE()) AS 'ANOS DE
EMPRESA',
DATEDIFF(MONTH, TTE.DATA_ADMISSAO, GETDATE()) AS 'MESES DE
EMPRESA',
DATEDIFF(DAY, TTE.DATA_ADMISSAO, GETDATE()) AS 'DIAS DE
EMPRESA',
CASE DATEDIFF(YEAR, TTE.DATA_ADMISSAO, GETDATE())
WHEN '1' THEN 'É NOVO, DA TEMPO DE SAIR'
WHEN '2' THEN 'CUIDADO PARA NAO FICAR MUITO TEMPO
NA EMPRESA'
WHEN '3' THEN 'TA FICANDO LASCADO(A), JA DEVE TER
4 FILHOS PARA SUSTENTAR'
t

WHEN '4' THEN 'TA FICANDO FODIDO(A), SAI ENQUANTO

É TEMPO'
WHEN '5' THEN 'NÃO TEM MAIS COMO FUGIR, PEÇA UM
MILAGRE'
WHEN '6' THEN 'JAERA, ESSE(A) NÃO TEM VOLTA'
ELSE 'VAI TRABALHAR ATÉ O TRABALHO EXISTIR OU ATÉ
MORRER'
END AS 'SITUAÇÃO DO PIAO',
IIF(DATEDIFF(DAY, DATA_ADMISSAO, GETDATE()) >= DATEDIFF(DAY,
DATA_NASCIMENTO, GETDATE()) ,'MAIOR TEMPO DE VIDA TRABALHANDO','AINDA É JOVEM' ) AS
'SITUAÇÃO DO PIAO2',
DATA_NASCIMENTO AS 'DIA QUE O(A) PIAO NASCEU',
DATEDIFF(DAY, DATA_NASCIMENTO, GETDATE()) / 365 AS 'IDADE DO(A)
PIAO',
DATEDIFF(DAY, DATA_ADMISSAO, GETDATE()) * 8 AS 'HORAS TOTAIS
TRABALHADAS',
DATEDIFF(DAY, DATA_ADMISSAO, GETDATE()) AS 'DIAS TRABALHADOS',
DATEDIFF(DAY, DATA_NASCIMENTO, GETDATE()) AS 'DIAS DE VIDA ATÉ O
MOMENTO',
SALARIO AS 'SALARIO MENSAL',
CAST(SALARIO / '22' AS MONEY) AS 'SALARIO DIARIO',
CAST(CAST(SALARIO / '22' AS MONEY) / 8 AS MONEY) AS 'GANHO POR
HORA',
CAST(CAST(SALARIO / '22' AS MONEY) / 8 AS MONEY) * DATEDIFF(DAY,
DATA_ADMISSAO, GETDATE()) AS 'DINHEIRO ARRECADADO EM TODO TEMPO DE TRABALHO'

FROM TRABALHADORES_LOUCOS AS TTE

ORDER BY [CÓDIGO DO FUNCIONARIO] DESC

COMMIT
------------------------------------------------------------------------------------
---------------------------------
-----INSERT DE SELECT DA TABELA ANTERIOR

---CRIANDO A TABELA SIMPLES

CREATE TABLE #TESTETEMPORARIA (
NOME VARCHAR(MAX),
OBS VARCHAR(MAX)
)

--INSERINDO OS DADOS DA TABELA ANTERIOR

INSERT INTO #TESTETEMPORARIA
SELECT TTE.NOME, TTE.OBS FROM TRABALHADORES_LOUCOS AS TTE

---CONSULTANDO
SELECT * FROM #TESTETEMPORARIA

------UTILIZANDO SELECT + INSERT + TOP(10), PARA PEGAR SÓ OS 10 MELHORES

DELETE #TESTETEMPORARIA -- DELETANDO

--INSERINDO OS 10 MELHORES
INSERT INTO #TESTETEMPORARIA
SELECT TOP(10) NOME, OBS FROM TRABALHADORES_LOUCOS
ORDER BY [CÓDIGO DO FUNCIONARIO] ASC
t

------------VENDO OQUE FOI DELETADO/INSERIDO

--DELETANDO
DELETE #TESTETEMPORARIA OUTPUT DELETED.*

--CONTULTANDO
SELECT * FROM #TESTETEMPORARIA

--INSERINDO E MOSTRANDO
INSERT INTO #TESTETEMPORARIA
OUTPUT INSERTED.NOME, INSERTED.OBS
SELECT NOME, OBS FROM TRABALHADORES_LOUCOS
------------------------------------------------------------------------------------
------------------------------------------------------------

---DECLARANDO UMA VARIAVEL COMO TABELA (VARIAVEL TABULAR) E INSERINDO DADOS NELA
DECLARE @REG_INSERT TABLE (NOME VARCHAR(MAX), OBS VARCHAR(MAX));

INSERT INTO #TESTETEMPORARIA --INSERINDO TABELAS NA TABELA

OUTPUT INSERTED.NOME, INSERTED.OBS INTO @REG_INSERT
SELECT * FROM #TESTETEMPORARIA

--------
SELECT * FROM @REG_INSERT

--------------------------------------------------------------------------
---USANDO TOP WITH TIES
USE PEDIDOS
SELECT TOP 1 WITH TIES * FROM TRABALHADORES_LOUCOS
ORDER BY SALARIO DESC

-- USANDO TOP COM PORCENTAGEM

USE PEDIDOS
SELECT TOP 5 PERCENT * FROM TRABALHADORES_LOUCOS
ORDER BY SALARIO DESC

--UPDATE COM TOP

USE PEDIDOS
UPDATE TOP(20) TRABALHADORES_LOUCOS SET SALARIO = SALARIO * 3
WHERE SALARIO <= $1500.00
--------------------------USANDO SUBQUERIES DE VARIAS
FORMAS------------------------------------------------------------------------------
---------

--USANDO ESSAS TABELAS A BAIXO.

USE PEDIDOS
SELECT * FROM [DBO].[EMPREGADOS]
SELECT * FROM [DBO].[TABELACAR]

--USANDO [IN] OU [=] PARA COMPARAR

--FILTRANDO SALARIO < QUE 5000
SELECT * FROM [DBO].[EMPREGADOS]
WHERE CODFUN IN (SELECT COD_CARGO FROM TABELACAR
WHERE SALARIO_INIC < 5000.00)
ORDER BY SALARIO DESC
t

--LISTA DE DEPARTAMENTOS EM QUE NÃO EXISTE NENHUM FUNCIONARIO CADASTRADO

--USANDO NOT IN PARA COMPARAÇÃO NEGATIVA
USE PEDIDOS
SELECT * FROM EMPREGADOS
WHERE CODFUN IN (SELECT COD_DEPTO FROM TABELADEP WHERE COD_DEPTO IS NOT NULL)

--USANDO EXISTS COM SUBQUERIES

SELECT * FROM EMPREGADOS AS E
WHERE EXISTS (SELECT * FROM TABELADEP
WHERE DEPTO = 'DIRETORIA')
AND COD_CARGO IN (SELECT COD_DEPTO FROM TABELADEP
WHERE DEPTO = 'DIRETORIA' )

--USANDO JOIN
USE PEDIDOS
SELECT * FROM [DBO].[VENDEDORES]
SELECT * FROM

SELECT V.CODVEN, V.NOME, V.FANTASIA, V.PORC_COMISSAO, SUM(I.PR_UNITARIO) FROM [DBO].

[VENDEDORES] AS V
JOIN [DBO].[ITENSPEDIDO] AS I ON V.CODVEN =
GROUP BY V.CODVEN, I.PR_UNITARIO

------------------------------------------------------------------------------------
------
--LISTANDO FUNCIONARIOS E MODIFICANDO A TABELA PARA NÃO ESQUECER
SELECT CODFUN AS 'CÓDIGO DO FUNCIONARIO',
NOME,
IIF(NUM_DEPEND >= 1,'TA LASCADO(A), VAI TRABALHAR PARA SUSTENTAR OS
FILHOS','SEM FILHOS AINDA') AS DEPENDENTES,
DATA_NASCIMENTO AS 'DATA DE NASCIMENTO',
DATEDIFF(YEAR,DATA_NASCIMENTO,GETDATE()) AS 'IDADE',
COD_DEPTO AS 'CÓDIGO DO DEPARTAMENTO',
COD_CARGO AS 'CÓDIGO DO CARGO',
DATA_ADMISSAO AS 'DATA DE ADIMISSAO',
IIF(SALARIO <= 2000.00,'MIXARIA' ,'SALARIO NORMAL') AS 'TIPO DE SALARIO',
SALARIO AS 'SALARIO :''(',
PREMIO_MENSAL AS 'GORJETA/BRINDE',
CASE SINDICALIZADO
WHEN 'S' THEN 'ESTE É EXPLORADO PELO SINDICATO QUE NÃO AJUDA EM NADA!'
WHEN 'N' THEN 'ESTE É EXPLORADO PELA EMPRESA PORQUÊ NÃO TEM NADA QUE O
DEFENDA!'
END AS 'SINDICALIZADO OU NÃO? KKKKK',
OBS AS 'DETALHE DO SUJEITO',
FOTO AS 'FOTO',
COD_SUPERVISOR AS 'CÓDIGO DO SUPERVISOR'

FROM EMPREGADOS
WHERE SALARIO = (SELECT MIN(SALARIO) FROM EMPREGADOS)

------------------------------------------------------------------------------------
--------------------------
---USANDO OUTER JOIN, LEFT E RIGHT JOIN ---TREINANDO-----

------- USANDO LEFT OUTER JOIN

--OUTER É OPCIONAL
t

USE PEDIDOS
SELECT * FROM [DBO].[IMPORTA_COD_CLASS_DESC] AS D
LEFT OUTER JOIN
[DBO].[IMPORTA_DEVIDO_INDEVIDO] AS I
ON D.CODIGO = I.[COD PROC]

------------USANDO RIGHT OUTER JOIN

-- OUTER É OPCIONAL
USE PEDIDOS
SELECT EMP.CODFUN, EMP.NOME, EMP.COD_CARGO, EMP.SALARIO, TABCAR.CARGO,
TABCAR.SALARIO_INIC, EMP.SALARIO - TABCAR.SALARIO_INIC AS 'DIFERENCIA SALARIAL
INICIAL' FROM [DBO].[EMPREGADOS] AS EMP
RIGHT JOIN
[DBO].[TABELACAR] AS TABCAR
ON EMP.COD_CARGO = TABCAR.COD_CARGO

---VERIFICANDO SE DA ERRO
USE PEDIDOS
SELECT * FROM EMPREGADOS EMP
LEFT JOIN
TABELACAR AS CAR
ON EMP.COD_CARGO = EMP.COD_CARGO
--ANOTAÇÃO: GERA UM ERRO, MULTIPLICANDO O NUMERO DE LINHAS DE UMA COLUNA POR O DE
OUTRA

--PROVA REAL A BAIXO

--USANDO @DECLARE

DECLARE @EMP INT

DECLARE @TAB INT
DECLARE @RESULTADO INT

SET @EMP = (SELECT COUNT(EMP.COD_CARGO) FROM EMPREGADOS AS EMP)

SET @TAB = (SELECT COUNT(TAB.COD_CARGO) FROM TABELACAR AS TAB)

SET @RESULTADO = @EMP * @TAB

PRINT @RESULTADO
--OBS: NULL NÃO CONTA
----------------------------
--CRIANDO UM FULL JOIN
SELECT * FROM EMPREGADOS AS EMP
FULL OUTER JOIN TABELACAR AS TAB
ON EMP.COD_CARGO = TAB.COD_CARGO

-----------------------------------------------------

SELECT * FROM EMPREGADOS AS EMP

FULL JOIN TABELACAR AS TABCAR
ON EMP.COD_CARGO = TABCAR.COD_CARGO

------------------------------------------

---PAREI NA 175

---------------------------------------SUBQUERIES--------------------------------
---USANDO EXISTS
t

USE PEDIDOS
SELECT * FROM [DBO].[BD_TRICK] AS TRI
WHERE EXISTS (SELECT * FROM [DBO].[BD_TRICK] AS TRI
WHERE TRI.ID = '2' OR TRI.ID = '3')

----- TESTANDO SUBQUERIES - UTILIZANDO MODOS DIFERENTES

USE PEDIDOS
SELECT * FROM [DBO].[PRODUTOS]
SELECT * FROM [DBO].[ITENSPEDIDO]

-------
--USANDO ORDER BY
SELECT PEDIDOS.NUM_PEDIDO,
PEDIDOS.COD_PRODUTO,
PEDIDOS.PR_UNITARIO AS 'PREÇO UNITARIO',

SUM(PEDIDOS.QUANTIDADE) AS 'QUANTIDADE',
SUM(PEDIDOS.QUANTIDADE * PEDIDOS.PR_UNITARIO) AS 'PREÇO TOTAL'
FROM ITENSPEDIDO AS PEDIDOS
WHERE PEDIDOS.DATA_ENTREGA IN (SELECT DATA_ENTREGA FROM ITENSPEDIDO
WHERE DATA_ENTREGA BETWEEN '2012.01.01' AND '2013.01.01')
AND NUM_PEDIDO = 9752

GROUP BY PEDIDOS.NUM_PEDIDO, PEDIDOS.COD_PRODUTO, PEDIDOS.PR_UNITARIO

----------------------------------------------------------

--TABELAS TEMPORARIAS USAM O DISCO EM VEZ DE RAM COMO AS SUBQUERIES E QUAISQUER

OUTROS TIPOS DE SELECTS.
-------CRIANDO TABELA TEMPORARIA--------
SELECT * FROM FUN_FUNCIONARIOS
SELECT * FROM DEPENDENTES
USE PEDIDOS
SELECT F.FUN_ID AS 'IDENTIFICAÇÃO DO FUNCIONARIO',
F.FUN_NOME AS 'NOME FUNCIONARIO',
F.FUN_DATA_NASCIMENTO AS 'NASCIMENTO FUNCIONARIO',
F.FUN_CPF AS CPF,
D.CODDEP AS 'CÓDIGO DEPENDENTE',
D.NOME AS 'NOME DEPENDENTE',
IIF(D.DATA_NASCIMENTO = NULL,GETDATE(),D.DATA_NASCIMENTO) AS 'NASCIMENTO
DEPENDENTE'

INTO ##PESQUISA_TEMPORARIA_FUNCIONARIOS
FROM [DBO].[FUN_FUNCIONARIOS] AS F
JOIN [DBO].[DEPENDENTES] AS D
ON F.FUN_ID = D.CODFUN

DROP TABLE ##PESQUISA_TEMPORARIA_FUNCIONARIOS

------------------------------------------
-----TRABALHANDO COM TABELAS TEMPORARIAS
SELECT * FROM ##PESQUISA_TEMPORARIA_FUNCIONARIOS

------------------------------------------------------------------------------------
--------------
--ESCOLHENDO AS COLUNAS
USE PEDIDOS
t

SELECT * FROM EMPREGADOS --MENOS SALARIO É 750.00

SELECT * FROM [DBO].[TABELACAR]

------------------------
---UPDATE COM JOIN
BEGIN TRANSACTION
UPDATE EMPREGADOS
SET SALARIO = 1500.40
FROM EMPREGADOS E JOIN TABELACAR T
ON E.COD_CARGO = T.COD_CARGO
WHERE T.COD_CARGO = 5

------
SELECT * FROM EMPREGADOS
WHERE COD_CARGO = 5

ROLLBACK

COMMIT

------TRUNCATE TABLE COM FROM JOIN ----- NÃO DA CERTO ----

BEGIN TRANSACTION

USE PEDIDOS
TRUNCATE TABLE EMPREGADOS
FROM EMPREGADOS E JOIN TABELACAR T
ON E.CODCARGO = T.COD_CARGO
WHERE T.COD_CARGO = 1
ROLLBACK

---------------------------------------------------------------------------
--USANDO AVG (ALL |DISTINCT )
USE PEDIDOS
SELECT * FROM [DBO].[TRABALHADORES_LOUCOS]

-------------------------------------------------------------------------------
-------AVG SIMPLES + ALL
--DIFERENCIA DE WHERE
SELECT AVG([CÓDIGO DO FUNCIONARIO]) AS 'CÓDIGO FUN', SALARIO AS 'SALARIOS' FROM
TRABALHADORES_LOUCOS
WHERE SALARIO <= 2000.00
GROUP BY ALL SALARIO
ORDER BY SALARIO ASC

----------------------------
--DIFERENCIA DO HAVING
SELECT AVG([CÓDIGO DO FUNCIONARIO]) AS 'CÓDIGO FUN', SALARIO AS 'SALARIOS' FROM
TRABALHADORES_LOUCOS
GROUP BY SALARIO
HAVING SALARIO <= 2000.00
ORDER BY SALARIO ASC
t

------------------------------------------------------------------------------------
------------

------INSERINDO A CLAUSULA (WITH ROLLUP)

--ESCOLHENDO TABELAS
USE PEDIDOS
SELECT * FROM [DBO].[PRODUTOS]
SELECT * FROM [DBO].[ITENSPEDIDO]

--------USANDO WITH ROLLUP

USE PEDIDOS
SELECT P.ID_PRODUTO, I.NUM_ITEM, SUM(I.QUANTIDADE) AS 'QUANTIDADE',
SUM(I.PR_UNITARIO) AS 'PREÇO TOTAL' FROM PRODUTOS AS P
JOIN ITENSPEDIDO AS I
ON P.ID_PRODUTO = I.ID_PRODUTO
GROUP BY P.ID_PRODUTO, I.NUM_ITEM
WITH ROLLUP;

-------USANDO WITH CUBE

USE PEDIDOS
SELECT P.ID_PRODUTO, I.NUM_ITEM, SUM(I.QUANTIDADE) AS 'QUANTIDADE',
SUM(I.PR_UNITARIO) AS 'PREÇO TOTAL' FROM PRODUTOS AS P
JOIN ITENSPEDIDO AS I
ON P.ID_PRODUTO = I.ID_PRODUTO
GROUP BY P.ID_PRODUTO , I.NUM_ITEM
WITH CUBE;

----------------------FINALIZANDO COM ALGUNS COMANDOS

SIMPLES-----------------------------------
-- USANDO LEN PARA CONTAR AS STRINGS(SILABAS) DE UMA PALAVRA
DECLARE @PALAVRA1 VARCHAR(MAX)
DECLARE @PALAVRA2 VARCHAR(MAX)
DECLARE @PALAVRA3 VARCHAR(MAX)
DECLARE @PALAVRA4 DATE

SET @PALAVRA1 = '1000000000'

SET @PALAVRA2 = '10000'
SET @PALAVRA3 = 'A BOLA DO KIKO É QUADRADA'

PRINT ('------VALORES/PALAVRAS NORMAIS------------')

PRINT @PALAVRA1
PRINT @PALAVRA2
PRINT @PALAVRA3

PRINT('---------ESTA FUNÇÃO CONTA AS SILABAS/STRINGS DA INFORMAÇÃO-------------')

PRINT LEN(@PALAVRA1)
PRINT LEN(@PALAVRA2)
PRINT LEN(@PALAVRA3)
PRINT('------ESTÁ FUNÇÃO REPLICA--------------')
PRINT REPLICATE(@PALAVRA2,5)
PRINT ('-----FUNÇÃO QUE REVERTE-----')
PRINT REVERSE(@PALAVRA3)
PRINT('---------ESTA FUNÇÃO RETORNA A PARTE DIRECIONADA DO CARACTER SELECIONADO E O
QUANTO QUER DELA-----------')
PRINT SUBSTRING(@PALAVRA3,16,10)
PRINT ('--------ESTÁ FUNÇÃO CONCATENA/JUNTA AS INFORMAÇÕES-----------')
PRINT CONCAT(@PALAVRA1,' ',@PALAVRA2,' ',@PALAVRA3)
t

PRINT ('-----ESTA FUNÇÃO RETORNA A STRING SELECIONADA EM QUANTIDADE DE UMA FRASE OU

TEXTO DE ALGUM DADO--------')
PRINT CHARINDEX('Q',@PALAVRA3)
PRINT ('---------USANDO FORMAT PARA FORMATAR UMA EXPRESSÃO---------------')
SET @PALAVRA4 = '11.01.2018'
PRINT CONCAT(FORMAT(@PALAVRA4,'DDDD'), ' ',FORMAT(@PALAVRA4,'DD.MM.YY'))
PRINT ('---------FIM DOS COMANDOS SIMPLES - IMPORTANTES---------')
------------------------------------------------------------------------------------
----------------------------------------------------

--------------------------USANDO CASE/WHEN ----------------------------------------

--USANDO CASE E WHEN
USE PEDIDOS
SELECT * FROM [DBO].[PRODUTOS]

DECLARE @DIA VARCHAR(MAX)

DECLARE @DIA1 DATE
DECLARE @DIA2 DATE
DECLARE @DIA3 DATE
DECLARE @DIA4 DATE
DECLARE @DIA5 DATE
DECLARE @DIA6 DATE
DECLARE @DIA7 DATE

SET @DIA = '---DIAS DA SEMANA---'

SET @DIA1 = '07.01.2018'
SET @DIA2 = '08.01.2018'
SET @DIA3 = '09.01.2018'
SET @DIA4 = '10.01.2018'
SET @DIA5 = '11.01.2018'
SET @DIA6 = '12.01.2018'

PRINT @DIA
PRINT FORMAT(@DIA1,'DDDD')
PRINT FORMAT(@DIA2,'DDDD')
PRINT FORMAT(@DIA3,'DDDD')
PRINT FORMAT(@DIA4,'DDDD')
PRINT FORMAT(@DIA5,'DDDD')
PRINT FORMAT(@DIA6,'DDDD')

--------------------------------------FIM--------------------
USE DB_CMS
SELECT * FROM [DBO].[TB_CMS_REP_HAGENT_30_MIN_SEQ_21]

--------------------------------

USE [DB_REL_OFICIAL]
SELECT * FROM [DBO].[TB_HH]
WHERE DATA = '01/01/2018'
AND CONTROLE_OPERACAO = 'FSPO'
AND CONTROLE_SITE = 'LBD' OR CONTROLE_SITE = 'SBE'
ORDER BY DATA ASC
t

------------CHOOSE E DATEPART------------------------------
SELECT
CHOOSE (DATEPART(WEEKDAY, CAST(CONVERT(DATETIME,DATEACK,103) AS DATE)),
'DOMINGO','SEGUNDA','TERCA','QUARTA','QUINTA','SEXTA','SABADO'
) AS DIADASEMANA
,DATEPART(WEEKDAY,CAST(CONVERT(DATETIME,DATEACK,103) AS DATE)) AS [DATEPART]
FROM [DBO].[VW_CGI_MIS50003_BACKLOG_INTRAGOV_D-1]

----------------------------------------------
----- DELIMITANDO AONDE QUERO PEGAR EM QUAL LINHA COM SET E OFFSET--------------
SELECT * FROM [DBO].[VW_CGI_MIS50003_BACKLOG_INTRAGOV_D-1] A
ORDER BY A.[NODEID]
OFFSET 10 ROWS FETCH NEXT 20 ROWS ONLY
-----------------------------------------------------------------------
----BULK INSERT PARA INSERIR DADOS (NÃO DEU CERTO)

--USE [DB_OUTROS]
--BULK INSERT [TB_BULK_INSERT_TEST]
-- FROM 'C:\TESTE\EXTRACAO__CARTA_E_FAX_TESTE.TXT'
-- WITH(
-- FIRSTROW = 2,
-- FIELDTERMINATOR =';'
-- );

--------------------------------------------
-----CRIAR TABERLA PARA BULK TESTE
USE [DB_OUTROS]
--DROP TABLE [DBO].[TB_BULK_INSERT_TEST]
GO
CREATE TABLE [DBO].[TB_BULK_INSERT_TEST](
CD_EXTRACAO VARCHAR(MAX),
DTH_EXTRACAO VARCHAR(MAX),
CD_ORIGEM VARCHAR(MAX),
CD_PROCESSO VARCHAR(MAX)
)
GO
--------------------------------------------------------------
USE [DB_WFM]
--DROP TABLE [TB_BUDA_DIM_CLP_TESTE]

MERGE [TB_BUDA_DIM_CLP_TESTE] AS A
USING [DB_WFM].[DBO].[TB_BUDA_DIM_FUNC] AS B
ON A.[ID_SEQ_FUNCIONARIO] = B.[ID_SEQ_FUNCIONARIO]
WHEN MATCHED THEN
UPDATE SET B.[ST_DES_CARGO] = 'CARGO_IGUAL';

SELECT TOP(100)* FROM [DB_WFM].[DBO].[TB_BUDA_DIM_FUNC] B

SELECT * FROM [TB_BUDA_DIM_CLP_TESTE] A

--------------------------------------------------------------
t

USE [DB_OUTROS]

DECLARE
@SELECT VARCHAR(MAX),
@TABELA VARCHAR(MAX),
@CONDIÇÃO VARCHAR(MAX),
@WHERE VARCHAR(MAX),
@RUN VARCHAR(MAX),
@RUN2 VARCHAR(MAX),
@UNION VARCHAR(MAX)

SET @SELECT = 'SELECT [INTERVALO]'

SET @TABELA = ' FROM [DB_OUTROS].[DBO].[OLD_TBL_REGUA_INTERVALOS]'
SET @WHERE = ' WHERE [INTERVALO] = '
SET @CONDIÇÃO = '''20:00:00'''
SET @UNION = '
UNION ALL
'

SET @RUN = @SELECT + @TABELA + @WHERE + @CONDIÇÃO

SET @RUN2 = @RUN + @UNION + @RUN

PRINT(@RUN2)

EXEC(@RUN2)
--------------

DECLARE @TESTESELECT VARCHAR(MAX)

SET @TESTESELECT = 'SELECT * FROM [DBO].[OLD_TBL_REGUA_INTERVALOS]'

PRINT(@TESTESELECT)

EXEC(@TESTESELECT)

------------------------

SELECT SCOPE_IDENTITY()

----------------------------------------------------------------------------
--INICIANDO UM MERGE TESTE

--CRIANDO TABELA TESTE TEMP

USE [DB_OUTROS]
SELECT * INTO [DBO].[JOBSTATUS_TEMP] FROM [DB_OUTROS].[DBO].[JOBSTATUS]

----------------------------------
--UPDATE EM ALGUMAS COISAS DA TEMP

SELECT * FROM [DBO].[JOBSTATUS_TEMP] AS T

WHERE T.[LAST_RUN_TIME] = 0
-----------------------------------

UPDATE [DBO].[JOBSTATUS_TEMP]
SET [ORIGINATING_SERVER] = ''
t

WHERE [LAST_RUN_TIME] = 0

-------------------------------------
SET IDENTITY_INSERT [JOBSTATUS_TEMP] OFF
--INICIANDO O MERGE
MERGE [JOBSTATUS_TEMP] AS T -- TABELA ALVO
USING [JOBSTATUS] AS ORIGI -- TABELA DE COMPARAÇÃO
ON T.[LAST_RUN_TIME] <> ORIGI.[LAST_RUN_TIME] --CONDIÇÃO DE
COMPARAÇÃO
WHEN MATCHED THEN
UPDATE SET T.[ORIGINATING_SERVER] = ORIGI.[ORIGINATING_SERVER]

WHEN NOT MATCHED

THEN
UPDATE SET T.[ORIGINATING_SERVER] = NULL;

---EXCLUINDO TEMP
DROP TABLE [DBO].[JOBSTATUS_TEMP]
----------------------------------------------------------------------
-----------------TESTANDO O MERGE NOVAMENTE
--CRIANDO TEMP
USE [DB_CONSUMO]
SELECT * INTO [DBO].[TB_WFM_MIS50064_GRUPO_69_TEMP] FROM [DBO].
[TB_WFM_MIS50064_GRUPO_69]
----------------
--DELETANDO TEMP
DROP TABLE [DBO].[TB_WFM_MIS50064_GRUPO_69_TEMP]
-----------------
SELECT * FROM [DBO].[TB_WFM_MIS50064_GRUPO_69_TEMP]
WHERE [DATA] = '20180321'
AND [RE] = '683561'
AND [QTD] = '28800'
------------------
--USANSDO UPDATE
UPDATE [DBO].[TB_WFM_MIS50064_GRUPO_69_TEMP]
SET [QTD] = NULL
WHERE [DATA] = '20180321'
AND [RE] = '683561'
--AND [QTD] = '28800'
---------------------------
--TESTANDO O MERGE
BEGIN TRANSACTION

MERGE [DBO].[TB_WFM_MIS50064_GRUPO_69_TEMP] AS TEMP --TABELA ALVO

USING [DBO].[TB_WFM_MIS50064_GRUPO_69] AS REF -- TABELA REFERENCIA
ON TEMP.RE = REF.[RE]

WHEN MATCHED AND TEMP.[QTD] <> REF.[QTD] THEN

UPDATE SET TEMP.[QTD] = REF.[QTD]

WHEN NOT MATCHED THEN --AND TEMP.[DATA] = '20180321'

INSERT([QTD]) VALUES ([QTD]);

ROLLBACK TRANSACTION
------------------------------------------------
-----TRABALHANDO COM OUTPUT
t

------------------TRABALHANDO COM PIVOT E UNPIVOT ----------------

--PIVOT()

SELECT [RE],
[1] AS 'MES 1',
[2] AS 'MES 2',
[3] AS 'MES 3',
[4] AS 'MES 4'
FROM
(SELECT
[RE],
MONTH(CAST(SUBSTRING(CAST([DATA] AS VARCHAR),5,2) AS FLOAT)) AS MES,
CAST([QTD] AS INT) AS [QTD]
FROM [DBO].[TB_WFM_MIS50064_GRUPO_69_TEMP]
WHERE SUBSTRING(CAST([DATA] AS VARCHAR),1,4) = '2018'
--AND [RE] = '1137685'
) AS P
--WHERE SUBSTRING(CAST([DATA] AS VARCHAR),1,4) = '2018'
PIVOT(AVG(QTD) FOR [MES] IN
([1], [2], [3], [4])
) AS PVT
-----------------------------------
--- UNPIVOT()
------------------------------------------------
---CRIANDO SEQUENCIAS----

--CRIANDO SEQUENCIA
CREATE SEQUENCE [DBO].TESTE_HENRIQUE
START WITH 1000
INCREMENT BY 10
MINVALUE 10
MAXVALUE 10000
CYCLE CACHE 10;

--CRIANDO TABELA
CREATE TABLE [DBO].[TB_STG_TEMP_TESTE_HENRIQUE]
(
ID INT NOT NULL,
NOME VARCHAR(MAX)
)

--INSERINDO DADOS REFERENCIANDO A SEQUENCIA

INSERT INTO [DBO].[TB_STG_TEMP_TESTE_HENRIQUE] (ID, NOME)
VALUES (NEXT VALUE FOR [DBO].[TESTE_HENRIQUE], 'TESTE');

SELECT * FROM [DBO].[TB_STG_TEMP_TESTE_HENRIQUE]

--VERIFICANDO TODAS SEQUENCIAS NO BANCO DE DADOS

USE DB_CONSUMO
SELECT * FROM SYS.SYSTEM_VIEWS
t

----------------------------------------------------------------------
USE DB_CONSUMO

CREATE TABLE [DBO].[TB_AALU_NOMES_TESTE_D-1]

(
ID INT,
NOME VARCHAR(MAX)
)

SELECT * FROM [TB_AALU_NOMES_TESTE_D-1]

---CRIANDO SINONIMO
CREATE SYNONYM [TB_AALU_NOMES_TESTE_D-1] FOR DBO.AALU;

--VERIFICANDO TABELA
SELECT * FROM DBO.[TB_AALU_NOMES_TESTE_D-1]

CREATE FUNCTION [DBO].[FUN_TESTE] (@VALOR INT)

RETURNS INT
WITH EXECUTE AS CALLER
AS
BEGIN
IF @VALOR% 12<> 0
BEGIN
SET @VALOR+= 12 - (@VALOR % 12)
END
RETURN(@VALOR);
END;

GO

SELECT DBO.FUN_TESTE(100) AS TESTE

CREATE SYNONYM DBO.[TEST_IN_FUNCTION] FOR DBO.FUN_TESTE;

-----------------------------------------------------------
--CRIANDO SININIMO PARA A TABELA
CREATE SYNONYM DBO.[VW_WMF_TESTE_SYNONYM] FOR [DBO].
[VW_WFM_MIS3453_QUARTIL_MOVEL_DADOS_OPER]

SELECT * FROM [DBO].[VW_WFM_MIS3453_QUARTIL_MOVEL_DADOS_OPER]

SELECT * FROM [DBO].[VW_WMF_TESTE_SYNONYM]

--------------------------------------------------------------

USE DB_CONSUMO
SELECT
DB.NAME,
(SUM(SIZE) *8)/1024 AS UTILIZADO_MB,
(SUM(MAX_SIZE)*8)/ 1024 AS TAMANHO_TOTAL_MB
FROM SYS.DATABASES DB
t

INNER JOIN SYS.MASTER_FILES

ON DB.DATABASE_ID = SYS.MASTER_FILES.DATABASE_ID
GROUP BY DB.NAME

---------------------------------------------
USE MASTER
SELECT * FROM SYSLOCKS

SELECT * FROM SYSPROCESSES

WHERE [LOGINAME] = 'ATENTOBR\EST_AB985452'

---
SELECT * FROM SYS.DM_TRAN_LOCKS

---
USE DB_CONSUMO
SELECT @@LOCK_TIMEOUT

------------

SELECT * FROM SYS.DM_OS_WAITING_TASKS

-------------
EXEC SP_CONFIGURE

-----------

USE [DB_OUTROS]

CREATE TABLE [DBO].PESSOA

(
COD INT,
NOME VARCHAR(50)
)

SELECT * FROM [DB_OUTROS].[DBO].[PESSOA]

INSERT INTO [DB_OUTROS].[DBO].[PESSOA]

SELECT * FROM OPENROWSET('MICROSOFT.ACE.OLEDB.12.0',
'EXCEL 12.0;DATABASE=C:\TESTE\PESSOAS.XLSX',
'SELECT COD, NOME FROM [NOMES$]')

DROP TABLE [DB_OUTROS].[DBO].[PESSOA]

-----------------------------------------------------
t

SELECT * FROM [DB_CONSUMO].SYS.VIEWS

--[ID_BANCO],[NAME], [BANCO], [ID TABELA], [NOME TABELA], [DATA CRIAÇÃO], [DATA DE

ALTERAÇÃO])

DECLARE @ID_DO_BANCO INT

DECLARE @NOME_DO_BANCO VARCHAR(MAX)
SET @ID_DO_BANCO = 1

WITH TB_CTE_ALL_VIEWS_ON_BDS ([BANCO])

AS

(
SELECT @ID_DO_BANCO

UNION ALL
SELECT @ID_DO_BANCO + 1 AS [BANCO]
FROM TB_CTE_ALL_VIEWS_ON_BDS
WHERE @ID_DO_BANCO < 20
/*
SELECT 'DB_CONSUMO' AS [BANCO],
[OBJECT_ID] AS [ID TABELA],
[NAME] AS [NOME TABELA],
[CREATE_DATE] AS [DATA CRIAÇÃO],
[MODIFY_DATE] AS [DATA DE ALTERAÇÃO]
FROM SYS.VIEWS
*/
)
SELECT * FROM TB_CTE_ALL_VIEWS_ON_BDS

---------------
SELECT * FROM SYS.DATABASES
SELECT MAX(DATABASE_ID) FROM SYS.DATABASES

--IDENTIFICAR O CODIGO DENTRO DE UMA VIEW

SELECT * FROM INFORMATION_SCHEMA.VIEW_COLUMN_USAGE AS A
SELECT * FROM INFORMATION_SCHEMA.VIEWS AS B

-------------------------------------------------------------

-----IDENTIFICAR VIEWS QUE REFERENCIAM VIEWS - OTIMIZACAO DO BANCO.

USE [DB_CONSUMO]

SELECT
A.[TABLE_CATALOG] AS [NOME_BANCO],
A.[VIEW_NAME] AS [NOME DA TABELA],
A.[TABLE_NAME] AS [TABELA_REFERENCIA_DA_VIEW],
B.[VIEW_DEFINITION] AS [CONTEUDO_DA_VIEW]

FROM
(SELECT DISTINCT [TABLE_CATALOG], [VIEW_NAME], [TABLE_NAME]
FROM INFORMATION_SCHEMA.VIEW_COLUMN_USAGE ) AS A
JOIN INFORMATION_SCHEMA.VIEWS B
ON A.[VIEW_NAME] = B.[TABLE_NAME]
t

WHERE A.[TABLE_NAME] LIKE 'VW%'

FOR XML RAW

------------------------------------------

SELECT * FROM SYSCOMMENTS

WHERE TEXTTYPE = 0

--------------------------------
--VERIFICAR PROCESSOS COM DEADLOCK `PROCESSOS TRANCADOS`
SP_WHO
SELECT * FROM SYS.DM_OS_WAITING_TASKS
------------------------------------------------------------------------------------
--
--habilitar a funçao openrowset
EXEC sp_configure 'show advanced option', '1';
reconfigure
------------------------------------------------------------------------------------
------
--ABRINDO ARQUIVO EXCEL SIMPLES
SELECT *
FROM OPENROWSET(
'Microsoft.ACE.OLEDB.12.0',
'Excel 12.0;Database=C:\teste\PESSOAS.XLSX',
'SELECT [COD], [NOME] FROM [NOMES$]')

----------------- -------------- -------------- -------------- --------------

SELECT TOP 1 * FROM SYS.VIEWS AS [VIEWS]
SELECT TOP 1* FROM SYSCOMMENTS AS [COMMENTS]

USE [DB_CONSUMO]
SELECT TOP 10
V.[type_DESC],
V.[NAME] AS [NOME DA VIEW],
V.[CREATE_DATE] AS [DATA DA CRIAÇÃO],
V.[modify_date] AS [DATA DA MODIFICAÇÃO],
CAST(C.[text] AS VARCHAR(MAX)) AS [QUERY DA VIEW]

FROM SYS.VIEWS AS [V]

INNER JOIN SYSCOMMENTS AS [C]
ON C.[ID] = V.[OBJECT_ID]
FOR XML RAW
-----------------------------------------------------------

------------VIEEWS PERSONALIZADAS----------------
--VIEW ENCRIPTADA

CREATE VIEW [dbo].[VW_TESTANO_UMA_VIEW_ENCRIPTADA] WITH ENCRYPTION

AS(
SELECT TOP 10
V.[type_DESC],
V.[NAME] AS [NOME DA VIEW],
V.[CREATE_DATE] AS [DATA DA CRIAÇÃO],
t

V.[modify_date] AS [DATA DA MODIFICAÇÃO],

CAST(C.[text] AS VARCHAR(MAX)) AS [QUERY DA VIEW]
FROM SYS.VIEWS AS [V]
INNER JOIN SYSCOMMENTS AS [C]
ON C.[ID] = V.[OBJECT_ID]
)
SELECT * FROM [dbo].[VW_TESTANO_UMA_VIEW_ENCRIPTADA]
--------------------------------------------------------
------------WITH SCHEMABINDING
--FAZ AS TABELAS REFERENCIADAS NÃO SEREM ALTERADAS ATÉ QUE A VIEW SEJA DESVINCULADA
OU EXCLUIDA.
-----------------------------------------------------------------
-----------UTILIZANDO CHECK OPTION
-- FAZ A CHECAGEM DAS INFORMA;'OES A CADA LINHA INSERIDA PARA QUE VOC"E POSSA SEMPRE
ACOMPANHAR A MESMA.
-------------------------------------------------------------
---UTILIZANDO SP_HELPTEXT / SYS.VIEWS / SYS.SQL_DEPENDENCIES

-- MOSTRA AS DEFINI;'OES DE VIEWS N'AO CRIPTOGRAFADAS

EXEC SP_HELPTEXT

-- exibe uma lista de views do banco de dados

SELECT TOP 10 * FROM SYS.VIEWS

--
SELECT TOP 10 * FROM SYS.SQL_DEPENDENCIES
-------------------------------------------------------------
-------FUNÇÕES AVANÇADAS--------------
DECLARE @@N1 INT
DECLARE @@N2 INT
SET @@N1 = 2
SET @@N2 = 2

SELECT
DAY([CREATE_DATE]) AS [DIA DA CRIAÇÃO],
AVG([SCHEMA_ID]) AS [CALCULA_MÉDIA], -- CALCULA A MÉDIA
COUNT([SCHEMA_ID]) AS [CONTA_REGISTROS], -- CONTADOR DE REGISTROS
SUM([SCHEMA_ID]) AS [SOMADOR_DE_REGISTROS], -- SOMA REGISTROS DECIMAIS
MIN([object_id]) AS [O_MENOR_REGISTRO], -- TRAZ O MENOR REGISTRO
MAX([object_id]) AS [O_MAIOR_REGISTRO], -- TRAZ O MAIOR REGISTRO
--GROUPING([PRINCIPAL_ID]) AS [GROUPING], -- IDENTIFICA VALORES NULOS GERADOS
POR CÓDIGO DOS PADRÕES JA EXISTENTES NA TABELA
STDEV(DISTINCT [object_id]) AS [RETORNA_DESVIO_PADRAO], -- RETORNA O DESVIO
PADRÃO ESTATÍSTICO DE TODOS OS VALORES DA EXPRESSÃO
STDEVP([object_id]) AS [FUNÇÃO DETERMINISTICA], --RETORNA VALORES ESPECIFICOS
PRÉ DETERMINADOS SE NÃO USAR OVER OU ORDER BY, E O AO CONTRARIO SE USAR.
VAR([object_id]) AS [VARIANCIA ESTATÍSTICA], --RETORNA A VARIANCIA
ESTATÍTTICA DE TODOS OS VALORES DA EXPRESSÃO.
--(VAR([SCHEMA_ID]) OVER (ORDER BY [SCHEMA_ID])) AS [VARIANCIA ESTATÍSTICA
COM OVER] --
VARP([object_id]) AS [RETORNA OS VALORES DE COTA] -- RETORNA OS VALORES DE
COTA, INCLUINDO OS VALORES DUPLICADOS.

FROM [DB_CONSUMO].SYS.VIEWS
GROUP BY DAY([create_date])
------------------------------------------------------------------------------------
------------
SELECT
t

(VAR([SCHEMA_ID]) OVER (ORDER BY [SCHEMA_ID])) AS [VARIANCIA ESTATÍSTICA COM OVER]

--RETORNA A VARIANCIA ESTATÍSTICA ORDENANDO A VARIAÇÃO COM ORDER BY
FROM [DB_CONSUMO].SYS.VIEWS
------------------------------------------------------------------------------------
------------

-------------------RETORNANDO DADOS TABULARES---------------------------

--CRIANDO PROCEDURE COM DADOS TABULARES

CREATE PROCEDURE [dbo].[PRC_PROCEDURE_TABULAR_AUTOVARIAVEL] @MES INT AS
BEGIN
SELECT * FROM [DB_CONSUMO].SYS.VIEWS
WHERE MONTH([create_date]) = @MES
END

--A EXECUÇÃO A BAIXO TRAZ O FILTRO CRIADO DA PROCEDURE TABULAR ACIMA

EXEC [PRC_PROCEDURE_TABULAR_AUTOVARIAVEL] 07 -- O NUMERO REFERENCIA O MÊS

--DROP PROCEDURE [dbo].[PRC_PROCEDURE_TABULAR_AUTOVARIAVEL]

-------------------------------------------------------------------------------
--CRIANDO/CONFIGURANDO COM USIARIOS

CREATE LOGIN AB000001

WITH PASSWORD = 'TESTE01';
GO
CREATE USER AB000001 FOR LOGIN AB000001;
GO
-------------------------------------------------------------------------------
--DESENVOLVENDO DADO TABULAR COM FUNÇÃO TABULAR
BEGIN TRANSACTION -- ABRIR UMA TRANSAÇÃO
CREATE FUNCTION [dbo].[FUNC_DADO_TABULAR_TESTE] (@DT1 INT, @DT2 INT) -- CRIANDO A
FUNÇÃO
RETURNS TABLE -- RETURNO DE TABELA DA FUNÇÃO
AS
RETURN(
SELECT * FROM [DB_CONSUMO].SYS.VIEWS --TABELA REFERENCIA.
WHERE MONTH([CREATE_DATE]) BETWEEN @DT1 AND @DT2 --FILTRO SOBRE
DADOS
)
GO

--EXECUTANDO A FUNÇÃO
SELECT * FROM [dbo].[FUNC_DADO_TABULAR_TESTE] ('07','08')
--DROPANDO A FUNCTION (EXCLUINDO)
DROP FUNCTION [dbo].[FUNC_DADO_TABULAR_TESTE]

-------------------------------------------------------------------------------
----------INTRODUÇÃO A PROGRAMAÇÃO NO SQL SERVER--------------------PG 166 - SQL MOD
II
DECLARE @NUM1 VARCHAR(MAX), @NUM2 VARCHAR(MAX)
SET @NUM1 = 'X'
SET @NUM2 = 'X'
IF @NUM1 > @NUM2
BEGIN
PRINT ('O NUM1 DE VALOR: ')+(@NUM1)+(' É MAIOR QUE O NUM2 DE
VALOR: ')+(@NUM2)
END
IF @NUM1 < @NUM2
t

BEGIN
PRINT ('O NUM1 DE VALOR: ')+(@NUM1)+(' É MENOR QUE O NUM2 DE
VALOR: ')+(@NUM2)
END
IF @NUM1 = @NUM2
BEGIN
PRINT('OS NUMEROS SÃO IGUAIS')
END
ELSE
BEGIN
PRINT ('IN CATCH')
END
------------------------------------------------------------------------------------
-------
--FORÇANDO UM ERRO COM PROGRAMAÇÃO
BEGIN TRANSACTION

CREATE TABLE [dbo].[TB_TABELA_TESTE_TESTINHA]

(
ID INT PRIMARY KEY
);

BEGIN TRY
INSERT [dbo].[TB_TABELA_TESTE_TESTINHA]
(ID) VALUES(1);
-- Force error 2627, Violation of PRIMARY KEY constraint to be raised.
INSERT [dbo].[TB_TABELA_TESTE_TESTINHA]
(ID) VALUES(1);
END TRY

BEGIN CATCH

PRINT 'In catch block.';

THROW;
END CATCH;

ROLLBACK TRANSACTION
COMMIT TRANSACTION
--
DROP TABLE [dbo].[TB_TABELA_TESTE_TESTINHA]
------------------------------------------------------------------------------------
-----PROGRAMAÇÃO NO SQL USANDO LOOP
DECLARE @COUNT INT = 0;

WHILE @COUNT <= 100

BEGIN
SET @COUNT = @COUNT + 1
PRINT @COUNT
END
PRINT 'FIM'

------------------------TESTE 2 LOOP
--USANDO RETORNO
PRINT 'PROJETO 1'
PRINT 'PROJETO 2'
RETURN
t

PRINT 'PROJETO 3'

PRINT 'PROJETO 4'

--USANDO GOTO COM WAIT FOR

GOTO INICIO

MEIO:
PRINT 'PASSO QUASE FINAL'
WAITFOR DELAY '00:00:02'
PRINT 'DELAY DE 2 SEGUNDOS'
GOTO FIM

INICIO:
PRINT 'PASSO UM'
WAITFOR DELAY '00:00:01'
PRINT 'DELAY DE 1 SEGUNDO'
GOTO MEIO

FIM:
PRINT 'PROCESSO TERMINADO'
---------------------------------------------

DECLARE @CONT INT = 0;

WHILE @CONT <= 100
BEGIN
BREAK
PRINT @CONT;
SET @CONT += 1;
END
PRINT 'FIM'
;
--------------------------------------------

-----use to learn about like------