Archive

Posts Tagged ‘Indexes’

Conhecendo um pouco de performance

Fala Galera, boa noite.

Tudo bem? Faz tempo neh!? Hoje não colocarei o desafio de T-SQL (não ainda..rs). Hoje vim pra divulgar um assunto que também estava ficando um pouco desatualizado ,mas, como algumas pessoas não conseguiram comparecer e algumas não ficaram sabendo, estou divulgando aqui no blog.

No dia 03/12 tivemos a última reunião, do ano de 2015, do SQLManiacs  organizada pelo Vitor Fava, onde eu falei um pouco de performance e tuning (novidade..) utilizando alguns cenários práticos do dia-a-dia.

Para quem tiver interesse em reproduzir todos os cenários descritos na reunião, basta fazer o download dos scripts através do link abaixo:

Reunião do SQLManiacs – Conhecendo um pouco de performance

Ou ir até o blog do Fava, pois, lá possui mais algumas informações, fotos e etc.

https://vfava.wordpress.com/2015/12/08/reuniao-do-sqlmaniacs-conhecendo-um-pouco-de-performance-3/

Muito Obrigado e até a próxima

 

 

Advertisements

Encontrando Índices Duplicados no SQL Server

Galera, boa noite.

Geralmente nós profissionais do mercado SQL Server sempre estamos procurando, desenvolvendo e criando maneiras de automatizar o trabalho do dia-a-dia. Com isso, podemos usar o nosso precioso tempo para poder desenvolver técnicas e recursos para agir com mais pró-atividade. E isso não seria diferente com os “scripts” que carregamos. A partir de hoje colocarei  nesta seção de scripts, alguns scripts que criei, outros que peguei na internet ou copiei de livros.  Não vou conseguir lembrar o nome de todos os autores do scripts, mas, geralmente serão os nomes dos profissionais mais conhecidos e ativos na comunidade (Se o autor ver seu script aqui, por favor, me mande um e-mail para que eu faça a referência). Até hoje uso os scripts que foram utilizados nas seções “30 Scripts que não podem faltar no pen driver de um DBA (parte 1/2). Que foi apresentada pelo Vitor Fava, Alexandre Lopes e Rodrigo. Simplesmente incrível.

Vamos ao que interessa! O script abaixo foi criado pelo Paul Nielsen para poder encontrar índices duplicados em um banco de dados SQL Sever. O script avalia apenas as chaves dos índices e não as colunas que foram adicionados ao Cover Index e ao Filtered Index:

/*
SELECIONAR INDICES DUPLICADOS ( KEYS INDEX ONLY )

http://sqlblog.com/blogs/paul_nielsen/archive/2008/06/25/find-duplicate-indexes.aspx

*/
— exact duplicates
with indexcols
as (
select
object_id as id
, index_id as indid
, name
, (
select
case keyno
when 0 then null
else colid
end as [data()]
from sys.sysindexkeys as k
where k.id = i.object_id
and k.indid = i.index_id
order by
keyno
, colid
for xml path(”)
) as cols
, (
select
case keyno
when 0 then colid
else null
end as [data()]
from sys.sysindexkeys as k
where k.id = i.object_id
and k.indid = i.index_id
order by
colid
for xml path(”)) as inc
from sys.indexes as i)
select
object_schema_name(c1.id) + ‘.’ + object_name(c1.id) as ‘table’
, c1.name as ‘index’
, c2.name as ‘exactduplicate’
from indexcols as c1
join indexcols as c2
on c1.id = c2.id
and c1.indid < c2.indid
and c1.cols = c2.cols
and c1.inc = c2.inc;

 

Obrigado Alisson Cardoso

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