Improving support for multiple connection types

nvarscar · nvarscar · commit 4be52deefe83 · 2019-01-04T11:28:18.000-06:00
diff --git a/functions/Invoke-DBODeployment.ps1 b/functions/Invoke-DBODeployment.ps1
@@ -114,9 +114,6 @@
             $config.SetValue($property, (Resolve-VariableToken $config.$property $config.Variables))
         }
 
-        # Build connection string
-        $connString = Get-ConnectionString -Configuration $config -Type $Type
-
         $scriptCollection = @()
         if ($PsCmdlet.ParameterSetName -ne 'Script') {
             # Get contents of the script files
@@ -151,25 +148,12 @@
             }
         }
 
-        # Build dbUp object
-        $dbUp = [DbUp.DeployChanges]::To
-        $dbUpConnection = Get-ConnectionManager -ConnectionString $connString -Type $Type
-        if ($Type -eq 'SqlServer') {
-            if ($config.Schema) {
-                $dbUp = [SqlServerExtensions]::SqlDatabase($dbUp, $dbUpConnection, $config.Schema)
-            }
-            else {
-                $dbUp = [SqlServerExtensions]::SqlDatabase($dbUp, $dbUpConnection)
-            }
-        }
-        elseif ($Type -eq 'Oracle') {
-            if ($config.Schema) {
-                $dbUp = [DbUp.Oracle.OracleExtensions]::OracleDatabase($dbUpConnection, $config.Schema)
-            }
-            else {
-                $dbUp = [DbUp.Oracle.OracleExtensions]::OracleDatabase($dbUpConnection)
-            }
-        }
+        # Get DbUp connection object
+        $dbUpConnection = Get-ConnectionManager -Configuration $config -Type $Type
+
+        # Get DbUpBuilder based on the connection
+        $dbUp = Get-DbUpBuilder -Connection $dbUpConnection -Type $Type
+
         # Add deployment scripts to the object
         $dbUp = [StandardExtensions]::WithScripts($dbUp, $scriptCollection)
 
@@ -208,43 +192,8 @@
         $dbUp = [StandardExtensions]::LogTo($dbUp, $dbUpLog)
         $dbUp = [StandardExtensions]::LogScriptOutput($dbUp)
 
-        # Configure schema versioning
-        if (!$config.SchemaVersionTable) {
-            $dbUpTableJournal = [DbUp.Helpers.NullJournal]::new()
-        }
-        elseif ($config.SchemaVersionTable) {
-            $table = $config.SchemaVersionTable.Split('.')
-            if (($table | Measure-Object).Count -gt 2) {
-                Stop-PSFFunction -EnableException $true -Message 'Incorrect table name - use the following syntax: schema.table'
-                return
-            }
-            elseif (($table | Measure-Object).Count -eq 2) {
-                $tableName = $table[1]
-                $schemaName = $table[0]
-            }
-            elseif (($table | Measure-Object).Count -eq 1) {
-                $tableName = $table[0]
-                if ($config.Schema) {
-                    $schemaName = $config.Schema
-                }
-                else {}
-            }
-            else {
-                Stop-PSFFunction -EnableException $true -Message 'No table name specified'
-                return
-            }
-            # Set default schema for known DB Types
-            if (!$schemaName) {
-                if ($Type -eq 'SqlServer') { $schemaName = 'dbo' }
-            }
-            #Enable schema versioning
-            if ($Type -eq 'SqlServer') { $dbUpJournalType = [DbUp.SqlServer.SqlTableJournal] }
-            elseif ($Type -eq 'Oracle') { $dbUpJournalType = [DbUp.Oracle.OracleTableJournal] }
-
-            $dbUpTableJournal = $dbUpJournalType::new( { $dbUpConnection }, { $dbUpLog }, $schemaName, $tableName)
-
-            #$dbUp = [SqlServerExtensions]::JournalToSqlTable($dbUp, $schemaName, $tableName)
-        }
+        # Define schema versioning (journalling)
+        $dbUpTableJournal = Get-DbUpJournal -Connection { $dbUpConnection } -Log { $dbUpLog } -Schema $config.Schema -SchemaVersionTable $config.SchemaVersionTable -Type $Type
         $dbUp = [StandardExtensions]::JournalTo($dbUp, $dbUpTableJournal)
 
         # Adding execution timeout - defaults to unlimited execution
diff --git a/functions/Invoke-DBOQuery.ps1 b/functions/Invoke-DBOQuery.ps1
@@ -180,7 +180,7 @@ function Invoke-DBOQuery {
         $status = [DBOpsDeploymentStatus]::new()
         $dbUpLog = [DBOpsLog]::new($config.Silent, $OutputFile, $Append, $status)
         $dbUpLog.CallStack = (Get-PSCallStack)[0]
-        if (-Not $config.Silent) {
+        if ($null -ne $dbUpConnection.IsScriptOutputLogged -and -Not $config.Silent) {
             $dbUpConnection.IsScriptOutputLogged = $true
         }
         try {
diff --git a/internal/classes/DBOps.enums.ps1 b/internal/classes/DBOps.enums.ps1
@@ -2,7 +2,8 @@ $enums = @'
 namespace DBOps {
     public enum ConnectionType {
         SQLServer,
-        Oracle
+        Oracle,
+        MySql
     }
     public enum ConfigProperty {
         ApplicationName,
diff --git a/internal/functions/Get-ConnectionManager.ps1 b/internal/functions/Get-ConnectionManager.ps1
@@ -16,4 +16,11 @@ function Get-ConnectionManager {
     elseif ($Type -eq 'Oracle') {
         return [DbUp.Oracle.OracleConnectionManager]::new($ConnectionString)
     }
+    elseif ($Type -eq 'MySql') {
+        return [DbUp.MySql.MySqlConnectionManager]::new($ConnectionString)
+    }
+    else {
+        Stop-PSFFunction -Message "Unknown type $Type" -EnableException $true
+        return
+    }
 }
diff --git a/internal/functions/Get-ConnectionString.ps1 b/internal/functions/Get-ConnectionString.ps1
@@ -29,7 +29,7 @@ function Get-ConnectionString {
         else {
             $CSBuilder["Integrated Security"] = $true
         }
-        if ($ConnectionType -eq 'SQLServer') {
+        if ($Type -eq 'SQLServer') {
             $CSBuilder["Application Name"] = $Configuration.ApplicationName
         }
         return $CSBuilder.ToString()
diff --git a/internal/functions/Get-DbUpBuilder.ps1 b/internal/functions/Get-DbUpBuilder.ps1
@@ -0,0 +1,39 @@
+function Get-DbUpBuilder {
+    # Returns a DbUp builder with a proper connection object
+    Param (
+        [Parameter(Mandatory)]
+        [object]$Connection,
+        [string]$Schema,
+        [DBOps.ConnectionType]$Type
+    )
+    $dbUp = [DbUp.DeployChanges]::To
+    if ($Type -eq [DBOps.ConnectionType]::SqlServer) {
+        if ($Schema) {
+            $dbUp = [SqlServerExtensions]::SqlDatabase($dbUp, $dbUpConnection, $Schema)
+        }
+        else {
+            $dbUp = [SqlServerExtensions]::SqlDatabase($dbUp, $dbUpConnection)
+        }
+    }
+    elseif ($Type -eq [DBOps.ConnectionType]::Oracle) {
+        if ($Schema) {
+            $dbUp = [DbUp.Oracle.OracleExtensions]::OracleDatabase($dbUp, $dbUpConnection, $Schema)
+        }
+        else {
+            $dbUp = [DbUp.Oracle.OracleExtensions]::OracleDatabase($dbUp, $dbUpConnection)
+        }
+    }
+    elseif ($Type -eq [DBOps.ConnectionType]::MySql) {
+        if ($Schema) {
+            $dbUp = [MySqlExtensions]::MySqlDatabase($dbUp, $dbUpConnection, $Schema)
+        }
+        else {
+            $dbUp = [MySqlExtensions]::MySqlDatabase($dbUp, $dbUpConnection)
+        }
+    }
+    else {
+        Stop-PSFFunction -Message "Unknown type $Type" -EnableException $true
+        return
+    }
+    return $dbUp
+}
diff --git a/internal/functions/Get-DbUpJournal.ps1 b/internal/functions/Get-DbUpJournal.ps1
@@ -0,0 +1,54 @@
+function Get-DbUpJournal {
+    # Returns a DbUp builder with a proper connection object
+    Param (
+        [Parameter(Mandatory)]
+        [scriptblock]$Connection,
+        [scriptblock]$Log,
+        [string]$Schema,
+        [string]$SchemaVersionTable,
+        [Parameter(Mandatory)]
+        [DBOps.ConnectionType]$Type
+    )
+    if ($SchemaVersionTable) {
+        # retrieve schema and table names
+        $table = $SchemaVersionTable.Split('.')
+        if ($table.Count -gt 2) {
+            Stop-PSFFunction -EnableException $true -Message 'Incorrect table name - use the following syntax: schema.table'
+            return
+        }
+        elseif ($table.Count -eq 2) {
+            $tableName = $table[1]
+            $schemaName = $table[0]
+        }
+        else {
+            $tableName = $table[0]
+            if ($Schema) {
+                $schemaName = $Schema
+            }
+        }
+        # define journal type based on target connection type
+        if ($Type -eq [DBOps.ConnectionType]::SQLServer) {
+            if (!$schemaName) {
+                $schemaName = 'dbo'
+            }
+            $dbUpJournalType = [DbUp.SqlServer.SqlTableJournal]
+        }
+        elseif ($Type -eq [DBOps.ConnectionType]::Oracle) {
+            $dbUpJournalType = [DbUp.Oracle.OracleTableJournal]
+        }
+        elseif ($Type -eq [DBOps.ConnectionType]::MySql) {
+            $dbUpJournalType = [DbUp.MySql.MySqlTableJournal]
+        }
+        else {
+            Stop-PSFFunction -Message "Unknown type $Type" -EnableException $true
+            return
+        }
+        # return a journal object
+        Write-PSFMessage -Level Verbose -Message "Creating journal object for $Type in $schemaName.$tableName"
+        return $dbUpJournalType::new( $Connection, $Log, $schemaName, $tableName)
+    }
+    else {
+        # return a null journal to disable journalling
+        return [DbUp.Helpers.NullJournal]::new()
+    }
+}
diff --git a/internal/functions/Get-SqlParser.ps1 b/internal/functions/Get-SqlParser.ps1
@@ -10,4 +10,7 @@ function Get-SqlParser {
     elseif ($Type -eq 'Oracle') {
         return [DbUp.Oracle.OracleObjectParser]::new()
     }
+    elseif ($Type -eq 'MySql') {
+        return [DbUp.MySql.MySqlObjectParser]::new()
+    }
 }
diff --git a/internal/json/dbops.dependencies.json b/internal/json/dbops.dependencies.json
@@ -1,12 +1,47 @@
 {
     "Oracle": [
-       {
-           "Name": "Oracle.ManagedDataAccess",
-           "Version": "12.2.1100",
-           "Path": [
-               "lib\\net40\\Oracle.ManagedDataAccess.dll"
-           ]
-       }
+        {
+            "Name": "Oracle.ManagedDataAccess",
+            "Version": "12.2.1100",
+            "Path": [
+                "lib\\net40\\Oracle.ManagedDataAccess.dll"
+            ],
+            "PSEdition": [
+                "Desktop"
+            ]
+        },
+        {
+            "Name": "Oracle.ManagedDataAccess.Core",
+            "Version": "2.12.0-beta2",
+            "Path": [
+                "lib\\netstandard2.0\\Oracle.ManagedDataAccess.Core.dll"
+            ],
+            "PSEdition": [
+                "Core"
+            ]
+        }
     ],
-    "SQLServer": []
+    "SQLServer": [],
+    "MySQL": [
+        {
+            "Name": "MySql.Data",
+            "Version": "6.9.5",
+            "Path": [
+                "lib\\net452\\MySql.Data.dll"
+            ],
+            "PSEdition": [
+                "Desktop"
+            ]
+        },
+        {
+            "Name": "MySql.Data",
+            "Version": "6.10.6",
+            "Path": [
+                "lib\\netstandard2.0\\MySql.Data.dll"
+            ],
+            "PSEdition": [
+                "Core"
+            ]
+        }
+    ]
 }
diff --git a/internal/json/dbops.json b/internal/json/dbops.json
@@ -2,7 +2,8 @@
     "Libraries": [
         "bin\\dbup-core.dll",
         "bin\\dbup-sqlserver.dll",
-        "bin\\dbup-oracle.dll"
+        "bin\\dbup-oracle.dll",
+        "bin\\dbup-mysql.dll"
     ],
     "Misc": [
         "bin\\deploy.ps1",
@@ -50,6 +51,8 @@
         "internal\\functions\\Get-ConnectionString.ps1",
         "internal\\functions\\Get-SqlParser.ps1",
         "internal\\functions\\Initialize-ExternalLibrary.ps1",
+        "internal\\functions\\Get-DbUpBuilder.ps1",
+        "internal\\functions\\Get-DbUpJournal.ps1",
         "internal\\classes\\DBOpsHelper.class.ps1",
         "internal\\classes\\DBOps.class.ps1",
         "internal\\classes\\DBOpsDeploymentStatus.class.ps1",

Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ function Invoke-DBOQuery {`
`180`	`180`	`$status = [DBOpsDeploymentStatus]::new()`
`181`	`181`	`$dbUpLog = [DBOpsLog]::new($config.Silent, $OutputFile, $Append, $status)`
`182`	`182`	`$dbUpLog.CallStack = (Get-PSCallStack)[0]`
`183`		`- if (-Not $config.Silent) {`
	`183`	`+ if ($null -ne $dbUpConnection.IsScriptOutputLogged -and -Not $config.Silent) {`
`184`	`184`	`$dbUpConnection.IsScriptOutputLogged = $true`
`185`	`185`	`}`
`186`	`186`	`try {`
Original file line number	Diff line number	Diff line change
`@@ -16,4 +16,11 @@ function Get-ConnectionManager {`
`16`	`16`	`elseif ($Type -eq 'Oracle') {`
`17`	`17`	`return [DbUp.Oracle.OracleConnectionManager]::new($ConnectionString)`
`18`	`18`	`}`
	`19`	`+ elseif ($Type -eq 'MySql') {`
	`20`	`+ return [DbUp.MySql.MySqlConnectionManager]::new($ConnectionString)`
	`21`	`+ }`
	`22`	`+ else {`
	`23`	`+ Stop-PSFFunction -Message "Unknown type $Type" -EnableException $true`
	`24`	`+ return`
	`25`	`+ }`
`19`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ function Get-ConnectionString {`
`29`	`29`	`else {`
`30`	`30`	`$CSBuilder["Integrated Security"] = $true`
`31`	`31`	`}`
`32`		`- if ($ConnectionType -eq 'SQLServer') {`
	`32`	`+ if ($Type -eq 'SQLServer') {`
`33`	`33`	`$CSBuilder["Application Name"] = $Configuration.ApplicationName`
`34`	`34`	`}`
`35`	`35`	`return $CSBuilder.ToString()`
Original file line number	Diff line number	Diff line change
`@@ -10,4 +10,7 @@ function Get-SqlParser {`
`10`	`10`	`elseif ($Type -eq 'Oracle') {`
`11`	`11`	`return [DbUp.Oracle.OracleObjectParser]::new()`
`12`	`12`	`}`
	`13`	`+ elseif ($Type -eq 'MySql') {`
	`14`	`+ return [DbUp.MySql.MySqlObjectParser]::new()`
	`15`	`+ }`
`13`	`16`	`}`