博客园_OK_008 blog

PowerShell应用之-可更新订阅的事务复制

2011-11-24T18:13:00Z

开始

在上一篇《PowerShell应用之-事务复制》，描述了如何通过PowerShell脚本配置发布&分发服务器、创建事务发布&发布项目、和创建推送&请求订阅。而且上篇订阅是只读的（ReadOnly），在这篇，将会讲述可更新订阅的事务复制，涉及到两种基本的订阅类型：队列更新（QueuedUpdate） & 即时更新（ImmediateUpdate ）。本篇使用的例子会沿用上一篇的部分脚本及测试数据库。在这边我们省略了配置发布&分发服务器部分，直接从创建事务发布和发布项目（TransPublication & TransArticle）开始。

创建事务发布和设置发布项目(TransPublication & TransArticle)

在原来的代码中，我们会在开始的输入部分多加两个变量描述可更新订阅的订阅类型，是否队列更新 & 是否即时更新

##允许队列更新订阅
#------------------------------------------------------------
$AllowQueuedTransactions=$True

##允许即时更新订阅
#------------------------------------------------------------
$AllowSynchronousTransactions=$True

在TransPublication创建之前，需要补上下面的简短代码，描述添加队列更新 & 即时更新到TransPublication可更新订阅选项中。

        #允许队列更新订阅
        if($AllowQueuedTransactions -eq $true)
        {
            $TransPublication.Attributes =$TransPublication.Attributes -bor [Microsoft.SqlServer.Replication.PublicationAttributes]::AllowQueuedTransactions
        }

        #允许即时更新订阅
        if($AllowSynchronousTransactions -eq $true)
        {
            $TransPublication.Attributes =$TransPublication.Attributes -bor [Microsoft.SqlServer.Replication.PublicationAttributes]::AllowSynchronousTransactions
        }

这部分的完整代码，我们可以查看PowerShell脚本：

Replication-5-Create a Publication(AllowQueuedTransactions).ps1

<#===========================创建事务发布&发布项目===========================#>

##配置发布、分发服务器者登录用户名&密码，这里发布与分发使用同一个实例
#------------------------------------------------------------
$serverInstance="WINSERVER01\SQL2008DE01"
$userName="sa"
$password="sql20081"

##设置域账号，应用于同步复制
#------------------------------------------------------------
$RAccount="TN\SQLAccount"
$RPassword="Sql123456"

##发布数据库
#------------------------------------------------------------
$DataBase="ReplicationDB"

##项目名称
#------------------------------------------------------------
$TransPublicationName=$DataBase+“_Tran_”

##项目对应的是表，使用"Select * Form TableName Where ...;"格式
#------------------------------------------------------------
$SQL="
Select * From DataOwner Where ID=2;
Select * From Data1 Where OwnerID=2;
Select * From Data2 Where ParentID In(Select ID From dbo.Data1 Where OwnerID=2);
Select * From DataRelation Where ParentID In(Select dbo.Data2.ID From dbo.Data1 Inner Join dbo.Data2 On dbo.Data1.ID = dbo.Data2.ParentID And dbo.Data1.OwnerID=2);
"

##发行项目选项
#------------------------------------------------------------
$PreCreationMethod="drop" #当名称已被使用时的操作.可以选择“none”，“delete”，“drop”,"truncate"

##允许队列更新订阅
#------------------------------------------------------------
$AllowQueuedTransactions=$True

##允许即时更新订阅
#------------------------------------------------------------
$AllowSynchronousTransactions=$True

<#================================================================#>

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Rmo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null

#Step 1: 创建连接
$ServerConnection =New-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password

#Step 2:

Try
{
    $ServerConnection.Connect()
    if ($ServerConnection.IsOpen)
    {
        $ReplicationDatabase =New-object "Microsoft.SqlServer.Replication.ReplicationDatabase" $DataBase,$ServerConnection
        $ReplicationDatabase.EnabledTransPublishing=$true

        #创建队列读取器代理
        if ($ReplicationDatabase.LogReaderAgentExists -eq $false)
        {
            $ReplicationDatabase.LogReaderAgentProcessSecurity.Login=$RAccount
            $ReplicationDatabase.LogReaderAgentProcessSecurity.Password=$RPassword
            $ReplicationDatabase.LogReaderAgentPublisherSecurity.WindowsAuthentication=$true

            $ReplicationDatabase.LogReaderAgentPublisherSecurity.SqlStandardLogin=$userName
            $ReplicationDatabase.LogReaderAgentPublisherSecurity.SqlStandardPassword=$password
            $ReplicationDatabase.LogReaderAgentPublisherSecurity.WindowsAuthentication=$false
            $ReplicationDatabase.CreateLogReaderAgent()
        }

        #创建事务发布
        $TransPublication=New-object "Microsoft.SqlServer.Replication.TransPublication" $TransPublicationName,$DataBase,$ServerConnection

        $TransPublication.SnapshotGenerationAgentProcessSecurity.Login=$RAccount
        $TransPublication.SnapshotGenerationAgentProcessSecurity.Password=$RPassword
        $TransPublication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication=$true

        $TransPublication.SnapshotGenerationAgentPublisherSecurity.SqlStandardLogin=$userName
        $TransPublication.SnapshotGenerationAgentPublisherSecurity.SqlStandardPassword=$password
        $TransPublication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication=$false

        #允许队列更新订阅
        if($AllowQueuedTransactions -eq $true)
        {
            $TransPublication.Attributes =$TransPublication.Attributes -bor [Microsoft.SqlServer.Replication.PublicationAttributes]::AllowQueuedTransactions
        }

        #允许即时更新订阅
        if($AllowSynchronousTransactions -eq $true)
        {
            $TransPublication.Attributes =$TransPublication.Attributes -bor [Microsoft.SqlServer.Replication.PublicationAttributes]::AllowSynchronousTransactions
        }

        if ($TransPublication.IsExistingObject -eq $false)
        {
            $TransPublication.Create()
        }


        #定义发布项目

        While($SQL.IndexOf(“`r”) -gt 0)   #处理Select列表
            {$SQL=$SQL.Replace("`r","")}

        While($SQL.IndexOf(“`n”) -gt 0)
            {$SQL=$SQL.Replace("`n","")}

        While($SQL.IndexOf(“`t”) -gt 0)
            {$SQL=$SQL.Replace("`t "," ")}

        While($SQL.IndexOf("  ") -gt 0)
            {$SQL=$SQL.Replace("  "," ")}
        $SQL=$SQL.ToLower()

        Foreach ($SqlLine In $SQL.split(";"))
        {
            if ($SqlLine.IndexOf("from") -gt 0)
            {
                $Where=""
                $TB=$SqlLine.split(" ")[3]
                If ($SqlLine.LastIndexOf("where") -gt 0)
                {
                    $Where=$SqlLine.substring([int32]($SqlLine.IndexOf("where")+6))
                }
                $Article=New-object "Microsoft.SqlServer.Replication.TransArticle" $TB,$TransPublicationName,$DataBase,$ServerConnection
                $Article.SourceObjectName=$TB
                $article.FilterClause=$Where
                $article.PreCreationMethod=$PreCreationMethod
                if ($Article.IsExistingObject -eq $false)
                {
                    $Article.Create()
                }
            }
        }

        Write-Host "事务发布 '$TransPublicationName' 已创建!"
    }
}
Catch
{

    Write-Error $_
}

执行上面的完整代码，我们就可以看到在事务发布ReplicationDB_Tran_的属性，查看可更新订阅选项内容：

如何创建推送订阅(Push Subscription)

创建可更新订阅的时候，与上篇创建订阅的有些不同，在这过程，我们代码开头位置多一个变量来描述可更新订阅类型。

##可更新订阅类型
#------------------------------------------------------------
$SubscriberType=“ImmediateUpdate”

在创建订阅之前会，根据开头设置的变量$SubscriberType，来描述订阅类型，

#更新类型
$TransSubscription.SubscriberType=[Microsoft.SqlServer.Replication.TransSubscriberType]::$SubscriberType

当要使用即时更新的时候，我们还需要设置在连接到发布服务器时立即更新订阅的同步触发器所使用的配置和安全信息。这里将应用到类"Microsoft.SqlServer.Replication.ReplicationDatabase"中的方法LinkPublicationForUpdateableSubscription。此方法类似T-SQL中的sp_link_publication系统存储过程。

                #在订阅端，设置连接发行服务器验证
                #在订阅端，确保登录账户“repllinkproxy”對订阅数据库具有db_onwer權限

                $ReplicationDatabase =New-object "Microsoft.SqlServer.Replication.ReplicationDatabase" $DataBase,$SubServerConnection
                If($ReplicationDatabase.LoadProperties())
                {
                    $Publisher=$serverInstance
                    $PublisherDB =$TransSubscription.SubscriptionDBName
                    $Publication=$TransPublication.Name
                    $Distributo=$null
                    $PublisherConnectionSecurityContext=New-object "Microsoft.SqlServer.Replication.PublisherConnectionSecurityContext"

                     <#--SqlStandard模式--#>
                     #<#
                    $PublisherConnectionSecurityContext.SecurityMode=[Microsoft.SqlServer.Replication.ReplicationSecurityMode]::SqlStandard
                    $PublisherConnectionSecurityContext.SqlStandardLogin=$userName
                    $PublisherConnectionSecurityContext.SqlStandardPassword=$password
                    ##>

                    <#--PredefinedServer模式--#> #需要创建一个固定的链接服务器，名字与$serverInstance相同
                    #$PublisherConnectionSecurityContext.SecurityMode=[Microsoft.SqlServer.Replication.ReplicationSecurityMode]::PredefinedServer


                    $ReplicationDatabase.LinkPublicationForUpdateableSubscription($Publisher,$PublisherDB,$Publication,$Distributo,$PublisherConnectionSecurityContext )
                }

注，在上面的即时更新脚本中，我们要确保发布服务器与订阅服务器的MSTDC要启动，要是存在防火墙需要开启135端口。

我们要注意”<#--SqlStandard模式—#>” 和“ <#--PredefinedServer模式--#>”两部分。使用”<#--SqlStandard模式—#>” 会指定动态远程过程调用 (RPC)。“ <#--PredefinedServer模式--#>”需要固定的链接服务器。是于这两者具体的差异，可能要另写一篇来详细描述，比较有意思的。

订阅的完整PowerShell脚本，我们可以参考：

Replication-5-Create a Publication(AllowQueuedTransactions).ps1

<#===========================创建推送订阅===========================#>

##分发代理程序执行账户
#------------------------------------------------------------
$serverInstance="WINSERVER01\SQL2008DE01"
$userName="sa"
$password="sql20081"

##设置域账号，应用于同步复制
#------------------------------------------------------------
$RAccount="TN\SQLAccount"
$RPassword="Sql123456"

##连接到订阅服务器账户
#------------------------------------------------------------
$SubserverInstance="TON-WINXP001\SQL2008DE"
$SubuserName="sa"
$Subpassword="WinXP00120081"

##发布对象
#------------------------------------------------------------
$DataBase="ReplicationDB"
$TransPublicationName=“ReplicationDB_Tran_”

##是否要初始化
#------------------------------------------------------------
$invalidate=$true

##可更新订阅类型
#------------------------------------------------------------
$SubscriberType=“ImmediateUpdate”

<#
ReadOnly        : 该订阅是只读的。在订阅服务器上所做的更改不会发送到发布服务器。

QueuedUpdate    : 启用排队更新的订阅。可以在订阅服务器上进行数据修改，将其存储在队列中，然后传播到发布服务器。Oracle 发布服务器不支持

ImmediateUpdate : 启用对即时更新订阅的支持。Oracle 发布服务器不支持。

QueuedFailover  : 将订阅启用为排队更新订阅，并允许更改为立即更新模式。
                  在订阅服务器和发布服务器之间建立连接之前，可以在订阅服务器上修改数据，并将数据修改存储在队列中。
                  建立起持续连接后，即可将更新模式更改为立即更新。Oracle 发布服务器不支持。

Failover        : 将排队更新作为故障转移的情况下启用用于即时更新的订阅。可以在订阅服务器上进行数据修改并立即传播到发布服务器。
                  如果发布服务器与订阅服务器未连接在一起，则可以更改更新模式以便将在订阅服务器上所做的数据修改存储在队列中，
                  直到订阅服务器与发布服务器重新连接在一起。Oracle 发布服务器不支持。

#>

<#================================================================#>

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Rmo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null

#Step 1: 创建连接
$ServerConnection =New-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password
$SubServerConnection =New-object "Microsoft.SqlServer.Management.Common.ServerConnection" $SubserverInstance,$SubuserName, $Subpassword

#Step 2:

Try
{
    $ServerConnection.Connect()
    $SubServerConnection.Connect()

    if ($ServerConnection.IsOpen -and $SubServerConnection.IsOpen)
    {
        $TransPublication=New-object "Microsoft.SqlServer.Replication.TransPublication" $TransPublicationName,$DataBase,$ServerConnection
        if ($TransPublication.LoadProperties() -eq $true)
        {
            ##设置推送订阅
            if($TransPublication.Attributes -notmatch  "AllowPush")
            {
                ##使用到位運算OR(inclusive) "-bor" ,如果要刪除某一特征就使用"-bxor"
                $TransPublication.Attributes =$TransPublication.Attributes -bor [Microsoft.SqlServer.Replication.PublicationAttributes]::AllowPush
            }

            $subscriptionDBName=$TransPublication.DatabaseName
            $publicationDBName=$TransPublication.DatabaseName
            $publicationName=$TransPublication.Name

            $TransSubscription=New-object "Microsoft.SqlServer.Replication.TransSubscription" $publicationName,$publicationDBName,$SubserverInstance,$subscriptionDBName,$ServerConnection

            if($TransSubscription.LoadProperties() -eq $false)
            {
                ##设置分发代理程序账号(Windows账号)
                $TransSubscription.SynchronizationAgentProcessSecurity.Login=$RAccount
                $TransSubscription.SynchronizationAgentProcessSecurity.Password=$RPassword

                ##设置订阅服务器登录账号(SQL Server账号)
                $TransSubscription.SubscriberSecurity.WindowsAuthentication=$false
                $TransSubscription.SubscriberSecurity.SqlStandardLogin=$SubuserName
                $TransSubscription.SubscriberSecurity.SqlStandardPassword=$Subpassword

                $TransSubscription.CreateSyncAgentByDefault=$true

                #每天执行
                $TransSubscription.AgentSchedule.FrequencyType=[Microsoft.SqlServer.Replication.ScheduleFrequencyType]::Daily

                #分钟
                $TransSubscription.AgentSchedule.FrequencySubDay=[Microsoft.SqlServer.Replication.ScheduleFrequencySubDay]::Minute

                #多少分钟执行一次
                $TransSubscription.AgentSchedule.FrequencySubDayInterval=1

                ##是否初始化
                if($invalidate -eq $false)
                {
                    $TransSubscription.SyncType=[Microsoft.SqlServer.Replication.SubscriptionSyncType]::ReplicationSupportOnly
                }

                #更新类型
                $TransSubscription.SubscriberType=[Microsoft.SqlServer.Replication.TransSubscriberType]::$SubscriberType

                #在订阅端，设置连接发行服务器验证
                #在订阅端，确保登录账户“repllinkproxy”對订阅数据库具有db_onwer權限

                $ReplicationDatabase =New-object "Microsoft.SqlServer.Replication.ReplicationDatabase" $DataBase,$SubServerConnection
                If($ReplicationDatabase.LoadProperties())
                {
                    $Publisher=$serverInstance
                    $PublisherDB =$TransSubscription.SubscriptionDBName
                    $Publication=$TransPublication.Name
                    $Distributo=$null
                    $PublisherConnectionSecurityContext=New-object "Microsoft.SqlServer.Replication.PublisherConnectionSecurityContext"

                     <#--SqlStandard模式--#>
                     #<#
                    $PublisherConnectionSecurityContext.SecurityMode=[Microsoft.SqlServer.Replication.ReplicationSecurityMode]::SqlStandard
                    $PublisherConnectionSecurityContext.SqlStandardLogin=$userName
                    $PublisherConnectionSecurityContext.SqlStandardPassword=$password
                    ##>

                    <#--PredefinedServer模式--#> #需要创建一个固定的链接服务器，名字与$serverInstance相同
                    #$PublisherConnectionSecurityContext.SecurityMode=[Microsoft.SqlServer.Replication.ReplicationSecurityMode]::PredefinedServer


                    $ReplicationDatabase.LinkPublicationForUpdateableSubscription($Publisher,$PublisherDB,$Publication,$Distributo,$PublisherConnectionSecurityContext )
                }

                $TransSubscription.Create()


                 #启动快照代理作业
                if ($TransPublication.SnapshotAvailable -eq $false )
                {
                    $TransPublication.StartSnapshotGenerationAgentJob()
                }


                Write-Host "订阅 "$TransSubscription.Name" 创建完成!"
            }
            Else
            {
                Write-Host "订阅 "$TransSubscription.Name" 已创建!"
            }

        }
        Else
        {
            Write-Host "发布对象 $TransPublicationName  不存在！"
        }
    }
}
Catch
{

    Write-Error $_
}

小结

本篇描述了PowerShell应用之-可更新订阅的事务复制，在我们测试过程中可能会发现一些问题，特别是即时更新类型的订阅，注意上面提到的注意内容。因时间问题，订阅部分只测试了Push订阅.如果你在测试过程还有其他不明白的地方，可以在文章的后面留言或直接发Email到我的邮箱。

本文链接

PowerShell应用之-事务复制

2011-11-22T15:39:00Z

概述

在之前的几篇描述了PowerShell在SQL Server对SMO（SQL Server Management Objects）的管理，现在开始描述在SQL Server Replication中如何使用PowerShell脚本实现同步复制功能。在本篇中讲述的是实现同步复制中的事务复制，涉及如何创建Publishing,Distribution, Publication, Subscription等。这里将让我们了解到RMO(Replication Management Objects)一些类的使用：

Microsoft.SqlServer.Replication.ReplicationServer
Microsoft.SqlServer.Replication.DistributionDatabase
Microsoft.SqlServer.Replication.DistributionPublisher
Microsoft.SqlServer.Replication.ReplicationDatabase
Microsoft.SqlServer.Replication.TransPublication
Microsoft.SqlServer.Replication.TransArticle
Microsoft.SqlServer.Replication.TransSubscription

如何配置发布和分发(Publishing & Distribution)

在具有域管理的环境中，配置Publishing & Distribution之前，我们先要准备好一些工作：

准备一个域账号，专门应用于同步复制使用
创建快照文件夹，设成共享，并设置该域账户具有修改快照文件夹的权限。

如何创建事务发布和设置发布项目(TransPublication & TransArticle)

<#===========================创建事务发布&发布项目===========================#>

##配置发布、分发服务器者登录用户名&密码，这里发布与分发使用同一个实例
#------------------------------------------------------------
$serverInstance="WINSERVER01\SQL2008DE01"
$userName="sa"
$password="sql20081"

##设置域账号，应用于同步复制
#------------------------------------------------------------
$RAccount="TN\SQLAccount"
$RPassword="Sql123456"

##发布数据库
#------------------------------------------------------------
$DataBase="ReplicationDB"

##项目名称
#------------------------------------------------------------
$TransPublicationName=$DataBase+“_Tran_”

##项目对应的是表，使用"Select * Form TableName Where ...;"格式
#------------------------------------------------------------
$SQL="
Select * From DataOwner Where ID=2;
Select * From Data1 Where OwnerID=2;
Select * From Data2 Where ParentID In(Select ID From dbo.Data1 Where OwnerID=2);
Select * From DataRelation Where ParentID In(Select dbo.Data2.ID From dbo.Data1 Inner Join dbo.Data2 On dbo.Data1.ID = dbo.Data2.ParentID And dbo.Data1.OwnerID=2);
"

##发行项目选项
#------------------------------------------------------------
$PreCreationMethod="drop" #当名称已被使用时的操作.可以选择“none”，“delete”，“drop”,"truncate"

<#================================================================#>

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Rmo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null

#Step 1: 创建连接
$ServerConnection =New-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password

#Step 2:

Try
{
    $ServerConnection.Connect()
    if ($ServerConnection.IsOpen)
    {
        $ReplicationDatabase =New-object "Microsoft.SqlServer.Replication.ReplicationDatabase" $DataBase,$ServerConnection
        $ReplicationDatabase.EnabledTransPublishing=$true

        #创建队列读取器代理
        if ($ReplicationDatabase.LogReaderAgentExists -eq $false)
        {
            $ReplicationDatabase.LogReaderAgentProcessSecurity.Login=$RAccount
            $ReplicationDatabase.LogReaderAgentProcessSecurity.Password=$RPassword
            $ReplicationDatabase.LogReaderAgentPublisherSecurity.WindowsAuthentication=$true

            $ReplicationDatabase.LogReaderAgentPublisherSecurity.SqlStandardLogin=$userName
            $ReplicationDatabase.LogReaderAgentPublisherSecurity.SqlStandardPassword=$password
            $ReplicationDatabase.LogReaderAgentPublisherSecurity.WindowsAuthentication=$false
            $ReplicationDatabase.CreateLogReaderAgent()
        }

        #创建事务发布
        $TransPublication=New-object "Microsoft.SqlServer.Replication.TransPublication" $TransPublicationName,$DataBase,$ServerConnection

        $TransPublication.SnapshotGenerationAgentProcessSecurity.Login=$RAccount
        $TransPublication.SnapshotGenerationAgentProcessSecurity.Password=$RPassword
        $TransPublication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication=$true

        $TransPublication.SnapshotGenerationAgentPublisherSecurity.SqlStandardLogin=$userName
        $TransPublication.SnapshotGenerationAgentPublisherSecurity.SqlStandardPassword=$password
        $TransPublication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication=$false
        if ($TransPublication.IsExistingObject -eq $false)
        {
            $TransPublication.Create()
        }


        #定义发布项目

        While($SQL.IndexOf(“`r”) -gt 0)   #处理Select列表
            {$SQL=$SQL.Replace("`r","")}

        While($SQL.IndexOf(“`n”) -gt 0)
            {$SQL=$SQL.Replace("`n","")}

        While($SQL.IndexOf(“`t”) -gt 0)
            {$SQL=$SQL.Replace("`t "," ")}

        While($SQL.IndexOf("  ") -gt 0)
            {$SQL=$SQL.Replace("  "," ")}
        $SQL=$SQL.ToLower()

        Foreach ($SqlLine In $SQL.split(";"))
        {
            if ($SqlLine.IndexOf("from") -gt 0)
            {
                $Where=""
                $TB=$SqlLine.split(" ")[3]
                If ($SqlLine.LastIndexOf("where") -gt 0)
                {
                    $Where=$SqlLine.substring([int32]($SqlLine.IndexOf("where")+6))
                }
                $Article=New-object "Microsoft.SqlServer.Replication.TransArticle" $TB,$TransPublicationName,$DataBase,$ServerConnection
                $Article.SourceObjectName=$TB
                $article.FilterClause=$Where
                $article.PreCreationMethod=$PreCreationMethod
                if ($Article.IsExistingObject -eq $false)
                {
                    $Article.Create()
                }
            }
        }

        Write-Host "事务发布 '$TransPublicationName' 已创建!"
    }
}
Catch
{

    Write-Error $_
}

如何创建推送订阅(Push Subscription)

如何创建请求订阅(Pull Subscription)

<#===========================创建请求订阅===========================#>

##分发代理程序执行账户
#------------------------------------------------------------
$serverInstance="WINSERVER01\SQL2008DE01"
$userName="sa"
$password="sql20081"

##设置域账号，应用于同步复制
#------------------------------------------------------------
$RAccount="TN\SQLAccount"
$RPassword="Sql123456"

##连接到订阅服务器账户
#------------------------------------------------------------
$SubserverInstance="TON-WINXP001\SQL2008DE"
$SubuserName="sa"
$Subpassword="WinXP00120081"

##发布对象
#------------------------------------------------------------
$DataBase="ReplicationDB"
$TransPublicationName=“ReplicationDB_Tran_”

##是否要初始化
#------------------------------------------------------------
$invalidate=$true

<#================================================================#>

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Rmo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null

#Step 1: 创建连接
$ServerConnection =New-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password
$SubServerConnection =New-object "Microsoft.SqlServer.Management.Common.ServerConnection" $SubserverInstance,$SubuserName, $Subpassword

#Step 2:

Try
{
    $ServerConnection.Connect()
    $SubServerConnection.Connect()

    if ($ServerConnection.IsOpen -And $SubServerConnection.IsOpen)
    {
        $TransPublication=New-object "Microsoft.SqlServer.Replication.TransPublication" $TransPublicationName,$DataBase,$ServerConnection
        if ($TransPublication.LoadProperties() -eq $true)
        {
            ##设置请求订阅
            if($TransPublication.Attributes -notmatch  "AllowPull")
            {
                ##使用到位运算符OR(inclusive) "-bor" ,如果要刪除某一特征就使用"-bxor"
                $TransPublication.Attributes =$TransPublication.Attributes -bor [Microsoft.SqlServer.Replication.PublicationAttributes]::AllowPull
            }

            $subscriptionDBName=$TransPublication.DatabaseName
            $publisherName=$serverInstance
            $publicationDBName=$TransPublication.DatabaseName
            $publicationName=$TransPublication.Name

            $TransSubscription=New-object "Microsoft.SqlServer.Replication.TransPullSubscription" $subscriptionDBName,$publisherName,$publicationDBName,$publicationName,$SubServerConnection

            if($TransSubscription.LoadProperties() -eq $false)
            {
                ##设置分发代理程序账号(Windows帳戶)
                $TransSubscription.SynchronizationAgentProcessSecurity.Login=$RAccount
                $TransSubscription.SynchronizationAgentProcessSecurity.Password=$RPassword

                ##设置分发服务器登录账号(SQL Server帳戶)
                $TransSubscription.DistributorSecurity.WindowsAuthentication=$false
                $TransSubscription.DistributorSecurity.SqlStandardLogin=$userName
                $TransSubscription.DistributorSecurity.SqlStandardPassword=$password

                $TransSubscription.CreateSyncAgentByDefault=$true

                #每天执行
                $TransSubscription.AgentSchedule.FrequencyType=[Microsoft.SqlServer.Replication.ScheduleFrequencyType]::Daily

                #分钟
                $TransSubscription.AgentSchedule.FrequencySubDay=[Microsoft.SqlServer.Replication.ScheduleFrequencySubDay]::Minute

                #多少分钟执行一次
                $TransSubscription.AgentSchedule.FrequencySubDayInterval=1

                $TransSubscription.Create()

                #是否初始化
                if($invalidate -eq $false)
                {
                    $SyncType=[Microsoft.SqlServer.Replication.SubscriptionSyncType]::ReplicationSupportOnly
                }
                Else
                {
                    $SyncType=[Microsoft.SqlServer.Replication.SubscriptionSyncType]::Automatic
                }

                #设置订阅服务器是否只读
                $subscriberType=[Microsoft.SqlServer.Replication.TransSubscriberType]::ReadOnly

                #在发布服务器上注册订阅服务器
                $TransPublication.MakePullSubscriptionWellKnown($SubserverInstance,$subscriptionDBName,$SyncType,$subscriberType)

                 #启动快照代理作业
                if ($TransPublication.SnapshotAvailable -eq $false )
                {
                    $TransPublication.StartSnapshotGenerationAgentJob()
                }


                Write-Host "订阅 "$TransSubscription.Name" 创建完成!"
            }
            Else
            {
                Write-Host "订阅 "$TransSubscription.Name" 已创建!"
            }

        }
        Else
        {
            Write-Host "发布对象 $TransPublicationName  不存在！"
        }
    }
}
Catch
{

    Write-Error $_
}

设置请求订阅的时候，需要设置域账户“TN\SQLAccount”对订阅数据库具有db_Owner成员权限，否则无法初始化。

小结

在同步复制使用PowerShell脚本创建，能为我们带来方便，特别是一次配置多个同步复制的时候。是于查看和检查同步复制，我们可以结合SSMS和复制监视器来完成。

本文链接

PowerShell应用之-批量还原数据库(支持完整，差异，事务日志)

2011-11-09T14:24:00Z

开始

直接切入主题，今天我们继续来描述PowerShell的一个应用，实现批量还原SQL Server数据库,可以支持SQL Server 2005\2008数据库。在本章中，我们将涉及到几个要点：

Microsoft.SqlServer.Management.Smo.Restore类
System.Data.DataTable类
PowerShell中的函数(Function)
PowerShell命令Get-Unique

Microsoft.SqlServer.Management.Smo.Restore类

在PowerShell要实现还原SQL Server数据库，我们需要应用到Microsoft.SqlServer.Management.Smo.Restore类。它为我们提供了丰富的还原数据库过程需要的各种属性和方法。首先，提供一份数据库备份文件，我们要还原它，我们需要知道备份文件的标头信息(backup header information),和备份文件里组成(数据文件&日志文件)(the database and log files contained in the backup set)

要是在SQL Server Management Studio(SSMS)里，直接可以调用Transact-SQL:

use master
go
Restore Headeronly From Disk='E:\DBBackup\myDB2008_20111107_01.trn'
Restore filelistonly From Disk='E:\DBBackup\myDB2008_20111107_01.trn'

在执行结果的第一个记录集中，我们可以找到对当前还原有用的信息，如DatabaseName,DackupType,Position,BackupStartDate。

第二个记录集，可以找出数据库myDB2008由两个数据文件”myDB2008” & “myDB20082”和一个日志文件”myDB2008_log”组成。还描述有各文件的物理存储位置，文件类型，文件ID等信息。

要是我们想在PowerShell中通过Restore类获得类似信息，需要通过Restore类提供的两个方法ReadBackupHeader 和 ReadFileList .这两个方法都是会返回一个DataTable对象。存在着备份文件的标头信息和文件组成信息。

e.g.

$serverInstance="WINSERVER01\SQL2008DE01" 
$userName="sa"
$password="sql20081"

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SmoExtended") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("System.Data") | Out-Null

$ServerConnection =new-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password  
$Server=new-object "Microsoft.SqlServer.Management.Smo.Server" $ServerConnection
$Restore=new-object "Microsoft.SqlServer.Management.Smo.Restore"  

$Restore.Devices.AddDevice("E:\DBBackup\myDB2008_20111107_01.trn", [Microsoft.SqlServer.Management.Smo.DeviceType]::File)

$Read=$Restore.ReadBackupHeader($Server)
$FileRead=$Restore.ReadFileList($Server)

$Read  | Format-Table -AutoSize -Wrap -Property DatabaseName,BackupType,BackupStartDate,Position
$FileRead | Format-Table -AutoSize -Wrap -Property LogicalName,PhysicalName,Type,FileId

我们在代码中看到有一行：”$Restore.Devices.AddDevice("E:\DBBackup\myDB2008_20111107_01.trn", [Microsoft.SqlServer.Management.Smo.DeviceType]::File)”描述添加备份文件到当前的还原对象$Restore中，这样我们才可以使用方法ReadBackupHeader 和 ReadFileList读取对应的信息。如果一个文件里面含有多个备份，当我们只需要读取某一个备份文件的标头信息、文件组成信息，就要先设置$Restore的属性FileNumber。系统预设属性FileNumber为0，方法ReadBackupHeader会读取所有文件，方法ReadFileList会默认读取第1个备份的文件组成内容。

e.g.

基本了解方法Restore类中的方法ReadBackupHeader 和 ReadFileList，我们接下来的就要实现如何还原数据库，在Restore类提供有一个还原数据库的方法SqlRestore。

e.g.

$serverInstance="WINSERVER01\SQL2008DE01" 
$userName="sa"
$password="sql20081"

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SmoExtended") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("System.Data") | Out-Null

$ServerConnection =new-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password  
$Server=new-object "Microsoft.SqlServer.Management.Smo.Server" $ServerConnection
$Restore=new-object "Microsoft.SqlServer.Management.Smo.Restore"  

$Restore.Devices.AddDevice("E:\DBBackup\test.bak", [Microsoft.SqlServer.Management.Smo.DeviceType]::File)

$Restore.Database="test"
$Restore.FileNumber=1
$Restore.ReplaceDatabase=$true
$Restore.Script($Server)
$Restore.SqlRestore($Server)

调用方法SqlRestore的时候，我们需要先设置对象$Restore的一些属性，如，

$Restore.Database="test" #数据库名
$Restore.FileNumber=1 #备份文件编号，当一个备份文件包含多个备份的时候，需要设置哪一个文件编号，不然系统会默认还原文件编号为1的备份。
$Restore.ReplaceDatabase=$true #是否覆盖现有数据库

代码$Restore.Script($Server)，只是显示出还原的Transact-SQL语句。当然还有其他的属性，如

$Restore.Action 描述还原的是数据库还是日志，默认是数据库.

$Restore.KeepReplication 描述是否保留复制设置。默认保留。

$Restore.NoRecovery 描述指定不发生回滚。从而使前滚按顺序在下一条语句中继续进行。如，当还原(完整+差异) 或还原(完整+事务日志)，需要设置。

有些时候我们还原数据库，碰到一些应用程序正在使用要还原的数据库。那么我们需要先终止对应的进程，不然还原会报错。在Restore类没有提供终止进程的方法，需要借助Server类的方法KillAllProcesses来删除某一数据库的所有进程。

e.g.

$Server.KillAllProcesses($Restore.Database)

System.Data.DataTable类

在前面我們說到Restore类的方法ReadBackupHeader 和 ReadFileList能返回一個DataTable对象，我们在后面的例子中会使用到DataTable对象，来存储备份的标头信息和文件组成信息。

e.g.


[System.Reflection.Assembly]::LoadWithPartialName("System.Data") | Out-Null

$ReadBackupHeader=New-Object "System.Data.DataTable"
$ReadBackupHeader.Columns.Add("DatabaseName","String") |Out-Null
$ReadBackupHeader.Columns.Add("BackupType","Int16") |Out-Null
$ReadBackupHeader.Columns.Add("BackupStartDate","DateTime") |Out-Null
$ReadBackupHeader.Columns.Add("BakFile","String") |Out-Null
$ReadBackupHeader.Columns.Add("NoRecovery","Boolean") |Out-Null
$ReadBackupHeader.Columns.Add("Position","Int16") |Out-Null


$ReadFileList=New-Object "System.Data.DataTable"
$ReadFileList.Columns.Add("DatabaseName","String") |Out-Null
$ReadFileList.Columns.Add("LogicalName","String") |Out-Null
$ReadFileList.Columns.Add("PhysicalName","String") |Out-Null
$ReadFileList.Columns.Add("Type","String") |Out-Null
$ReadFileList.Columns.Add("FileId","Int16") |Out-Null
$ReadFileList.Columns.Add("BakFile","String") |Out-Null
$ReadFileList.Columns.Add("FileNumber","Int16") |Out-Null

定义$ReadBackupHeaderd对象來存储Restore类的方法ReadBackupHeader返回的结果集。定义$ReadFileList对象來存储Restore类的方法ReadFileList返回的结果集。后面的实际例子我们还将应用到增加和删除行的方法.

#增加行
$newRow=$ReadBackupHeader.NewRow()
$newRow["DatabaseName"]="myDB"
$newRow["BackupType"]=2
$newRow["BackupStartDate"]="2011-11-8"
$newRow["BakFile"]=""
$newRow["NoRecovery"]=$true
$newRow["Position"]=1
$ReadBackupHeader.Rows.Add($newRow)
$ReadBackupHeader.AcceptChanges()

#显示行
$ReadBackupHeader | Format-Table -AutoSize -Wrap

#刪除行
$ReadBackupHeader.Rows[0].Delete()
$ReadBackupHeader.AcceptChanges()

#显示行
$ReadBackupHeader | Format-Table -AutoSize -Wrap

代码中有两行“$ReadBackupHeader.AcceptChanges()”描述结束编辑状态。

提示，引用MSDN对AcceptChanges方法的描述：在调用 AcceptChanges 时，EndEdit 方法被隐式调用，以便终止任何编辑。如果行的 RowState 原来是“Added”或“Modified”，则 RowState 将变成“Unchanged”。如果 RowState 是“删除”，则该行将被移除。

PowerShell中的函数(Function)

在本章中將應用到PowerShell中的Function。这里将应用到两种用法：

function <名称> {

begin {<处理语句列表>}

process {<处理语句列表>}

end {<处理语句列表>}

}

e.g.

$DBList="DBA,DBB,DBC"

Function CheckDB
{
    Param([String]$DBvar)
    
    Begin 
    {
        [Boolean]$CheckResult=$false
    }
    Process
    {
        If($DBList -eq "")
        {
            $CheckResult=$true
        }
        Else
        {
            Foreach($x In $DBList.Split(","))
            {
                If($x -eq $DBvar)
                {
                    $CheckResult=$true
                    Break
                }
            }
        }
    }
    End
    {
        Return $CheckResult
    }
}

CheckDB 'A'

函数checkDB，主要是检查输入的$DBvar 是否在清单$DBList中。存在的时候返回True，不存在的時候返回False,有一種特殊的需求就是當$DBList為””的時候。后面的实际例子将会应用到这个函数。

函数的另外一种简单应用就是，不含Begin{},Process{},End{}部份，如

function <name> {

param ([type]$parameter1[,[type]$parameter2])

}

Function fn_UpdateRow
{
    Param([string]$DatabaseName,[int32]$row)
    $ReadBackupHeader.Rows[$row]["DatabaseName"]=$DatabaseName
    $ReadBackupHeader.AcceptChanges()
}
$ReadBackupHeader | Format-Table -AutoSize -Wrap

fn_UpdateRow -DatabaseName "Test" -row 0 
$ReadBackupHeader | Format-Table -AutoSize -Wrap

这里定义一函数fn_UpdateRow实现更新DataTable对象$ReadBackupHeader中的”DatabaseName”值。这里函数只作为处理过程，不返回任何值。

PowerShell命令Get-Unique

前面，我们使用DataTable对象$ReadBackupHeader暂存备份的标头信息，当我们要还原一个目录下面的所有备份文件，会把各个数据库备份的标头信息，暂存至$ReadBackupHeader中，再遍历各个数据库进行还原。这里遍历数据库过程我们将应用到命令Get-Unique，过滤掉重复的数据库名称。

e.g.

#遍历数据库    
        Foreach( $db In $(Foreach($Row In $ReadBackupHeader.rows){$Row["DatabaseName"]}) | Sort-Object | Get-Unique )
        {
               #还原数据库过程
         }

其中“$(Foreach($Row In $ReadBackupHeader.rows){$Row["DatabaseName"]})”返回的是一个Array对象。

实际例子

<#===========================================#>
##还原数据库

$serverInstance="WINSERVER01\SQL2008DE01"
$userName="sa"
$password="sql20081"

$Path="E:\DBBackup\"

$DBList=""
$RestorePath="E:\DATA\SQL2008DE01\"
$StopAt="2011-11-8 18:28:00" #还原到至时间点 [DateTime]

<#===========================================#>

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SmoExtended") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("System.Data") | Out-Null

$ServerConnection =new-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password

$ReadBackupHeader=New-Object "System.Data.DataTable"
$ReadBackupHeader.Columns.Add("DatabaseName","String") |Out-Null
$ReadBackupHeader.Columns.Add("BackupType","Int16") |Out-Null
$ReadBackupHeader.Columns.Add("BackupStartDate","DateTime") |Out-Null
$ReadBackupHeader.Columns.Add("BakFile","String") |Out-Null
$ReadBackupHeader.Columns.Add("NoRecovery","Boolean") |Out-Null
$ReadBackupHeader.Columns.Add("Position","Int16") |Out-Null

$ReadFileList=New-Object "System.Data.DataTable"
$ReadFileList.Columns.Add("DatabaseName","String") |Out-Null
$ReadFileList.Columns.Add("LogicalName","String") |Out-Null
$ReadFileList.Columns.Add("PhysicalName","String") |Out-Null
$ReadFileList.Columns.Add("Type","String") |Out-Null
$ReadFileList.Columns.Add("FileId","Int16") |Out-Null
$ReadFileList.Columns.Add("BakFile","String") |Out-Null
$ReadFileList.Columns.Add("FileNumber","Int16") |Out-Null

#--------------------------------------
#检查备份数据库清单
#--------------------------------------
Function CheckDB
{
    Param([String]$DBvar)

    Begin
    {
        [Boolean]$CheckResult=$false
    }
    Process
    {
        If($DBList -eq "")
        {
            $CheckResult=$true
        }
        Else
        {
            Foreach($x In $DBList.Split(","))
            {
                If($x -eq $DBvar)
                {
                    $CheckResult=$true
                    Break
                }
            }
        }
    }
    End
    {
        Return $CheckResult
    }
}

#--------------------------------------
#还原数据库函数
#--------------------------------------
Function RestoreDB
{

    begin
    {
        [Boolean]$ExecResult=$False
    }
    Process
    {

        $rowsBackupHeader=$ReadBackupHeader.Select("DatabaseName='"+$db+"'","BackupStartDate Asc")
        If ($rowsBackupHeader)
        {
            Foreach($rowBackupHeader In $rowsBackupHeader)
            {

                $File=$rowBackupHeader["BakFile"]
                $BackupType=$rowBackupHeader["BackupType"]
                $rowsFileList=$ReadFileList.Select("BakFile='"+$File+"' And FileNumber="+$rowBackupHeader["Position"])


                $Restore.Devices.Clear()
                $Restore.RelocateFiles.Clear()

                $Restore.Database=$db
                $Restore.Devices.AddDevice($File, [Microsoft.SqlServer.Management.Smo.DeviceType]::File)
                $Restore.ReplaceDatabase=$true
                $Restore.KeepReplication=$False #不保留同步设置
                $Restore.NoRecovery=$rowBackupHeader["NoRecovery"]
                $Restore.FileNumber=$rowBackupHeader["Position"]

                If ($BackupType -eq 2 ) #事务日志
                {
                    $Restore.Action="Log"
                    $Restore.ToPointInTime=$(if($StopAt -gt $rowBackupHeader["BackupStartDate"]){$null} Else {$StopAt})
                }
                Else
                {
                    $Restore.Action="Database"
                    $Restore.ToPointInTime=$null
                }


                foreach($rowFileList In $rowsFileList)
                {
                    $logicalFileName=$rowFileList["LogicalName"]
                    If ($rowFileList.Type -eq "D")
                    {
                        $physicalFileName=$RestorePath+$logicalFileName+".mdf"
                    }
                    ElseIf ($rowFileList.Type -eq "L")
                    {
                        $physicalFileName=$RestorePath+$logicalFileName+".ldf"
                    }
                    $Restore.RelocateFiles.Add((New-Object "Microsoft.SqlServer.Management.Smo.RelocateFile" $logicalFileName,$physicalFileName)) |Out-Null

                }

                #清除正在当前数据库的进程
                $Server.KillAllProcesses($db)

                #执行还原动作
                $Restore.SqlRestore($Server)
                $Restore.Wait()
                Write-Host "已还原数据库. DataBase:" $DB "`t`.FileNumber=" $Restore.FileNumber "`tBakFile: " $File
                $ExecResult=$True
            }

         }
         Else
         {
            Write-Warning  "在数据库 $DB .没有可还原的备份文件。"
         }

    }
    End
    {
        Return $ExecResult
    }
}

#--------------------------------------
#过滤备份文件
#--------------------------------------
Function FilterDB
{
        #完整
        $tmpRows1=$ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=1 And BackupStartDate<='"+$StopAt+"'","BackupStartDate Desc")
        [DateTime]$tmpDate="1900-01-01"

        if ($tmpRows1)
        {
            $tmpRow=$tmpRows1[0]
            $tmpDate=$tmpRow["BackupStartDate"]
            Foreach($row In $ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=1 And BakFile<>'"+$tmpRow["BakFile"]+"'"))
            {
                $row.Delete()
            }
        }
        Else
        {
            Foreach($row In $ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=1"))
            {
                $row.Delete()
            }
        }



        #差异
        $tmpRows5=$ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=5 And BackupStartDate<='"+$StopAt+"' And BackupStartDate>'"+$tmpDate+"' ","BackupStartDate Desc")
        if ($tmpRows1 -and $tmpRows5)
        {
            $tmpRow=$tmpRows5[0]
            Foreach($row In $ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=5 And BakFile<>'"+$tmpRow["BakFile"]+"'"))
            {
                $row.Delete()
            }
        }
        Else
        {
            Foreach($row In $ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=5"))
            {
                $row.Delete()
            }
        }



        #事务日志
        $tmpRows2=$ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=2 And BackupStartDate>='"+$StopAt+"'","BackupStartDate Asc")
        if ($tmpRows1 -and $tmpRows2)
        {

            $tmpRow=$tmpRows2[0]
            Foreach($row In $ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=2 And BackupStartDate>='"+$StopAt+"' And BakFile<>'"+$tmpRow["BakFile"]+"'"))
            {
                $row.Delete()
            }
        }ElseIf($tmpRows1)
        {

            Foreach($row In $ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=2 And BackupStartDate<='"+$tmpDate+"'"))
            {
                $row.Delete()
                #$ReadBackupHeader | Format-Table -AutoSize -Wrap
            }
        }
        Else
        {
            Foreach($row In $ReadBackupHeader.Select("DatabaseName='"+$db+"' And BackupType=2"))
            {
                $row.Delete()
            }
        }

        #结束对DataTable的编辑
        $ReadBackupHeader.AcceptChanges()

        #设置NoRecovery
        $tmpRows=$ReadBackupHeader.Select("DatabaseName='"+$db+"'","BackupStartDate Desc")
        If($tmpRows)
        {$tmpRows[0]["NoRecovery"]=$false}


}

#--------------------------------------
Try
{
    $ServerConnection.Connect()
}
Catch
{
    Write-Error $_
}

if($ServerConnection.IsOpen)
{

    Try
    {
        $Server=new-object "Microsoft.SqlServer.Management.Smo.Server" $ServerConnection
        $Restore=new-object "Microsoft.SqlServer.Management.Smo.Restore"

        $StopAt=$(If($StopAt -eq ""){"3000-12-31"}Else{[DateTime]$StopAt})

        $Path=$Path+$(If($($Path.Split("\"))[-1] -eq "" ){""} Else {"\"})

        $RestorePath=$(If($RestorePath -eq ""){$Server.Settings.DefaultFile}Else{$RestorePath}) #数据库文件默认路径(数据&日志文件同一路径)
        $RestorePath=$RestorePath+$(If($($RestorePath.Split("\"))[-1] -eq "" ){""} Else {"\"})

        Foreach($Bak In Get-ChildItem -Path $Path | Where-Object -FilterScript {$_.Mode -eq "-a---"}) #遍历备份文件夹
        {
            $File=$Path+$Bak.Name
            $Restore.Devices.Clear()
            $Restore.Devices.AddDevice($File, [Microsoft.SqlServer.Management.Smo.DeviceType]::File)
            $Restore.FileNumber=0
            $Read=$Restore.ReadBackupHeader($Server)
            Foreach ($row In $Read)
            {
                $newRow =$ReadBackupHeader.NewRow();
                $newRow["DatabaseName"]=$row["DatabaseName"]
                $newRow["BackupType"]=$row["BackupType"]
                $newRow["BackupStartDate"]=$row["BackupStartDate"]
                $newRow["BakFile"]=$File
                $newRow["NoRecovery"]=$true
                $newRow["Position"]=$row["Position"]
                $ReadBackupHeader.Rows.Add($newRow)

                $DBName=$row["DatabaseName"]
                $Restore.FileNumber=$row["Position"]
                $FileRead=$Restore.ReadFileList($Server)
                Foreach ($Filerow In $FileRead)
                {
                    $FileNewRow =$ReadFileList.NewRow();
                    $FileNewRow["DatabaseName"]=$DBName
                    $FileNewRow["LogicalName"]=$Filerow["LogicalName"]
                    $FileNewRow["PhysicalName"]=$Filerow["PhysicalName"]
                    $FileNewRow["Type"]=$Filerow["Type"]
                    $FileNewRow["FileId"]=$Filerow["FileId"]
                    $FileNewRow["BakFile"]=$File
                    $FileNewRow["FileNumber"]=$Restore.FileNumber
                    $ReadFileList.Rows.Add($FileNewRow)
                }
            }

        }

        #结束对DataTable的编辑
        $ReadBackupHeader.AcceptChanges()
        $ReadFileList.AcceptChanges()


        #遍历数据库
        Foreach( $db In $(Foreach($Row In $ReadBackupHeader.rows){$Row["DatabaseName"]}) | Sort-Object | Get-Unique )
        {
            If(CheckDB($db) -eq $true) #检查备份数据库清单
            {
                #过滤备份
                FilterDB

                #还原数据库
               $Result=RestoreDB

            }
        }
    }
    Catch
    {
        Write-Error $_
    }

}

上面脚本能实现的是，在一个目录下存在着各个数据库的完整、差异、事务日志备份文件，可以根据设置“还原至时间点”还原某一个时间点的数据库。支持一个备份文件包含多个备份，支持自定义还原数据库清单。以上的脚本在PowerShell 2.0 + SQL Server2005+WinXP 和PowerShell 2.0 + SQL Server2008 R2+Windows Server 2008 R2 測試通過。

小結

本章我们描述了PowerShell2.0的一个应用，批量还原数据库，支持完整、差异、事务日志备份文件，并对其中的一些知识要点提取出来说明，让我们对PowerShell 2.0 有进一步的了解。在真实中，一些时候，特别是要在数据库后台批量处理一些任务，我们发觉PowerShell能为我们带来许多的方便。当然了，这里只是取1个批量的还原的例子，在实际的应用中，我们也许会碰到比当前例子更为复杂的情况，如页面还原、段落还原、联机还原等。可根据特定的场景，修改或编写更为复杂的脚本。

本文链接

PowerShell应用之-生成创建表的Transact-SQL脚本

2011-11-03T16:54:00Z

开始

在上一篇《PowerShell应用之-(SMO) 类库》，我们对SMO类库的应用有了基本的了解，在这里我们将继续对SMO类库进一步了解。在这篇，涉及这几个内容：

表对象(Table)
脚本选项(ScriptingOptions)
Sort-Object命令
Get-Date命令
Out-File命令

下面我们着重描述表对象和脚本选项两个部分，其他部分写在后面的完整代码中。

表对象(Table)

要生成创建表的Transact-SQL脚本，先要找到着手点。在SMO类库中，Microsoft.SqlServer.Management.Smo.Table类中有两个方法,Script()和Script(ScriptingOptions)能为我们提供创建表的Transact-SQL脚本。如果我们要生成一个实例下的一个数据库里面所有表的脚本，我们要借助Microsoft.SqlServer.Management.Smo.Server类下的Databases属性，在Databases属性包含有数据库对象集合。我们接着可以在Databases对象集合中找到Tables属性，它包含有对应数据库的表对象(Table)集合.这一过程就是一层一层的往下检索对应的对象，犹如Tree列表，一层一层的往下搜。

e.g.<代码01>

<#===========================================#>
$serverInstance="WINSERVER01\SQL2008DE01" 
$userName="sa"
$password="sql20081"
$DataBase="test"

<#===========================================#>
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null

$ServerConnection =new-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password  

Try
{
    $ServerConnection.Connect()
}
Catch
{
    Write-Error $_
}

if($ServerConnection.IsOpen)
{
    #获得数据库中的用户表
    $Tables=((New-Object "Microsoft.SqlServer.Management.Smo.Server" $ServerConnection).databases[$DataBase]).tables | Where-Object -FilterScript{$_.IsSystemObject -eq $False}
    
}

我们在Windows PowerShell ISE上编写上面<代码01>。“获得数据库中用户表”的那行代码我们已作简化，要是一层一层的应用可以这样写：

$Server=New-Object "Microsoft.SqlServer.Management.Smo.Server" $ServerConnection
    $DataBases=$Server.Databases
    $Tables=$DataBases.tables  | Where-Object -FilterScript{$_.IsSystemObject -eq $False}

在获取数据库中的用户表代码行中，应用到了Where-Object命令把系统创建的表给过滤掉。在Table对象中的属性IsSystemObject就是描述是否是系统表。

脚本选项(ScriptingOptions)

前面我们提到Microsoft.SqlServer.Management.Smo.Table类中有两个方法,Script()和Script(ScriptingOptions)能生成创建表的脚本。Script()方法是最简单的方法，不过生成的脚本中不包含外键，主键等约束，也没有能生成索引。

为了能把脚本生成得更完整，我们这里调用第二种方法Script(ScriptingOptions),通过设置脚本选项(ScriptingOptions)来生成所需要的脚本。

脚本选项，是ScriptingOptions对象，它对应的类是Microsoft.SqlServer.Management.Smo.ScriptingOptions类。ScriptingOptions对象能为我们提供丰富的对象脚本选项.

e.g.

#腳本选项设置
    $ScriptingOptions = New-Object "Microsoft.SqlServer.Management.Smo.ScriptingOptions"

通过命令“$ScriptingOptions | Get-Member”，可以查到到脚本选项包含的属性，也可以直接执行命令”$ScriptingOptions”查看当前的脚本选项，

e.g.

我们还可以通过设置$ScriptingOptions中的各个属性描述生成脚本的内容格式等。

e.g.

$ScriptingOptions.DriAllKeys         = $True
    $ScriptingOptions.DriClustered       = $True
    $ScriptingOptions.DriAllConstraints  = $True     
    $ScriptingOptions.DriDefaults        = $True
    $ScriptingOptions.DriIndexes         = $True
    $ScriptingOptions.DriNonClustered    = $True
    $ScriptingOptions.DriPrimaryKey      = $True
    $ScriptingOptions.DriUniqueKeys      = $True     
    $ScriptingOptions.AnsiFile           = $False
    $ScriptingOptions.ClusteredIndexes   = $True
    $ScriptingOptions.IncludeHeaders     = $False
    $ScriptingOptions.Indexes            = $True
    $ScriptingOptions.SchemaQualify      = $False
    $ScriptingOptions.Triggers           = $True
    $ScriptingOptions.XmlIndexes         = $True
    $ScriptingOptions.ExtendedProperties = $True
    $ScriptingOptions.NoFileGroup        = $True
    $ScriptingOptions.NoCollation        = $True
    $ScriptingOptions.IncludeIfNotExists = $True
    $ScriptingOptions.NoIdentities       = $True

可根据实际需要来设置，这里只是列出部分的内容及设置。

e.g.生成脚本

foreach($t in $Tables)
    {
        $t.Script($ScriptingOptions)
    }

考虑存在外键

上面的生成脚本，执行后直接能在PowerShell控制台显示出来，但我们需要判断外键约束的时候，生成要有先后顺序，要把脚本保存为”.sql”格式文件，而且脚本文件名包含有生成的日期。

为了能对于有外键的表需要注意生成顺序，我们引用了命令Sort-Object把表中的CreateDate和表ID进行排序即可。

e.g.

foreach($t in $Tables  | Sort-Object -Property CreateDate,ID)
    {
        $t.Script($ScriptingOptions)
    }

CreateDate创建日期比较早的排序在前，当创建日期相同，再按表的ID升序排序，这样即可应付存在外键的情况。

完整的代码

<#===========================================#>
##生成创建表的脚本，包含Constraints,Indexes,Triggers


$serverInstance="WINSERVER01\SQL2008DE01" 
$userName="sa"
$password="sql20081"
$DataBase="ReplicationDB"
$SrciptOutputPath="E:\"

<#===========================================#>
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null

$ServerConnection =new-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password  

Try
{
    $ServerConnection.Connect()
}
Catch
{
    Write-Error $_
}

if($ServerConnection.IsOpen)
{    
    #腳本选项设置
    $ScriptingOptions = New-Object "Microsoft.SqlServer.Management.Smo.ScriptingOptions"
    $ScriptingOptions.DriAllKeys         = $True
    $ScriptingOptions.DriClustered       = $True
    $ScriptingOptions.DriAllConstraints  = $True     
    $ScriptingOptions.DriDefaults        = $True
    $ScriptingOptions.DriIndexes         = $True
    $ScriptingOptions.DriNonClustered    = $True
    $ScriptingOptions.DriPrimaryKey      = $True
    $ScriptingOptions.DriUniqueKeys      = $True     
    $ScriptingOptions.AnsiFile           = $False
    $ScriptingOptions.ClusteredIndexes   = $True
    $ScriptingOptions.IncludeHeaders     = $False
    $ScriptingOptions.Indexes            = $True
    $ScriptingOptions.SchemaQualify      = $False
    $ScriptingOptions.Triggers           = $True
    $ScriptingOptions.XmlIndexes         = $True
    $ScriptingOptions.ExtendedProperties = $True
    $ScriptingOptions.NoFileGroup        = $True
    $ScriptingOptions.NoCollation        = $True
    $ScriptingOptions.IncludeIfNotExists = $True
    $ScriptingOptions.NoIdentities       = $True

    #获得数据库中的用户表
    $Tables=((New-Object "Microsoft.SqlServer.Management.Smo.Server" $ServerConnection).databases[$DataBase]).tables | Where-Object -FilterScript{$_.IsSystemObject -eq $False}
    
    if($Tables)
    {
        [System.Text.StringBuilder]$Sript="Use ["+$DataBase+"]`nGo`n"
        [int]$count=1
        
        #刪除腳本
        foreach($tb In $Tables | Sort-Object -Property CreateDate,ID -Descending)
        {
            $i=$Sript.AppendLine("If object_id('[" +$Tb.Name+ "]') Is Not null `n`t  Drop Table ["+ $Tb.Name+ "]")
        }
        
        #创建脚本
        foreach($tb In $Tables | Sort-Object -Property CreateDate,ID)
        {
            foreach($s In $tb.Script($ScriptingOptions))
            {    
                $i=$Sript.AppendLine($s)
            }
            Write-Host "處理完表 (" $count "/" $Tables.Count ")"  ": " $tb.Name  
            $count+=1       
        }
        
        $i=$Sript.AppendLine("Go")
        
        #输出脚本
        [string]$Path=$SrciptOutputPath+$DataBase+"-"+(Get-Date -format yyyyMMdd)+".sql"
        $Sript.ToString() | Out-File -FilePath $Path            
    }
    Else
    {
        Write-Error "无效的数据库： $DataBase 。或在数据库中找不到对应的表！"
    }

}

小结

上面描述了通过PowerShell 2.0生成创建表的Transact-SQL脚本，包含创建表，约束，外键，默认值，触发器和索引。可以根据自己实际的场景需要，修改部分的脚本选项。当然我在测试上面的脚本中，发现Table.Script(ScriptingOptions)方法生成脚本的方法比较慢，特别是一个数据库中包含有100以上的表，就感觉到缓慢，这方面有待优化提高。

本文链接

PowerShell应用之-(SMO) 类库

2011-11-02T16:43:00Z

SMO类库描述

在命名空间Microsoft.SqlServer.Management.Smo下提供有丰富的类库，来描述SQL Server数据库引擎核心对象，包含实例(instances)、数据库(databases),表(tables),存储过程(stored procedures)和视图(views)。它能为我们实现：

连接SQL Server实例
查询和修改实例设置(instance settings)和配置选项(configuration options)
查询和修改数据库对象
在SQL Server实例执行DDL(data definition language)操作
生成数据库对象脚本
执行数据库维护任务，如备份和还原操作

下面我们测试其中一两个例子描述它的应用。

连接SQL Server实例

连接SQL Server实例，我们需要应用到命名空间Microsoft.SqlServer.Management.Smo空间下的Server类。

e.g.<Scripts01>

$serverInstance="WINSERVER01\SQL2008DE01" #SQL Server实例名
$userName="sa" #登录账号
$password="sql20081" #登录密码

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null #加载程序集Microsoft.SqlServer.Smo
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null  #加载程序集Microsoft.SqlServer.ConnectionInfo
$ServerConnection =new-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password 
$Server=New-Object "Microsoft.SqlServer.Management.Smo.Server" $ServerConnection

Try
{
    $ServerConnection.Connect()
    Write-Host "实例" $serverInstance "连接OK！" 
}
Catch
{
    Write-Error "实例" $serverInstance "无法连接！" 
}

<Scripts01>中代码：

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null #加载程序集Microsoft.SqlServer.Smo
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null #加载程序集Microsoft.SqlServer.ConnectionInfo

描述加载的程序集，我们在应用命名空间Microsoft.SqlServer.Smo下的各个类库都需要先加载对应的程序集。如这里用到的类Microsoft.SqlServer.Management.Smo.Server对应的程序集是Microsoft.SqlServer.Smo,类Microsoft.SqlServer.Management.Common.ServerConnection，对应的程序集是Microsoft.SqlServer.ConnectionInfo。

我这里看到

[System.Reflection.Assembly]::Load()无法应用。在PowerShell 2.0中反而应用到

[System.Reflection.Assembly]::LoadWithPartialName()

看MSDN的时候，提到

[System.Reflection.Assembly]::LoadWithPartialName()

在.Net Framework 2.0之后已过时。这是我感觉比较纠结的位置。

查询和修改实例设置(instance settings)和配置选项(configuration options)

当我们连接上SQL Server实例后，我们可以提供类Server提供的属性Settings和属性configuration options，来修改设置和配置选项。我例子沿用上边的例子，继续。

e.g.<Scripts02>查询部分：

if ($ServerConnection.IsOpen -eq $true)
{
    $Settings=$Server.Settings
    $Configuration=$Server.Configuration
    
    #显示设置
    $Settings
    
    #显示配置选项
    "MinServerMemory : " + [int]$Configuration.MinServerMemory.RunValue +"MB"
    "MaxServerMemory : " + [int]$Configuration.MaxServerMemory.RunValue +"MB"
    "IsSqlClrEnabled : " + [boolean]$Configuration.IsSqlClrEnabled.RunValue
    "RemoteDacConnectionsEnabled : " + [boolean]$Configuration.RemoteDacConnectionsEnabled.RunValue
    
    
}

这里只是列出settings和configuration options的一小部分内容。如果想了解更多的信息可以通过get-member获取对应的属性，再输出到PowerShell控制台。我们不引可以查询settings和configuration options的内容，还可以修改它们的内容。

e.g.<Scripts03>修改部分：

#修改设置
$Settings.DefaultFile="E:\DATA" #修改前是“ E:\DATA\SQL2008DE01”
$Settings.DefaultLog="E:\DATA" #修改前是“ E:\DATA\SQL2008DE01”

$Configuration.IsSqlClrEnabled.ConfigValue=0 #修改前是1
$Server.Alter()

<Scripts03>如果我们使用的是编辑器是Windows PowerShell ISE，一样可以执行所选的部分代码。

<Scripts03>代码中，说明一点修改设置的时候，最后必须调用实例对象$Server的Alter()方法，不然不会应用到SQL Server实例中。我们这里可以检查修改后的实例信息：

实际应用例子

这里是一个实际中的例子，脚本的功能，主要是查询出某一个实例中的默认数据库路径，实例登录账号、数据库列表。

<#===========================================#>

$serverInstance="WINSERVER01\SQL2008DE01" 
$userName="sa"
$password="sql20081"


<#===========================================#>
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | Out-Null

$ServerConnection =new-object "Microsoft.SqlServer.Management.Common.ServerConnection" $serverInstance,$userName, $password  

Try
{$ServerConnection.Connect()}
Catch
{Write-Error $_}

if($ServerConnection.IsOpen -eq $True)
{    

    $Server=New-Object "Microsoft.SqlServer.Management.Smo.Server" $ServerConnection
    Write-Host
    Write-Host "Server Name  :" $Server.Name
    Write-Host
    Write-Host "======================= Settings ================================"
    Write-Host "DefaultFile  : " $Server.Settings.DefaultFile
    Write-Host "DefaultLog   : " $Server.Settings.DefaultLog
    Write-Host

    Write-Host "======================= Configuration ================================"
    "XPCmdShellEnabled              : "+ [boolean]$Server.Configuration.XPCmdShellEnabled.RunValue
    "DatabaseMailEnabled            : "+ [boolean]$Server.Configuration.DatabaseMailEnabled.RunValue
    "IsSqlClrEnabled                : "+ [boolean]$Server.Configuration.IsSqlClrEnabled.RunValue
    "SqlMailXPsEnabled              : "+ [boolean]$Server.Configuration.SqlMailXPsEnabled.RunValue
    "DatabaseMailEnabled            : "+ [boolean]$Server.Configuration.DatabaseMailEnabled.RunValue
    "OleAutomationProceduresEnabled : "+ [boolean]$Server.Configuration.OleAutomationProceduresEnabled.RunValue
    "AdHocDistributedQueriesEnabled : "+ [boolean]$Server.Configuration.AdHocDistributedQueriesEnabled.RunValue
    Write-Host
    Write-Host "======================= Logins ================================"
    $Server.Logins | Format-Table -AutoSize -Wrap -Property Name,CreateDate,IsDisabled,LoginType,IsSystemObject

    Write-Host
    Write-Host "======================= DataBases ================================"
    $Server.Databases| Sort-Object -Property @{Expression="IsSystemObject";Descending=$True},@{Expression="ID";Ascending=$True}  | Format-Table -AutoSize -Wrap -Property Name,IsSystemObject,Size,Status,CreateDate,PrimaryFilePath
}

小结

以上是举例子简单描述如何通过PowerShell 2.0，调用命名空间Microsoft.SqlServer.Management.Smo下的类库，管理数据库实例。在真实的场景中，我们碰到更复杂的应用。不管如何，我们需要应用到SMO类库，具体的用法可以参阅：http://technet.microsoft.com/en-us/library/gg720307.aspx

本文链接

临时表 Vs 表变量

2011-11-01T17:00:00Z

开始

说临时表和表变量，这是一个古老的话题，我们在网上也找到很多的资料阐述两者的特征，优点与缺点。这里我们在SQL Server 2005\SQL Server 2008版本上通过举例子，说明临时表和表变量两者的一些特征，让我们对临时表和表变量有进一步的认识。在本章中，我们将从下面几个方面去进行描述，对其中的一些特征举例子说明：

约束(Constraint)
索引(Index)
I/0开销
作用域(scope)
存儲位置
其他

例子描述

约束(Constraint)

在临时表和表变量，都可以创建Constraint。针对表变量，只有定义时能加Constraint。

e.g.在Microsoft SQL Server Management Studio（MSSMS）查询中，创建临时表并建Constraint场景，<脚本S1.>

Use tempdb
go
if object_id('Tempdb..#1') Is Not Null 
   Drop Table #1                
Go
Create Table #1
(
 ID int,
 Nr nvarchar(50) not null,
 OperationTime datetime default (getdate()),
 Constraint PK_#1_ID Primary Key (ID)
)

Alter Table #1 Add Constraint CK_#1_Nr Check(Nr Between '10001' And '19999')
Go

< 脚本S1.>中，可以看出在临时表#1的创建时，创建Constraint如“Constraint PK_#1_ID Primary Key(ID)”，也可以在创建临时表#1后创建Constraint，如“Alter Table #1 Add Constraint CK_#1_Nr Check(Nr Between '10001' And'19999')”，下面我们来看表变量的场景，在定义表变量时不能指定Constraint名，定义表变量后不能对表变量创建Constraint。

e.g. 在定义表变量时不能指定Constraint名<代码S2.>

Use tempdb
Go
Declare @1 Table
(
 ID int,
 Nr nvarchar(50) not null,
 OperationTime datetime default (getdate()),
 Constraint [PK_@1_ID] Primary Key (ID)
)

在定义表变量后不能对表变量创建Constraint，<代码S3.>

use tempdb
go
Declare @1 Table
(
 ID int primary key clustered,
 Nr nvarchar(50),
 OperationTime datetime default (getdate())
)

Alter Table @1 Add Constraint [CK_@1_Nr] Check(Nr Between '10001' And '19999')

在<代码S2.>和<代码S3.>中可以发现，在解析T-SQL语法过程就发生错误，也就是SQL Server不支持定义表变量时对Constraint命名，也不支持定义表变量后，对其建Constraint。

这里慎重提示下，在<代码S1.>给临时表建Constraint的时候，特别是在并发场景中，不要指定具体的Constraint名称，不然会发生对象已存在的错误提示。

e.g. 在MSSMS中我们先执行之前<代码S1.>的创建临时表#1，不关闭当前会话的情况下，另建一个查询，执行与<代码S1.>相同的代码，如图

左边的查询窗口，是执行原先的<代码S1.>，右边的查询窗口，是后执行相同的<代码S1.>。在这里，我们注意红色圈圈部分，发现在创建临时表#1的过程，明确给了一个主键名称“PK_#1_ID”，当右边再创建相同临时表#1的时候就发生了对象重复错误问题。我们也可以通过SQL Server提供的系统视图sys.objects查询约束“PK_#1_ID”的信息，

use tempdb

go

Select * from sys.objects Where name='PK_#1_ID'

在系统视图sys.objects，发现“PK_#1_ID”名称后面不加如何的随机数值表述不同会话有不同的对象。根据SQL Server对sys.objects的描述规则，sys.objects中的Name列数据是唯一的。当另一个会话创建相同的对象时就会发生对象重复的错误。

在Constraint中，Foreign Key是不能应用与表变量，对于临时表，创建Foreign Key是没有意义的。也就是说临时表不受Foreign Key约束。下面我们通过例子来说明临时表的情况，

e.g.< 脚本S4.>

use tempdb
go
if object_id('Tempdb..#1') Is Not Null
    Drop Table #1                
Go
if object_id('Tempdb..#2') Is Not Null
    Drop Table #2                
Go
Create Table #1
(

    ID int,
    Nr nvarchar(50) not null,
    OperationTime datetime default(getdate()),
    Constraint PK_#1_ID Primary Key(ID)
)
Alter Table #1 Add Constraint CK_#1_Nr Check(Nr Between '10001' And '19999')
Create table #2
(
    ID int Primary Key,
    ForeignID int Not null ,foreign Key(ForeignID) References #1(ID)
)
Go

可以看出对于临时表不强制Foreign Key约束,我们也可以通过SQL Server系统视图sys.foreign_keys查询

use tempdb
go
Select * from sys.tables Where name like '#[1-2]%'
Select * From sys.foreign_keys

右边的查询，只看到在sys.tables表哦中存在刚才创建的临时表#1和#2，在sys.foreign_keys看不到有关Foreign Key约束信息。这也验证了左边SQL Server提示的，在临时表中无法强制使用Foreign Key约束。

索引(Index)

从索引方面看临时表和表变量，与从Constraint上分析有些类似，在临时表中，它与真实表一样可以创建索引。在表变量定义过程中，也可以创建一些类似唯一和聚集索引。

e.g.< 脚本S5.>

use tempdb

go

declare @1 Table(      

                ID int  primary key clustered,

                Nr nvarchar(50) unique Nonclustered

)

Insert into @1 (id,Nr) values(1,'10001')

Insert into @1 (id,Nr) values(2,'10002')

Insert into @1 (id,Nr) values(8,'10003')

Insert into @1 (id,Nr) values(3,'10004')

Insert into @1 (id,Nr) values(7,'10005')

Select top 2 *

                From sys.indexes As a

                                Inner Join sys.tables As b On b.object_id=a.object_id

                Order by b.create_date Desc

Select Nr From @1 Where Nr='10005'

go

上面截的是两张图，第一张图描述在表变量使聚集Primary Key，创建非聚集的Unique约束，第二张图描述查询语句”Select Nr From @1 Where Nr='10005'” 应用到在表变量创建的唯一索引“UQ_#……”

是于临时表索引的例子，我们拿一个例子说明，与前边说的Constraint例子有点相似，这里我们对临时表创建索引，并给索引一个具体名称，测试是否会重复。

e.g.在MSSMS新增两个查询，编写下面的SQL语句：

< 脚本S6.>

Use tempdb
Go
if object_id('#1') is not null    
    Drop Table #1 
    
Create Table #1
(
 ID int primary key,
 Nr nvarchar(50) not null,
 OperationTime datetime default (getdate()),
)

create nonclustered index IX_#1_Nr on #1(Nr Asc)
go
Select b.name As TableName,
       a.* 
    from sys.indexes As a
        Inner join sys.tables As b On b.object_id=a.object_id
    Where b.name like '#1[_]%'
    Order by b.create_date Asc

从返回的结果，我们看到在系统视图表Sys.Indexes中，创建有两个相同的索引”IX_#1_Nr”，但注意下object_id数据不同。在SQL Server中是允许不同的表索引名称可以相同的。在并发的环境下，按原理是可以对临时表创建的索引给明确名称的。除非并发的情况会发生重复的表名或重复的Constraint，或其它系统资源不足的问题，才会导致出错。

I/0开销

临时表与表变量，在I/O开销的描述，我们直接通过一个特殊的例子去描述它们，在MSSMS上新增两个查询，分别输入临时表和表变量的测试代码：

e.g.< 脚本S7.>临时表：

Use tempdb
Go
if object_id('#1') is not null    
    Drop Table #1 
    
Create Table #1
(
 ID int primary key,
 Nr nvarchar(50) not null,
 OperationTime datetime default (getdate())
)

Insert into #1(ID,Nr,OperationTime)
Select top 50000 row_number()over (order by a.object_id),left(a.name+b.name,50) ,a.create_date
    from master.sys.all_objects As a ,sys.all_columns As b
    Where type='S'



Select Nr,count(Nr) As Sum_ 
    From #1 
    Where Nr like 'sysrscolss%'    
    Group by Nr

< 脚本S8.>表变量：

Use tempdb
Go
Declare @1 Table
(
 ID int primary key,
 Nr nvarchar(50) not null,
 OperationTime datetime default (getdate())
)

Insert into @1(ID,Nr,OperationTime)
Select top 50000 row_number()over (order by a.object_id),left(a.name+b.name,50) ,a.create_date
    from master.sys.all_objects As a ,sys.all_columns As b
    Where type='S'
    

Select Nr,count(Nr) As Sum_ 
    From @1 
    Where Nr like 'sysrscolss%'    
    Group by Nr

< 脚本S7.>和< 脚本S8.>，主要是看最后的查询语句I/O的开销，两者有何不同。通过上面的运行结果图形描述，可以看出查询开始，不管是临时表还是表变量，都使用到了聚集索引扫描(Clustered Index Scan)，两者虽然返回的数据一致，但I/O的开销不同。临时表的I/O开销是0.324606,而表变量只有0.003125 相差非常大。在临时表的执行计划图形中，我们发现一行“缺少索引（影响 71.9586):CREATE ……）”提示信息。我们对临时表#1，在字段“Nr”上创建一个非聚集索引，再看执行执行结果：

create nonclustered index IX_#1_Nr On #1(Nr)

我们在临时表#1上创建完索引“IX_#1_Nr”，运行看上面的图形显示，就感觉非常的有意思了。在临时表#1查询时用了索引搜索（Index Seek），而且I/O开销减少到了0.0053742。虽然开始查询的时候I/O开销还是比表变量开始查询的时候大一些，但执行步骤中比变变量少了一个“排序(Sort)”开销，后最后的看回Select结果，估计子树的成本比使用表变量的大大减少。

这里的例子只是描述一个特殊的情况，在真实的环境中，要根据实际的数据量来判断是否使用临时表或表变量。倘若在存储过程中，当数据量非常少如只有不到50行记录，数据占的页面也不会超过1个页面，那么使用表变量是一个很好的解决方案。

作用域(scope)

表变量像局部变量(local variable)一样，有着很窄的作用域，只能应用于定义的函数、存储过程或批处理内。如，一个会话里面有几个批处理，那么表变量只能作用在它定义所在的批处理范围内。其他的批处理无法再调用它。

e.g.在MSSMS新增一个查询，编写< 脚本S9.>

use tempdb
Go
Set Nocount on
declare @1 Table(      
                ID int  primary key clustered,
                Nr nvarchar(50) unique Nonclustered
)
Insert into @1 (id,Nr) values(1,'10001')
Insert into @1 (id,Nr) values(2,'10002')
Insert into @1 (id,Nr) values(8,'10003')
Insert into @1 (id,Nr) values(3,'10004')
Insert into @1 (id,Nr) values(7,'10005')

Select * From @1

Go --批处理结束点

Select * From @1

< 脚本S9.>所在的查询相当于一个会话，”Go”描述的一个批处理的结束点。在”Go”之前定义的表变量，在”Go”之后调用是发生“必须声明变量@1”的错误提示。

临时表与表变量不同，临时表的作用域是当前会话都有效，一直到会话结束或者临时表被Drop的时候。也就是说可以跨当前会话的几个批处理范围。

e.g.< 脚本S10.>

Use tempdb
go
if object_id('Tempdb..#1') Is Not Null 
   Drop Table #1                
Go
Create Table #1
(
 ID int,
 Nr nvarchar(50) not null,
 OperationTime datetime default (getdate()),
 Constraint PK_#1_ID Primary Key (ID)
)
Select * from #1

go --批处理结束点

Select * from #1

< 脚本S10.>中可以看出在”GO”前后都可以查询到临时表#1。

在描述临时表与表变量的作用域时，有个地方要注意的是，当 sp_executesql 或 Execute 语句执行字符串时，字符串将作为它的自包含批处理执行. 如果表变量在sp_executesql 或 Execute 语句之前定义，在sp_executesql 或 Execute 语句的字符串中无法调用外部定义的表变量。

e.g.< 脚本S11.>

use tempdb
go
Set nocount on
declare @1 Table(      
                ID int  primary key clustered,
                Nr nvarchar(50) unique Nonclustered
)
Insert into @1 (id,Nr) values(1,'10001')
Insert into @1 (id,Nr) values(2,'10002')
Insert into @1 (id,Nr) values(8,'10003')
Insert into @1 (id,Nr) values(3,'10004')
Insert into @1 (id,Nr) values(7,'10005')

Select * From @1

Execute(N'Select * From @1')

go

< 脚本S11.>中，当执行到”Execute(N'Select * From @1')”时候，同样发生与< 脚本S9.>一样的错误提示“必须声明变量@1”.

临时表是可以在sp_executesql 或 Execute 语句执行字符串中被调用。这里不再举例子，如果你有所模糊可以参考< 脚本S11.>把表变量转成临时表测试下就能加深理解与记忆。

存儲位置

说到临时表和表变量的存储位置，我们可以看到有很多版本的说法，特别是表变量。有的说表变量数据存储在内存中，有的说存储在数据库tempdb中，有的说有部分存储在内存，部分存储在数据库tempdb中。根据我查到的官方资料，说的是在SQL Server 2000下:

“A table variable is not a memory-only structure. Because a table variable might hold more data than can fit in memory, it has to have a place on disk to store data. Table variables are created in the tempdb database similar to temporary tables. If memory is available, both table variables and temporary tables are created and processed while in memory (data cache). ”

在SQL Server 2005\SQL2008的版本，表变量存储与临时表有相似，都会在数据库tempdb创建，使用到tempdb存储空间。

e.g.< 脚本S12.>临时表

use tempdb
go
Set nocount on

Exec sp_spaceused /*插入数据之前*/

if object_id('#1') Is not null 
    Drop Table #1 
    
create table #1(ID int ,Nr nvarchar(50))
Insert into #1  (ID,Nr)
    Select top(1) row_number() Over(order By a.object_id),left(a.name+b.name,50)
        From sys.all_objects As a,
            sys.all_columns As b    
                                
Select top(1) name,object_id,type,create_date from sys.tables Order by create_date Desc            

Exec sp_spaceused /*插入数据之后*/
Go

在< 脚本S12.>执行后，我们可以看到在数据库tempdb中的表sys.tables创建有表#1。我们接着看空间的使用情况，插入数据之前，数据库未使用空间(unallocated space)为510.39MB,向临时表#1插入1条数据后，数据库未使用空间为501.38MB,未使用空间变小了。再来看整个数据库的数据(data)使用的空间变化,从552KB变成560KB,使用了一页的数据空间(8kb)。这说明一点，临时表，即使你只插入一条数据都会使用到数据库tempdb的空间。也许会有人问，要是我只建临时表#1,不插入数据，会如何。我们可以结果：

这里你会发现前后的空间大小不变，不过，不要认为没有使用到数据库tempdb数据空间，当你多用户创建临时表结构的时候，你就会发现其实都会应用到数据库tempdb的空间。我这里创建了10个#1后的效果如：

相同的原理，我们使用类似的方法测试表变量的情况，发现结论是与临时表的一致的，会使用到数据库tempdb的空间.

e.g.< 脚本S13.>表变量

use tempdb
go
Set nocount on
Exec sp_spaceused /*插入数据之前*/

Declare @1 table(ID int ,Nr nvarchar(50))
Insert into @1  (ID,Nr)
    Select top(1) row_number() Over(order By a.object_id),left(a.name+b.name,50)
        From sys.all_objects As a,
            sys.all_columns As b            
            
Select top(1) name,object_id,type,create_date from sys.objects Where type='U' Order by create_date Desc            

Exec sp_spaceused /*插入数据之后*/

Go
Exec sp_spaceused /*Go之后*/

< 脚本S13.>中，我多写了一个”GO”之后检查空间大小的存储过程sp_spaceused。这样为了了更能体现表变量使用空间变化情况。从插入数据前和插入数据后的结果图来看，表变量不仅在数据库tempdb创建了表结构#267ABA7A类似的这样表，表变量也应用到了数据库tempdb的空间。不过这里注意一点就是在”Go”之后，我们发现表变量@1,会马上释放所使用的数据空间。为了更能体现使用空间情况。我们可以向表变量@1插入大量数据看空间变化情况（测试插入1000万的数据行）。

e.g.< 脚本S14.>

use tempdb
go
Set nocount on
Exec sp_spaceused /*插入数据之前*/

Declare @1 table(ID int ,Nr nvarchar(50))
Insert into @1  (ID,Nr)
    Select top(10000000) row_number() Over(order By a.object_id),left(a.name+b.name,50)
        From sys.all_objects As a,
            sys.all_columns As b            
            
Select top(1) name,object_id,type,create_date from sys.objects Where type='U' Order by create_date Desc            

Exec sp_spaceused /*插入数据之后*/

Go
Exec sp_spaceused /*Go之后*/

这里我们可清晰的看到数据库tempdb的大小(database_size)变化情况，从插入数据前的552.75MB变成插入数据之后的892.75MB。非常有意思的是我们在”Go之后”发现数据库大小保存在892.75MB,但数据使用空间(data)从560KB—>851464KB—>536KB ，说明SQL Server自动释放为使用的数据空间，但不会马上自动释放数据库分配的磁盘空间。我们在实际的环境中，发现临时数据库tempdb使用的磁盘空间越来越大，这是其中的原因之一。

其他

临时表与表变量，还有其他的特征，如临时表受事务回滚，而表变量不受事务回滚影响。对应事务方面，更为正确的说法是表变量的事务只在表变量更新期间存在。因此减少了表变量对锁定和记录资源的需求。

e.g.< 脚本S15.>

use tempdb
go
Set nocount on

if object_id('#1') Is not null 
    Drop Table #1     
create table #1(ID int ,Nr nvarchar(50))
Declare @1 table(ID int ,Nr nvarchar(50))

begin tran /*开始事务*/

Insert into #1  (ID,Nr)
    Select top(1) row_number() Over(order By a.object_id),left(a.name+b.name,50)
        From sys.all_objects As a,
            sys.all_columns As b    


Insert into @1  (ID,Nr)
    Select top(1) row_number() Over(order By a.object_id),left(a.name+b.name,50)
        From sys.all_objects As a,
            sys.all_columns As b    
            
rollback tran /*回滚事务*/

Select * from #1
Select * from @1

Go

这里发现”Rollback Tran”之后，临时表#1没有数据插入，而表变量@1还有一条数据存在。说明表变量不受”Rollback Tran”所影响。它的行为有类似于局部变量一样。

另外SQL Server对表变量不保留任何的统计信息，因为如此，我们在数据量大的时候使用表变量，发现比临时表要慢许多。前面在I/O开销那里我们取有一个特殊的例子，这里不再举例。

小结

无论如何，临时表和表变量有各自的特征，有自己优点和缺点。在不同的场景选择它们灵活应用。本文章是我对临时表和表变量的一些认识理解，可能有些地方说的不够好或者遗漏，你可以留言或Email与我联系，我会继续改进或纠正，我也不希望有些错误的见解会误导别人。正如Phil Factor说的一句" I'd hate to think of anyone being misled by my advice!".

附参考：

http://support.microsoft.com/kb/305977/en-us

http://stackoverflow.com/questions/27894/whats-the-difference-between-a-temp-table-and-table-variable-in-sql-server

http://msdn.microsoft.com/en-us/library/aa175774(SQL.80).aspx

http://msdn.microsoft.com/en-us/library/cc966545.aspx

http://www.simple-talk.com/sql/t-sql-programming/temporary-tables-in-sql-server/

http://support.microsoft.com/kb/942661/en-us

本文链接

PowerShell应用之-批量执行SQL脚本

2011-10-25T15:57:00Z

这一篇，我们来实现PowerShell 2.0在SQL Server中的一个应用,是批量执行SQL脚本。在接下来的内容，将使用到下面的命令或类库。

Sort-Object
out-null
Write-Error
$_
System.IO.DirectoryInfo
Microsoft.SqlServer.Management.Common.ServerConnection

创建测试环境

为了更能说明PowerShell脚本的应用，我们这里创建个测试环境，模拟一个要升级的SQL脚本文件；首先，要创建两个数据库『TestingDB01』和『TestingDB02』：

use master
Go
if db_id('TestingDB01') Is Not null
Drop Database TestingDB01
Go
Create Database TestingDB01
Go
if db_id('TestingDB02') Is Not null
Drop Database TestingDB02
Go
Create Database TestingDB02
Go

在Microsoft SQL Server Management Studio(MSSMS)中执行上面的创建数据库SQL语句。接下来我们创建三个SQL脚本文件：

1. 01_ TestingDB_CreateTB&InitializeData.sql

2. 02_ TestingDB_Procedures_0001.sql

3. 03_ TestingDB_Procedures_0002.sql

第1个脚本，应用于创建数据表和初始化数据使用，第2、3个脚本，只要是存储过程的脚本文件，其中有1个存储过程包含有动态的SQL语句，每一个脚本都包含有对数据库『TestingDB01』和『TestingDB02』的脚本。这些脚本制作是模拟真实环境中的升级脚本，列举常见的脚本内容样本。下面是描述这三个SQL脚本文件的具体内容。

[01_ TestingDB_CreateTB&InitializeData.sql]文件內容：

use TestingDB01
GO
if object_id('rTestingTB1') Is Not Null
    Drop proc rTestingTB1
Go
Create Proc rTestingTB1
As
Select ID,Data From TestingTB1
Go

use TestingDB02
GO
if object_id('rTestingTB2') Is Not Null
    Drop proc rTestingTB2
Go
Create Proc rTestingTB2
(
    @Columns nvarchar(max)=null,
    @Where nvarchar(max)=null
)
As
If Isnull(@Columns,'')=''
    Set @Columns='ID,Data'

If Isnull(@Where,'')>''
    Set @Where=' Where '+@Where
Else
    Set @Where=''

Exec(N'Select '+@Columns+' From TestingTB1'+@Where)
Go

[03_ TestingDB_Procedures_0002.sql]文件內容：

use TestingDB01
GO
if object_id('rTestingTB') Is Not Null
Drop proc rTestingTB
Go
Create Proc rTestingTB
As
Select ID,Data From TestingTB1 Where Not Exists(Select 1 From TestingDB02 Where id=a.id)
Go

我们把上面的三个SQL脚本文件存储在本机的某一文件路径下面，如“E:\ExecuteSQLScript”

这里提示下，对于这三个脚本，需根据实际场景，按执行先后顺序，对SQL脚本文件名作编号，如格式“01_…”,”02_…”,”03_…”.

编写PowerShell脚本

在前边我们创建好了测试环境，接下来就开始编写PowerShell来实现执行SQL脚本文件功能。编写PowerShell脚本的时候，我们会考虑这几点问题：

如何连接到SQL Server实例，如何执行SQL脚本.
如何读取SQL脚本文件内容，如何按SQL脚本编号读取.
如何处理错误

如何连接到SQL Server实例，如何执行SQL脚本

PowerShell基于.NET Framework上构建，我们可以根据.NET Framework提供的丰富的类库实现我们需要的功能。这里我们引用到Microsoft.SqlServer.Management.Common命名空間下的ServerConnection类，它可以让我们连接到某一SQL Server实例，而且在ServerConnection类中提供有方法ExecuteNonQuery()，可执行T-SQL语句功能。

e.g.

$serverInstance="WINSERVER01\SQL2008DE01" 
$userName="sa"
$password="sql20081"

[void][System.Reflection.Assembly]::LoadWithPartialName('Microsoft.SqlServer.ConnectionInfo') |out-null
$ServerConnection =new-object Microsoft.SqlServer.Management.Common.ServerConnection $serverInstance,$userName, $password
$ServerConnection.ExecuteNonQuery(“use test Update myTable Set Data='test' Where ID=3”)

上面的例子，我们更新数据库test中的表myTable数据，从PowerShell控制台返回的信息”1”可以判断更新脚本已经在实例”WINSERVER01\SQL2008DE01”上执行。当然我们可以在MSSMS上查询验证所更新的数据。

如何读取SQL脚本文件内容，如何按SQL脚本编号读取.

读SQL脚本文件，需要获得文件路径下的文件名，把脚本文件内容按文件编号读取出来，把数据转换成字符串类型String。这样我们才能调用应用到上边的ServerConnection类的ExecuteNonQuery()方法中。这里我们System.IO.DirectoryInfo类来实现。

e.g.

$ScriptPath="E:\ExecuteSQLScript\"
[System.IO.DirectoryInfo]$DirectoryInfo=New-Object System.IO.DirectoryInfo $ScriptPath | Sort-Object
    foreach( $f In ($DirectoryInfo.GetFiles("*.sql"))) 
    {
        $f.Name
    }

我们下面定义1个类型为[System.Text.StringBuilder]的变量$Sql,调用类System.Io.File中的方法OpenText()，获取上面三个SQL脚本文件的内容，

e.g.

$ScriptPath="E:\ExecuteSQLScript\"
[System.Text.StringBuilder]$Sql=""
[System.IO.DirectoryInfo]$DirectoryInfo=New-Object System.IO.DirectoryInfo $ScriptPath | Sort-Object
    foreach( $f In ($DirectoryInfo.GetFiles("*.sql"))) 
    {
        $Sql=$Sql.AppendLine(([System.Io.File]::OpenText($ScriptPath+$f.Name)).ReadToEnd())
    }
    
$Sql.ToString()

如何处理错误

我们无法保证我们所写的PowerShell脚本完全能正常运行，或在运行中发生错误，我们需要作一些特殊的错误处理，如自定义错误提示等。在PowerShell脚本为我们提供类似C#或SQL Server 2005\SQL Server 2008的”Try …Catch”用法。

e.g.

Try
{
    $0=0
    $value=1/$0
}
Catch
{
    Write-Error $_
}

主要考虑的几个问题，我们已经一一针对它们去解决了，下面我们写成完整的PowerShell脚本，实现批量执行SQL脚本功能：

<#批量执行SQL脚本文件 Andy 2011-10-25 #>
<#===========================================#>
$serverInstance="WINSERVER01\SQL2008DE01" 
$userName="sa"
$password="sql20081"
$ScriptPath="E:\ExecuteSQLScript\"
$ScriptList="

"
<#===========================================#>
$n="`n"
$r="`r"
While ($ScriptList.IndexOf($n) -gt 0)
    {$ScriptList=$ScriptList.Replace($n,";")}
While ($ScriptList.IndexOf($r) -gt 0)
    {$ScriptList=$ScriptList.Replace($r,";")}    
While ($ScriptList.IndexOf(" ") -gt 0)    
    {$ScriptList=$ScriptList.Replace(" ","")}
While ($ScriptList.IndexOf(",") -gt 0)    
    {$ScriptList=$ScriptList.Replace(",","")}
If ($ScriptList.IndexOf(".sql") –le 0)
{
    $ScriptList=""
    [System.IO.DirectoryInfo]$DirectoryInfo=New-Object System.IO.DirectoryInfo $ScriptPath | Sort-Object
    foreach( $f In ($DirectoryInfo.GetFiles("*.sql"))) 
    {
        $ScriptList=$ScriptList+";"+$f.Name
    }
}
Try
{
    [void][System.Reflection.Assembly]::LoadWithPartialName('Microsoft.SqlServer.ConnectionInfo') |out-null
    $ServerConnection =new-object Microsoft.SqlServer.Management.Common.ServerConnection $serverInstance,$userName, $password
    try
    {
        $ServerConnection.BeginTransaction()
        Write-Host "BeginTransaction ."
        
        [System.Text.StringBuilder]$Sql=""
        Foreach($File In $ScriptList.Split(";"))
        {        
            if($File -ne "")
            {
                $Sql=$Sql.AppendLine(([System.Io.File]::OpenText($ScriptPath+$File)).ReadToEnd())
                $ServerConnection.ExecuteNonQuery($Sql)|out-null
                $Sql=""
                
                Write-Host $ScriptPath$File  " ...OK!"
            }
        }
        $ServerConnection.CommitTransaction()
        
        Write-Host "CommitTransaction ."      
    }
    Catch
    {
        If ($ServerConnection.TransactionDepth -gt 0)
            {
                $ServerConnection.RollBackTransaction()
                Write-Host "RollBackTransaction ."
            }            
         
        Write-Error $_     
    }    
}
Catch
{
    Write-Error $_
   
}

运行脚本结果如图：

提示：

以上脚本测试，使用的SQL Server & Windows环境是：

Microsoft SQL Server 2008 (SP2) - 10.0.4000.0 (Intel X86)
    Sep 16 2010 20:09:22
    Copyright (c) 1988-2008 Microsoft Corporation
    Enterprise Edition on Windows NT 6.0 <X86> (Build 6001: Service Pack 1)

另外在PowerShell 2.0+SQL Server 2005(sp4) + Windows 20003(Windows XP)上测试通过。

本文链接

PowerShell应用之-Get-WmiObject -Class Win32_Service

2011-10-20T23:19:00Z

开始

引用Windows PowerShell官方的说明，Windows PowerShell 是专为系统管理员设计的新 Windows 命令行 shell。Windows PowerShell 包括交互式提示和脚本环境，两者既可以独立使用也可以组合使用。在我学习PowerShell过程中，发觉学习PowerShell的门槛不高，学起来不费劲，要是有DOTNET或其它编程语言基础，那么感觉就更容易了。因为，PowerShell最基本的功能命令就是cmdlet(command-let),cmdlet标准格式是“动词-名词”，如.Get-Help ,Get-Host,New-Service等。这让人感觉很顺口，不会花太多的时间去记住复杂的命令。下面，从一个实际的例子来描述PowerShell的应用。下面的例子，你将了解到命令：

Get-WmiObject
Format-Table
Where-Objec

前不久，有寫過一篇《通过批处理脚本启动/停止SQL Server服务》，今天寫出一篇通過PowerShell腳本實現相同的功能，而且使用比批處理腳本更為方便。通過PowerShell腳本實現，最大的優點是，針對控制網絡電腦上的SQL Server服務，沒必要通過遠端桌面連線工具，就可以實現。

先製作一個CSV格式文件『SQLSeverList.csv』，描述各個PC的SQL Server服務內容，數據項要求包含：PC ,ServerNr ,SQLServer, Agent ,FullTextSearch

『SQLSeverList.csv』存儲文件內容如下：

#SQL Server服務列表，本機使用"."來描述

PC,ServerNr,SQLServer,Agent,FullTextSearch

VM162,1,MSSQL$SQL2005DE1,SQLAgent$SQL2005DE1,msftesql$SQL2005DE1

VM162,2,MSSQL$SQL2005DE2,SQLAgent$SQL2005DE2,msftesql$SQL2005DE2

… …

PC20,1,MSSQL$SQL01,SQLAgent$SQL01,msftesql$SQL01

PC20,2,MSSQL$SQL02,SQLAgent$SQL02,msftesql$SQL02

… …

.,2,MSSQL$SQL2005DE2,SQLAgent$SQL2005DE2,msftesql$SQL2005DE2

.,3,MSSQL$SQL2005DE3,SQLAgent$SQL2005DE3,msftesql$SQL2005DE3

.,4,MSSQL$TEST,SQLAgent$TEST,msftesql$TEST

通過這個『SQLSeverList.csv』文件列表就可以找到對應的管理SQL Server服務。接下來通過PowerShell腳本，從文件『SQLSeverList.csv』篩選出要啟動的SQL Server服務。再通過PowerShell中的命令 Get-WmiObject -Class Win32_Service 獲取服務對象，然後調用服務對象Win32_Service中的方法StartService() 、 StopService() 啟動或停止服務。

如果是連接遠程PC，可以採用類似命令:

Get-WmiObject -Class Win32_Service –ComputerName <string[]> – Credential <PSCredential>

完整代碼：


#===============配置部份===========================
$User='HQ\Andy';
$CsvFile='E:\Stop&StartSQLServer\SQLSeverList.csv'


#==============可輸入部份(開始)====================

$PC="VM162"           #本機使用"."來描述,非本機使用電腦名稱

$ServerNr=4     #SQL Server實例編號,來源于SQLSeverList.csv文件

$ActionType=0     # 1: 開啟服務 ,0: 停止服務

#==============可輸入部份(結束)====================
<#

“===可控制的服務列表: ”
Import-Csv -Path $CsvFile | Format-Table -AutoSize -Wrap

#>
try
{
    $ServiceStr=Import-Csv -Path $CsvFile | Where-Object -FilterScript {($_.PC -eq $PC) -And ($_.ServerNr -eq $ServerNr)}
    
    if ($PC -ne ".")  #本機
    {
        $Credential_Login=Get-Credential -Credential $User
        $Service_Agent=Get-WmiObject -Class Win32_Service -ComputerName $PC -Credential $Credential_Login | Where-Object -FilterScript {$_.Name -eq $ServiceStr.Agent}
        $Service_SQLServer=Get-WmiObject -Class Win32_Service -ComputerName $PC -Credential $Credential_Login | Where-Object -FilterScript {$_.Name -eq $ServiceStr.SQLServer}
        $Service_FullTextSearch=Get-WmiObject -Class Win32_Service -ComputerName $PC -Credential $Credential_Login | Where-Object -FilterScript {$_.Name -eq $ServiceStr.FullTextSearch}
    
    }
    Else #網絡
    {
        $Service_Agent=Get-WmiObject -Class Win32_Service | Where-Object -FilterScript {$_.Name -eq $ServiceStr.Agent}
        $Service_SQLServer=Get-WmiObject -Class Win32_Service | Where-Object -FilterScript {$_.Name -eq $ServiceStr.SQLServer}
        $Service_FullTextSearch=Get-WmiObject -Class Win32_Service | Where-Object -FilterScript {$_.Name -eq $ServiceStr.FullTextSearch}
    
    }
    
    
    $Running="Running"
    $Stopped="Stopped"
    
    If ($ActionType -eq 1) #Start Service
    {
        if ($Service_SQLServer.State -eq $Running)
            {$Service_SQLServer.Name +" 正在運行"}
        Else 
            {$Result=$Service_SQLServer.StartService()}
            
        if ($Service_Agent.State -eq $Running)
            {$Service_Agent.Name +" 正在運行"}
        Else 
            {$Result=$Service_Agent.StartService()}
        
        if ($Service_FullTextSearch.State -eq $Running)
            {$Service_FullTextSearch.Name +" 正在運行"}
        Else 
            {$Result=$Service_FullTextSearch.StartService()}                  
    }
    Else #Stop Service
    {
        if ($Service_FullTextSearch.State -eq $Stopped)
            {$Service_FullTextSearch.Name +" 已停止."}
        Else 
            {$Result=$Service_FullTextSearch.StopService()}
        
        if ($Service_Agent.State -eq $Stopped)
            {$Service_Agent.Name +" 已停止."}
        Else 
            {$Result=$Service_Agent.StopService()}
        
        if ($Service_SQLServer.State -eq $Stopped)
            {$Service_SQLServer.Name +" 已停止."}
        Else 
            {$Result=$Service_SQLServer.StopService()}                    
    }
    
    "命令處理OK!"
    
}
Catch
{
    Write-Warning "執行腳本過程發生錯誤"
    Write-Error $_ #輸出當前錯誤內容
}

演示：

現在要啟動遠程PC的SQL Server實例『VM\SQL2005DE4』，包含『VM\SQL2005DE4』的3個服務：

MSSQL$SQL2005DE4

SQLAgent$SQL2005DE4

msftesql$SQL2005DE4

$User 這裡使用的是與帳戶”HQ\Andy”,而且這個帳戶具有管理電腦VM162的權限功能。

點擊Powershell_ise介面上的三角形執行腳本按鈕。

這裡會彈出一個Windows登錄認證窗口，輸入我們的帳號密碼，點擊確認按鈕繼續。

從狀態欄就會看到正在執行的信息提示，根據實際情況運行時間長短的不同，最後我們會收到是否處理完成的提示：

如果服務已經在運行，我們就看到服務正在運行的信息提示：

小結

PowerShell腳本代碼，看起來是很容易的，而且功能還不錯，它是建立在 .NET (CLR) 和 .NET Framework 上，而且可接受和傳回 .NET 對象。在安裝SQL Server 2008中就附帶有PowerShell 1.0。目前最新版本是PowerShell 2.0.帶有Powershell_ise工具，使用起來更便捷。如果你經常涉及到管理Windows系統或SQL Server 服務器，那麼學習瞭解PowerShell是不錯的選擇。

本文链接

發行項帶篩選的合併複製問題之----訂閱者更新導致部份數據丟失

2011-10-14T14:43:00Z

开始，下边的内容是我在工作中，碰到的问题，并且拿出来进行分析和解决，是对其过程的描述。由于时间原因没有进行繁体简体的转换。在一些字眼或术语中，简体繁体之间可能存在些差异。如有不明可以通过文章后面的留言发表意见和建议，或发Email与我联系。

問題描述

在SQL Server 2005(版本：Microsoft SQL Server 2005 - 9.00.4035.00 (Intel X86))，帶篩選的合併複製中，發現有這樣的一個問題，在訂閱者Insert數據，數據上傳到發行者，然後下載至訂閱者，發現訂閱者的部份數據被Delete，如圖描述：

腳本中的存儲過程sp_InsertData，sp_DeleteData 只是爲了分析過程應用到。

下面抽取【中央DB】à【分支DB】其中1條ReplicationDB同步例子來看在訂閱者Insert數據，會導致訂閱者部份數據給Delete掉，如圖描述（同步設置過程這裡忽略）：

上图，在訂閱者向表DataRelation插入了5條記錄，並且成功上載至發行者。最後一行發現下載變更到訂閱者，對表DataRelation刪除了剛上載的5條記錄。導致了訂閱者DataRelation新增的數據丟失。在發行者上，對DataRelation新插入的數據是沒有被刪除的。

下面表格是補充例子中的幾個資料表的篩選條件：

在發行者上Insert，會不會發生類似的問題呢？在實際例子中是正常的，如图：

可以看出在在發行者向表DataRelation插入數據，下載變更到訂閱者過程中只有插入5條記錄的動作，沒看到在訂閱者的刪除動作。

問題分析

接下來，我們跟蹤合併複製的過程，來分析問題所在。SQL Server提供了一些系統表來為我們跟蹤複製的同步過程,如：

Sysmergearticles 描述發行項內容，包含有nickname發現項的暱稱，分析過程會用到這一字段關聯。
MSmerge_contents 包含已發行資料表中Inserted/Updated的行(row).
MSmerge_tombstone包含已發行資料表中deleted的行(row).
MSmerge_genhistory包含傳遞至發行者或訂閱者的變更集合.簡單說就是記錄發行者/訂閱者的Inserted/Updated/deleted歷史。
MSmerge_partition_groups資料表會針對給定資料庫中每個預先計算的資料分割，各儲存一個資料列。當前分析，暫不用應用不到。
MSmerge_current_partition_mappings 描述Inserted/Updated的分區信息，與MSmerge_contents 相關。
MSmerge_past_partition_mappings描述Updated/Deleted的分區信息，與MSmerge_contents 和MSmerge_tombstone 相關。

做個例子，在Microsoft SQL Server Management Studio(MSSMS)，連接到訂閱者伺候器上，對ReplicationDB數據庫做個Insert數據的實例，類似于前面的操作：

use ReplicationDB
GO
Begin Tran
    Insert into Data1(ID,OwnerID)
            values ('80B370BA-446A-48D3-9EAC-2DE7FDC11997',3)
            
    
    Exec sp_InsertData 
            @ID = 'ACE3BA3E-C6FE-49B5-8E19-AB2F0F894F09', -- uniqueidentifier
            @ParentID = '80B370BA-446A-48D3-9EAC-2DE7FDC11997', -- uniqueidentifier
            @DataType1 = 1, -- smallint
            @DataType2 = 2, -- smallint
            @DataType3 = default -- smallint
    
    Exec sp_InsertData 
            @ID = 'AFD1B3B5-45D1-4F97-B4DA-AA6BF965C8BD', -- uniqueidentifier
            @ParentID = '80B370BA-446A-48D3-9EAC-2DE7FDC11997', -- uniqueidentifier
            @DataType1 = 1, -- smallint
            @DataType2 = 2, -- smallint
            @DataType3 = 3 -- smallint
Commit tran

Commit Tran代碼後面，填寫上跟蹤同步過程的T-SQL語句：

--跟蹤
Select * From sysmergearticles Where name='DataRelation'
Select * From MSmerge_contents Where tablenick=16720001 Order by generation Desc /*tablenick=25999002: OUPartitionAssignmentPlan*/
Select * From MSmerge_tombstone Where tablenick=16720001 Order by generation Desc /*tablenick=25999002: OUPartitionAssignmentPlan*/
Select * From MSmerge_genhistory Where art_nick=16720001 Order by coldate Desc,generation Desc /*art_nick=25999002: OUPartitionAssignmentPlan*/
Select a.*,b.name From MSmerge_current_partition_mappings As a Inner Join sysmergearticles As b On b.nickname=a.tablenick
Select * From MSmerge_past_partition_mappings  Where tablenick=16720001 Order by generation Desc

對MSmerge, MSmerge_tombstone, MSmerge_genhistory, MSmerge_past_partition_mappings表，只是查詢出有關DataRelation表的數據，通過sysmergearticles表中的nickname列返回的值作為Where參考值。經過執行上面的兩個連續的腳本，可得到似下面的結果數據：

這裡捕捉到訂閱者MSmerge_genhistory表中有一條記錄generation=74，genstatus=1(已開啟狀態)

，來自訂閱者本身的Insert操作，影響記錄行為2，在MSmerge_contents表可以找到兩行generation=74的記錄行與之對應。

等到數據同步OK(連續執行的合併複製，默認訂閱間隔時間是1分鐘),我們再看回MSmerge_genhistory,MSmerge_contents,MSmerge_tombstone表的數據變化：

相隔大約1分鐘后，數據從發行者同步回到訂閱者，MSmerge_genhistory 發現多了1行generation=75的歷史記錄，而且在MSmerge_tombstone表中發現新加入5行generation=75的記錄行。說明有資料表DataRelation有數據被刪除了。

在訂閱者，我們發現了DataRelation 表Insert動作，引發同步過程的變化。在此期間，我們先不要對資料表DataRelation進行其他的更新刪除操作，接著來看在發行者，DataRelation 表的Insert 過程如何變化。

在發行者，MSmerge_genhistory表新插入有兩條記錄，coldate時間比較少的1條的genstatus=2,表示已關閉，並且已在另一個訂閱者產生，這個訂閱者為subscriber_number=2(可以通過Select subscriber_number,subscriber_server from sysmergesubscriptions查詢到subscriber_number對應的subscriber_serve數據)。是于generation=63，在這裡無法找到對應的關聯數據，可能是在上載到發行者的時候發生，這位置捕捉不到。

MSmerge_genhistory表中，coldate時間比較晚的1條generation=65，可以在MSmerge_contents，MSmerge_past_partition_mappings表中找到對應的數據。問題就是這裡，MSmerge_past_partition_mappings中怎麼會存在generation=65的數據，按正常，Insert數據的時候，在MSmerge_current_partition_mappings表有1條或多條記錄與之對應。出現在MSmerge_past_partition_mappings表，只有Update or Delete的時候才會發生。

跟蹤都這裡，開始的時候，我判斷在SQL Server 合併複製中的觸發器某一環節出現bug導致這樣的問題出現，還在SQL Server 2008 R2上測試沒問題。後來查證了MSDN上的資料，得到一些啓發:

在合併同步處理期間，依預設，發行項將按物件間相依性所需的順序處理，包括在基底資料表上定義的宣告式參考完整性 (DRI) 條件約束。處理包括列舉對資料表所作的變更，然後套用這些變更。如果沒有 DRI，但資料表發行項之間存在聯結篩選或邏輯記錄，發行項將以篩選和邏輯記錄所需的順序處理。透過 DRI、聯結篩選、邏輯記錄或其他相依性與任何其他發行項無關的發行項。

根據這一說明，先從DRI方面考慮，先去瞭解各個表的結構。因為沒有設置過邏輯記錄的順序處理編號，通過下面的T-SQL語句可以查詢：

Select name,processing_order From sysmergearticles

當看回表結構的時候，果真發現了問題所在：

Create Table [DataRelation]
    (
        [ID] uniqueidentifier not null ,
        [ParentID] uniqueidentifier Null ,
        [DataTypeID] smallint Null 
    )
    Alter Table [DataRelation] Add Constraint [PK_DataRelation] Primary Key Nonclustered ([ID] Asc)
    Alter Table [DataRelation] Add Constraint [FK_DataRelation_DataTypeID] Foreign Key ([DataTypeID]) References [SysDataType] ([ID])
    Alter Table [DataRelation] Add Constraint [U_DataRelation_ParentID_DataTypeID] Unique Nonclustered ([ParentID],[DataTypeID])

資料表DataRelation，在字段ParentID上沒有創建外鍵約束。這裡沒有外鍵約束，同步過程中無法套用DRI條件約束，而且又沒設置邏輯記錄的順序處理，導致了問題所在。

提示：

如果想瞭解有關SQL Server 合併複製的跟蹤說明，可以參考聯機幫助文檔的《合併式複寫如何追蹤和列舉變更》：

http://msdn.microsoft.com/zh-cn/library/ms151789(v=SQL.90).aspx （簡體說明）

http://msdn.microsoft.com/zh-tw/library/ms151789(v=SQL.90).aspx (繁體說明)

http://msdn.microsoft.com/en-us/library/ms151789(v=SQL.90).aspx (英文說明)

《指定合併發行項的處理順序》:

http://msdn.microsoft.com/zh-cn/library/ms152469(v=SQL.90) (簡體說明)

http://msdn.microsoft.com/zh-tw/library/ms152469(v=SQL.90) (繁體說明)

術語：

DRI: declarative referential integrity 宣告式參考完整性，簡體意思是声明性引用完整性。

解決方法

根據前邊的分析，這裡列出幾個解決方法:

增加外鍵約束，在資料表DataRelation字段ParentID上增加外鍵約束
增加Check約束，在資料表DataRelation創建Check約束，檢查ParentID是否在資料表DATA2存在
設置邏輯記錄的處理順序

增加外鍵約束:

在不重新設置同步複寫的前提下，在發行者實例上執行創建外鍵的腳本：

use ReplicationDB
Go
if object_id('FK_DataRelation_ParentID') Is null
    Alter table DataRelation Add COnstraint FK_DataRelation_ParentID foreign Key(ParentID) References Data2(ID)
Go

增加Check約束:

在不重新設置同步複寫的前提下，增加Check約束需要按嚴格的步驟進行。先在發行者和訂閱者兩個實例上執行腳本(檢查資料表DataRelation中的ParentID列數據是否在資料表Data2中存在)：

use ReplicationDB
Go
if object_id('Fn_CheckDataRelation_ParentID') Is Not Null
    Drop Function Fn_CheckDataRelation_ParentID
GO
Create Function Fn_CheckDataRelation_ParentID
(
    @ParentID uniqueidentifier
)
Returns bit
As
begin
Return(Select Case When Exists(Select 1 From Data2 Where ID=@ParentID) Then 1 Else 0 End)
End
Go

再在發行者實例上執行下面的創建Check約束腳本：

use ReplicationDB
Go
if object_id('CK_DataRelation_ParentID') Is null
    Alter table DataRelation Add COnstraint CK_DataRelation_ParentID Check(dbo.Fn_CheckDataRelation_ParentID(ParentID)=1)
Go

設置邏輯記錄的處理順序:

在不重新設置同步複寫的前提下，在發行者實例上執行下面的腳本

use ReplicationDB
Go
Exec sys.sp_changemergearticle 
      @publication = 'Merge-PC3',
        @article = 'DataOwner',
        @property = 'processing_order',
        @value = 10,
        @force_invalidate_snapshot =0,
        @force_reinit_subscription =0

Exec sys.sp_changemergearticle 
      @publication = 'Merge-PC3',
        @article = 'Data1',
        @property = 'processing_order',
        @value = 20,
        @force_invalidate_snapshot =0,
        @force_reinit_subscription =0
        
Exec sys.sp_changemergearticle 
      @publication = 'Merge-PC3',
        @article = 'Data2',
        @property = 'processing_order',
        @value = 30,
        @force_invalidate_snapshot =0,
        @force_reinit_subscription =0

Exec sys.sp_changemergearticle 
      @publication = 'Merge-PC3',
        @article = 'DataRelation',
        @property = 'processing_order',
        @value = 40,
        @force_invalidate_snapshot =0,
        @force_reinit_subscription =0

上面腳本是通過SQL Server提供的系統函數sys.sp_changemergearticle 來設置各個表的同步處理順序：

當Insert數據的時候，會先處理資料表DataOwner，最後是處理資料表DataRelation。相反，當Delete數據的時候，會先處理資料表DataRelation,最後處理資料表DataOwner。

數值10,20,30,40 這樣的設置，也是有其意義的，當我們日後有新增一張資料表，它在合併複製中的處理順序是在資料表Data1和資料表Data2之間，那麼我們直接設置新增加的資料表處理順序為25，不需要再設置處理順序>20的資料表處理順序。這一點在真實應用環境中，是值得參考的。

小結：

綜上所述，在具有篩選的合併式複製中，在篩選條件中含有多表關聯時候，特別要注意表的結構，檢查篩選的字段是否存在外鍵、Check約束，或者是否有設置了合併複製的處理順序。在一些古老的數據庫機構中，我們無法保證篩選的字段存在外鍵或Check約束，這時候，個人認為優先考慮的是外鍵，無法使用外鍵的時候，考慮是否可以使用Check約束；在不能改變數據庫資料表結構，或者對各表的關係非常的熟悉，最後可以考慮使用合併複製中的處理順序功能。

附件，提供这篇文章的DOC格式文档，喜欢的朋友下载调式：

/Files/wghao/發行項帶篩選的合併複製問題之----訂閱者更新導致部份數據丟失.doc

本文链接

通过批处理脚本启动/停止SQL Server服务

2011-09-23T15:30:00Z

原因

先说写这篇文章的原因，这里通过两个简单的案例说明。

案例一：在一个Windows操作系统中，安装有10个SQL Server实例，每一个实例存在大约120个数据库。现在要同时启动10个实例的服务(SQL Server & SQL Server Agent & SQL Server FullText Search)。通过SQL Server Configuration Manager，需要一个实例，一个服务的一一启动。那是多么繁琐、笨拙的操作。

案例二：在案例一的场景，启动了全部的实例。不久，就发现程序运行缓慢，即使在Microsoft SQL Server Management Studio(MSMS)管理器查询数据，都有如蜗牛爬树。这时候，需要关闭一些暂时不用的SQL Server实例的服务。等需要的时候再启动。一些时候，可能会碰到经常要关闭这个实例的服务，启动另外实例的服务，以便解决Windows系统资源紧张的问题。

解决

解决上面案例繁琐的操作问题，可以考虑通过Net命令，来启动或停止各个SQLServer服务，如：

net Start SQLAgent$SQL2005DE1 /*启动实例SQL2005DE1中的SQLAgent服务*/

net Stop SQLAgent$SQL2005DE1 /*停止实例SQL2005DE1中的SQLAgent服务*/

根据Net命令，可以通过编写一个批处理脚本实现，启动各个实例的各服务。Copy下面的代码，存储为后缀名为Bat的批处理文件“Start&StopSQLServer.bat”:

:a
echo 本机的实例列表：
echo ---------------------------
echo     1    PC143\SQL2005DE1
echo     2    PC143\SQL2005DE2
echo     3    PC143\SQL2005DE3
echo     4    PC143\SQL2005DE4
echo     5    PC143\SQL2005DE5
echo     6    PC143\SQL2005DE6
echo     7    PC143\SQL2005DE7
echo     8    PC143\SQL2005DE8
echo     9    PC143\SQL2005DE9
echo     10    PC143\SQL2005DE10
echo ---------------------------
echo 操作动作：
echo     1     启动服务
echo     0     停止服务
echo ---------------------------
echo.
Set/p var2=请输入操作动作：[1/0]
Set/p var1=请输入实例编号：[1/2/3/4/5/6/7/8/9/10]
if %var1% ==1 if %var2% ==1 goto S1
if %var1% ==2 if %var2% ==1 goto S2
if %var1% ==3 if %var2% ==1 goto S3
if %var1% ==4 if %var2% ==1 goto S4
if %var1% ==5 if %var2% ==1 goto S5
if %var1% ==6 if %var2% ==1 goto S6
if %var1% ==7 if %var2% ==1 goto S7
if %var1% ==8 if %var2% ==1 goto S8
if %var1% ==9 if %var2% ==1 goto S9
if %var1% ==10 if %var2% ==1 goto S10
if %var1% ==1 if %var2% ==0 goto T1
if %var1% ==2 if %var2% ==0 goto T2
if %var1% ==3 if %var2% ==0 goto T3
if %var1% ==4 if %var2% ==0 goto T4
if %var1% ==5 if %var2% ==0 goto T5
if %var1% ==6 if %var2% ==0 goto T6
if %var1% ==7 if %var2% ==0 goto T7
if %var1% ==8 if %var2% ==0 goto T8
if %var1% ==9 if %var2% ==0 goto T9
if %var1% ==10 if %var2% ==0 goto T10
echo.
cls
goto a:
echo.
:S1
net Start SQLAgent$SQL2005DE1 /Y
net Start msftesql$SQL2005DE1 /Y
goto EndApp
echo.
:S2
net Start SQLAgent$SQL2005DE2 /Y
net Start msftesql$SQL2005DE2 /Y
goto EndApp
echo.
:S3
net Start SQLAgent$SQL2005DE3 /Y
net Start msftesql$SQL2005DE3 /Y
goto EndApp
echo.
:S4
net Start SQLAgent$SQL2005DE4 /Y
net Start msftesql$SQL2005DE4 /Y
goto EndApp
echo.
:S5
net Start SQLAgent$SQL2005DE5 /Y
net Start msftesql$SQL2005DE5 /Y
goto EndApp
echo.
:S6
net Start SQLAgent$SQL2005DE6 /Y
net Start msftesql$SQL2005DE6 /Y
goto EndApp
echo.
:S7
net Start SQLAgent$SQL2005DE7 /Y
net Start msftesql$SQL2005DE7 /Y
goto EndApp
echo.
:S8
net Start SQLAgent$SQL2005DE8 /Y
net Start msftesql$SQL2005DE8 /Y
goto EndApp
echo.
:S9
net Start SQLAgent$SQL2005DE9 /Y
net Start msftesql$SQL2005DE9 /Y
goto EndApp
echo.
:S10
net Start SQLAgent$SQL2005DE10 /Y
net Start msftesql$SQL2005DE10 /Y
goto EndApp
echo.
:T1
net Stop MSSQL$SQL2005DE1 /Y
net Stop msftesql$SQL2005DE1 /Y
goto EndApp
echo.
:T2
net Stop MSSQL$SQL2005DE2 /Y
net Stop msftesql$SQL2005DE2 /Y
goto EndApp
echo.
:T3
net Stop MSSQL$SQL2005DE3 /Y
net Stop msftesql$SQL2005DE3 /Y
goto EndApp
echo.
:T4
net Stop MSSQL$SQL2005DE4 /Y
net Stop msftesql$SQL2005DE4 /Y
goto EndApp
echo.
:T5
net Stop MSSQL$SQL2005DE5 /Y
net Stop msftesql$SQL2005DE5 /Y
goto EndApp
:T6
net Stop MSSQL$SQL2005DE6 /Y
net Stop msftesql$SQL2005DE6 /Y
goto EndApp
:T7
net Stop MSSQL$SQL2005DE7 /Y
net Stop msftesql$SQL2005DE7 /Y
goto EndApp
:T8
net Stop MSSQL$SQL2005DE8 /Y
net Stop msftesql$SQL2005DE8 /Y
goto EndApp
:T9
net Stop MSSQL$SQL2005DE9 /Y
net Stop msftesql$SQL2005DE9 /Y
goto EndApp
:T10
net Stop MSSQL$SQL2005DE10 /Y
net Stop msftesql$SQL2005DE10 /Y
goto EndApp
:EndApp
Set/p var3=是否继续操作：[y/n]
If %var3% == y goto a:

这里演示了PC143上的10个SQL Server实例启动、停止的批处理脚本。下面来运行这个脚本，启动PC143上其中一个实例服务PC143\SQL2005DE4：

关闭实例服务，类似启动实例服务，如：

小结

上面的批处理脚本，虽然代码看似很长，其实格式很简单，熟悉Windows批处理脚本的朋友，一定能简化它。启动或停止实例的服务，还可以使用别的后台脚本语言实现，如Windows PowerShell，或Python。无论使用哪一种，最终目的是要解决文章开头的两个案例问题。写批处理脚本，能让我们少敲次键盘，少按几次鼠标。通过简单的脚本代码实现，代替一些繁琐笨拙的操作，久而久之，会发觉它们能为我们节省了不少的时间，提高了工作效率。

本文链接