-
-
Notifications
You must be signed in to change notification settings - Fork 790
/
Write-DbaDbTableData.ps1
662 lines (544 loc) · 28.1 KB
/
Write-DbaDbTableData.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
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
function Write-DbaDbTableData {
<#
.SYNOPSIS
Writes data to a SQL Server Table.
.DESCRIPTION
Writes a .NET DataTable to a SQL Server table using SQL Bulk Copy.
.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 Database
The database where the Input Object data will be written
.PARAMETER InputObject
This is the DataTable (or data row) to import to SQL Server.
.PARAMETER Table
The table name to import data into. You can specify a one, two, or three part table name. If you specify a one or two part name, you must also use -Database.
If the table does not exist, you can use -AutoCreateTable to automatically create the table with inefficient data types.
If the object has special characters please wrap them in square brackets [ ].
Using dbo.First.Table will try to import to a table named 'Table' on schema 'First' and database 'dbo'.
The correct way to import to a table named 'First.Table' on schema 'dbo' is by passing dbo.[First.Table]
Any actual usage of the ] must be escaped by duplicating the ] character.
The correct way to import to a table Name] in schema Schema.Name is by passing [Schema.Name].[Name]]]
.PARAMETER Schema
Defaults to dbo if no schema is specified.
.PARAMETER BatchSize
The BatchSize for the import defaults to 5000.
.PARAMETER NotifyAfter
Sets the option to show the notification after so many rows of import
.PARAMETER AutoCreateTable
If this switch is enabled, the table will be created if it does not already exist. The table will be created with sub-optimal data types such as nvarchar(max)
.PARAMETER NoTableLock
If this switch is enabled, a table lock (TABLOCK) will not be placed on the destination table. By default, this operation will lock the destination table while running.
.PARAMETER CheckConstraints
If this switch is enabled, the SqlBulkCopy option to process check constraints will be enabled.
Per Microsoft "Check constraints while data is being inserted. By default, constraints are not checked."
.PARAMETER FireTriggers
If this switch is enabled, the SqlBulkCopy option to fire insert triggers will be enabled.
Per Microsoft "When specified, cause the server to fire the insert triggers for the rows being inserted into the Database."
.PARAMETER KeepIdentity
If this switch is enabled, the SqlBulkCopy option to preserve source identity values will be enabled.
Per Microsoft "Preserve source identity values. When not specified, identity values are assigned by the destination."
.PARAMETER KeepNulls
If this switch is enabled, the SqlBulkCopy option to preserve NULL values will be enabled.
Per Microsoft "Preserve null values in the destination table regardless of the settings for default values. When not specified, null values are replaced by default values where applicable."
.PARAMETER Truncate
If this switch is enabled, the destination table will be truncated after prompting for confirmation.
.PARAMETER BulkCopyTimeOut
Value in seconds for the BulkCopy operations timeout. The default is 30 seconds.
.PARAMETER WhatIf
If this switch is enabled, no actions are performed but informational messages will be displayed that explain what would happen if the command were to run.
.PARAMETER Confirm
If this switch is enabled, you will be prompted for confirmation before executing any operations that change state.
.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 UseDynamicStringLength
By default, all string columns will be NVARCHAR(MAX).
If this switch is enabled, all columns will get the length specified by the column's MaxLength property (if specified)
.NOTES
Tags: DataTable, Insert
Author: Chrissy LeMaire (@cl), netnerds.net
Website: https://dbatools.io
Copyright: (c) 2018 by dbatools, licensed under MIT
License: MIT https://opensource.org/licenses/MIT
.LINK
https://dbatools.io/Write-DbaDbTableData
.EXAMPLE
PS C:\> $DataTable = Import-Csv C:\temp\customers.csv
PS C:\> Write-DbaDbTableData -SqlInstance sql2014 -InputObject $DataTable -Table mydb.dbo.customers
Performs a bulk insert of all the data in customers.csv into database mydb, schema dbo, table customers. A progress bar will be shown as rows are inserted. If the destination table does not exist, the import will be halted.
.EXAMPLE
PS C:\> $tableName = "MyTestData"
PS C:\> $query = "SELECT name, create_date, owner_sid FROM sys.databases"
PS C:\> $dataset = Invoke-DbaQuery -SqlInstance 'localhost,1417' -SqlCredential $containerCred -Database master -Query $query
PS C:\> $dataset | Select-Object name, create_date, @{L="owner_sid";E={$_."owner_sid"}} | Write-DbaDbTableData -SqlInstance 'localhost,1417' -SqlCredential $containerCred -Database tempdb -Table myTestData -Schema dbo -AutoCreateTable
Pulls data from a SQL Server instance and then performs a bulk insert of the dataset to a new, auto-generated table tempdb.dbo.MyTestData.
.EXAMPLE
PS C:\> $DataTable = Import-Csv C:\temp\customers.csv
PS C:\> Write-DbaDbTableData -SqlInstance sql2014 -InputObject $DataTable -Table mydb.dbo.customers -AutoCreateTable -Confirm
Performs a bulk insert of all the data in customers.csv. If mydb.dbo.customers does not exist, it will be created with inefficient but forgiving DataTypes.
Prompts for confirmation before a variety of steps.
.EXAMPLE
PS C:\> $DataTable = Import-Csv C:\temp\customers.csv
PS C:\> Write-DbaDbTableData -SqlInstance sql2014 -InputObject $DataTable -Table mydb.dbo.customers -Truncate
Performs a bulk insert of all the data in customers.csv. Prior to importing into mydb.dbo.customers, the user is informed that the table will be truncated and asks for confirmation. The user is prompted again to perform the import.
.EXAMPLE
PS C:\> $DataTable = Import-Csv C:\temp\customers.csv
PS C:\> Write-DbaDbTableData -SqlInstance sql2014 -InputObject $DataTable -Database mydb -Table customers -KeepNulls
Performs a bulk insert of all the data in customers.csv into mydb.dbo.customers. Because Schema was not specified, dbo was used. NULL values in the destination table will be preserved.
.EXAMPLE
PS C:\> $passwd = ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force
PS C:\> $AzureCredential = New-Object System.Management.Automation.PSCredential("AzureAccount"),$passwd)
PS C:\> $DataTable = Import-Csv C:\temp\customers.csv
PS C:\> Write-DbaDbTableData -SqlInstance AzureDB.database.windows.net -InputObject $DataTable -Database mydb -Table customers -KeepNulls -SqlCredential $AzureCredential -BulkCopyTimeOut 300
This performs the same operation as the previous example, but against a SQL Azure Database instance using the required credentials.
.EXAMPLE
PS C:\> $process = Get-Process
PS C:\> Write-DbaDbTableData -InputObject $process -SqlInstance sql2014 -Table "[[DbName]]].[Schema.With.Dots].[`"[Process]]`"]" -AutoCreateTable
Creates a table based on the Process object with over 60 columns, converted from PowerShell data types to SQL Server data types. After the table is created a bulk insert is performed to add process information into the table
Writes the results of Get-Process to a table named: "[Process]" in schema named: Schema.With.Dots in database named: [DbName]
The Table name, Schema name and Database name must be wrapped in square brackets [ ]
Special characters like " must be escaped by a ` character.
In addition any actual instance of the ] character must be escaped by being duplicated.
This is an example of the type conversion in action. All process properties are converted, including special types like TimeSpan. Script properties are resolved before the type conversion starts thanks to ConvertTo-DbaDataTable.
#>
[CmdletBinding(SupportsShouldProcess, ConfirmImpact = "Low")]
param (
[Parameter(Mandatory)]
[ValidateNotNull()]
[DbaInstanceParameter]$SqlInstance,
[ValidateNotNull()]
[PSCredential]$SqlCredential,
[object]$Database,
[Parameter(Mandatory, ValueFromPipeline)]
[Alias("DataTable")]
[ValidateNotNull()]
[object]$InputObject,
[Parameter(Position = 3, Mandatory)]
[ValidateNotNullOrEmpty()]
[string]$Table,
[Parameter(Position = 4)]
[ValidateNotNullOrEmpty()]
[string]$Schema = 'dbo',
[ValidateNotNull()]
[int]$BatchSize = 50000,
[ValidateNotNull()]
[int]$NotifyAfter = 5000,
[switch]$AutoCreateTable,
[switch]$NoTableLock,
[switch]$CheckConstraints,
[switch]$FireTriggers,
[switch]$KeepIdentity,
[switch]$KeepNulls,
[switch]$Truncate,
[ValidateNotNull()]
[int]$bulkCopyTimeOut = 5000,
[switch]$EnableException,
[switch]$UseDynamicStringLength
)
begin {
# Null variable to make sure upper-scope variables don't interfere later
$steppablePipeline = $null
#region Utility Functions
function Invoke-BulkCopy {
<#
.SYNOPSIS
Copies a datatable in bulk over to a table.
.DESCRIPTION
Copies a datatable in bulk over to a table.
.PARAMETER DataTable
The datatable to copy.
.PARAMETER SqlInstance
Needs not be specified. The SqlInstance targeted. For message purposes only.
.PARAMETER Fqtn
Needs not be specified. The fqtn written to. For message purposes only.
.PARAMETER BulkCopy
Needs not be specified. The bulk copy object used to perform the copy operation.
#>
[CmdletBinding()]
param (
$DataTable,
[DbaInstance]$SqlInstance = $SqlInstance,
[string]$Fqtn = $fqtn,
$BulkCopy = $bulkCopy
)
Write-Message -Level Verbose -Message "Importing in bulk to $fqtn"
$rowCount = $DataTable.Rows.Count
if ($rowCount -eq 0) {
$rowCount = 1
}
if ($Pscmdlet.ShouldProcess($SqlInstance, "Writing $rowCount rows to $Fqtn")) {
foreach ($prop in $DataTable.Columns.ColumnName) {
$null = $bulkCopy.ColumnMappings.Add($prop, $prop)
}
$bulkCopy.WriteToServer($DataTable)
if ($rowCount -is [int]) {
Write-Progress -id 1 -activity "Inserting $rowCount rows" -status "Complete" -Completed
}
}
}
function New-Table {
<#
.SYNOPSIS
Creates a table, based upon a DataTable.
.DESCRIPTION
Creates a table, based upon a DataTable.
.PARAMETER DataTable
The DataTable to base the table structure upon.
.PARAMETER PStoSQLTypes
Automatically inherits from parent.
.PARAMETER SqlInstance
Automatically inherits from parent.
.PARAMETER Fqtn
Automatically inherits from parent.
.PARAMETER Server
Automatically inherits from parent.
.PARAMETER DatabaseName
Automatically inherits from parent.
.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 UseDynamicStringLength
Automatically inherits from parent.
#>
[CmdletBinding(SupportsShouldProcess)]
param (
$DataTable,
$PStoSQLTypes = $PStoSQLTypes,
$SqlInstance = $SqlInstance,
$Fqtn = $fqtn,
$Server = $server,
$DatabaseName = $databaseName,
[switch]$EnableException
)
Write-Message -Level Verbose -Message "Creating table for $fqtn"
# Get SQL datatypes by best guess on first data row
$sqlDataTypes = @();
$columns = $DataTable.Columns
if ($null -eq $columns) {
$columns = $DataTable.Table.Columns
}
foreach ($column in $columns) {
$sqlColumnName = $column.ColumnName
try {
$columnValue = $DataTable.Rows[0].$sqlColumnName
} catch {
$columnValue = $DataTable.$sqlColumnName
}
if ($null -eq $columnValue) {
$columnValue = $DataTable.$sqlColumnName
}
<#
PS to SQL type conversion
If data type exists in hash table, use the corresponding SQL type
Else, fallback to nvarchar.
If UseDynamicStringLength is specified, the DataColumn MaxLength is used if specified
#>
if ($PStoSQLTypes.Keys -contains $column.DataType) {
$sqlDataType = $PStoSQLTypes[$($column.DataType.toString())]
if ($UseDynamicStringLength -and $column.MaxLength -gt 0 -and ($column.DataType -in ("String", "System.String"))) {
$sqlDataType = $sqlDataType.Replace("(MAX)", "($($column.MaxLength))")
}
} else {
$sqlDataType = "nvarchar(MAX)"
}
$sqlDataTypes += "[$sqlColumnName] $sqlDataType"
}
$sql = "BEGIN CREATE TABLE $fqtn ($($sqlDataTypes -join ' NULL,')) END"
Write-Message -Level Debug -Message $sql
if ($Pscmdlet.ShouldProcess($SqlInstance, "Creating table $Fqtn")) {
try {
$null = $Server.Databases[$DatabaseName].Query($sql)
} catch {
Stop-Function -Message "The following query failed: $sql" -ErrorRecord $_
return
}
}
}
#endregion Utility Functions
#region Prepare type for bulk copy
if (-not $Truncate) { $ConfirmPreference = "None" }
#endregion Prepare type for bulk copy
#region Resolve Full Qualified Table Name
$fqtnObj = Get-ObjectNameParts -ObjectName $Table
if ($fqtnObj.$parsed) {
Stop-Function -Message "Unable to parse $($fqtnObj.InputValue) as a valid tablename."
return
}
if ($null -eq $fqtnObj.Database -and $null -eq $Database) {
Stop-Function -Message "You must specify a database or fully qualified table name."
return
}
if (Test-Bound -ParameterName Database) {
if ($null -eq $fqtnObj.Database) {
$databaseName = "$Database"
} else {
if ($fqtnObj.Database -eq $Database) {
$databaseName = "$Database"
} else {
Stop-Function -Message "The database parameter $($Database) differs from value from the fully qualified table name $($fqtnObj.Database)."
return
}
}
} else {
$databaseName = $fqtnObj.Database
}
if ($fqtnObj.Schema) {
$schemaName = $fqtnObj.Schema
} else {
$schemaName = $Schema
}
$tableName = $fqtnObj.Name
$quotedFQTN = New-Object System.Text.StringBuilder
if ($server.ServerType -ne 'SqlAzureDatabase') {
<#
Skip adding database name to Fully Qualified Tablename for Azure SQL DB
Azure SQL DB does not support Three Part names
#>
[void]$quotedFQTN.Append( '[' )
if ($databaseName.Contains(']')) {
[void]$quotedFQTN.Append( $databaseName.Replace(']', ']]') )
} else {
[void]$quotedFQTN.Append( $databaseName )
}
[void]$quotedFQTN.Append( '].' )
}
[void]$quotedFQTN.Append( '[' )
if ($schemaName.Contains(']')) {
[void]$quotedFQTN.Append( $schemaName.Replace(']', ']]') )
} else {
[void]$quotedFQTN.Append( $schemaName )
}
[void]$quotedFQTN.Append( '].' )
[void]$quotedFQTN.Append( '[' )
if ($tableName.Contains(']')) {
[void]$quotedFQTN.Append( $tableName.Replace(']', ']]') )
} else {
[void]$quotedFQTN.Append( $tableName )
}
[void]$quotedFQTN.Append( ']' )
$fqtn = $quotedFQTN.ToString()
Write-Message -Level SomewhatVerbose -Message "FQTN processed: $fqtn"
#endregion Resolve Full Qualified Table Name
#region Connect to server and get database
try {
$server = Connect-SqlInstance -SqlInstance $SqlInstance -SqlCredential $SqlCredential
} catch {
Stop-Function -Message "Error occurred while establishing connection to $SqlInstance" -Category ConnectionError -ErrorRecord $_ -Target $SqlInstance
return
}
if ($server.ServerType -eq 'SqlAzureDatabase') {
<#
For some reasons SMO wants an initial pull when talking to Azure Sql DB
This will throw and be caught, and then we can continue as normal.
#>
try {
$null = $server.Databases
} catch {
# here to avoid an empty catch
$null = 1
}
}
try {
$databaseObject = $server.Databases[$databaseName]
#endregion Connect to server and get database
#region Prepare database and bulk operations
if ($null -eq $databaseObject) {
Stop-Function -Message "$databaseName does not exist." -Target $SqlInstance
return
}
$databaseObject.Tables.Refresh()
if ($schemaName -notin $databaseObject.Schemas.Name) {
Stop-Function -Message "Schema does not exist."
return
}
$targetTable = $databaseObject.Tables | Where-Object { $_.Name -eq $tableName -and $_.Schema -eq $schemaName }
$tableExists = $targetTable.Count -eq 1
} catch {
Stop-Function -Message "Failure" -ErrorRecord $_ -Continue
}
if ((-not $tableExists) -and (-not $AutoCreateTable)) {
Stop-Function -Message "Table does not exist and automatic creation of the table has not been selected. Specify the '-AutoCreateTable'-parameter to generate a suitable table."
return
}
$bulkCopyOptions = 0
$options = "TableLock", "CheckConstraints", "FireTriggers", "KeepIdentity", "KeepNulls", "Default"
foreach ($option in $options) {
$optionValue = Get-Variable $option -ValueOnly -ErrorAction SilentlyContinue
if ($option -eq "TableLock" -and (!$NoTableLock)) {
$optionValue = $true
}
if ($optionValue -eq $true) {
$bulkCopyOptions += $([Data.SqlClient.SqlBulkCopyOptions]::$option).value__
}
}
if ($Truncate -eq $true) {
if ($Pscmdlet.ShouldProcess($SqlInstance, "Truncating $fqtn")) {
try {
Write-Message -Level Verbose -Message "Truncating $fqtn."
$null = $server.Databases[$databaseName].Query("TRUNCATE TABLE $fqtn")
} catch {
Write-Message -Level Warning -Message "Could not truncate $fqtn. Table may not exist or may have key constraints." -ErrorRecord $_
}
}
}
# Create SqlBulkCopy object - Database name needs to be appended as not set in $server.ConnectionContext
$bulkCopy = New-Object Data.SqlClient.SqlBulkCopy("$($server.ConnectionContext.ConnectionString);Database=$databaseName", $bulkCopyOptions)
$bulkCopy.DestinationTableName = $fqtn
$bulkCopy.BatchSize = $BatchSize
$bulkCopy.NotifyAfter = $NotifyAfter
$bulkCopy.BulkCopyTimeOut = $BulkCopyTimeOut
$elapsed = [System.Diagnostics.Stopwatch]::StartNew()
# Add RowCount output
$bulkCopy.Add_SqlRowsCopied( {
$script:totalRows = $args[1].RowsCopied
$percent = [int](($script:totalRows / $rowCount) * 100)
$timeTaken = [math]::Round($elapsed.Elapsed.TotalSeconds, 1)
Write-Progress -id 1 -activity "Inserting $rowCount rows." -PercentComplete $percent -Status ([System.String]::Format("Progress: {0} rows ({1}%) in {2} seconds", $script:totalRows, $percent, $timeTaken))
})
$PStoSQLTypes = @{
#PS datatype = SQL data type
'System.Int32' = 'int';
'System.UInt32' = 'bigint';
'System.Int16' = 'smallint';
'System.UInt16' = 'int';
'System.Int64' = 'bigint';
'System.UInt64' = 'decimal(20,0)';
'System.Decimal' = 'decimal(38,5)';
'System.Single' = 'bigint';
'System.Double' = 'float';
'System.Byte' = 'tinyint';
'System.SByte' = 'smallint';
'System.TimeSpan' = 'nvarchar(30)';
'System.String' = 'nvarchar(MAX)';
'System.Char' = 'nvarchar(1)'
'System.DateTime' = 'datetime2';
'System.DateTimeOffset' = 'datetimeoffset';
'System.Boolean' = 'bit';
'System.Guid' = 'uniqueidentifier';
'Int32' = 'int';
'UInt32' = 'bigint';
'Int16' = 'smallint';
'UInt16' = 'int';
'Int64' = 'bigint';
'UInt64' = 'decimal(20,0)';
'Decimal' = 'decimal(38,5)';
'Single' = 'bigint';
'Double' = 'float';
'Byte' = 'tinyint';
'SByte' = 'smallint';
'TimeSpan' = 'nvarchar(30)';
'String' = 'nvarchar(MAX)';
'Char' = 'nvarchar(1)'
'DateTime' = 'datetime2';
'DateTimeOffset' = 'datetimeoffset';
'Boolean' = 'bit';
'Bool' = 'bit';
'Guid' = 'uniqueidentifier';
'int' = 'int';
'long' = 'bigint';
}
$validTypes = @([System.Data.DataSet], [System.Data.DataTable], [System.Data.DataRow], [System.Data.DataRow[]])
#endregion Prepare database and bulk operations
#region ConvertTo-DbaDataTable wrapper
try {
$wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('ConvertTo-DbaDataTable', [System.Management.Automation.CommandTypes]::Function)
$splatCDDT = @{
TimeSpanType = (Get-DbatoolsConfigValue -FullName 'commands.Write-DbaDbTableData.timespantype' -Fallback 'TotalMilliseconds')
SizeType = (Get-DbatoolsConfigValue -FullName 'commands.Write-DbaDbTableData.sizetype' -Fallback 'Int64')
IgnoreNull = (Get-DbatoolsConfigValue -FullName 'commands.Write-DbaDbTableData.ignorenull' -Fallback $false)
Raw = (Get-DbatoolsConfigValue -FullName 'commands.Write-DbaDbTableData.raw' -Fallback $false)
}
$scriptCmd = { & $wrappedCmd @splatCDDT }
$steppablePipeline = $scriptCmd.GetSteppablePipeline()
$steppablePipeline.Begin($true)
} catch {
Stop-Function -Message "Failed to initialize "
}
#endregion ConvertTo-DbaDataTable wrapper
}
process {
if (Test-FunctionInterrupt) { return }
if ($null -ne $InputObject) { $inputType = $InputObject.GetType() }
else { $inputType = $null }
if ($inputType -eq [System.Data.DataSet]) {
$inputData = $InputObject.Tables
$inputType = [System.Data.DataTable[]]
} else {
$inputData = $InputObject
}
#region Scenario 1: Single valid table
if ($inputType -in $validTypes) {
if (-not $tableExists) {
try {
New-Table -DataTable $InputObject -EnableException
$tableExists = $true
} catch {
Stop-Function -Message "Failed to create table $fqtn" -ErrorRecord $_ -Target $SqlInstance
return
}
}
try { Invoke-BulkCopy -DataTable $InputObject }
catch {
Stop-Function -Message "Failed to bulk import to $fqtn" -ErrorRecord $_ -Target $SqlInstance
}
return
}
#endregion Scenario 1: Single valid table
foreach ($object in $inputData) {
#region Scenario 2: Multiple valid tables
if ($object.GetType() -in $validTypes) {
if (-not $tableExists) {
try {
New-Table -DataTable $object -EnableException
$tableExists = $true
} catch {
Stop-Function -Message "Failed to create table $fqtn" -ErrorRecord $_ -Target $SqlInstance
return
}
}
try { Invoke-BulkCopy -DataTable $object }
catch {
Stop-Function -Message "Failed to bulk import to $fqtn" -ErrorRecord $_ -Target $SqlInstance -Continue
}
continue
}
#endregion Scenario 2: Multiple valid tables
#region Scenario 3: Invalid data types
else {
$null = $steppablePipeline.Process($object)
continue
}
#endregion Scenario 3: Invalid data types
}
}
end {
#region ConvertTo-DbaDataTable wrapper
if ($null -ne $steppablePipeline) {
$dataTable = $steppablePipeline.End()
if (-not $tableExists) {
try {
New-Table -DataTable $dataTable[0] -EnableException
$tableExists = $true
} catch {
Stop-Function -Message "Failed to create table $fqtn" -ErrorRecord $_ -Target $SqlInstance
return
}
}
try { Invoke-BulkCopy -DataTable $dataTable[0] }
catch {
Stop-Function -Message "Failed to bulk import to $fqtn" -ErrorRecord $_ -Target $SqlInstance
}
}
#endregion ConvertTo-DbaDataTable wrapper
if ($bulkCopy) {
$bulkCopy.Close()
$bulkCopy.Dispose()
}
}
}