Archive

Posts Tagged ‘Top’

Conhecendo Indices Step-by-Step V

Fala Galera, blz? Bem vindos ao quinto artigo da série “Conhecendo Indices Step-By-Step”. Esse post é dedicado a Bianca Almeida de Oliveira, que esta sempre ao meu lado , minha incrível esposa. Hoje iremos ver como o SQL Server acessa os dados de um índice nonclustered em uma tabela clusterizada. Na seção três vimos como o SQL Server usa o RID para encontrar um registro especifico, conhecido como RID Lookup. A técnica aplicado para o caso de hoje é o que chamamos de KeyLookup. Vamos a prática:

Neste exemplo usaremos uma tabela chamada TB_CLIENTES que possui apenas um índice clustered na coluna ID_CLIENTE. Fazendo a query a seguir, o SQL Server optou por usar um Clustered Index Scan, vejamos:

SET STATISTICS IO ON

SELECT ID_Cliente, Nome, Col1

FROM TB_CLIENTES

WHERE Nome = ‘Colin B9A7D004’

SET STATISTICS IO OFF

Abaixo o resultado e o plano de execução:

Plano de execução:

Voltando as posts iniciais desta série é correto afirmar que os índices são construídos em estruturas B-Tree. No nosso plano o que foi apresentado foi um clustered index scan, mas, será que não seria interessante criarmos um nonclustered index por nome? Vamos avaliar?

CREATE NONCLUSTERED INDEX IXNC_Nome ON TB_CLIENTES(Nome)

Ao criar o índice, podemos afirmar que o SQL Server utilizará o índice para buscar os nomes, porém, como foi dito nos posts anteriores: O SQL server cria uma estrutura B-Tree pra cada índice e neste caso é o nome. Pare um pouco e pense caro leitor, a query apenas solicita o nome? NÃO. Ela ainda precisa retornar para o cliente a coluna Col1 e o Id_cliente, como o SQL Server busca essa informação? Ao executar a mesma query do inicio do artigo, podemos perceber que o SQL Server apenas efetuou seis leituras lógicas e fez o que chamamos de KeyLookup:

O KeyLookup pode ser visto como um dos responsáveis por alto custo no plano de execução:

Thiago! Não entendi, como o SQL Server fez isso? Vamos simular a leitura dos índices para entender esse comportamento.

Obs: Lembrando que o conceito, é muito parecido com os posts anteriores.

Tendo como base o comando DBCC PAGE gerado, vamos começar a leitura.

SELECT dbo.fn_HexaToDBCCPAGE(Root), *

FROM sys.sysindexes

WHERE name = ‘IXNC_Nome’

AND id = OBJECT_ID (‘TB_CLIENTES’)

DBCC TRACEON (3604)

DBCC PAGE (31,3,303,3) — 1º Leitura

Baseando-se no resultado do print, foram retornados dois registros. A pergunta é: A letra “C” vem antes ou depois da letra “J”? Resposta fácil: Que dizer que nossa próxima leitura é na ChildPageId 26528.

DBCC PAGE (31,3,26528,3) — 2º Leitura

Na nossa segunda leitura podemos ver que o cliente Colin B9A7D004, pode estar dentro da página 26661 ou 26662. Mas qual será a página certa? Posso afirmar com certeza que é a página 26661, pois, o cliente Colin que procuramos começa com B e em uma ordenação, os números sempre veem antes das letras. Que dizer que o cliente Colin 90026186 está antes do Colin B9A7D004. Vamos para a terceira leitura:

DBCC PAGE (31,3,26661,3) — 3º Leitura

EURECA! Encontramos nosso cara! Se você que está lendo, vem acompanhando todos os artigos da série, você deve se lembrar que quando fizemos essa mesma quantidade de leitura para uma Heap, encontramos uma coluna de nome “Heap RID (Key)” com valores em hexadecimais. Como estamos falando de uma tabela Clusterizada, temos a referência do nosso índice clustered (Coluna id_cliente(Key)) dentro do índice nonclustered. Thiago! Que dizer que todos nonclustered indexes possui o clustered index? CORRETO.

Obs: Muito cuidado ao escolher seus clustereds index. Caso você tenha uma tabela com um índice clustered composto por três colunas. E nesta tabela você tenha dois nonclustered indexes…as três colunas do índice clustered irá aparecer no índice nonclustered. Isso é um grande vilão de performance. Fique sempre atento: PERFORMANCE COMEÇA NA MODELAGEM.

Voltando ao assunto do post: A partir daqui fizemos três leituras, mas, o SQL Server apenas sabe qual o nome do cliente que ele está buscando no índice e automaticamente seu id_cliente que é 77939. Mais uma pergunta! Então, até agora apenas navegamos na estrutura B-Tree do índice nonclustered Thiago? Sim. Agora o que o SQL Server faz é pegar a “chave” e navegar na estrutura do índice clustered. Vamos então a quarta leitura? Mas, primeiro precisamos retornar o DBCC PAGE do índice clustered:

SELECT dbo.fn_HexaToDBCCPAGE(Root), *

FROM sys.sysindexes

WHERE name = ‘PK’

AND id = OBJECT_ID (‘TB_CLIENTES’)

DBCC PAGE (31,3,295,3) — 4º Leitura

Novamente a pergunta que o SQL Server faz. O valor de id_cliente 77939 é maior que o id_clente 40899? A resposta é sim. Vamos a quinta leitura, tendo como base a ChildPageID 19328.

DBCC PAGE (31,3,19328,3) — 5º Leitura

Como podemos ver, o cliente de id 77939 encontra-se dentro da página 20241 onde o id_cliente 77913 é menor que o id_cliente 77939. Vamos para a sexta e última leitura:

DBCC PAGE (31,3,20241,3) – 6º Leitura Encontramos o ID_Cliente = 77939

Pronto! Simulamos as seis leituras lógicas do SQL Server. Thiago uma pergunta! Como faço pra evitar que o SQL Server faça as últimas três leituras adicionais? Não seria mais performático pra ele achar a Col1 quando chegar no nível folha do índice nonclustered? A resposta é: Sim, seria mais fácil. No próximo post sobre índices, veremos uma das features que surgiu a partir do SQL Server 2005, o Covered Index que particularmente acho incrível.

Espero ter ajudado

Thiago Carlos [TC] de Alencar

Conhecendo Indices Step-by-Step IV

Boa tarde, comunidade SQL Server. Dando continuidade a série “Conhecendo índices Step-By-Step”. No  último artigo foi abordado como o SQL Server navega em um índice nonclustered em uma heap. Já neste artigo mostraremos como o SQL Server navega em um clustered index.

Iremos utilizar uma tabela chamada ClusteredTable que tem apenas um clustered index. A coluna que estamos falando é a coluna id_cliente. Iremos executar a query e analisaremos o plano de execução gerado.

SET STATISTICS IO ON

SELECT * 

  FROM ClusteredTable

 WHERE ID_Cliente = 500

SET STATISTICS IO OFF

Plano de execução:

Resultado:

Leituras lógicas realizadas foram três, uma a menos do que no nonclustered index do artigo anterior. Vamos entender? O procedimento de verificar as leituras é idêntico ao do artigo anterior.

Executaremos a query com a função que nos traz o comando dbcc.

SELECT dbo.fn_HexaToDBCCPAGE(Root), *

  FROM sys.sysindexes

 WHERE name = ‘PK_CL’

Abaixo executo os comandos dbcc onde encontra-se o registro:

DBCC TRACEON (3604)

DBCC PAGE (31,3,288,3)  — 1º Leitura

A segunda leitura resume-se na ChildPageId 14728.

DBCC TRACEON (3604)

DBCC PAGE (31,3,14728,3) — 2º Leitura

Como pode ser visto, o id_cliente 500 encontra-se na página 14606. Mas como assim? O motivo é porque página 14606 começa no id_cliente 443 e termina no id_cliente 516 que é onde começa a próxima página. Executando o comando dbcc podemos confirmar isso:

DBCC TRACEON (3604)

DBCC PAGE (31,3,14606,3) — 3º Leitura Encontramos o ID_Cliente = 500

No resultado da nossa terceira leitura podemos ver que o registro está lá no slot 57. Até o próximo post. E o assunto a ser falado será!? Suspense. Index..rs

Conhecendo Indices Step-by-Step III

Fala galera, blz? Bem-vindo ao terceiro artigo da série Conhecendo Índice Step-by-Step. Hoje iremos “navegar” pelos nossos índices e demonstrar como o SQL Server faz isso por debaixo dos Panos. Literalmente é isso mesmo “NAVEGAR”…rs. Não adianta saber onde um índice pode ajuda-lo ou atrapalha-lo sem saber como o SQL Server decide usá-lo e quando decide usá-lo. Este post é dedicado ao Mestre Fabiano Neves Amorim, um cara que manja demais de QO. Com o treinamento de Avanced Tunning que tive ministrado por ele, abriu muito minha cabeça e isso me ajudou a crescer profissionalmente. Vamos para de falar e mão na massa…..

Obs: Os scripts que foram usados para a carga da tabela pertencem ao Fabiano Amorim.

A tabela que utilizaremos se chama Heap. Essa tabela não possui um índice sequer, o que o SQL Server irá fazer. Primeiros precisamos listar todas as páginas que são alocadas para a nossa heap. Thiago, mas, como faremos isso? Simples! Faremos isso através dos comandos dbcc. O comando abaixo retorna todas as páginas alocadas para a nossa heap e mais algumas informações importantes. Vejamos:

DBCC TRACEON (3604)

DBCC IND (dbMonitoring, Heap, 1)

Todas as informações retornadas são importantes, porém, eu irei falar das colunas que mais considero importante para o nosso propósito:

PageFID – Id do arquivo de banco de dados que no caso da minha base de dados é o três. Isso porque eu tenho um arquivo .ldf (id 2), um arquivo de dados primário .mdf (Id 1) e um arquivo secundário .ndf (id 3) onde encontram-se todos os meus objetos definidos pelo o usuário.

PageId – Id da página de dados.

PageType – Tipo da página de dados:

  • 1 – data page
  • 2 – index page
  • 3 and 4 – text pages
  • 8 – GAM page
  • 9 – SGAM page
  • 10 – IAM page
  • 11 – PFS page

Após o comando retorna essas informações, usaremos o PageFID e o PageID no comando dbcc. A sintaxe para o comando é:

DBCC PAGE({‘NomeDoBanco’ | IdDB}, IDArquivo, NumPagina [,printopt={0|1|2|3}])

No nosso caso ficaria da seguinte forma

DBCC PAGE(dbMonitoring, 3, 298, 3) — O número da página passada dever ser o da página IAM

Serão retornadas diversas informações da página de dados com o id 298 (a IAM), eu selecionei dois trechos de informações que considero bastante importantes. Abaixo pode ser visto o primeiro bloco de informações:

No segundo print podemos ver informações abaixo do cabeçalho da nossa página:

Agora iremos realizar um select na nossa tabela heap. Já que uma heap não tem uma ordenação física dos registros, o que o SQL Server irá fazer? Se você pensou em um Table Scan. Parabéns, você está prestando atenção. Vamos fazer um select e analisar o plano de execução:

SELECT * FROM Heap WHERE ID_Produto = 50

O plano de execução mostra para a query é o seguinte:

O produto retornado é o:

Até o momento é correto afirmar que: Um select em uma heap sem um nonclustered index o SQL Server optará por um Table Scan (Se existisse estatísticas para esta tabela, provavelmente o SQL escolheria outro plano, ainda não fiz este teste).

Agora se tivéssemos um nonclustered index? PENSE, antes de dar a resposta. No artigo anterior eu falei como o nonclustered index se comporta. Ele apenas cria a estrutura da B-Tree para as colunas no índice, certo? No nosso exemplo estamos solicitando o retorno de todas as colunas com o “*”. Como o SQL Server “encontra” as demais informações quando temos um nonclustered index em uma Heap? Se você for ao artigo anterior (criar um link aki), você verá que ele usa o RID. Mas o que diabos é o RID? Vamos ver o comportamento na prática. Vamos executar essa consulta novamente com o os statistics io ligado.

–Crio o indice para a tabela Heap

CREATE NONCLUSTERED INDEX IDX_Heap ON Heap(ID_Produto)

Executando a mesma query:

SET STATISTICS IO ON

SELECT * FROM Heap

WHERE ID_Produto = 50

SET STATISTICS IO OFF

Podemos ver que: O SQL Server optou por usar o nonclustered index para encontrar o id_produto = 50. Fazendo um RID Lookup para encontrar as demais informações (devido ao uso do “*”).

Thiago! E quantas leituras o SQL Server fez para encontrar meu registro? A reposta é: 4.

Agora vamos pular para a parte boa do artigo! Iremos simular o que o SQL Server faz nessas quatro leituras.

O primeiro passo é retorna o hexadecimal do índice que o SQL Server utilizou e depois transformar o hexadecimal em decimal para poder passar os valores para o DBCC PAGE. CALMA! Não se preocupem, o nosso amigo Fabiano Neves Amorim criou uma função que recebe o hexadecimal da página root, e retorna o comando dbcc page com os valores já convertidos.

SELECT dbo.fn_HexaToDBCCPAGE(Root), *

  FROM sys.sysindexes

 WHERE name = ‘IDX_Heap’

Vamos executar o commando DBCC retornado e simular as leituras do SQL Server.

DBCC TRACEON (3604)

DBCC PAGE (31,3,10538,3) – 1º Leitura

O retorno traz a página e suas páginas filhas. A pergunta é: Onde está o registros com o id_produto = 50? Simples meu caro Watson, está na ChildPageId 10536. Mas como assim? A segunda linha tem o id_produto a partir do 207516. O número 207516 é menor ou maior que 50? Maior. Completamos a primeira leitura, agora iremos fazer o mesmo DBCC PAGE mudando apenas a página de dados.

DBCC TRACEON (3604)

DBCC PAGE (31,3,10536,3) — 2º Leitura

Agora faremos a mesma pergunta que a anterior, a única coisa que irá mudar é o ChildPageID. : Onde está o registros com o id_produto = 50? Está na ChildPageId 10408. Mas como assim? A segunda linha tem o id_produto a partir do 540. O número 540 é menor ou maior que 50? Maior. Segunda leitura concluída. Vamos para a terceira.

DBCC TRACEON (3604)

DBCC PAGE (31,3,10408,3) — 3º Leitura

Até agora simulamos 3º leituras. Thiago, já chegamos no valor do Id_produto 50, não acaba por aqui? Simplesmente não, pois, a query ainda retorna mais duas colunas: Descricao e Col1. Agora o SQL Server irá usar o RID para chegar nesses valores.

Primeiro precisamos converter o valor do hexadecimal 0x4890000003003100. Inicialmente temos que querbar esse valor em quatro blocos, ficando assim:

0x4890 0000 0300 3100

Agora precisamos fazer uma alteração neste consjunto de números: O primeiro valor de cada bloco passa a ser o terceiro valor, e o segundo valor passa a ser o quarto valor, ficando da seguinte maneira: 0x9048 0000 0003 0031

Após termos os valores em mãos, basta converter para inteiro no SQL Server e ter nossos dados, para o DBCC PAGE e assim realizar a quarta leitura que o SQL Server fez anteriormente.

SELECT CONVERT(Int, 0x9048)AS Página,CONVERT(Int, 0x0003) AS Arquivo ,CONVERT(Int, 0x0031) AS Slot

Agora só precisamos executar novamente o quarto DBCC PAGE:

DBCC PAGE (31,3,36936,3) — 4º Leitura

Como pode ser visto no resultado, nosso registro esta lá No Slot 49 e as três colunas: ID_Produto, Descricao e Col1.

Espero Ter ajudado

Thiago Carlos [TC] de Alencar

Conhecendo Indices Step-by-Step II

Nesta segunda parte do nosso artigo post iremos entender como o SQL Server armazena e lê os dados através de Clustered Indexes, NonClustered Indexes e  Heaps. O objetivo deste post é mostrar conceitualmente como o SQL Server armazena os dados e de como os indices funcionam dentro do SQL Server. Esse post é dedicado ao Luciano [LUTI] Caixeta Moreira, pois, ele é uma das minhas maiores inspirações, após, eu ter realizado o treinamento de SQL Server Internals.

Clustered Tables:

Clustered Tables são conhecidas assim, quando possuem um clustered index. Os dados são armazenados ordenados fisicamente baseando-se na chave do índice, por exemplo. A tabela clientes possui um clustered index sobre a coluna Id, que dizer que os índices são armazenados na ordem dos valores ID. Esses valores podem estar em ordem crescente ou decrescente, iremos ver essa opção na criação do índice mais tarde neste artigo. Como falado anteriormente, existe uma “lista” duplamente ligada entre cada página do índice e a navegação entre os níveis são feitos através de um valor chave. Só pode existir um clustered index por tabela, a pergunta é: Por quê ? Simples! Os dados são armazenados ordenados fisicamente baseando-se na chave do índice. Pra deixar mais claro, vamos a um exemplo completamente BOBO, mas, que pode ajudar na compreensão. Voltando ao tempo de escola quando a “TIA” pedia para que fizéssemos uma fila por ordem de tamanho, neste momento estávamos realizando uma “ordenação física” a um critério que neste caso é o tamanho. Sei que o exemplo parece meio estúpido, mas, esse é um dos motivos pelo qual podemos criar apenas um clustered index por tabela. No caso da professora, ela só pode optar por uma ordem física da fila. Cada clustered index tem uma linha na sys.partitions com o index_id = 1. Abaixo temos a estrutura B-tree do clustered index :

Heaps

Uma heap é uma tabela SEM um clustered index, os dados não são armazenados em uma ordem particular ou obedecem a uma sequencia em particular. Cada heap tem uma linha na sys.partitions com o index_id = 0. Tratando-se de questão de múltiplas partições em uma heap, pode ser aplicado o mesmo conceito que o clustered index . O que difere o clustered index para uma heap é de como o SQL Server realiza a navegação entre as páginas de dados. As páginas de dados não estão ligada em uma lista duplamente ligada com o clustered index então o SQL Server usa uma página IAM (Index Allocation Map) para navegar entre as páginas de uma heap. Na figura abaixo temos a estrutura de uma heap:

Indices NonClustereds:

Índices nonclustered tem a mesma estrutura de uma B-Tree como a de um clustered index. Exceto por as seguintes diferenças:

  • As linhas subjacentes da tabela não são ordenadas e armazenadas baseadas na ordem de suas chaves nonclustereds.
  • O nível folha de um nonclustered índice é feito de páginas de índices ao invés de páginas de dados.

Os índices nonclustereds, podem ser criados em tabelas, views ou em heaps. Basicamente os tipos de índices que existem no SQL Server são: clustereds, Xml índices, Spacial índices e nonclustered indexes (podendo ter variações como: Filtereds, Covereds, Computados e Hash Indexs, que serão cobertos em outros posts). Cada linha de um nonclustered index contém um valor de chave nonclustered (nonclustered key value) e um indicador de linha (row locator). Esse indicador de linha é usado como um ponteiro em um clustered index ou em uma heap. As condições para os dois casos são:

  • Se a tabela é uma Heap, significa ela não tem um clustered index, o localizador é um ponteiro para a linha que é chamado de RID (FileID, PageID e SlotId)
  • Se a tabela tem um clustered index ou o index existe em uma view indexada, o localizador é o que chamamos de chave de clustered index (clustered index key). Pra simplificar é o seguinte, cada nonclustered index dentro de uma tabela clusterizada tem uma referência para um índice clustered.

Índices nonclustereds também podem ser encontrados como as heaps e os clustereds indexes dentro da sys.partitions com o index_id > 1.

Espero ter ajudado!

[] Thiago Carlos [TC] de Alencar

 

 

Conhecendo Indices Step-By-Step

Olá Galera, boa noite.

Desta vez escolhi um assunto extremamente importante e que vejo muita gente falando por ai. Porém, muitas pessoas ainda não entendem perfeitamente como funciona perfeitamente. Meu objetivo neste post é fazer com que o leitor entende como o SQL Server armazena e lê os dados. Isso mesmo, irei falar sobre índices. Esse artigo será divido em diversas partes, por ser um assunto com muito conteúdo e de certa forma complexo.  Já cheguei a falar sobre este assunto no blog, porém, de uma forma introdutória. Este post é dedicado a Andressa A. Martins, ela é uma pessoa que tem me ajudado muito na minha mais nova empreitada e me instruiu como os meus posts podem ter maior visibilidade na comunidade SQL Server.

Obs: Nos posts eu não vou traduzir nonclustered indexes, clustered indexes e alguns termos conhecido na documentação, pelo simples motivo de ficar ZUADO a tradução ao pé da letra.

Introdução:

Os índices são criados em colunas de uma tabela ou em view. O índice oferece uma maneira rápida de procurar dados com base nos valores dentro dessas colunas. Por exemplo, se você criar um índice para a chave primária e em seguida, procure uma linha de dados baseado em um dos valores de chave primária, SQL Server primeiro verifica que o valor no índice, e depois usa o índice para localizar rapidamente toda a linha de dados. Sem o índice, uma verificação de tabela teria de ser realizada a fim de localizar a linha, que pode ter um efeito significativo no desempenho.

Você pode criar índices na maioria das colunas de uma tabela ou em uma view. As exceções são principalmente as colunas configuradas com tipos de dados, tais como imagem, texto, e varchar (max) conhecidos como LOB’s. Você também pode criar índices em colunas XML, mas esses índices são ligeiramente diferentes do índice básico.

B-Tree:

No SQL Server, índices são organizados em B-Trees (O B é de Balanced e não de Binário). Cada página de um index em uma B-Tree é chamada de Nó (Node). O topo do nó da da B-Tree é chamado de Nó Root(Root Node). O ultimo nível desta estrutura é chamado de Nivel Folha (Leaf nodes). Qualquer nível entre o nível folha e o root é conhecido como Nível Intermediário.  As páginas de cada nível do índice estão relacionadas em uma lista duplamente ligada. Tendo como a função de um ponteiro de página para página, porém, isso não ocorre apenas em um sentido. Esses “ponteiros” existem em ambos os sentidos das páginas de dados, cada página tem referência para a página anterior (Last Page) e para a próxima página (Next Page).

Organização de uma Tabela:

A tabela contém uma ou mais partições e cada partição contém linhas de uma heap ou clustered index. As páginas de uma heap ou clustered index são gerenciadas em uma ou mais unidades de alocações (allocation unit) dependendo do tipo de dados. Como pode ser visto, podemos ter três diferentes tipos de unidade de alocação que gerenciam este armazenamento, como: Data, LOB e Row-Overflow.

Para verificar as unidades de alocações usadas pelo seu banco de dados, consulte a DMV: select* from sys.allocation_units

No meu caso eu estou mostrando quais as unidades de alocação que estão sendo utilizadas:

Partições:

Tabelas e páginas de índices são contidas em uma ou mais partições. Por padrão, uma tabela ou índice tem somente uma partição que contém toda a tabela ou as páginas de índice. Uma partição reside em apenas um único FileGroup. Quando temos uma tabela ou índice em múltiplas partições, os dados são particionados horizontalmente e um determinado grupo de linhas que é mapeado dentro de uma partição individual. Esse comportamento pode ser verificado em um artigo que falo sobre particiona mento: https://tcalencar.wordpress.com/2012/03/06/particionando-tabelas/. Para verificar as partições do seu banco de dados, consulte a DMV: select* from sys.partitions

E os níveis da B-Tree que você falou, onde estão? Vamos procurar a nossa resposta. O script cria uma tabela, adiciona um clustered index e realiza algumas inserções.

USE tempdb

GO

IF OBJECT_ID(‘dbo.TabelaFramentada ‘) IS NOT NULL

BEGIN

      DROP TABLE dbo.TabelaFramentada

END

 

CREATE TABLE dbo.TabelaFramentada (ID CHAR(800),

Nome CHAR(2100),

UltimoNome CHAR(2500),

Cidade CHAR(2200))

GO

 

CREATE CLUSTERED INDEX [IXNC_FragTable_ID] ON dbo.TabelaFramentada

(

[ID] ASC

) ON [PRIMARY]

GO

 

INSERT INTO dbo.TabelaFramentada (ID,Nome,UltimoNome,Cidade)

SELECT TOP 100 ROW_NUMBER() OVER (ORDER BY a.name) RowID,

‘Thiago’,

CASE WHEN ROW_NUMBER() OVER (ORDER BY a.name)%2 = 1 THEN ‘Bianca’

ELSE ‘Andressa Martin’ END,

CASE WHEN ROW_NUMBER() OVER (ORDER BY a.name)%10 = 1 THEN ‘Pinho’

WHEN ROW_NUMBER() OVER (ORDER BY a.name)%10 = 5 THEN ‘TT Maia’

WHEN ROW_NUMBER() OVER (ORDER BY a.name)%10 = 3 THEN ‘Luiz Henrique’

ELSE ‘Bruno Catapano’ END

FROM sys.all_objects a

CROSS JOIN sys.all_objects b

Para verificar os níveis do índice, executaremos a seguinte query:

SELECT OBJECT_NAME(object_id)

,index_level

,record_count

FROM sys.dm_db_index_physical_stats(DB_ID(‘TempDb’),OBJECT_ID(‘dbo.TabelaFramentada’),NULL,NULL,’DETAILED’)

Comparando o resultado da query com o primeiro print deste post (Estrutura B-Tree) podemos afirmar que temos os seguintes níveis: Um nível folha, dois níveis intermediários e o Nível Root.

No próximo post iremos entender como o SQL Server armazena e lê os dados através de Clustered Indexes, NonClustered Indexes e  Heaps.

 

Referências:

http://blog.sqlauthority.com/2010/07/04/sql-server-index-levels-page-count-record-count-and-dmv-%C2%A0sys-dm_db_index_physical_stats/

http://www.simple-talk.com/sql/learn-sql-server/sql-server-index-basics/

Books  On Line

Espero ter ajudado!

[] Thiago Carlos [TC] de Alencar

Clausula TOP em Subqueries

Ola Galera! Vou postar uma coisa que hoje estava avaliando junto a um amigo desenvolvedor aqui na nossa fábrica. Marcos Meskelis…Um dos melhores que ja conheci…dono de uma super lógica. Já me ajudou a sair de várias, mas, vamos aos fatos e ao SQL Server (a melhor parte). Tinhamos uma query que criava uma derived table e que dentro dela havia duas outras quries simples…por um tempo que conversavamos sobre o “Brasileirão” e tal… Veio a pergunta! O que o SQL Server faz se dentro da subquery uma das consultas tiver uma clausula TOP e a consulta “externa” que gera a Derived Table também tiver uma Clausula TOP que retorna uma menor quantidade de linhas da Clausula TOP interna? Será que o SQL Server irá ler as duas tabelas da subquery pra aplicar o filtro no TOP da query externa no output das  subqueries? A melhor resposta que tivemos de imediato foi. Vamos Testar!  Crio duas tabelas uma de cliente e uma outra tabela de fornecedor. Na tabela TB_CLIENTE e na tabela TB_FORNECEDOR e realizo a inserção de seis registros para cada.

use tempdb
go
IF OBJECT_ID(‘dbo.TB_CLIENTE’) IS NOT NULL
DROP TABLE dbo.TB_CLIENTE ;
IF OBJECT_ID(‘dbo.TB_FORNECEDOR’) IS NOT NULL
DROP TABLE dbo.TB_FORNECEDOR ;

CREATE TABLE dbo.TB_CLIENTE
(
COD INT IDENTITY
,NOME VARCHAR(50)
,CPF CHAR(20)
,RG CHAR(25)
CONSTRAINT PK_TB_CLIENTE PRIMARY KEY CLUSTERED(COD)
)

CREATE TABLE dbo.TB_FORNECEDOR
(
COD INT IDENTITY
,RAZAO_SOCIAL VARCHAR(50)
,NOME_FANTASIA VARCHAR(80)
,CNPJ CHAR(20)
CONSTRAINT PK_TB_FORNECEDOR PRIMARY KEY CLUSTERED(COD)
)

INSERT INTO dbo.TB_CLIENTE(NOME,CPF,RG) 
VALUES (‘THIAGO ALENCAR’,’89636978925′,’78452362X’) 
,(‘EMANOEL ALENCAR’,’79636978925′,’88452362X’) 
,(‘CAIO LACRAIA’,’99636978925′,’784523625′) ;

INSERT INTO dbo.TB_CLIENTE(NOME,CPF,RG) 
VALUES (‘ALENCAR’,’89636978925′,’78452362X’) 
,(‘EMANOEL ‘,’79636978925′,’88452362X’) 
,(‘CAIO ‘,’99636978925′,’784523625’) ;
INSERT INTO dbo.TB_FORNECEDOR(RAZAO_SOCIAL,NOME_FANTASIA,CNPJ)
VALUES (‘D2 DA SILVA’,’MISIFIO LTDA’,’01.222.333/0001-12′)
,(‘KARATE / ARTES ‘,’JULIAO LTDA’,’01.222.333/0001-00′)
,(‘T. BUENO LTDA’,’TB GUARULHOS’,’01.222.333/0001-00′)
INSERT INTO dbo.TB_FORNECEDOR(RAZAO_SOCIAL,NOME_FANTASIA,CNPJ)
VALUES (‘D2′,’MISIFIO LTDA’,’01.222.333/0001-12′)
,(‘ARTES ‘,’JULIAO LTDA’,’01.222.333/0001-00′)
,(‘T. BUENO LTDA’,’GUARULHOS’,’01.222.333/0001-00′)

Vamos testar…rs! Habilite o plano de execução (Ctrl+M) e execute a query abaixo:

SET STATISTICS PROFILE ON
SELECT 
TOP 6 * 
FROM 
(
SELECT  COD, NOME,CPF FROM dbo.TB_CLIENTE 
UNION ALL
SELECT COD, NOME_FANTASIA,CNPJ FROM DBO.TB_FORNECEDOR 
) AS A
OPTION(RECOMPILE)
SET STATISTICS PROFILE OFF
A tabela de TB_CLIENTE contém 6 registros, assim como a de fornecedor. O SQL Server realiza um clustered index scan nas duas tabelas, porém, não é retornado nenhum registro da tabela de fornecedor. Pois o SQL Server  sabe que existem 6 registros na tabela de cliente e o TOP da consulta “externa” solicita o retorno de 6 registros.  Esse comportamento pode ser visto no plano de execução.
Obs: O SQL Server é completamente inteligente para não realizar a leitura em outro indice de uma  outra tabela. Já que o resultado do TOP quer apenas 6 registros. Vale lembrar que esse é apenas  um cenário para ver como as coisas funionam e qual caminho o SQL Server optou usar. Quando o TOP  é maior que 100 o SQL Server realiza um outro algoritmo. Isso pode mudar o plano de execução
 apresentado aqui.

Cuidado ao escrever queries

Post dedicado ao meu irmão gêmeo Emanoel Carlos de Alencar, que está se esforçando pra entrar na área de banco. Infelizmente foi pro Oracle, quem sabe consigo puxá-lo para o “mundo” SQL Server.
Obs: Apenas uma brincadeira, os dois produtos são bons. Sempre temos que avaliar qual a real necessidade do cliente para poder sugerir uma solução que o atenda e que “entre” no seu bolso.

Ola galera. blz? Em um dos meus artigos anteriores eu mostrei como trocar o uso do NOT IN para o  Left JOIN(Link), porém, porque fizemos isso? Qual Ganho de performance ?
Se você já executou as duas queries do artigo anterior com o plano de execução habilitado, você verá que o plano e o custo estimado de ambos são iguais. Vamos ver?

SELECT c.cod,c.nome FROM dbo.TB_CLIENTE c WHERE c.cod NOT IN(SELECT p.cod_cli FROM dbo.tb_pedido p) OPTION(RECOMPILE)

SELECT c.cod,c.nome, p.COD,p.COD_CLI FROM dbo.TB_CLIENTE c LEFT JOIN dbo.tb_pedido p ON c.cod = p.cod_cli
WHERE p.COD_CLI is null OPTION(RECOMPILE)

Thiago Que dizer que não ganhamos nada fazendo essa troca!?Não é assim! O que faz com que o SQL Server escolha quais operadores irão ser usados para acessar os dados, são as estatisticas das suas tabelas e também os indices. Neste post não irei entrar em detalhes, mas , se quiserem saber mais umas das otimas referências que temos no cenário brasileiro é o Fabiano Neves Amorim(Sabe tudo de QO). O objetivo deste post é mostrar que quando temos duas tabelas com quantidade insignificantes de registros, o SQL Server, pode escolher o mesmo plano, realizar um clustered index scan para obter o mesmo resultado e devolve-lo ao usuário. Isso foi visto no print anterior que com queries diferentes o SQL Server montou o mesmo plano. Mas se as tabelas existissem milhões de linhas e de pagina de dados,  será que o SQL Server iria usar os mesmos operadores para devolver os dados? Vamos ver isso na pratica? O que iremos fazer é:  atualizar as estatisticas do SQL Serve e executar novamente as duas queries.

–Atualiza as estatisticas da tabela TB_CLIENTE
UPDATE STATISTICS dbo.TB_CLIENTE WITH ROWCOUNT = 500000, PAGECOUNT = 200
–Atualiza as estatisticas da tabela TB_PEDIDO
UPDATE STATISTICS TB_PEDIDO WITH ROWCOUNT = 500000, PAGECOUNT = 200

Obs: Na verdade nos comandos acima estamos atualizando as estatisticas apenas para propositos de testes. Isso apenas mostra como é importante deixar as estatisticas sempre atualizadas dos nossos banco de dados.

SELECT c.cod,c.nome FROM dbo.TB_CLIENTE c WHERE c.cod NOT IN(SELECT p.cod_cli FROM dbo.tb_pedido p) OPTION(RECOMPILE)

SELECT c.cod,c.nome, p.COD,p.COD_CLI FROM dbo.TB_CLIENTE c LEFT JOIN dbo.tb_pedido p ON c.cod = p.cod_cli
WHERE p.COD_CLI is null OPTION(RECOMPILE)

Executando novamente as queries, podemos ver que a diferença entre o custo usado pelo plano de execução da query que utiliza o NOT IN é superior ao custo da query que usa o operador LEFT JOIN. Quando você está trabalhando com otimização de queries, sempre tente imaginar um cenário com muitas linhas, pois, banco de dados crescem. Uma vez ouvi o seguinte de um certo gestor que tive: “Essa aplicação, funcionava no começo! Porque agora está apresentando lentidão?”. Simples o banco de dados no inicio da aplicação tinha 20 MB de base de dados, hoje tem 130 GB. Então fica a dica, queries bem escritas + estatisticas atualizadas + indices corretos = Vida com Menos Stress

Espero ter ajudado