-
-
Notifications
You must be signed in to change notification settings - Fork 794
/
Publish-DbaDacPackage.ps1
376 lines (325 loc) · 19 KB
/
Publish-DbaDacPackage.ps1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
function Publish-DbaDacPackage {
<#
.SYNOPSIS
The Publish-DbaDacPackage command takes a dacpac and publishes it to a database.
.DESCRIPTION
Publishes the dacpac taken from SSDT project or Export-DbaDacPackage. Changing the schema to match the dacpac and also to run any scripts in the dacpac (pre/post deploy scripts).
.PARAMETER SqlInstance
The target SQL Server instance or instances.
.PARAMETER SqlCredential
Login to the target instance using alternative credentials. Accepts PowerShell credentials (Get-Credential).
Windows Authentication, SQL Server Authentication, Active Directory - Password, and Active Directory - Integrated are all supported.
For MFA support, please use Connect-DbaInstance.
.PARAMETER Path
Specifies the filesystem path to the DACPAC
.PARAMETER PublishXml
Specifies the publish profile which will include options and sqlCmdVariables.
.PARAMETER Database
Specifies the name of the database being published.
.PARAMETER ConnectionString
Specifies the connection string to the database you are upgrading. This is not required if SqlInstance is specified.
.PARAMETER GenerateDeploymentScript
If this switch is enabled, the publish script will be generated.
.PARAMETER GenerateDeploymentReport
If this switch is enabled, the publish XML report will be generated.
.PARAMETER Type
Selecting the type of the export: Dacpac (default) or Bacpac.
.PARAMETER DacOption
Export options for a corresponding export type. Can be created by New-DbaDacOption -Type Dacpac | Bacpac
.PARAMETER OutputPath
Specifies the filesystem path (directory) where output files will be generated.
.PARAMETER ScriptOnly
If this switch is enabled, only the change scripts will be generated.
.PARAMETER IncludeSqlCmdVars
If this switch is enabled, SqlCmdVars in publish.xml will have their values overwritten.
.PARAMETER WhatIf
Shows what would happen if the command were to run. No actions are actually performed.
.PARAMETER Confirm
Prompts you for confirmation before executing any changing operations within the command.
.PARAMETER EnableException
By default, when something goes wrong we try to catch it, interpret it and give you a friendly warning message.
This avoids overwhelming you with "sea of red" exceptions, but is inconvenient because it basically disables advanced scripting.
Using this switch turns this "nice by default" feature off and enables you to catch exceptions with your own try/catch.
.PARAMETER DacFxPath
Path to the dac dll. If this is omitted, then the version of dac dll which is packaged with dbatools is used.
.NOTES
Tags: Migration, Database, Dacpac
Author: Richie lee (@richiebzzzt)
Website: https://dbatools.io
Copyright: (c) 2018 by dbatools, licensed under MIT
License: MIT https://opensource.org/licenses/MIT
Deploying a dacpac uses the DacFx which historically needed to be installed on a machine prior to use. In 2016 the DacFx was supplied by Microsoft as a nuget package (Microsoft.Data.Tools.MSBuild) and this uses that nuget package.
.LINK
https://dbatools.io/Publish-DbaDacPackage
.EXAMPLE
PS C:\> $options = New-DbaDacOption -Type Dacpac -Action Publish
PS C:\> $options.DeployOptions.DropObjectsNotInSource = $true
PS C:\> Publish-DbaDacPackage -SqlInstance sql2016 -Database DB1 -DacOption $options -Path c:\temp\db.dacpac
Uses DacOption object to set Deployment Options and updates DB1 database on sql2016 from the db.dacpac dacpac file, dropping objects that are missing from source.
.EXAMPLE
PS C:\> Publish-DbaDacPackage -SqlInstance sql2017 -Database WideWorldImporters -Path C:\temp\sql2016-WideWorldImporters.dacpac -PublishXml C:\temp\sql2016-WideWorldImporters-publish.xml -Confirm
Updates WideWorldImporters on sql2017 from the sql2016-WideWorldImporters.dacpac using the sql2016-WideWorldImporters-publish.xml publish profile. Prompts for confirmation.
.EXAMPLE
PS C:\> New-DbaDacProfile -SqlInstance sql2016 -Database db2 -Path C:\temp
PS C:\> Export-DbaDacPackage -SqlInstance sql2016 -Database db2 | Publish-DbaDacPackage -PublishXml C:\temp\sql2016-db2-publish.xml -Database db1, db2 -SqlInstance sql2017
Creates a publish profile at C:\temp\sql2016-db2-publish.xml, exports the .dacpac to $home\Documents\sql2016-db2.dacpac. Does not prompt for confirmation.
then publishes it to the sql2017 server database db2
.EXAMPLE
PS C:\> $loc = "C:\Users\bob\source\repos\Microsoft.Data.Tools.Msbuild\lib\net46\Microsoft.SqlServer.Dac.dll"
PS C:\> Publish-DbaDacPackage -SqlInstance "local" -Database WideWorldImporters -Path C:\temp\WideWorldImporters.dacpac -PublishXml C:\temp\WideWorldImporters.publish.xml -DacFxPath $loc -Confirm
Publishes the dacpac using a specific dacfx library. Prompts for confirmation.
.EXAMPLE
PS C:\> Publish-DbaDacPackage -SqlInstance sql2017 -Database WideWorldImporters -Path C:\temp\sql2016-WideWorldImporters.dacpac -PublishXml C:\temp\sql2016-WideWorldImporters-publish.xml -GenerateDeploymentScript -ScriptOnly
Does not deploy the changes, but will generate the deployment script that would be executed against WideWorldImporters.
#>
[CmdletBinding(DefaultParameterSetName = 'Obj', SupportsShouldProcess, ConfirmImpact = 'Medium')]
param (
[DbaInstance[]]$SqlInstance,
[PSCredential]$SqlCredential,
[Parameter(Mandatory, ValueFromPipelineByPropertyName)]
[string]$Path,
[Parameter(Mandatory, ParameterSetName = 'Xml')]
[string]$PublishXml,
[Parameter(Mandatory, ValueFromPipelineByPropertyName)]
[string[]]$Database,
[string[]]$ConnectionString,
[parameter(ParameterSetName = 'Xml')]
[switch]$GenerateDeploymentScript,
[parameter(ParameterSetName = 'Xml')]
[switch]$GenerateDeploymentReport,
[Switch]$ScriptOnly,
[ValidateSet('Dacpac', 'Bacpac')]
[string]$Type = 'Dacpac',
[string]$OutputPath = "$home\Documents",
[switch]$IncludeSqlCmdVars,
[Parameter(ParameterSetName = 'Obj')]
[Alias("Option")]
[object]$DacOption,
[switch]$EnableException,
[String]$DacFxPath
)
begin {
if ((Test-Bound -Not -ParameterName SqlInstance) -and (Test-Bound -Not -ParameterName ConnectionString)) {
Stop-Function -Message "You must specify either SqlInstance or ConnectionString."
return
}
if ($Type -eq 'Dacpac') {
if ((Test-Bound -ParameterName GenerateDeploymentScript) -or (Test-Bound -ParameterName GenerateDeploymentReport)) {
$defaultcolumns = 'ComputerName', 'InstanceName', 'SqlInstance', 'Database', 'Dacpac', 'PublishXml', 'Result', 'DatabaseScriptPath', 'MasterDbScriptPath', 'DeploymentReport', 'DeployOptions', 'SqlCmdVariableValues'
} else {
$defaultcolumns = 'ComputerName', 'InstanceName', 'SqlInstance', 'Database', 'Dacpac', 'PublishXml', 'Result', 'DeployOptions', 'SqlCmdVariableValues'
}
} elseif ($Type -eq 'Bacpac') {
if ($ScriptOnly -or $GenerateDeploymentReport -or $GenerateDeploymentScript) {
Stop-Function -Message "ScriptOnly, GenerateDeploymentScript, and GenerateDeploymentReport cannot be used in a Bacpac scenario." -ErrorRecord $_
return
}
$defaultcolumns = 'ComputerName', 'InstanceName', 'SqlInstance', 'Database', 'Bacpac', 'Result', 'DeployOptions'
}
if ((Test-Bound -ParameterName ScriptOnly) -and (Test-Bound -Not -ParameterName GenerateDeploymentScript) -and (Test-Bound -Not -ParameterName GenerateDeploymentScript)) {
Stop-Function -Message "You must at least one of GenerateDeploymentScript or GenerateDeploymentReport when using ScriptOnly"
return
}
function Get-ServerName ($connstring) {
$builder = New-Object System.Data.Common.DbConnectionStringBuilder
$builder.set_ConnectionString($connstring)
$instance = $builder['data source']
if (-not $instance) {
$instance = $builder['server']
}
return $instance.ToString().Replace('\', '-').Replace('(', '').Replace(')', '')
}
if ((Test-Bound -Not -ParameterName 'DacfxPath') -and (-not $script:core)) {
$dacfxPath = "$script:PSModuleRoot\bin\smo\Microsoft.SqlServer.Dac.dll"
if ((Test-Path $dacfxPath) -eq $false) {
Stop-Function -Message 'No usable version of Dac Fx found.' -EnableException $EnableException
return
} else {
try {
Add-Type -Path $dacfxPath
Write-Message -Level Verbose -Message "Dac Fx loaded."
} catch {
Stop-Function -Message 'No usable version of Dac Fx found.' -EnableException $EnableException -ErrorRecord $_
}
}
}
#Check Option object types - should have a specific type
if ($Type -eq 'Dacpac') {
if ($DacOption -and $DacOption -isnot [Microsoft.SqlServer.Dac.PublishOptions]) {
Stop-Function -Message "Microsoft.SqlServer.Dac.PublishOptions object type is expected - got $($DacOption.GetType())."
return
}
} elseif ($Type -eq 'Bacpac') {
if ($DacOption -and $DacOption -isnot [Microsoft.SqlServer.Dac.DacImportOptions]) {
Stop-Function -Message "Microsoft.SqlServer.Dac.DacImportOptions object type is expected - got $($DacOption.GetType())."
return
}
}
}
process {
if (Test-FunctionInterrupt) {
return
}
if (-not (Test-Path -Path $Path)) {
Stop-Function -Message "$Path not found."
return
}
if ($PsCmdlet.ParameterSetName -eq 'Xml') {
if (-not (Test-Path -Path $PublishXml)) {
Stop-Function -Message "$PublishXml not found."
return
}
}
foreach ($instance in $sqlinstance) {
try {
$server = Connect-SqlInstance -SqlInstance $instance -SqlCredential $sqlcredential
} catch {
Stop-Function -Message "Failure." -Category ConnectionError -ErrorRecord $_ -Target $instance -Continue
}
$ConnectionString += $server.ConnectionContext.ConnectionString.Replace('"', "'")
}
#Use proper class to load the object
if ($Type -eq 'Dacpac') {
try {
$dacPackage = [Microsoft.SqlServer.Dac.DacPackage]::Load($Path)
} catch {
Stop-Function -Message "Could not load Dacpac." -ErrorRecord $_
return
}
} elseif ($Type -eq 'Bacpac') {
try {
$bacPackage = [Microsoft.SqlServer.Dac.BacPackage]::Load($Path)
} catch {
Stop-Function -Message "Could not load Bacpac." -ErrorRecord $_
return
}
}
#Load XML profile when used
if ($PsCmdlet.ParameterSetName -eq 'Xml') {
try {
$options = New-DbaDacOption -Type $Type -Action Publish -PublishXml $PublishXml -EnableException
} catch {
Stop-Function -Message "Could not load profile." -ErrorRecord $_
return
}
}
#Create/re-use deployment options object
elseif ($PsCmdlet.ParameterSetName -eq 'Obj') {
if (!$DacOption) {
$options = New-DbaDacOption -Type $Type -Action Publish
} else {
$options = $DacOption
}
}
#Replace variables if defined
if ($IncludeSqlCmdVars) {
Get-SqlCmdVars -SqlCommandVariableValues $options.DeployOptions.SqlCommandVariableValues
}
foreach ($connstring in $ConnectionString) {
$cleaninstance = Get-ServerName $connstring
$instance = $cleaninstance.ToString().Replace('--', '\')
foreach ($dbname in $database) {
#Set deployment properties when specified
if (Test-Bound -ParameterName GenerateDeploymentScript) {
$options.GenerateDeploymentScript = $GenerateDeploymentScript
}
if (Test-Bound -ParameterName GenerateDeploymentReport) {
$options.GenerateDeploymentReport = $GenerateDeploymentReport
}
#Set output file paths when needed
$timeStamp = (Get-Date).ToString("yyMMdd_HHmmss_f")
if ($GenerateDeploymentScript) {
$options.DatabaseScriptPath = Join-Path $OutputPath "$cleaninstance-$dbname`_DeployScript_$timeStamp.sql"
$options.MasterDbScriptPath = Join-Path $OutputPath "$cleaninstance-$dbname`_Master.DeployScript_$timeStamp.sql"
}
if ($connstring -notmatch 'Database=') {
$connstring = "$connstring;Database=$dbname"
}
#Create services object
try {
$dacServices = New-Object Microsoft.SqlServer.Dac.DacServices $connstring
} catch {
Stop-Function -Message "Error occurred while establishing connection to $instance" -Category ConnectionError -ErrorRecord $_ -Target $server -Continue
}
try {
$null = $output = Register-ObjectEvent -InputObject $dacServices -EventName "Message" -SourceIdentifier "msg" -ErrorAction SilentlyContinue -Action {
$EventArgs.Message.Message
}
#Perform proper action depending on the Type
if ($Type -eq 'Dacpac') {
if ($ScriptOnly) {
if (!$options.GenerateDeploymentScript) {
Stop-Function -Message "GenerateDeploymentScript option should be specified when running with -ScriptOnly" -EnableException $true
}
if (!$options.DatabaseScriptPath) {
Stop-Function -Message "DatabaseScriptPath option should be specified when running with -ScriptOnly" -EnableException $true
}
if ($Pscmdlet.ShouldProcess($instance, "Generating script")) {
$result = $dacServices.Script($dacPackage, $dbname, $options)
}
} else {
if ($Pscmdlet.ShouldProcess($instance, "Executing Dacpac publish")) {
$result = $dacServices.Publish($dacPackage, $dbname, $options)
}
}
} elseif ($Type -eq 'Bacpac') {
if ($Pscmdlet.ShouldProcess($instance, "Executing Bacpac import")) {
$dacServices.ImportBacpac($bacPackage, $dbname, $options, $null)
}
}
} catch [Microsoft.SqlServer.Dac.DacServicesException] {
Stop-Function -Message "Deployment failed" -ErrorRecord $_ -Continue
} finally {
Unregister-Event -SourceIdentifier "msg"
if ($Pscmdlet.ShouldProcess($instance, "Generating deployment report and output")) {
if ($options.GenerateDeploymentReport) {
$deploymentReport = Join-Path $OutputPath "$cleaninstance-$dbname`_Result.DeploymentReport_$timeStamp.xml"
$result.DeploymentReport | Out-File $deploymentReport
Write-Message -Level Verbose -Message "Deployment Report - $deploymentReport."
}
if ($options.GenerateDeploymentScript) {
Write-Message -Level Verbose -Message "Database change script - $($options.DatabaseScriptPath)."
if ((Test-Path $options.MasterDbScriptPath)) {
Write-Message -Level Verbose -Message "Master database change script - $($result.MasterDbScript)."
}
}
$resultoutput = ($output.output -join "`r`n" | Out-String).Trim()
if ($resultoutput -match "Failed" -and ($options.GenerateDeploymentReport -or $options.GenerateDeploymentScript)) {
Write-Message -Level Warning -Message "Seems like the attempt to publish/script may have failed. If scripts have not generated load dacpac into Visual Studio to check SQL is valid."
}
$server = [dbainstance]$instance
if ($Type -eq 'Dacpac') {
$output = [pscustomobject]@{
ComputerName = $server.ComputerName
InstanceName = $server.InstanceName
SqlInstance = $server.FullName
Database = $dbname
Result = $resultoutput
Dacpac = $Path
PublishXml = $PublishXml
ConnectionString = $connstring
DatabaseScriptPath = $options.DatabaseScriptPath
MasterDbScriptPath = $options.MasterDbScriptPath
DeploymentReport = $DeploymentReport
DeployOptions = $options.DeployOptions | Select-Object -Property * -ExcludeProperty "SqlCommandVariableValues"
SqlCmdVariableValues = $options.DeployOptions.SqlCommandVariableValues.Keys
}
} elseif ($Type -eq 'Bacpac') {
$output = [pscustomobject]@{
ComputerName = $server.ComputerName
InstanceName = $server.InstanceName
SqlInstance = $server.FullName
Database = $dbname
Result = $resultoutput
Bacpac = $Path
ConnectionString = $connstring
DeployOptions = $options
}
}
$output | Select-DefaultView -Property $defaultcolumns
}
}
}
}
}
}