# Referências
[void][system.reflection.assembly]::loadfrom("C:\Program Files\Microsoft SQL Server\100\SDK\Assemblies\Microsoft.SqlServer.Smo.dll")

# Objetos
$srv = new-object Microsoft.SqlServer.Management.Smo.Server(".\SQLEXPRESS")

$db = $srv.Databases["DemoAspNet"]

# 1. Gerando o Script do banco de dados
$db.Script() | Out-File "C:\Temp\DemoAspNet.sql"

# 2. Gerando o Script das tabelas do banco de dados
$db.Tables | % { $_.Script() } | Out-File "C:\Temp\DemoAspNet_Tables.sql"

# 3. Script com o GO entre as linhas (Forma 1)
$go = "`nGO`n"
$db.Tables | % { $_.Script() | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_Tables.sql"

# 4. Script com o GO entre as linhas (Forma 2)
$go = "
GO
"
$db.Tables | % { $_.Script() | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_Tables.sql"

# 5. Gerando o DROP das tabelas
$options = new-object Microsoft.SqlServer.Management.Smo.ScriptingOptions
$options.ScriptDrops = $TRUE

$go = "`nGO`n"
$db.Tables | % { $_.Script($options) | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_TableDrop.sql"

# 6. Gerando o script das tabelas com as Primary Keys
$options = new-object Microsoft.SqlServer.Management.Smo.ScriptingOptions
$options.DriPrimaryKey = $TRUE

$go = "`nGO`n"
$db.Tables | % { $_.Script($options) | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_TableKey.sql"

# 7. Gerando o script das tabelas com as Keys e Constraints, sem Collation
$options = new-object Microsoft.SqlServer.Management.Smo.ScriptingOptions
$options.DriAll = $TRUE
$options.NoCollation = $TRUE

$go = "`nGO`n"
$db.Tables | % { $_.Script($options) | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_TableAll.sql"

Forma resumida para este script se executado dentro do próprio contexto do SQL Server (Jobs, PowerShell do SQL Server ou sqlps.exe):

# Sem referências

# Objetos
sl SQLSERVER:\SQL\LOCALHOST\SQLEXPRESS\Databases\DemoAspNet

$db = get-item .

# 1. Gerando o Script do banco de dados
$db.Script() | Out-File "C:\Temp\DemoAspNet.sql"

# 2. Gerando o Script das tabelas do banco de dados
dir Tables | % { $_.Script() } | Out-File "C:\Temp\DemoAspNet_Tables.sql"

# 3. Script com o GO entre as linhas (Forma 1)
$go = "`nGO`n"
dir Tables | % { $_.Script() | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_Tables.sql"

# 4. Script com o GO entre as linhas (Forma 2)
$go = "
GO
"
$db.Tables | % { $_.Script() | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_Tables.sql"

# 5. Gerando o DROP das tabelas
$options = new-object Microsoft.SqlServer.Management.Smo.ScriptingOptions
$options.ScriptDrops = $TRUE

$go = "`nGO`n"
dir Tables | % { $_.Script($options) | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_TableDrop.sql"

# 6. Gerando o script das tabelas com as Primary Keys
$options = new-object Microsoft.SqlServer.Management.Smo.ScriptingOptions
$options.DriPrimaryKey = $TRUE

$go = "`nGO`n"
dir Tables | % { $_.Script($options) | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_TableKey.sql"

# 7. Gerando o script das tabelas com as Keys e Constraints, sem Collation
$options = new-object Microsoft.SqlServer.Management.Smo.ScriptingOptions
$options.DriAll = $TRUE
$options.NoCollation = $TRUE

$go = "`nGO`n"
dir Tables | % { $_.Script($options) | % { $_ + $go} } | Out-File "C:\Temp\DemoAspNet_TableAll.sql"

Artigo relacionado:

PowerShell no SQL Server – Step 1

Para primeira demonstração, vamos ver como é simples gerar o script de criação do banco de dados:

using System;
using System.IO;
using Microsoft.SqlServer.Management.Smo;

namespace DemoSmo
{
    class DemoScript1
    {
        static void Main()
        {
            const string serverName = @".\SQLEXPRESS";

            const string databaseName = "DemoAspNet";

            const string scriptPath = @"C:\TEMP\DemoAspNet.sql";

            var server = new Server(serverName);

            var database = server.Databases[databaseName];

            // Gerando o script do banco de dados e salvando este em um arquivo
            using (var file = new StreamWriter(scriptPath))
            {
                Console.WriteLine("Script do banco de dados...");

                foreach (var str in database.Script())
                {
                    file.WriteLine(str);
                    file.WriteLine("GO");
                }
            }

            Console.WriteLine("Script concluído ...");

            Console.ReadKey();
        }
    }
}

Agora a geração do script das tabelas do banco de dados:

using System;
using System.IO;
using System.Linq;
using Microsoft.SqlServer.Management.Smo;

namespace DemoSmo
{
    class DemoScript2
    {
        static void Main()
        {
            const string serverName = @".\SQLEXPRESS";

            const string databaseName = "DemoAspNet";

            const string scriptPath = @"C:\TEMP\DemoAspNet.sql";

            var server = new Server(serverName);

            var database = server.Databases[databaseName];

            using (var file = new StreamWriter(scriptPath))
            {
                Console.WriteLine("Script das tabelas...");

                // Relacionando as tabelas do banco de dados
                foreach (var table in database.Tables.Cast<Table>().Where(table => !table.IsSystemObject))
                {
                    // Gerando o script de cada uma das tabelas
                    file.WriteLine("--");
                    file.WriteLine("-- Tabela: [{0}].[{1}]", table.Schema, table.Name);
                    file.WriteLine("--");
                    foreach (var str in table.Script())
                    {
                        file.WriteLine(str);
                        file.WriteLine("GO");
                    }
                }
            }

            Console.WriteLine("Script concluído ...");
            Console.ReadKey();
        }
    }
}

Na geração do script das tabelas, é bem provável que você vá se perguntar “onde estão as constraints das tabelas?”, ai entra o objeto ScriptOptions, o qual pode ser utilizado como argumento para o método Script, afim de definir como e do que será gerado o script.

Para entender isso, temos abaixo um ScriptOptions configurado para gerar o script das tabelas com as Primary Keys (DriPrimaryKey):

var scriptOptions = new ScriptingOptions { DriPrimaryKey = true };

O ScriptOptions para gerar o script de DROP das tabelas (ScriptDrops):

var scriptOptions = new ScriptingOptions { ScriptDrops = true };

E para um exemplo final, utilizando o ScriptOption afim de gerar o script das tabelas com as Keys e Constraints (DriAll) e sem informar Collation das colunas (NoCollation):

using System;
using System.IO;
using System.Linq;
using Microsoft.SqlServer.Management.Smo;

namespace DemoSmo
{
    class DemoScript3
    {
        static void Main()
        {
            const string serverName = @".\SQLEXPRESS";

            const string databaseName = "DemoAspNet";

            const string scriptPath = @"C:\TEMP\DemoAspNet.sql";

            var server = new Server(serverName);

            var database = server.Databases[databaseName];

            //Definindo o objeto ScriptingOptions
            var scriptOptions = new ScriptingOptions { DriAll = true, NoCollation = true };

            using (var file = new StreamWriter(scriptPath))
            {
                Console.WriteLine("Script das tabelas...");

                foreach (var table in database.Tables.Cast<Table>().Where(table => !table.IsSystemObject))
                {
                    //ScriptingOptions com argumento do método Script
                    file.WriteLine("\n\n--\n-- Tabela: [{0}].[{1}]\n--\n", table.Schema, table.Name);
                    foreach (var str in table.Script(scriptOptions))
                    {
                        file.WriteLine(str);
                        file.WriteLine("GO");
                    }
                }
            }

            Console.WriteLine("Script concluído ...");
            Console.ReadKey();
        }
    }
}

No artigo da próxima semana veremos como utilizar o objeto Scripter para gerar o script de vários objetos ao mesmo tempo, e ainda nesta semana a versão deste artigo para PowerShell.

Para o nosso primeiro script de Backup com PowerShell, precisaremos referenciar os assemblies do SMO, e criar um código semelhante ao que vimos com .NET:

# Referências
[void][system.reflection.assembly]::loadfrom("C:\Program Files\Microsoft SQL Server\100\SDK\Assemblies\Microsoft.SqlServer.Smo.dll")
[void][system.reflection.assembly]::loadfrom("C:\Program Files\Microsoft SQL Server\100\SDK\Assemblies\Microsoft.SqlServer.SmoExtended.dll")

# Objetos
$srv = new-object Microsoft.SqlServer.Management.Smo.Server(".\SQLEXPRESS")

$bk = new-object Microsoft.SqlServer.Management.Smo.Backup

# Definindo de qual banco de dados será executado o backup
$bk.Database = "BASE1"

# Definindo onde será salvo o backup
$bk.Devices.AddDevice("C:\TEMP\BASE1_PowerShell.bak", [Microsoft.SqlServer.Management.Smo.DeviceType]::File)

# Executando o backup
$bk.SqlBackup($srv)

Mas quando no contexto do PowerShell do SQL Server (scripts executados em Jobs ou diretamente pelo PowerShell presente no SQL Server Management Studio ou SQLPS.exe), teremos algumas facilidades, como não precisar referenciar os assemblies do SMO e utilizar de “atalhos” para instanciar as variáveis do SQL Server (ex.: Smo.Server):

# Sem referências

# Objetos
$srv = get-item SQLSERVER:\SQL\LOCALHOST\SQLEXPRESS

$bk = new-object Microsoft.SqlServer.Management.Smo.Backup

# Definindo de qual banco de dados será executado o backup
$bk.Database = "BASE1"

# Definindo onde será salvo o backup
$bk.Devices.AddDevice("C:\TEMP\BASE1_PowerShell.bak", [Microsoft.SqlServer.Management.Smo.DeviceType]::File)

# Executando o backup
$bk.SqlBackup($srv)

Referências:

How To Load .NET Assemblies In A PowerShell Session

Nesta semana, demonstrarei como utilizar as classes Smo.Backup e Smo.BackupDeviceItem, de um outro assembly do SMO, o SmoExtended, que poderá ser encontrado no caminho:

C:\Program Files\Microsoft SQL Server\100\SDK\Assemblies\Microsoft.SqlServer.SmoExtended.dll

As classes Smo.Backup e Smo.BackupDeviceItem são responsáveis respectivamente por gerar backup e determinar onde este será salvo.

Para demonstrar a utilização destas classes, adequei o exemplo da semana passada, que relacionava os bancos de dados de uma determinada instancia do SQL Server, para também possibilitar identificar a data de ultimo backup de um determinado banco de dados e realizar o backup do mesmo:

Ajuste realizado:

// Gerando a classe Smo.Backup
var backup = new Backup { Database = database.Name };

// Definindo com o Smo.BackupDeviceItem onde será salvo o backup
var path = string.Format(@"C:\Temp\{0}_{1:yyyy-MM-dd HH_mm_ss}.bak", database.Name, DateTime.Now);

backup.Devices.AddDevice(path, DeviceType.File);

// Executando o backup
backup.SqlBackup(server);

Código completo:

using System;
using System.Linq;
using System.Security;
using Microsoft.SqlServer.Management.Smo;
using Microsoft.SqlServer.Management.Common;

namespace DemoSmo
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("Servidor:");
            var serverInstance = Console.ReadLine();
            Console.WriteLine();

            Console.WriteLine("Usuário:");
            var user = Console.ReadLine();
            Console.WriteLine();

            ServerConnection conn;

            if (!string.IsNullOrEmpty(user))
            {
                Console.WriteLine("Senha:");
                var pass = ReadPassword();
                Console.WriteLine();

                // Criando um objeto de conexão com SQL Authentication
                conn = new ServerConnection(serverInstance, user, pass);
            }
            else
            {
                // Criando um objeto de conexão com Windows Authentication
                conn = new ServerConnection(serverInstance);
            }

            // Criando um objeto que abstrai a instância do SQL Server
            var server = new Server(conn);

            Console.WriteLine("Carregando lista de bancos de dados ...");
            Console.WriteLine();

            try
            {
                // Recuperando a lista de banco de dados
                var lst = server.Databases.Cast<Database>().OrderBy(db => db.ID).ToArray();

                // Escrevendo a relação de banco de dados encontrados
                foreach (var db in lst) Console.WriteLine("{0}. {1}", db.ID, db.Name);

                // Recuperando o banco de dados por meio do número informado pelo usuário
                Console.WriteLine();
                Console.WriteLine("Digite o número do banco de dados:");

                var key = Console.ReadLine();

                int id;

                if (!int.TryParse(key, out id)) return;

                var database = lst.FirstOrDefault(db => db.ID == id);

                if (database == null) return;

                Console.WriteLine();

                // Recuperando informações do último backup do banco de dados
                if (database.LastBackupDate == DateTime.MinValue)
                {
                    Console.WriteLine("Nenhum backup encontrado.");
                }
                else
                {
                    Console.WriteLine("Último backup: {0:yyyy-MM-dd HH:mm:ss}", database.LastBackupDate);
                }
                Console.WriteLine();
                Console.WriteLine("Aperte ENTER para gerar um backup, ou qualquer outra tecla para sair.");

                if (Console.ReadKey().Key != ConsoleKey.Enter) return;

                // Gerando a classe Smo.Backup
                var backup = new Backup { Database = database.Name };

                // Definindo com o Smo.BackupDeviceItem onde será salvo o backup
                var path = string.Format(@"C:\Temp\{0}_{1:yyyy-MM-dd HH_mm_ss}.bak", database.Name, DateTime.Now);

                backup.Devices.AddDevice(path, DeviceType.File);

                // Executando o backup
                backup.SqlBackup(server);

                Console.WriteLine();
                Console.WriteLine("Backup concluído ...");
                Console.ReadKey();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        // Método para evitar que a senha digitada apareça na tela da aplicação
        private static SecureString ReadPassword()
        {
            var pass = new SecureString();

            while (true)
            {
                var key = Console.ReadKey(true);

                if (key.Key == ConsoleKey.Enter) break;

                pass.AppendChar(key.KeyChar);

                Console.Write("*");
            }

            Console.WriteLine();

            return pass;
        }
    }
}

Além destas duas formas de interação, temos o SMO (SQL Server Management Objects) que nos permite gerenciar o SQL Server utilizando um coleção de assemblies .NET, que podem ser utilizados em scripts do PowerShell ou em aplicações .NET de forma bem transparente.

Há alguns anos escrevi um artigo para revista Mundo .NET sobre este assunto, mas não demonstrei muito do potencial que temos com SMO.

A partir deste artigo, pretendo iniciar uma nova série de artigos que tratarão várias formas de utilizar SMO com .NET e também com PowerShell (mais como um comparativo de como fazer com .NET e com PowerShell).

Hoje, vamos começar com uma aplicação .NET simples que ilustra bem a utilização do SMO.

Tento um projeto .NET, o primeiro passo será encontrar os assemblies que compõe a SMO, no caso do SQL Server 2008 (100). Eles podem ser encontrados nas pastas:

C:\Program Files\Microsoft SQL Server\100\SDK\Assemblies
C:\Program Files (x86)\Microsoft SQL Server\100\SDK\Assemblies

Caso não os encontre, você pode instalá-los:
http://www.microsoft.com/download/en/details.aspx?id=16177#SMO
(Microsoft SQL Server 2008 Management Objects)

Para a nossa primeira aplicação, precisaremos dos seguintes assemblies referenciados em nossa aplicação:

Microsoft.SqlServer.Smo.dll
Microsoft.SqlServer.ConnectionInfo.dll
Microsoft.SqlServer.Management.Sdk.Sfc.dll

Adicionadas as referencias ao projeto, será possível criar uma aplicação simples em .NET (em C# no meu caso) para relacionar os bancos de dados de uma determinada instancia do SQL Server:

using System;
using System.Linq;
using System.Security;
using Microsoft.SqlServer.Management.Smo;
using Microsoft.SqlServer.Management.Common;

namespace DemoSmo
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("Servidor:");
            var serverInstance = Console.ReadLine();
            Console.WriteLine();

            Console.WriteLine("Usuário:");
            var user = Console.ReadLine();
            Console.WriteLine();

            ServerConnection conn;

            if (!string.IsNullOrEmpty(user))
            {
                Console.WriteLine("Senha:");
                var pass = ReadPassword();
                Console.WriteLine();

                // Criando um objeto de conexão com SQL Authentication
                conn = new ServerConnection(serverInstance, user, pass);
            }
            else
            {
                // Criando um objeto de conexão com Windows Authentication
                conn = new ServerConnection(serverInstance);
            }

            // Criando um objeto que abstrai a instância do SQL Server
            var server = new Server(conn);

            Console.WriteLine("Carregando lista de bancos de dados ...");
            Console.WriteLine();

            try
            {
                // Recuperando a lista de banco de dados
                var lst = server.Databases;

                // Escrevendo a relação de banco de dados encontrados
                foreach (var db in lst.Cast<Database>().OrderBy(e => e.ID))
                {
                    Console.WriteLine("{0}. {1}", db.ID, db.Name);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.WriteLine();
            Console.WriteLine("Concluído ...");
            Console.ReadKey();
        }

        // Método para evitar que a senha digitada apareça na tela da aplicação
        private static SecureString ReadPassword()
        {
            var pass = new SecureString();

            while (true)
            {
                var key = Console.ReadKey(true);

                if (key.Key == ConsoleKey.Enter) break;

                pass.AppendChar(key.KeyChar);

                Console.Write("*");
            }

            Console.WriteLine();

            return pass;
        }
    }
}

E por fim, executando a aplicação por SQL Authentication:

E por Windows Authetication:

Por enquanto não há muitos materiais no blog sobre SMO, então você pode esperar novos artigos serem publicados, encontrar outras fontes pela internet ou comprar a revista que tem o artigo que escrevi sobre SMO.

Até o próximo artigo!

Seja consciente, a cada instalação em Português do Windows Server ou SQL Server,
morre um mico leão dourado…

Então pensem no bem das futuras gerações, instalem o Windows Server
e o SQL Server em Inglês.

Agradecimentos ao @magalhaesv pela frase que deu origem a esta campanha.

Seguindo tradição do blog, pelo terceiro Natal consecutivo, estava planejando algo bem diferente dos anos anteriores, e em conversas com o @WilliamPietro, tivemos a ideia de criar um script de PowerShell especial para esta data.

Abaixo o script:

$a = (Get-Host).UI.RawUI
$a.WindowTitle = "PowerShell - Especial de Natal"
$b = $a.WindowSize
$b.Width = 18
$b.Height = 12
$a.WindowSize = $b

$c = "        .`n       .#.`n      .###.`n     .#%##%.`n    .%##%###.`n   .##%###%##.`n  .#%###%##%##.`n        #`n        #`n"

1..300 | % {
	$a.BackgroundColor = "darkgreen"
	$a.ForegroundColor = "white"
	cls
	Write-Host $c
	Write-Host "    HO HO HO"
	Wait-Event -timeout 1
	$a.BackgroundColor = "red"
	$a.ForegroundColor = "white"
	cls
	Write-Host $c
	Write-Host "   Feliz Natal"
	Wait-Event -timeout 1
}

Resultado, durante aproximadamente 10 minutos a tela do PowerShell exibirá de forma alternada as seguintes mensagens:

Boas festas, e que tenhamos um ótimo 2012!

Artigos relacionados:

Artigo de Natal de 2009

Artigo de Natal de 2010

Como existem poucos artigos em português para explicar como desenvolver COM+ com .NET, procurei a demonstrar a criação de componente simples com C# no Visual Studio 2010.

Para a criação do componente, utilizei um projeto do tipo Class Library:

A este projeto adicionei referência à System.EnterpriseServices:

Nas propriedades do projeto, editei a “Assembly Information”,

especificando o Assembly como COM-Visible:

De acordo com a plataforma do sistema legado (x64, x86) que o COM+ irá trabalhar, defini esta em Plataform target:

Obs.: Esta opção é muito importante, pois é muito comum criar um componente em x64 e este não ser visível para uma aplicação VB x86, assim como tentar criar componentes x86 para tentar acessar por um VBScript que será executado em uma plataforma x64.

Por fim, criei uma chave “strong name” para o projeto:

Para uma classe .NET ser considerada componente, ela deverá ser herdada de System.EnterpriseServices.ServicedComponent, conforme abaixo, onde temos uma classe simples cujo o seu único método retorna um texto:

using System.EnterpriseServices;

namespace DemoCom
{
    public class Objeto : ServicedComponent
    {
        public string Teste()
        {
            return "Demo COM+ //By SQL From Hell";
        }
    }
}

Após realizar o build do projeto, utilizei o regsvcs de acordo com a plataforma x86/x64 e versão da .NET Framework do projeto, informando o caminho do seu assembly (DLL) onde esta “$(TargetPath)”.

C:\Windows\Microsoft.NET\Framework\v4.0.30319\regsvcs.exe $(TargetPath)

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\regsvcs.exe $(TargetPath)

Após a instalação do componente, este será visível na relação de COM+ Applications no Component Services:

Para testar o COM+, utilizarei um VBScript simples:

Dim obj
Set obj = CreateObject("DemoCom.Objeto")
MsgBox obj.Teste

Também sendo possível por Ole Automation do SQL Server:

DECLARE @obj INT

DECLARE @return INT, @text NVARCHAR(4000)

-- Criando a 'instância' do componentes

EXEC @return = sp_OACreate 'DemoCom.Objeto', @obj OUT

-- Verificando se a chamada obteve sucesso.

IF @return = 0 PRINT 'COM: OK'

-- Chamando o método Teste

EXEC @return = sp_OAMethod @obj, 'Teste', @text OUT

IF @return = 0 PRINT 'Teste: OK'

PRINT 'Resultado: ' + @text

E por fim, para desinstalar o componente, bastará utilizar o mesmo regsvcs informando “/u”.

C:\Windows\Microsoft.NET\Framework\v4.0.30319\regsvcs.exe /u $(TargetPath)

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\regsvcs.exe /u $(TargetPath)

Artigos relacionados:

Acessando dados de Web Service com Ole Automation Procedures

Gerando templetes das System Views:

Gerando templates das Information Functions:

Os principais problemas são visíveis já na atividade de Planejamento, onde são determinadas as ações pelas quais as estratégias da organização serão suportadas ou executadas pela área de TI. O excesso de planejamento neste momento pode estar relacionado ao uso demasiado de tempo para planejar como se dará toda a execução, numa tentativa utópica de planejar tudo o que será feito e prever todos os problemas que podem ocorrer durante a execução, tirando muito da autonomia de quem executará, além do planejamento ter que lidar com problemas tão complexos e dinâmicos que não poderão estar claros neste momento.

Da mesma forma, o descaso no planejamento pode tornar o objetivo da execução algo muito vago e exigir muito da autonomia de pessoas que talvez não estejam aptas para tomar iniciativas ou decisões. Assim, a busca de um equilíbrio no planejamento, permitindo uma visão clara do que é esperado da equipe e além de dar um pouco de autonomia à equipe (de acordo com a maturidade desta), para que esta equipe tenha o poder de planejar a execução das atividades mais específicas e tomar decisões a fim de resolver problemas de pouco impacto que venham a surgir durante a execução.

A atividade de Organização é vítima normalmente do descaso, por não orientar a equipe sobre as responsabilidades de cada elemento e também não definindo as regras que devem ser obedecidas (ex.: como se dará a comunicação com outras áreas da organização, clientes e fornecedores), o que poderá gerar conflitos internos na equipe durante o andamento dos trabalhos, ou conflitos entre a equipe e as outras áreas da organização.

A atividade de Organização permite a equipe entenda suas responsabilidades e as regras para execução das suas atividades. Sendo estas bem definidas, exigirá poucas mudanças durante a execução das atividades, além de suprimir conflitos desnecessários e evitar que determinadas pessoas fiquem sobrecarregadas de atividades.

Se as atividades de Organização e Planejamento não estiverem bem definidas, os problemas serão visíveis na atividade de Execução, resultando em retrabalhos, conflitos, atrasos e não alcançando os resultados esperados pelas suas atividades.

Durante a atividade de Execução, a atividade de Controle permite verificar problemas não esperados ou observar o comportamento e o impacto de problemas previstos, o que possibilita à equipe e ao gestor definir novos planos e se reorganizar a fim de resolver tais ocorrências. Esta atividade requer um pouco de prudência do gestor, pois a falta de controle do que esta acontecendo pode comprometer toda a execução das atividades, e o excesso de controle pode gerar insatisfação por conflitar com a maturidade e a cultura da equipe (hábitos, forma de fazer suas atividades e resolver problemas).

A atividade de Liderança pode sofrer pelo excesso, tornando a figura do gestor mais como um “pai” da equipe, tornando a equipe superdependente do seu gestor. Ou sofrer pelo descaso, onde o gestor não é visto como elemento que merece alguma consideração por parte da equipe ou que visto como uma figura que “só atrapalha, no lugar de ajudar”.

A figura do gestor deve vista de acordo com a maturidade da equipe, na qual deve ser visto como um elemento de auxilio (representante na comunicação com os outros setores da organização, parceiros, clientes e fornecedores) para equipes maduras e que já possuem autonomia, ou como elemento de orientação para que a equipe ainda não madura chegue a desenvolver seus relacionamentos e aos poucos conquistar sua autonomia.

Assim, evitando o excesso ou o descaso com as atividades de gestão na área de TI, será possível alcançar os resultados esperados pela organização, assim como fomentar a maturidade e autonomia da equipe, exigindo do gestor o papel de coordenar a equipe e melhorar os relacionamentos desta com elementos internos e externos da organização.

Rascunho escrito em Setembro de 2011.

Mesmo que o comportamento “padrão” nestes cenários na maioria das vezes é dar um REPLACE no cabeçalho do XML, vamos aprender como resolver esta situação de forma prática.

O XML que usarei para o exemplo possui um namespace bem comum para dados oriundos de aplicações como o http://tempuri.org/, que é o namespace padrão do exemplo (URL declarada com xmlns sem qualquer sufixo):

DECLARE @X XML

SET @X = '
<ArrayOfDsItem xmlns="http://tempuri.org/" xmlns:ns2="http://tempuri2.org/">
  <DsItem Code="1" Value="ACRE" Value2="AC">
    <ns2:Status>Não existe</ns2:Status>
  </DsItem>
  <DsItem Code="5" Value="BAHIA" Value2="BA" />
  <DsItem Code="11" Value="MATO GROSSO" Value2="MT" />
  <DsItem Code="13" Value="MINAS GERAIS" Value2="MG" />
  <DsItem Code="19" Value="RIO DE JANEIRO" Value2="RJ" />
  <DsItem Code="21" Value="RIO GRANDE DO SUL" Value2="RS" />
  <DsItem Code="24" Value="SÃO PAULO" Value2="SP" />
</ArrayOfDsItem>'

Visto que estamos tratando de um namespace padrão, podemos determinar ou por T-SQL ou por XQuery, que este é o bendito namespace de todo o XML:

-- Definindo o namespace padrão
;WITH XMLNAMESPACES (DEFAULT 'http://tempuri.org/')
SELECT
	E.value('@Value', 'varchar(25)') AS Estado,
	E.value('@Value2', 'char(2)') AS Sigla
FROM @X.nodes('//ArrayOfDsItem/DsItem') AS N(E)

SELECT
	E.value('@Value', 'varchar(25)') AS Estado,
	E.value('@Value2', 'char(2)') AS Sigla
FROM @X.nodes('
	declare default element namespace "http://tempuri.org/";
	//ArrayOfDsItem/DsItem
') AS N(E)

Ou podemos criar um namespace sinônimo (ns), o que afetará um pouco a nossa XQuery:

-- Definindo um sinonimo para namespace padrão (ns)
;WITH XMLNAMESPACES ('http://tempuri.org/' AS ns)
SELECT
	E.value('@Value', 'varchar(25)') AS Estado,
	E.value('@Value2', 'char(2)') AS Sigla
FROM @X.nodes('//ns:ArrayOfDsItem/ns:DsItem') AS N(E)

SELECT
	E.value('@Value', 'varchar(25)') AS Estado,
	E.value('@Value2', 'char(2)') AS Sigla
FROM @X.nodes('
	declare namespace ns = "http://tempuri.org/";
	//ns:ArrayOfDsItem/ns:DsItem
') AS N(E)

Mas e agora, tenho dois ou mais namespaces no XML, o que podemos fazer? Podemos optar por qualquer uma das práticas anteriores (definindo um sinônimo ou definindo o namespace padrão) e mais os sinônimos para os namespaces secundários:

-- Definindo o namespace padrão e o sinonimo para o secundário (ns2)
;WITH XMLNAMESPACES (
	DEFAULT 'http://tempuri.org/',
	'http://tempuri2.org/' AS ns2
)
SELECT
	E.value('@Value', 'varchar(25)') AS Estado,
	E.value('@Value2', 'char(2)') AS Sigla,
	E.value('ns2:Status[1]', 'varchar(25)') AS Comentario
FROM @X.nodes('//ArrayOfDsItem/DsItem') AS N(E)

SELECT
E.value('@Value', 'varchar(25)') AS Estado,
E.value('@Value2', 'char(2)') AS Sigla,
E.value('
	declare namespace ns2 = "http://tempuri2.org/";
	ns2:Status[1]
' , 'varchar(25)') AS Comentario
FROM @X.nodes('
	declare default element namespace "http://tempuri.org/";
	//ArrayOfDsItem/DsItem
') AS N(E)

-- Definindo sinonimos para namespace padrão (ns) e para o secundário (ns2)
;WITH XMLNAMESPACES (
	'http://tempuri.org/' AS ns,
	'http://tempuri2.org/' AS ns2
)
SELECT
	E.value('@Value', 'varchar(25)') AS Estado,
	E.value('@Value2', 'char(2)') AS Sigla,
	E.value('ns2:Status[1]', 'varchar(25)') AS Comentario
FROM @X.nodes('//ns:ArrayOfDsItem/ns:DsItem') AS N(E)

SELECT
E.value('@Value', 'varchar(25)') AS Estado,
E.value('@Value2', 'char(2)') AS Sigla,
E.value('
	declare namespace ns2 = "http://tempuri2.org/";
	ns2:Status[1]
' , 'varchar(25)') AS Comentario
FROM @X.nodes('
	declare namespace ns = "http://tempuri.org/";
	//ns:ArrayOfDsItem/ns:DsItem
') AS N(E)

Ficou legal, não ficou? Mas nada te impede de colocar alguns REPLACEs na sua query e ser feliz…

No próximo artigo veremos com iniciar um pequeno caos com o FOR XML e Namespaces…

Neste sábado, estaremos (eu, o @WilliamPietro e o @VitorBitner) em São Paulo para assistir o melhor evento de SQL Server que este país já viu, o SQL Saturday 100. Evento que contará com a presença de feras de SQL Server do Brasil e de outros países, permitindo além de ver novidades do SQL Server 2012, também a oportunidade de aprender e conhecer estas feras.

Agradecimento ás esposas e namoradas que com um pouco de LeroLeroInjetion* permitiram a nossa viagem para lá!

Abaixo a minha agenda:

*: Termo utilizado pelo Vitor, não assumo responsabilidades… XD

Neste artigo, tratarei de três práticas que considero importantes quando requer a utilização desta função, mas se alguém quiser comentar sobre outras práticas ou soluções que considere melhores, fique a vontade.

A primeira dica esta relacionada à divergência da data do servidor/cliente da aplicação em comparação ao servidor do banco de dados, pois é comum aparecer problemas em regras de negócios que envolvem a utilização da função GETDATE() e outras funções com finalidades semelhantes pela aplicação (ex.: VB.NET/C# – System.DateTime.Now()) quando a data/hora dos servidores/clientes estão diferentes (horário de verão que o diga). Desta forma, procure criar políticas para manter as datas/horas dos servidores sincronizadas, e utilizar somente a data/hora de um dos servidores (normalmente o servidor de banco de dados) nas regras de negócio.

Outra dica é referente ao conflito de fuso horário (ou timezone), pois quando você possui servidores em dois ou mais lugares distantes no mundo, a função GETDATE() pode gerar um pouco de dor de cabeça. Assim, utilizar a função SYSDATETIMEOFFSET ao invés de GETDATE, e o tipo DATETIMEOFFSET ao invés de DATETIME, permitirá solucionar estes conflitos e também dará ‘transparência’ em relação aos fusos horários nas consultas.

A função GETUTCDATE também pode ser útil para fusos horários distintos, mas não oferece a mesma transparência em relação ás datas entre os diversos fusos, por utilizar o horário UTC.

Para ‘conversões’ entre os fusos horários, utilize a função SWITCHOFFSET.

A terceira dica é referente ao conflito com os valores obtidos pela função GETDATE() em um mesmo script. Sim, isso existe! Ou estava pensando que o valor da função GETDATE() é obtido só uma vez durante todos os comandos de um script, veja o exemplo:

A fim de solucionar estas divergências, opte pela utilização de variáveis para identificar o valor da função GETDATE() durante os comandos de um script, exemplo:

Espero que tenham gostado destas dicas.

Ainda tenho outras dicas a respeito da precisão das datas/horas, mas as deixo para uma próxima oportunidade.

Para relacionar o framework das cinco forças com a gestão de carreira sob a ótica do profissional, é possível identificar como cada uma destas “forças” estão relacionadas à competitividade do mercado na busca de melhores oportunidades de trabalho.

A primeira força, denominada poder de barganha dos fornecedores, que na carreira de um profissional esta relacionada às universidades, centros de treinamento e certificação. Estas universidades e centros de treinamento permitem que o profissional possa adquirir uma formação adequada (matéria-prima) para atuar no mercado, e determinam as exigências e qualificações mínimas para a capacitação dos profissionais.

O poder de barganha das universidades e centros de treinamento e certificação envolve muitas vezes a dificuldade de um profissional desenvolver uma formação que se mostre como um diferencial no mercado, como no caso de graduações, MBAs, mestrados e doutorados em universidades de renome, ou certificações que exijam alto grau de capacitação e experiência.

A segunda força, denominada poder de barganha dos clientes, na gestão de carreiras é possível relacionar aos empregados, que definem requisitos e responsabilidades mínimas para o profissional ser aceito pela empresa, e os benefícios muitas vezes vinculados à escassez da formação e experiência deste profissional.

Dos requisitos, podemos identificar os requisitos essenciais que definem o mínimo que o profissional precisa ter para ocupar determinado cargo (ex.: DBA conhecer SQL, Programador .NET conhecer VB ou C# …) e requisitos complementares e específicos, que diferenciam o que o empregador precisa do profissional para conseguir ocupar o cargo pretendido numa dada empresa, como por exemplo as empresas de atuação internacional exigem profissionais que sabem dois ou mais idiomas, e as empresas que possuem certificações ISO ou CMMI exigem profissionais que tenham experiência em organizações com qualificações semelhantes .

A respeito dos benefícios, estes variam com a escassez e a necessidade do mercado por um profissional com um determinado tipo de formação e experiência, assim como os salários de profissionais de TI que estão hoje acima da média dos profissionais de outras áreas de atuação, devido a atual escassez (lei da oferta e da procura).

A terceira força esta relacionada às ameaças de substitutos, como no caso dos computadores “desktops” que são aos poucos substituídos por tecnologias móveis (notebooks, netbooks, tablets e celulares). No caso dos profissionais, há possibilidade de ser depreciado (ou até mesmo descartado) pelo mercado por não se capacitar e adquirir novas experiências.

Na área de TI é raro ver uma tecnologia ser completamente substituída, pois ao mesmo tempo que surge a necessidade de profissionais que possuem competências em novas tecnologias, também surge a necessidade de profissionais que possuem competências em tecnologias mais antigas, seja para manutenção ou para novas implementações, pois o legado de TI possui uma sobrevida relativamente alta (ex.: COBOL), além de oferecer muitas oportunidades à profissionais que pretendem entrar no mercado.

A quarta força esta relacionada às ameaças de novos entrantes, isso diz respeito na gestão de carreiras à facilidade de profissionais que estão entrando no mercado substituir aqueles já que estavam lá, como por exemplo, os profissionais com baixo nível de capacitação que são substituídos por outros que estão entrando no mercado que já possuem um nível de capacitação equivalente ou requerem salários mais baixos.

A quinta força esta relacionada à competitividade interna do próprio mercado, onde profissionais que possuem capacitações diversas concorrem por melhores empregos, bons empregadores e melhores currículos.

A quinta força pode ser vista sob outra contribuição de Porter, ao analisar como fomentar vantagens competitivas sob a ótica do “custo”, da “diferenciação” e da “especialização”.

Em relação ao “custo” na gestão de carreira, podemos identificar os novos entrantes do mercado como os estagiários e profissionais que conseguem boas oportunidades por exigirem salários relativamente baixos, ou aqueles atuam como consultores ou terceirizados de acordo com as demandas dos empregadores/clientes.

No que tange a “diferenciação”, temos os profissionais que possuem competências dadas como escassas no mercado, como profissionais com experiência e formação que os tornem melhor capacitados que outros.

Sobre a ótica da “especialização”, teremos os profissionais com alto grau de domínio em determinadas tecnologias (ex.: profissionais com certificações MCM, MCA, ITIL Master, OCM) ou que relacionem competências distintas (ex.: gestores de projetos de TI, profissionais de TI que atuam com dados espaciais, desenvolvedores de jogos, analistas de sistemas com formação em engenharia civil ou florestal) se tornando extremamente importantes para determinados ramos do mercado.

Dado este experimento de vincular o conceito de gestão de carreira e ao framework de Porter com a finalidade de definir como se dá a competitividade dos profissionais na busca por melhores colocações no mercado, espero que além do entendimento a respeito do tema, que seja possível ao leitor se identificar no meio deste mundo competitivo e procure através de um bom planejamento de sua carreira uma colocação que permita sua autorrealização.

http://thedailywtf.com/Articles/The-Query-of-Despair.aspx

Se alguem quiser encaminhar outros exemplos para publicar no blog, fiquem a vontade!