Archive

Posts Tagged ‘create index’

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

Índices no SQL Server 2000

Esta semana(No ano de 2008) me deparei com um problema de otimização e então li muito a respeito. Hoje falarei de índices.
Antes de falarmos sobre os índices, falaremos como os dados no SQL Server são armazenados e como os mesmo são acessados.

Armazenamento de dados
Uma pilha é uma coleção de páginas de dados:
• Cada página contém 8 quilobytes (KB) de informações.
• Quando os registros são inseridos em uma página, e ela já está cheia, as páginas de dados são divididas.
• Um grupo de 8 páginas adjacentes é chamado de extensão.

Acesso aos Dados
O SQL Server acessa os dados de dois métodos.
• Examinando todas as páginas de dados das tabelas – chamado de exame de tabela. Ao executar um exame de tabela o SQL Server:
• Começa no inicio da tabela.
• Examina todos os registros da tabela, página a página.
• Extrai os registros que satisfazem os critérios da consulta.

• Usando índices. Ao usar um índice, o SQL Server:
• Percorre a estrutura da árvore do índice para localizar os registros solicitados pela consulta.
• Extrai apenas os registros necessários que satisfazem os critérios da consulta

Como Criar Índices?

Ao criar índices, leve em conta dois fatores: a natureza dos dados e a natureza das consultas realizada nas tabelas.
Natureza dos dados – Quando me refiro a natureza de dados, sempre levo em conta o tipo da coluna em que colocarei um índice, é recomendável que índices estejam em colunas do tipo: int, char, bigint, tinyint, smallint e datetime.
Natureza das consultas – As naturezas das consultas se referem em qual campo da minha tabela devo criar um índice, exemplo: Imagine um cenário que tenho que criar uma consulta que traga os pedidos emitidos por data de emissão e que a situação seja somente os pedidos liberados. Naturalmente na minha tabela de pedidos eu teria o campo data de emissão e situação do pedido. Essas são colunas aconselháveis para a criação de índices.
Os índices são úteis, porém consomem espaço em disco e acarretam custos de manutenção e sobrecarga. Não crie um índice que não será usado com freqüência.

Índice Clustered ou Agrupamento
Esse tipo de índice é útil para as colunas pesquisadas com freqüência ou em busca de chave de valores. Ao criar um índice desse tipo, considere as seguintes diretrizes:
• Cada tabela só pode ter um índice clustered.
• A ordem física dos registros da tabela e a ordem dos registros do índice são iguais. Primeiramente é aconselhável que seja criado o indice clustered antes do índice não clusterizado.
• Quando um registro é excluído, o espaço é restaurado e torna-se disponível para outro registro.
• Quando se cria uma coluna como PRIMARY KEY, automaticamente essa coluna torna-se um índice clustered.
• O tamanho médio de um índice clustered é aproximadamente 5% do tamanho da tabela. No entanto, esse tamanho varia dependendo do tamanho da coluna indexada.

Índice No-Clustered ou Sem Agrupamento
Um índice não clusterizado é eficiente quando os usuários precisam de vários critérios de pesquisa. Por exemplo, um vendedor pode pesquisar na tabela de pedidos pelo número do pedido, data de emissão, cliente e o representante deste cliente. Ao criar um índice não clusterizado, considere os seguintes fatos:
• A ordem das páginas no nível folha se um índice não clusterizado é diferente da ordem
• Pode existir até 249 índices não clusterizado por tabela.
• O SQL Server recria automaticamente os índices não clusterizados existentes quando ocorre uma das situações a seguir:
• Um índice clustered é criado.
• Um índice clustered é descartado.
• A opção DROP_EXISTING é usada para alterar as colunas que definem o índice de agrupamento.

Colunas que devem ser indexadas.
Crie índices em colunas pesquisadas com freqüências como:
• Chaves primárias (PK).
• Chaves externas (FK) ou colunas usadas frequentemente para unir tabelas.
• Colunas pesquisadas para a localização de faixa de valores de chave. (quando usamos a clausula IN, NOT IN, BETWEEN).
• Colunas acessadas na ordem de classificação (ORDER BY)
• Colunas usadas durante a agregação. (GROUP BY)

Colunas que NÃO devem ser indexadas.
Não referencie colunas que:
• Raramente são usadas em um consulta.
• Contenham poucos valores únicos. Por exemplo, um índice em uma coluna com dois valores, Masculino e feminino, retorna uma alta porcentagem de registros.
• Sejam definidas com os tipos de dados text, ntext, varchar e image. Não é possível indexar colunas com esses tipos de dados.

Criando índices.
Ao criar índice em uma tabela considere os fatos:
• Você deve ser proprietário da tabela.
• Quando se cria uma constraint do tipo PRIMARY KEY e UNIQUE, automaticamente o SQL Server cria índices clustered para elas.
• Você pode criar índices em VIEWS
• Você não pode criar índice em colunas que já existam os mesmos.
• Você pode criar índice na hora de criação de sua tabela.

Sintaxe:
CREATE NONCLUSTERED INDEX nomeDoIndice ON Tabela(CampoIndexado)
Apagando índice
Ao apagar um índice você deve levar em conta as seguintes diretrizes:
• Você não pode apagar os índices criados pelas restrições PRIMARY KEY e UNIQUE.
• Você não pode apagar os índices das tabelas do sistema.
• Você deve está no banco que reside o índice para apagá-lo.

Sintaxe:
DROP INDEX Tabela.NomeDoIndice

Na prática:
DROP INDEX DptoEmpresa.IdxEmpresaID

Até a próxima e espero que todos tenham gostado.
Obs: Esse post retirei de um site que havia publicado a muito tempo atras quando comecei a trabalhar com SQL Server, futuramente irei adicionar a questão de indicec om as features do SQL Server 2008