Sei que no meu post anterior (http://zavaschi.com/index.php/2010/03/powerpivot-mltiplas-fontes-de-dados/) falei que o próximo artigo da série seria sobre DAX (Data Analysis eXpressions), mas recentemente tive uma série de problemas para instalar o PowerPivot for SharePoint, o que é compreensível visto que é um CTP (beta) e a base de dados utilizada (SQL Server 2008 R2) também é CTP, então decidi blogar sobre!

Esta instalação é para propósitos de demonstrações e testes, para cenários de produção haverão outras coisas para se atentar. O cenário que utilizei para iniciar a instalação foi:

Utilizei o Virtualbox para a construção da VM, pois necessitava de uma VM x64 e não tinha como utilizar o Hyper-V.

Windows Server 2008 R2 Enterprise x64, com o papel de domain control (controladora de domínio). Em um ambiente de produção você NÃO DEVE utilizar o servidor de domain control para isto. Vocês verão que pela máquina ser controladora de domínio tem uma série de passos/preocupações que devemos ter para garantir a instalação com sucesso.

Este artigo, em grande parte, é uma tradução/baseado do/no artigo escrito pelo Vidas (@VidasM – www.powerpivot-info.com). Apenas adicionei alguns detalhes relativos ao meu caso e removi algumas coisas para simplicar. O cenário da instalação descrito pelo Vidas é muito similar ao meu. Utilizei o guia dele para alguns apectos dos workarounds necessários.

Fonte em inglês: http://powerpivot-info.com/post/66-step-by-step-guide-on-installing-powerpivot-for-sharepoint

Este é um guia para a instalação do produto BETA! Na versão RTM será bem mais tranquilo, e claro, postarei um passo a passo para vocês também!

Instalação do SharePoint Server 2010

Além de colocar a máquina como domain control, habilite no servidor a feature “Desktop Experience” ("Server Manage"->"Features"->"Add Feature"), para habilitar o servidor a trabalhar como uma estação de trabalho.

A sua conta de login deve ser administradora do domínio!

NÃO INSTALE o SQL Server 2008 R2 ainda, você fará isso em um passo mais adiante.

Antes de instalar o SharePoint, você deve instalar os pré-requisitos.

O único problema que tive neste ponto foi que o Microsoft Chart Controls for Microsoft .NET Framework 3.5 não conseguiu ser baixado sozinho. Baixei e instalei separadamente. http://www.microsoft.com/downloads/details.aspx?FamilyId=130F7986-BF49-4FE5-9CA8-910AE6EA442C&displaylang=en

Caso encontre outros problemas, terá que fazer a instalação manual dos pré-requisitos.

Observações: Se você tiver o PowerShell 1.0 instalado na máquina você terá problemas. Você terá que remover o PowerShell1.0 manualmente (isto não se aplica ao PowerShell 2.0).

Instale um hotfix WCF

• Windows 2008 e Vista:
  http://support.microsoft.com/kb/971831 (this is the KB article)
  http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=KB971831&DownloadId=7285 (this is the download)
• Para Windows Server 2008 R2 e Windows 7
  https://connect.microsoft.com/VisualStudio/Downloads/DownloadDetails.aspx?DownloadID=23806&wa=wsignin1.0

Se a sua máquina for controladora de domínio (como a minha) você terá qeu rodar o seguinte script em PowerShell para ativar soluções sandbox.
Observação: O script foi escrito por Jie Li e foi copiado daqui.

Crie um arquivo de texto chamado sp.ps1 e coloque dentro dele:

$acl = Get-Acl HKLM:\System\CurrentControlSet\Control\ComputerName
$person = [System.Security.Principal.NTAccount]"Users"
$access = [System.Security.AccessControl.RegistryRights]::FullControl
$inheritance = [System.Security.AccessControl.InheritanceFlags]"ContainerInherit,ObjectInherit"
$propagation = [System.Security.AccessControl.PropagationFlags]::None
$type = [System.Security.AccessControl.AccessControlType]::Allow
$rule = New-Object System.Security.AccessControl.RegistryAccessRule($person, $access,$inheritance, $propagation, $type)
$acl.AddAccessRule($rule)
Set-Acl HKLM:\System\CurrentControlSet\Control\ComputerName $acl

Para executar o script:

1) copy script to file sp.ps1
2) in command line enter "PowerShell"
3) enter "Set-executionpolicy unrestricted" (without double quotes)
4) enter "C:\Scripts\sp.ps1" (without double quotes)
5) enter "Set-executionpolicy restricted" (without double quotes)
6) enter "Exit" (without double quotes)

Inicie a instalação do SharePoint 2010.

Cuidado: É muito importante que você siga estas opções de configuração. Caso contrário você não conseguirá configurar para o PowerPivot for SharePoint em passos futuros.ê esteja instalando tudo em um único servidor (Standalone) você não deve selecionar a opção standalone.

Na próxima janela em server type, escolha a opção Complete - Install all components. Can add servers to form a SharePoint farm".

Termine de instalar o SharePoint, e após isto na janela que aparecer (“Run configuration Wizard”) desmarque a opção “Run the SharePoint Products and Technologies Configuration Wizard now"” e clique em close.

Instalando o SQL Server 2008 R2 November CTP

Agora é hora de configurar o PowerPivot e isto é feito através da instalação do SQL Server 2008 R2.

Inicie a instalação do SQL Server e na parte de “Setup Role” escolha: "Analysis Services with SharePoint Integration" e para a opção "Add Gemini service to:" escolha "New farm".

Na janela de "New SharePoint Farm Configuration" especifique os dados pedidos.

No meu caso utilizei a mesma conta que estou usando. Não é o método mais seguro, mas como eu disse, é apenas para efeitos de demonstração e teste.

Nas próximas janelas preencha os dados conforme requeridos e se coloque como administrador e outros usuários conforme necessário. E inicie a instalação propriamente dita.

Se o seu controlador de domínio (domain controler) é outra máquina então estará tudo praticamente pronto. Caso contrário você DEVE seguir os passos abaixo:

Durante a instalação propriamente dita do Analysis Services (geminibi) abra o gerenciador de serviços (services.msc).

Durante a instalação ele trocará a conta que vai subir o serviço do Analysis Services para “Local system account”. Isto ocasionará um erro de timeout. Então quando a instalação chegar aproximadamente neste ponto (ver figura abaixo), troque a conta de serviço para a correta e reinicie(referência em inglês: http://powerpivotgeek.com/2009/11/17/installing-powerpivot-for-sharepoint-on-a-domain-controller/).

Sim, você deve ficar dando refresh na lista o tempo inteiro até o serviço aparecer e ocorrer a mudança. Lembre-se, é um produto beta.

Depois de você mudar o serviço, reinicie-o e deixe o setup do SQL Server terminar.

Observação: Na minha máquina virtual levou cerca de 45 minutos neste passo final até que a instalação fizesse a troca das contas e desligasse o serviço. A isntalação do SQL Server levou uma hora ao todo.

A instalação foi feita com sucesso. Já pode acessar o SharePoint pelo nome da sua maquina (http://maquina/). :)

Agora configure seu SharePoint da maneira que preferir. :)

Próximos post relacionados a PowerPivot (não necessariamente nesta ordem):

1. DAX
2. PowerPivot for SharePoint problemas conehcidos (CTP3)
3. Deploy dos reports no PowerPivot for SharePoint

Por hoje é isto!

Abraços a todos!!
Thiago Zavaschi

O artigo de hoje é a base de um dos itens/indicadores utilizados nas suas análises de health check dos servidores SQL Server: Verificar o crescimento dos seus arquivos de base de dados e log.

Antes de mais nada vamos revisar um ponto importante quanto ao crescimento das databases:

É muito comum encontrar em servidores configurações como: crescimento proporcional 10% para a base e para o arquivo de log e com irrestrito por exemplo. A imagem a seguir mostra onde visualizar estas informações.

Em que isso impacta? Valores pequenos de taxas de crescimento para bases que crescem muito é extremamente prejudicial, pois teremos altas taxas (overhead) de I/O para o crescimento dos arquivos. Por outro lado, valores muito grandes podem gerar um uso descontrolado dos seus discos.

Em um mundo/cenário ideal os crescimentos das databases são monitorados e o aumento físico dos mesmos são planejados e executados de maneira manual. Claro que pela comodidade, é difícil DBAs optarem por esta abordagem.

Mas e como monitorar, ou melhor, prever o crescimento, já que muitos DBAs deixam essas configurações automáticas? Uma das maneiras que eu acho muito elegante é através da utilização do Add-in para o Office 2007, mais especificamente a opção Forecast.

O conteúdo deste post pode ser adaptado para fazer outras previsões através do Office!

O que preciso para começar? 

“Então Thiago, o que eu preciso para iniciar?”

Será necessário basicamente:

Microsoft Office Excel 2007; (a princípio não funciona no Office 2010 beta, mas estou verificando se há algum meio).

E um dos pares abaixo:

SQL Server Analysis Service 2008;
Data Mining Add-Ins for Office 2007 (SQL 2008);
http://www.microsoft.com/downloads/details.aspx?familyid=AF070F2C-46F4-47B6-B7BF-48979B999AEB&displaylang=en

OU

SQL Server Analysis Service 2005;
Data Mining Add-Ins for Office 2007 (SQL 2005);
http://www.microsoft.com/downloads/details.aspx?familyid=7C76E8DF-8674-4C3B-A99B-55B17F3C4C51&displaylang=en

Mãos a obra!

Coletando os dados de tamanho das databases

O primeiro passo é definir um mecanismo para a coleta dos dados.

Para isso vamos criar uma tabela que armazenará os dados relativos ao tamanho dos arquivos. Essa tabela poderá ter variações para outros fins, mas manterei ela com um certo grau de simplicidade.

CREATE TABLE TamanhoBaseHistorico
(
    id INT PRIMARY KEY IDENTITY,
    nome varchar(128) NOT NULL, -- nome da base
    nome_fisico VARCHAR(2000) NOT NULL, -- nome físico do arquivo, com diretório
    tamanho INT NOT NULL, -- tamanho do arquivo em Kb
    dblog BIT NOT NULL, -- se o arquivo é de log
    data DATETIME NOT NULL -- data da medição
)
GO

De tempos em tempos algum mecanismo deverá coletar os dados necessários e inserí-los nesta tabela.

Entre outras formas (como por exemplo o powershell), podemos fazer uso da system stored procedure chamada sp_msforeachdb e associar a execução da mesma a um job do banco de dados.

Essa stored procedure executa um comando para cada database, substituindo a “tag” [?] pelo nome da base. As informações virão da system view chamada sys.database_files.

O comando que será agendado como um job no SQL Server Agent será, para o nosso caso, o seguinte:

EXECUTE sp_msforeachdb
        'INSERT INTO TamanhoBaseHistorico
        SELECT name, physical_name, size, type, GETDATE()
        FROM [?].sys.database_files'

Não vou entrar nos méritos da criação de jobs no Agent, mas vamos assumir que estes dados sejam carregados todos os meses, uma vez por mês.

Na próxima parte veremos o processo de instalação do add-in e a utilização do mesmo!

Abraços,

Thiago Zavaschi

No artigo anterior (http://zavaschi.com/index.php/2009/11/novidades-do-sql-server-2008-r2-parte-ii-powerpivot-conceitos/) eu introduzi os conceitos relacionados ao self-service BI, mais precisamente os relacionados ao PowerPivot. Consulte-os quando surgirem dúvidas. :)

Apenas lembrando, PowerPivot é uma grande promessa de Self-Service BI real da Microsoft (“Mas e o Report Builder?” - Calma, depois comento sobre ele), anteriormente era conhecido como projeto Gemini. E ele é divido basicamente em PowerPivot for Excel 2010 e PowerPivot for SharePoint 2010.

O PowerPivot for Excel 2010, como veremos, é muito simples de usar e possui poderosa capacidade de análise.

“Ok Thiago, este nome significa que nós o usaremos de dentro do Excel 2010, certo? O quão rápida essa solução é?”

Sim, o uso (composição da análise) será de dentro do Microsoft Excel 2010. Isto é devido ao fato de que o Excel é a ferramenta mais usada e familiar para as pessoas que usualmente tomam as decisões ou que fazem análise. Isso já ocorre atualmente com o uso de tabelas dinâmicas associadas a cubos do Analysis Services, ou através dos plugins de Data Mining para o Excel. Nós normalmente temos uma quantidade muito grande de dados para analizar, oq ue pode ser um processo caro computacionalmente se não for otimizado, mas com o novo PowerPivot for Excel nós podemos analisar grandes quantidades de dados de uam forma bem rápida.

Aqui cabem algumas ressalvas: o comportamento em ambientes cuja arquitetura é x64 é melhor que x86 para trabalhar com o PowerPivot (desempenho). O PowerPivot faz operações em memória então pode ser necessário um hardware que acompanhe, porém como eu disse, ele está otimizado e consegue trabalhar com enorme quantidade de dados (dezenas de milhões de linhas) fácil e rapidamente.

O PowerPivot é muito mais poderoso do que simplesmente utilizar tabelas dinâmicas com cubos SSAS (na série de artigos que estou iniciando sobre PowerPivot veremos com detalhes todo o poder disponível). A análise gerada pelo Excel pode ser publicada no SharePoint 2010 e assim ter esses dados disponíveis a todos (entenda-se todos como aqueles que possuem permissões para acessar essa área no SharePoint).

O que você pode estar pensado é que a planilha com a análise uma vez no servidor pode ficar vulnerável e desatualizada. Ou você pode estar pensando neste exato momente “Ih.. é mesmo, então o PowerPivot não é legal, certo?!”.. ERRADO!!!

Você pode fazer (agendar) com que a planilha se atualize sozinha no servidor, além de ter o Excel Services (componente do SharePoint 2010) que torna possível fazer pequenas alterações na planilha para visualização momentânea (mas considere a planilha como sendo sempre read-only, após publicada, isso garante a consistência dos dados).

Mas a integração com o SharePoint 2010 é tema de um próximo post. (:

“Ok Thiago, você me convenceu. Como começo? O que eu preciso para trabalhar com o PowerPivot for Excel?”

Tudo o que você vai precisar já está disponível publicamente, seguem os links para download:

Microsoft SQL Server 2008 R2 (Nov CTP): http://www.microsoft.com/sqlserver/2008/en/us/R2.aspx

Microsoft Office 2010 Beta: http://www.microsoft.com/office/2010/en/default.aspx

PowerPivot for Excel 2010 (certifique-se de pegar o plugin correspondente a arquitetura que o seu Office está instalado, pois você pode ter um sistema com arquitetura x64 e ter botado o Office x86): http://powerpivot.com/download.aspx

Instale o Microsoft Office 2010, o SQL Server 2008 R2 (Nov CTP) e então o plugin para o  PowerPivot for Excel. No site oficial do PowerPivot (www.powerpivot.com) também há um guia (em inglês) para o processo de instalação se acharem necessário. O processo é bem tranquilo, até eu consegui! :)

“Bom Thiago eu tenho tudo instalado e agora vou analizar .... Vou analizar o que?”

Com o PowerPivot nós podemos usar uma série de recursos como fontes de dados: cubos SSAS, tabelas do excel, SQL Server, Oracle e assim por diante. o seguinte site contém diversas bases de dados que você pode utilizar como fonte para os seus experimentos: http://www.powerpivot-info.com/post/50-list-suggested-datasets-to-test-powerpivot.

Eu irei usar para os experimentos deste post a seguinte base de dados (em Access): http://powerpivotsampledata.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=35438.

Agora com tudo instalado e um conjunto de dados, podemos começar a diversão!

Primeras Impressões

A primeira coisa que você irá perceber é uma nova aba no Excel, denominada PowerPivot (conforme a figura 1):

Figura 1: A nova aba no Microsoft Excel 2010.

Nesta aba nós temos seis grupos: Launch. Measures, View, Excel Data, Help e Show/Hide.

O início de tudo se dá no grupo Launch, mais precisamente no botão PowerPivot Window presente na Ribbon. A figura 2 mostra a janela que deverá aparecer para você.

Figura 2: A janela do PowerPivot

Nós não temos nenhum dado carregado ainda. O que nós temos basicamente habilitados são os botões de recuperação dos dados, listar/configurar as conexões existentes. Você também tem a opçõ de retornar para a janela principal do Excel.

Antes de importar os dados da fonte que mencionei anteriormente, vamos ver quais são os tipos de fontes de dados que podemos utilizar. Inicialmente você irá ver os tipos mais comuns de fontes de dados, mas você pode clicar em “From Other Sources” para ver a grande gama que temos disponível. E são eles (pelo menos no CTP de novembro do SQL Server 2008 R2):

• Microsoft SQL Server
• Microsoft SQL Azure
• Microsoft Access
• Microsoft SQL Server Analysis Services
• PowerPivot workbooks published to Analysis Services running in SharePoint Integrated Mode
• Oracle
• Teradata
• Sybase
• Informix
• DB2
• DataFeeds
• Excel workbooks
• Text files

Você pode conectar também com qualquer fonte de dados que seja compatível com conexões ODBC ou OLEDB.

Na minha opinião, a possibilidade de usar informação proveniente de um cubo SSAS com outras fontes de informação (por exemplo) é fantástica! Esta capacidade é muitas vezes mais poderosa doq ue simplesmente utilizar as tabelas dinâmicas com cubos SSAS.

Figura 3: Fontes de Dados Disponíveis.

Fonte de dados de Exemplo

A fonte de dados de exemplo contém quatro arquivos:

• AccessQuery.txt - contém uma query de exemplo pra executar contra o banco fornecido no pacote também. Utilizaremos em nosso exemplo.
• AW_Companysales.accdb e IndustryBikeSales.accdb - que são bases de exemplo em Access que estão disponíveis para testes.
• Country.xlsx - que é um arquivo excel simples que contém um mapeamento sigla-país.

Alimentando o PowePivot

Clique em “From Database” e selecione “From Access”, selecione a base de dados IndustryBikeSales. Preencha o nome com um nome amigável ( :) ). esta base de dados não necessita de login e senha, deixe estes campos em branco.

Na próxima janela selecione a opção que deixe você escrever a sua query customizada. Coloque a seguinte query (é a fornecida nos arquivos mencionados anteriormente) e clique no botão Import:

SELECT IndustrySales.Country, IndustrySales.Quarter,
IndustrySales.[Type Of Bike], IndustrySales.Channel,
IndustrySales.Units
FROM IndustrySales
WHERE ( (IndustrySales.Quarter >='2001 Q3')
AND (IndustrySales.Quarter<='2009 Q2') )

A sua janela do PowerPivot deve estar parecida com a figura 4:

Figura 4: Dados resultantes da query sobre a base IndustryBikeSales

Nós temos as informações sobre as vendas por trimestre, divididas por tipo de produto (bicicleta no caso). Vocês devem concordar comigo que é um pouco confuso tomar desições através da análise direta destes dados (1152 linhas). Não seria muito bom se nós pudéssemos simplesmente organizar o total de vendas por tipo, ou por país (trimestre etc.) de uma maneira rápida e com poucos cliques?

Nós podemos fazer isso utilizando o PowerPivot for Excel, com pousos esforços podemos extrair muita informação. Você pode adicionar fórmlas do excel, expressões DAX, criando novas colunas baseadas nos seus dados (sobre isso teremos novos posts) para ter mais subsídios para a sua análise.

na figura 4 você pode observar que nós temos vários outros botões habilitados: Refresh, Manual e PivotTable.

O botão “Refresh” importa novamente os dados das fontes. É como qualquer outro botão de atualizar :). O botão PivotTable é o próximo botão que você tem que olhar. Clicar nele irá te mostrar algo similar a figura 5.

Figura 5: Menu PivotTable

Quando você selecionar um destes itens, o Exel irá perguntar onde você quer criar o template: num novo worksheet ou em um existente. Independente do que você escolher, o template será criado pelo PowerPivot. O seu Microsoft Excel 2010 deverá estar parecido com a figura 6. Para o meu exemplo usei a opção: Four Charts (quatro gráficos).

Figura 6: O template com os gráficos gerados pelo PowerPivot

Eu selecionei para adicionar em um workbook existente (”Sheet 1”). agora nós temos algumas coisas que você provavelmente (espero, hehe) percebeu: nós temos 4 abas novas (Data for Sheet 1 Chart 1, Data for Sheet 1 Chart 2, ... e assim por diante) e quando você clica em um destes gráficos você verá o grupo Pivot Chart Toolsna ribbon (figura 7) e o Gemini Task Pane (figura 8). Eu não vou entrar em detalhes sobre a ribbon, a maioria das opções são sobre formatações e coisas do gênero.

Ess painel do Gemini é familiar pra você? Eu acho que é muito parecido com o painel de tabela dinâmica do Excel, mas com os slicers (veremos a seguir).

Figura 7: PivotChart Tools: Design

Figura 8: Gemini Task Pane

Nós agora iremos selecionar alguns dados para popular os relatóios. Você pode simplesmente marcar as checkboxes ou arrastar e soltar na região que desejar: Legend Fields, Axis fields, Values ou filtrar alguma informação. Você também pode usar os slicers. Os slicers são como filtros que você pode ligá-los ou desligá-los apenas clicando neles! Vamos relembrar que o PowerPivot é voltado aos gerentes, diretores e tomadores de decisão, então este comportamento é realmente útil.

Após simplesmente adicionar algumas colunas aos gráficos e adicionado o Trimestre (Quarter) e País (Country) como slicers (com, realmente, poucos cliques) nós temos algo parecido com a figura 9.

Figura 9: Dashboard sobre os dados sendo analisados com o PowerPivot!!! Criado com pouquíssimos cliques!

Olhe na parte esquerda da figura 9. Estes são os slicers que comentei anteriormente. eu facilmente selecionei apenas as informações de 2003 e 2004 e excluí da análise os Estados Unidos. Se o desejo fosse analisar Estados Unidos x Alemanha, por exemplo, eu poderia simplesmente clicar nos slicers correspondentes e não ateraria nada nos gráficos! Eu também tenho que dizer que essa operação é extremamente rápida, mesmo quando tivermos milhões de linhas.

A última coisa que você tem que olhar agora é nas outras abas criadas pelo PowerPivot. Os dados parecem familiares? Estes são os dados que estão sendo usados na criação dos ráficos apresentados na dashboard.

O próximo passo é compartilhar a análise feta no Excel, para evitar duplicamento de informações e manter tudo em um ponto central. O PowerPivot for SharePoint vem somar recursos às capacidades grande que já temos (veremos com mais detalhes em artigos futuros)!

Bom, isso é tudo que eu queria mostrar hoje pessoal. E essa é só a ponta deste iceberg chamado PowerPivot. Eu irei mostrar features mais avançadas e a integração com o SharePoint 2010 (múltiplas fontes simultâneas, DAX) no próximo artigo!

Abraços a todos!

Thiago Zavaschi

Bom, mostrei um pouco de teoria, mostrei alguns exemplos didáticos (o de números é bastante utilizado na prática), mas vamos ver mais alguns exemplos:

Vou começar com um exemplo já mostrado aqui no blog (sim, finalmente este é o post sobre o qual falei no referido post :) ).

Este é o método baseado em CTE para realizar Split no SQL Server (atentar para o limite da recursividade, se necessário usar o maxrecursion).

DECLARE @s VARCHAR(8000), @d VARCHAR(10)
SET @s = 'separar por espaço em branco'
SET @d = ' ' 

;WITH split(i,j) AS
(
SELECT i = 1, j = CHARINDEX(@d, @s + @d)
UNION ALL
SELECT i = j + 1, j = CHARINDEX(@d, @s + @d, j + 1) FROM split
   WHERE CHARINDEX(@d, @s + @d, j + 1) <> 0
)
SELECT SUBSTRING(@s,i,j-i)
FROM split

O método é facilmente adaptável para o seu outro grande uso: parser de textos CSV. Basta apenas trocar o delimitador. Simples não?

DECLARE @s VARCHAR(8000), @d VARCHAR(10)
SET @s = '123;4;thiago@zavaschi.com;2232323'
SET @d = ';' 

-- Continuação mostrada anteriormente.

Um exemplo interessante que sempre cobro em aula (acho que vou ter que parar de cobrar :P) é para realizar o exemplo clássico do fatorial. O resultado final eu diria ser muito elegante.

WITH fat(f, n) AS
(
    SELECT CAST (1 as bigint) as f, 0  as n -- fat de 0 é 1
    UNION ALL
    SELECT CAST (1 as bigint) as f, 1 as n -- fat de 1 é 1
    UNION ALL
    SELECT f * (n + 1), n +1
    FROM fat
    WHERE n < 20 AND n <> 0
    -- 20 é o limite neste caso, pois o fatorial de 21 
    -- não cabe em um tipo bigint. O <> 0 é para cortar a recursão
    -- do primeiro âncora, senão repetiria tudo, faça o teste. 
)
SELECT f
FROM fat
WHERE n = 6 -- troque n pelo fatorial que quer calcular

Para melhorar a legibilidade das queries. podemos encapsular isso em uma função:

CREATE FUNCTION fatorial
(
    @n INT
)
RETURNS INT
AS
BEGIN
    DECLARE @val INT;
    WITH fat(f, n) AS
    (
        SELECT CAST (1 as bigint) as f, 0  as n
        UNION ALL
        SELECT CAST (1 as bigint) as f, 1 as n
        UNION ALL
        SELECT f * (n + 1), n +1
        FROM fat
        WHERE n < 20 AND n <> 0
    )
    SELECT @val = f
    FROM fat
    WHERE n = @n
    RETURN @val
END
GO

-- Testando a função
SELECT dbo.fatorial(3);
SELECT dbo.fatorial(4);
SELECT dbo.fatorial(7);

(Abrindo um parênteses importante:

A única resalva que faço é quanto a estes calculos matemáticos intensos em queries. O SQL Server trabalha muito bem com as ditas set based operations. ou seja, operações baseadas em conjuntos. Operações envolvendo manipulação de strings e cálculos matemáticos complexos não são o forte do SQL Server. Como resolver então, de outra maneira?

Desde o SQL Server 2005 (apareceu junto com as CTEs) o SQL Server tem a CLR integrada ao seu core. Isso quer dizer que é possível criar objetos para o SQL Server (User Defined Types – UDT, Stored Procedures, Functions, etc) programando em uma linguagem compatível com a Common Language Runtime e adicionar o assembly gerado ao seu banco SQL Server. Não fiz testes para esse exemplo do fatorial (farei em um futuro breve), mas é provável que o tempo de execução seja menor se o mesmo estivesse sendo executado pela CLR.

Farei um post detalhando melhor e também na Mundo.NET da edição de Dezembro/2009 sairá um artigo meu sobre como programar com SQLCLR usando C#!

Fechando o parênteses muito importante)

Para o próximo exemplo eu preciso fazer algumas considerações.

Com o SQL Server 2008 surgiu o tipo de dados HIERACHYID e que é, na minha visão, o melhor método de se trabalhar com registros que possuem comportamento hierárquico. Por uma série de motivos: o banco é SQL Server 2005 (ou esta com Compability Level 90), ou é uma estrutura legada, e se você deseja tratar hierarquias?

Commom Table Expressions podem fazer, e fazem, esse papel muito bem. Digamos que temos uma estrutura hirárquica de empregados e cada registro faz uma referência a outro registro que seria o seu supervisor dentro de uma empresa. O diretor da empresa não possui ligação com ninguém, uma vez que ele não teria um supervisor.

Para esse exemplo poderia usar a tabela de empregados do AdventureWorks, mas como nem sempre todos a possuem instalada (deveriam, pois há centenas de exemplos que a utilizam), eu mesmo montarei uma pequena “base”.

Segue o modelo de dados e script para criação da estrutura.

-- Cria tabela base
CREATE TABLE Empregado
(
    id INT PRIMARY KEY,
    nome VARCHAR(50) NOT NULL,
    cargo VARCHAR(50) NOT NULL,
    id_supervisor INT NULL
        CONSTRAINT fk_productSales_pid
        FOREIGN KEY REFERENCES Empregado(id)
);

-- Popula a tabela (reparem na sintaxe do insert, 
-- só é permitida no SQL Server 2008 ou superior).
INSERT INTO Empregado VALUES
(1, 'Thiago Zavaschi', 'Diretor', null),
(2, 'Angelina Jolie', 'Gerente de Vendas', 1),
(3, 'Megan Fox', 'Gerente de Marketing', 1),
(4, 'Uma Thurman', 'Vendedor', 2),
(5, 'Jessica Alba', 'Vendedor', 2),
(6, 'Julia Roberts', 'Estagiário', 3);

Ao executar um simples select nesta tabela temos:

id       nome                       cargo                            id_supervisor
-------- -------------------------- -------------------------------- -------------
1        Thiago Zavaschi            Diretor                          NULL
2        Angelina Jolie             Gerente de Vendas                1
3        Megan Fox                  Gerente de Marketing             1
4        Uma Thurman                Vendedor                         2
5        Jessica Alba               Vendedor                         2
6        Julia Roberts              Estagiário                       3

Creio que todos deverão concordar comigo que esta visulização torna praticamente impossível a noção de hierarquia (e olhe que temos poucos registros, imagine termos centenas dos mesmos.

É fácil retornar qual é o nome do supervisor, mas isso de maneira recursiva não seria nada tranquilo. Vou montar uma query que me retorne o nível da pessoa na hierarquia. Ou seja, para o Diretor o valor será 1, para os gerentes será 2, e para o restante será 3. Com a minah CTE retornando isso, a query subsequente, que consome a CTE podera formatar os resultados, filtrar, enfim, tudo baseado no resultado da consulta recursiva já processada, bacana né? Vamos lá!

;WITH hierarquia(id, nome, cargo, id_supervisor, nivel_hierarquia)
AS
(
    SELECT  id, nome, cargo, id_supervisor, 1 as nivel_hierarquia
    FROM Empregado
    WHERE id_supervisor IS NULL
    -- Perceba que aqui no âncora temos como retorno somente o diretor.
    UNION ALL -- Ligação para a recursão
    SELECT e.id, e.nome, e.cargo, e.id_supervisor, nivel_hierarquia + 1
    FROM Empregado e
    INNER JOIN hierarquia h ON h.id= e.id_supervisor
)
SELECT * FROM hierarquia

A saída deste script é (reparem na coluna nivel_herarquia):

id       nome                 cargo                       id_supervisor nivel_hierarquia
-------- -------------------- --------------------------- ------------- ----------------
1        Thiago Zavaschi      Diretor                     NULL          1
2        Angelina Jolie       Gerente de Vendas           1             2
3        Megan Fox            Gerente de Marketing        1             2
6        Julia Roberts        Estagiário                  3             3
4        Uma Thurman          Vendedor                    2             3
5        Jessica Alba         Vendedor                    2             3

“Ok thiago, mas ainda assim não estou conseguindo visualizar, por exemplo, quem é o supervisor, tem como melhorar?”

Tem sim. uma das utilidades das CTEs é: a mesma retornar um result set “complexo de ser calculado” (como o caso da hierarquia) e deixar para o select mais abaixo fazer a formatação/filtragem/ordenação. Isso eixar a estrutura da sua CTE mais genérica e menos “engessada”, fazendo até mesmo com que você possa reaproveitar esse código em outro lugar.

Por exemplo: quero uma listagem com todo o time operacional (maior valor em nivel_hierarquia) da empresa, com seus respectivos supervisores. A query poderia ficar assim:

;WITH hierarquia(id, nome, cargo, id_supervisor, nivel_hierarquia)
AS
(
    SELECT  id, nome, cargo, id_supervisor, 1 as nivel_hierarquia
    FROM Empregado
    WHERE id_supervisor IS NULL
    -- Perceba que aqui no âncora temos como retorno somente o diretor.
    UNION ALL -- Ligação para a recursão
    SELECT e.id, e.nome, e.cargo, e.id_supervisor, nivel_hierarquia + 1
    FROM Empregado e
    INNER JOIN hierarquia h ON h.id= e.id_supervisor
)
SELECT
h.nome + '/' + h.cargo as [Operacional], -- perceba a formatação ocorrendo aqui
s.nome + '/' + s.cargo as [Tático]
FROM hierarquia h JOIN Empregado s ON h.id_supervisor = s.id
WHERE h.nivel_hierarquia =
(SELECT MAX(nivel_hierarquia) FROM hierarquia) -- perceba que o filtro ocorreu aqui

Com o seguinte output:

Operacional                     Tático
------------------------------- ------------------------------------
Julia Roberts/Estagiário        Megan Fox/Gerente de Marketing
Uma Thurman/Vendedor            Angelina Jolie/Gerente de Vendas
Jessica Alba/Vendedor           Angelina Jolie/Gerente de Vendas

Tranquilo né? E assim poderíamos evoluir de “N” formas, cada uma atendendo a uma necessidade específica.

Common table Expressions também podem ser utilizadas de outras formas, para fazer tratamento de datas, carga, e muitas outras funções (ver links no final do post para maiores informações).

O que mais saber sobre Common Table Expressions (CTE) ?

Bom, já vimos bastante coisa sobre o que é uma CTE, como funciona, onde se aplica (com alguns exemplos), mas o que mais devemos saber?

Devemos saber que há restrições sobre oq eu podemos usar ou não em CTEs. Vou listar alguams das que eu considero principais (no Books Online – BOL, há a lista completa, ver link ao final do post).

Bom acredito que a primeira coisa que é importante saber é que NÃO é permitido fazer uma referência recursiva dentro de uma subquery. Vou usar o exemplo anterior para demonstrar:

...
UNION ALL
    SELECT e.id, e.nome, e.cargo, e.id_supervisor,
    (SELECT h.nivel_hierarquia_2 FROM hierarquia) -- ISSO NÃO É PERMITIDO.
    FROM Empregado e
    ...
)
...

O que nos gera um erro similar a:

Msg 465, Level 16, State 1, Line 32
Recursive references are not allowed in subqueries.

O que mais não é permitido na definição do membro recursivo? Segue a lista:

• SELECT DISTINCT
• GROUP BY
• HAVING
• Scalar aggregation
• TOP
• LEFT, RIGHT, OUTER JOIN (obs: o INNER JOIN é permitido)
• A hint applied to a recursive reference to a CTE inside a CTE_query_definition.

Você, leitor, deve ter percebido que eu normalmente iniciei minhas CTE’s com um ponto e vírgula (‘;’), não, não fiquei maluco e nem coloquei por engano.
A questão é que a sintaxe para execução da CTE obriga que o statement anterior termine com ponto e vírgula, então acabo sempre colocando, já que o statement anterior normalmente não possui “;” ao seu término!

Há algumas guidelines no books online e vou apenas trancrever aqui, em inglês mesmo (consultar o link no final para o texto completo – em inglês), omiti sobre o maxrecursion que eu já comentei.

Using CLR Integration in SQL Server 2005 (Se alguém quiser ir se adiantando um pouco no assunto!)
http://msdn.microsoft.com/en-us/library/ms345136%28SQL.90%29.aspx

Finalizando

UFA! Bom pessoal, espero que todos tenham chegado até aqui, e espero também que gostem tanto do artigo quanto eu gostei de fazê-lo!

Utilizem como referência para consultas futuras e qualquer sugestão estou aberto para ouvir!

Comentei que há o tipo de dados HIERARCHYID, presente no SQL Server 2008 e superirores) para manipular registros essencialmente hierárquicos, mas acho que isso não compete a este post, abordo isso mais profundamente numa próxima oportunidade!

Grande abraço!
Thiago Zavaschi

PS: Tive que dividir o artigo em duas partes, pois o Spaces não deixa publicar posts grandes (para a primeira parte veja o post anterior).

A uma primeira vista parece que as coisas “complicaram”, mas depois de escrever uma ou duas CTE’s é facilmente perceptível o quão fácil (e vantajoso) é trabalhar com as mesmas.

Antes de dar uma descrição formal de uma CTE, vou executar um dos exemplos mais simples que pode ser feito.

;WITH Simples(valor, nome)
AS
(
    SELECT 1, 'thiago'
)
SELECT * FROM Simples

E o resultado é:

valor       nome
----------- ------
1           thiago

(1 row(s) affected)

Ahmm, ok, eu poderia ter feito o mesmo usando simplesmente algo como:

SELECT 1, 'thiago' 

Mas a vantagem (a primeira das muitas) é que você pode referenciar várias vezes a cte em sua query. Mas antes de demonstrar isso, creioq eu cabe a necessidade de uma definição formal do que seja uma Common Table Expression. Definição segundo o Books Online do SQL Server 2008:

Uma CTE (Common Table Expression) pode ser encarada como um result set que tem seu escopo definido pela execução de um única cláusula SELECT, INSERT, UPDATE, DELETE ou CREATE VIEW. O result set da CTE existe apenas durante a execução da query.
Uma CTE tem duas grandes capacidades: pode se auto referenciar (CTE recursiva) e pode ser referenciada várias vezes na mesma query.

A sintaxe de uma CTE é demonstrada a seguir:

WITH expression_name [ ( column_name [,...n] ) ]
AS
( CTE_query_definition )

A lista de nomes de colunas é opcional somente se a query da CTE retornar colunas com nomes únicos. Contudo, é uma boa prática definir os nomes.

O comando para rodar a CTE seria:

SELECT <column_list>
FROM expression_name;

Um exemplo de uma CTE sendo referenciada várias vezes na mesma query:

;WITH VariasVezes(valor)
AS
(
    SELECT 1
    UNION
    SELECT 33
    UNION
    SELECT 8
)
SELECT
(SELECT MAX(valor) FROM VariasVezes) +
(SELECT SUM(valor) FROM VariasVezes) AS val

Perceba que no select que consome a CTE eu a referenciei (“VariasVezes”) duas vezes. Cuidado que nas funções agregadas o conteúdo da CTE sofre scan para cada função agregada, e, dependendo, uma abordagem diferente pode ser mais performática, mas ganha-se muito com a legibilidade da query. Observe os scans no plano de execução da CTE VariasVezes.

Para facilitar a análise, segue o plano de execução em modo texto (instrução SET SHOWPLAN_TEXT).

StmtText
----------------------------------------------------------------------------------------------------------
  |--Compute Scalar(DEFINE:([Expr1012]=[Expr1004]+[Expr1010]))
       |--Nested Loops(Inner Join)
            |--Stream Aggregate(DEFINE:([Expr1004]=MAX([Union1003])))
            |    |--Concatenation
            |        |--Constant Scan(VALUES:(((1))))
            |         |--Constant Scan(VALUES:(((33))))
            |         |--Constant Scan(VALUES:(((8))))
            |--Compute Scalar(DEFINE:([Expr1010]=CASE WHEN [Expr1019]=(0) THEN NULL ELSE [Expr1020] END))
                 |--Stream Aggregate(DEFINE:([Expr1019]=Count(*), [Expr1020]=SUM([Union1009])))
                      |--Concatenation
                          |--Constant Scan(VALUES:(((1))))
                           |--Constant Scan(VALUES:(((33))))
                           |--Constant Scan(VALUES:(((8))))

Essa característica já seria o suficiente para tornar o uso de CTEs muito interessante, mas na minha opinião a capacidade de auto-referenciar (queries recursivas) é que torna CTE um recurso tão poderoso.

Queries Recursivas com Common Table Expressions

Como já mencionei as CTEs podem se auto referenciar, isto é, dentro da própria definição da CTE.
Já ministrei diversos treinamentos em que CTE era um dos itens da ementa, e percebi que o melhor jeito de entender o funcionamento das mesmas é através de exemplos. Começarei com alguns simples e vou até alguns mais elaborados, com o passo a passo de cada execução para facilitar. :)

Vamos pensar um pouco, em que seria interessante a utilização de uma query recursiva? O exemplo clássico seria o cálculo de fatorial (faremos mais adiante), geração de números sequênciais, etc, etc.

Mas para usar uma CTE recursiva basta apenas referenciar ela mesma? Sim e não, na verdade não. É necessário a utilização do operador UNION ALL além da introdução de dois novos termos/conceitos: Membro Âncora e o Membro Recursivo. Segue a estruturação na forma de um exemplo que gera números sequênciais de 1 até 10:

;WITH NumerosSequenciais(num)
AS
(
     SELECT 1 AS num -- Este é o membro âncora, será o primeiro a ser executado. 
     UNION ALL -- Fará a ligação do membro âncora com o membro recursivo.
     SELECT num + 1 AS num FROM NumerosSequenciais
     WHERE num < 10 -- perceba que o WHERE é bastante importante para delimitar a parada da recursão.
)
SELECT * FROM NumerosSequenciais

Uma coisa comum, que vejo muitos se confundirem (o que é razoavél, uma vez que essa recursão é um pouco diferente das demais), é achar que o membro âncora será o critério de parada, e isso NÃO é verdade. Na realidade, ele é o primeiro a ser executado. O critério de parada é o membro recursivo parar de fornecer novas linhas de retorno para serem “processadas”. Veja a execução do passo a passo mais adiante.

Segue mais um exemplo, mas agora manipulando um elemento do tipo VARCHAR. Um ponto importante a se observar é que não funcionará sem a utilização da função CONVERT, e se deve ao fato de que os (os? veja adiante) membros âncoras e recursicos (plural novamente? veja adiante)  devem retornar o mesmo tipo de dado em cada coluna (no caso, VARCHAR(4000)).

;WITH Nome(nome)
AS
(
    SELECT nome = CONVERT(VARCHAR(4000),'Thiago')
    UNION ALL
    SELECT CONVERT(VARCHAR(4000),nome + 'Zavaschi') FROM Nome
    WHERE LEN(nome) < 30
)
SELECT nome FROM Nome

O resultado da query recursiva acima é:

Thiago
ThiagoZavaschi
ThiagoZavaschiZavaschi
ThiagoZavaschiZavaschiZavaschi

Queries recursivas com mais de um membro âncora/recursivo

Aqui é que as coisas podem parecer confusas (e até são de certo modo), tenho que confessar que nunca (que eu me lembre) precisei usar mais de um membro recursivo na mesma CTE, mas devemos conhecer todas as possibilidades!

Vamos voltar a query anterior que concatenava ‘Zavaschi’ ao nome ‘Thiago’ e adicionarei um novo âncora.

Mas e como fazer isso? Basta adicionar mais um SELECT que não faça referência à propria CTE (senão seria um membro recursivo, hehe). o resultado fica algo parecido com:

;WITH Nome(nome)
AS
(
    SELECT nome = CONVERT(VARCHAR(4000),'Thiago')
    UNION ALL
    SELECT nome = CONVERT(VARCHAR(4000),'José')
    UNION ALL
    SELECT CONVERT(VARCHAR(4000),nome + 'Zavaschi') FROM Nome
    WHERE LEN(nome) < 30
)
SELECT nome FROM Nome

Conseguem imaginar o que irá acontecer? Na verdade o que eu acho que um desenvolvedor tem que se preocupar é a ORDEM com que será retornado os registros (supondo que já haja um entendimento sobre CTEs).

O resultado desta query é:

nome
-------------------------------------
Thiago
José
JoséZavaschi
JoséZavaschiZavaschi
JoséZavaschiZavaschiZavaschi
JoséZavaschiZavaschiZavaschiZavaschi
ThiagoZavaschi
ThiagoZavaschiZavaschi
ThiagoZavaschiZavaschiZavaschi

(9 row(s) affected)

Por que isso ocorre? Ou melhor, “me explica o que ocorreu”. Vamos lá! Obs: vou ir negritando os registros e colocando a query que foi “executada” para facilitar no entendimento do output encontrado.

1) Como a “parte” que é executada primeiro é a da âncora, ou das âncoras, e por ordem no UNIOL ALL, temos o ‘Thiago’ e depois o ‘José’.

SELECT nome = CONVERT(VARCHAR(4000),'Thiago')
UNION ALL
SELECT nome = CONVERT(VARCHAR(4000),'José')

Thiago
José
JoséZavaschi
JoséZavaschiZavaschi
JoséZavaschiZavaschiZavaschi
JoséZavaschiZavaschiZavaschiZavaschi
ThiagoZavaschi
ThiagoZavaschiZavaschi
ThiagoZavaschiZavaschiZavaschi

2) Foram executados os âncoras agora é a vez da execução do membro recursivo.

SELECT CONVERT(VARCHAR(4000),nome + 'Zavaschi') FROM Nome
    WHERE LEN(nome) < 30

O conteúdo do “nome” atual é “José” (última âncora selecionada), perceba que no FROM temos referenciada a própria CTE!

A execução da query seria algo como (de maneira BEM simplificada):

SELECT ‘José’ + 'Zavaschi' WHERE LEN(‘José’ + 'Zavaschi') < 30

Esse registro retornou alguma linha? Sim. então continua processando esta query recursiva.

Thiago
José
JoséZavaschi
JoséZavaschiZavaschi
JoséZavaschiZavaschiZavaschi
JoséZavaschiZavaschiZavaschiZavaschi
ThiagoZavaschi
ThiagoZavaschiZavaschi
ThiagoZavaschiZavaschiZavaschi

3) Mas qual é o conteúdo do “nome” neste momento? “JoséZavaschi”.

A query recursiva retorna mais alguma linha (atentar para o WHERE)? Sim. entao retorna o valor presente em “nome” e continua.
O processo se mantém enquanto o conteúdo de “nome” atender à nossa restrição no WHERE (o WHERE é feito com o conteúdo de nome da iteracao anterior, ANTES, da concatenação).

Thiago
José
JoséZavaschi
JoséZavaschiZavaschi
JoséZavaschiZavaschiZavaschi
JoséZavaschiZavaschiZavaschiZavaschi
ThiagoZavaschi
ThiagoZavaschiZavaschi
ThiagoZavaschiZavaschiZavaschi

4) o Conteúdo de “nome” agora é:  JoséZavaschiZavaschiZavaschiZavaschi que possui mais de 30 caracteres, então a query recursiva não retorna mais registros e se encerra…ria, caso só tivéssemos uma única âncora. Mas o processo continua para a âncora anterior e assim por diante. E é por isto que temos a saída do Thiago, ThiagoZavaschi, e assim por diante.

Thiago
José
JoséZavaschi
JoséZavaschiZavaschi
JoséZavaschiZavaschiZavaschi
JoséZavaschiZavaschiZavaschiZavaschi
ThiagoZavaschi
ThiagoZavaschiZavaschi
ThiagoZavaschiZavaschiZavaschi

5) Quando a query recursiva não retornar mais nada, a CTE verifica se há alguma outra âncora “esperando”, se não há então já temos o result set que servirá de base para o SELECT, INSERT, DELETE, etc., que estiver após a CTE. Caso tenha uma outra âncora, esta será processada e assim por diante.

---

E para mais de um membro recursivo, como ficaria? Bem não vou fazer execução detalha, pois ficaria muito grande e seria muito repetitivo, mas vejam os seguintes scripts (e os testem).

;WITH Nome(nome)
AS
(
    SELECT nome = CONVERT(VARCHAR(4000),'Thiago')
    UNION ALL
    SELECT CONVERT(VARCHAR(4000),nome + 'Zavaschi') FROM Nome
    WHERE LEN(nome) < 30
    UNION ALL
    SELECT CONVERT(VARCHAR(4000),nome + 'Silva') FROM Nome
    WHERE LEN(nome) < 30
)
SELECT nome FROM Nome

Para esse teremos (omitindo o output):
(39 row(s) affected)

E se colocarmos mais uma âncora? Vai dobrar o número de resultados, certo? Errado. Esqueceu do WHERE LEN(nome) < 30?

;WITH Nome(nome)
AS
(
    SELECT nome = CONVERT(VARCHAR(4000),'Thiago')
    UNION ALL
    SELECT nome = CONVERT(VARCHAR(4000),'José')
    UNION ALL
    SELECT CONVERT(VARCHAR(4000),nome + 'Zavaschi') FROM Nome
    WHERE LEN(nome) < 30
    UNION ALL
    SELECT CONVERT(VARCHAR(4000),nome + 'Silva') FROM Nome
    WHERE LEN(nome) < 30
)
SELECT nome FROM Nome

Se utilizarmos os mesmos valores para âncoras e nas partes recursivas aí sim a adição de um âncora dobraria o total atual de registros retornados.

--

Limite de Recursividade

Para este caso utilizarei um dos exemplos já mostrados:

;WITH NumerosSequenciais(num)
AS
(
     SELECT 1 AS num -- Este é o membro âncora, será o primeiro a ser executado. 
     UNION ALL -- Fará a ligação do membro âncora com o membro recursivo.
     SELECT num + 1 AS num FROM NumerosSequenciais
     WHERE num < 10 -- perceba que o WHERE é bastante importante para delimitar a parada da recursão.
)
SELECT * FROM NumerosSequenciais

É conhecido que o resultado desta CTE será uma sequência de 1 até 10. A query a seguir retornaria o que?.

;WITH NumerosSequenciais(num)
AS
(
     SELECT 1 AS num -- Este é o membro âncora, será o primeiro a ser executado. 
     UNION ALL -- Fará a ligação do membro âncora com o membro recursivo.
     SELECT num + 1 AS num FROM NumerosSequenciais
     WHERE num < 1000 -- perceba que o WHERE é bastante importante para delimitar a parada da recursão.
)
SELECT * FROM NumerosSequenciais

O que mudou foi o nosso “critério de parada” permitindo listar até o número 1000, e é isso que vai acontecer, certo?

Errado. A execução será interrompida em um certo momento e teremos um output semelhante a:

1
2
3
…
98
99
100
101
Msg 530, Level 16, State 1, Line 1
The statement terminated. The maximum recursion 100 has been exhausted before statement completion.

“Ahhhhm, não entendi.”

O SQL Server por padrão tem um mecanismo que serve para evitar que “descuidados” larguem queries recursivas infinitas, o que pode compromoter o desempenho do ambiente. É possível colocar um outro valor até o máximo de 32767. Basta adicionar ao final da query o hint: OPTION (maxrecursion <n>). No nosso exemplo anterior ficaria:

;WITH NumerosSequenciais(num)
AS
(
     SELECT 1 AS num -- Este é o membro âncora, será o primeiro a ser executado. 
     UNION ALL -- Fará a ligação do membro âncora com o membro recursivo.
     SELECT num + 1 AS num FROM NumerosSequenciais
     WHERE num < 1000 -- perceba que o WHERE é bastante importante para delimitar a parada da recursão.
)
SELECT * FROM NumerosSequenciais
OPTION (maxrecursion 3000)

Ainda assim a sua recursividade passa do limite de 32767? Então avalie:

É REALMENTE necessária uma recursão maior que isso?

Não há uma maneira alternativa (e menos custosa) de executar a mesma tarefa? Normalmente há.

Nunca precisei na prática, mas é possível colocar “ilimitadas” recursões: basta colocar o valor do “maxrecursion” para 0.
Mas lembro: eu, Thiago Zavaschi, não vejo isso como uma boa prática.

Continua no próximo post..

Em muitas ocasiões nos deparamos com situações em que precisamos trabalhar em alguma coluna que seja identity. Este mini-artigo descreve alguns comandos úteis na manipulação destas colunas.

Criando uma tabela com campo identity: Devemos criar com o parâmetro identity, e configurar o primeiro valor, e o valor de incremento, respectivamente (IDENTITY (<inicio>,<incremento>)). Conforme no exemplo a seguir:

CREATE TABLE Tabela (
      Id INT IDENTITY (1,1) PRIMARY KEY,
      Valor VARCHAR(50)
)

Reiniciando o valor do campo identity: Algumas vezes precisamos alterar o valor do identity (para reiniciar a contagem, por exemplo). Há o comando truncate que além de limpar a tabela (entre outras coisas), também zera o valor do identity. No entanto, se o nosso objetivo é apenas trocar o valor do identity, o truncate não é uma saída interessante. Para manipular o identity podemos fazer como descrito a seguir:

Vamos imaginar que queremos que o próximo registro a ser inserido na tabela Tabela queremos que sua chave primária Id, se inicie em 1.

Para resolver esse problema, podemos usar a seguinte instrução:

DBCC CHECKIDENT (Tabela, reseed, 0)

O último parâmetro se torna o valor atual do identity. Ao inserir o próximo registro, o mesmo virá com o seu Id com o valor identity somado de 1 (caso seja um identity de incremento 1), o valor do identity da tabela vai para 1, e assim por diante.

Recuperar o último valor inserido de um campo identity: Para recuperar o último valor de identity inserido (ex: inserir algo em uma tabela, e cadastrar um novo registro com o id do registro recém inserido), podemos utilizar:

@@IDENTITY, que retorna o valor do identity do último registro inserido na tabela, ou;

SCOPE_IDENTITY(), que retorna o último valor mas dentro do escopo em que a query foi executada.

Não recomendo a utilização de @@IDENTITY, pois isso pode acarretar problemas de consistência em cenários onde existe um alto grau de inserção/manipulação dos dados no banco (ou mais especificamente, na tabela em questão).

Um exemplo simples de uso pode ser:

DECLARE @techId INT
INSERT INTO Tabela (Valor) VALUES (‘Testando Identity’)
SELECT @techId = SCOPE_IDENTITY()

---

Um complemento em relação ao post original:

”Zavaschi, e se eu quiser inserir um registro em uma tabela, mas somente nessa inserção quero especificar o valor do campo identity. É possível?”

É sim, basta fazer da seguinte forma:

SET IDENTITY_INSERT Tabela ON
INSERT INTO Tabela (Id, Valor) VALUES (123, ‘Informação’)
SET IDENTITY_INSERT Tabela OFF

Simples, mas temos que lembrar que precisamos explicitar os campos, ainda que estejamos fazendo uma inserção em todas as colunas.

É isso, espero que tenham gostado!

Abraços!

Thiago Zavaschi

Postei um tempo atrás um artigo sobre o DatabaseMail (aqui), mas era através dos menus de configuração. Hoje trago para vocês a realização da mesma tarefa, só que através de scripts.

Configurando o DatabaseMail

-- Cria uma account do Database Mail
EXECUTE msdb.dbo.sysmail_add_account_sp
    @account_name = 'SQL',
    @description = 'Conta de email para o envio do
    email na rotina de log de erro.', -- Uma descrição para a sua account
    @email_address = 'sql@zavaschi.com', -- Email que será 
    -- mostrado como o emissor
    @replyto_address = 'sql@zavaschi.com', -- Email de reply
    @display_name = 'SQL Server', -- Nome mostrado no email enviado
    @mailserver_name = 'smtp.zavaschi.com', -- Servidor smtp
    @port = 25, -- Porta
    @username = 'sql', -- Login do servidor de smtp
    @password = 'sql'; -- senha do servidor de smtp 

-- Cria um profile do Database Mail
EXECUTE msdb.dbo.sysmail_add_profile_sp
    @profile_name = 'SQL Profile',
    @description = 'Profile usado para o
    envio do email na rotina de log de erro.' ;
    -- Cria o profile 

-- Adiciona a account ao profile
EXECUTE msdb.dbo.sysmail_add_profileaccount_sp
    @profile_name = 'SQL Profile',
    @account_name = 'SQL',
    @sequence_number =1 ; -- Associa a account ao profile, recém criados. 

-- Garante acesso ao profile a todos os usuarios da base msdb
EXECUTE msdb.dbo.sysmail_add_principalprofile_sp
    @profile_name = 'SQL Profile',
    @principal_name = 'public',
    @is_default = 1; -- Configura o profile criado como público e padrão. 

Pronto, só isso. E agora para enviar email é da mesma maneira:

EXEC msdb.dbo.sp_send_dbmail @profile_name='SQL Profile',
@recipients='sql@zavaschi.com',
@subject='Titulo',
@body='Corpo da mensagem.'

Tranquilo né? Mas se ao executar a procedure de envio de email você obter o seguinte erro:

Msg 15281, Level 16, State 1, Procedure sp_send_dbmail, Line 0

SQL Server blocked access to procedure 'dbo.sp_send_dbmail' of component 'Database Mail XPs' because this component is turned off as part of the security configuration for this server. A system administrator can enable the use of 'Database Mail XPs' by using sp_configure. For more information about enabling 'Database Mail XPs', see "Surface Area Configuration" in SQL Server Books Online.

É pelo fato do DatabaseMail estar desabilitado no seu SQL Server, então rode o seguinte script:

sp_configure 'Database Mail XPs', 1
GO
RECONFIGURE 

Há alguns casos que não é possível executar o RECONFIGURE diretamente (sem entrar nos méritos)

Executar então: RECONFIGURE WITH OVERRIDE

Espero que seja útil para você, acredito que sim, pois muitos me pedem!

Grande abraço!

Thiago Zavaschi

Tutorial: Configurando o DatabaseMail

O Database Mail é a evolução do SQL Mail (método marcado como obsoleto e fadado a ser removido do SQL Server em uma próxima versão) com melhorias. Se você por alguma razão utiliza o SQLMail com o SQL Server 2005 ou 2008, considere a mudança imediata.

O objetivo deste artigo é mostrar o wizard de configuração do DatabaseMail e demonstrar como enviar emails através do T-SQL, além de como verificar o status dos emails enviados.

A base deste tutorial é o novo SQL Server 2008, porém os passos são muito similares no SQL Server 2005.

Configurando o Database Mail

Abra a instância desejada, abra a janela Object Explorer, abra a pasta Management e clique duas vezes no “Database Mail” para abrir a seguinte janela:

Iniciaomente somos deparados com a tela de boas vindas do wizard de configuração. Não há muito oq ue fazer aqui, podemos marcar para não ser exibida novamente e clicar em Next para prosseguir.

Marque a opção “Set up Database Mail by performing the following tasks:” e clique em next.

Caso o Database Mail não esteja habilitado você será indagado a habilitá-lo. Clique em Yes para ativar.

Dê um nome e uma descrição a conta. Após isto clique em “Add”.

Configure os dados pedidos: Nome, descrição, endereço de email, servidor smtp, e assim por diante. Clique em Ok quando terminar.

Clique em next para prosseguir.

Aqui estou tornando essa configuração pública (marcando a checkbox “public”) e tornando o perfil padrão.

Agora é a hora de configurar alguns parâmetros de sistema, como por exemplo, a extensão de arquivos que não podem ser enviados ao utilizar o database mail.
Após configurar como desejar, clique em next.

Clique em finish para encerrar o wizard e terminar de configurar a sua conta.

Esta tela mostra o progresso da configuração. Repare na coluna status, pois ela fornece a informação de se a tarefa foi bem sucedida ou não. Clique em close para encerrar.

Enviando emails

Para enviar emails através do DatabaseMail é bastante simples.

É necessário primeiramente executar a seguinte configuração para garantir que não haverá problemas:

sp_configure 'show advanced', 1
GO
RECONFIGURE
GO
sp_configure 'Database Mail XPs', 1
GO
RECONFIGURE
GO

Na sequência podemos utilizar a stored procedure de sistema denominada: sp_send_dbmail, cuja sintaxe é mostrada a seguir (para mais detalhes consulte o books online):

sp_send_dbmail [ [ @profile_name = ] 'profile_name' ]
    [ , [ @recipients = ] 'recipients [ ; ...n ]' ]
    [ , [ @copy_recipients = ] 'copy_recipient [ ; ...n ]' ]
    [ , [ @blind_copy_recipients = ] 'blind_copy_recipient [ ; ...n ]' ]
    [ , [ @subject = ] 'subject' ]
    [ , [ @body = ] 'body' ]
    [ , [ @body_format = ] 'body_format' ]
    [ , [ @importance = ] 'importance' ]
    [ , [ @sensitivity = ] 'sensitivity' ]
    [ , [ @file_attachments = ] 'attachment [ ; ...n ]' ]
    [ , [ @query = ] 'query' ]
    [ , [ @execute_query_database = ] 'execute_query_database' ]
    [ , [ @attach_query_result_as_file = ] attach_query_result_as_file ]
    [ , [ @query_attachment_filename = ] query_attachment_filename ]
    [ , [ @query_result_header = ] query_result_header ]
    [ , [ @query_result_width = ] query_result_width ]
    [ , [ @query_result_separator = ] 'query_result_separator' ]
    [ , [ @exclude_query_output = ] exclude_query_output ]
    [ , [ @append_query_error = ] append_query_error ]
    [ , [ @query_no_truncate = ] query_no_truncate ]
    [ , [ @mailitem_id = ] mailitem_id ] [ OUTPUT ]

Segue um exemplo prático de envio de email:

USE msdb

GO

EXEC sp_send_dbmail @profile_name='Zavaschi', -– Coloque o profile desejado.

@recipients='thiagoh@techresult.com.br', – Coloque os receptores da mensagem.

@subject='Título da Mensagem',

@body='Corpo da mensagem.

E-mail recebido através do database mail do SQL Server!!!!'

Note que o envio não é disparado necessariamente na hora, ele é posto numa fila e o envio dependerá das condições da rede e de conectividade.

Podemos analisar as mensagens e o status do envio das mesmas, através dos seguintes comandos de seleção:

SELECT * FROM sysmail_mailitems

GO

GO

É isso, abraços pessoal!

Thiago Zavaschi