Wie rufe ich eine SQL Server gespeicherte Prozedur von Powershell?

Question

Ich habe eine große CSV-Datei und ich möchte eine gespeicherte Prozedur für jede Zeile auszuführen.

Was ist der beste Weg, um eine gespeicherte Prozedur von Powershell auszuführen?

Answer 1

Diese Antwort wurde gezogen von http://www.databasejournal.com/features /mssql/article.php/3683181

Das gleiche Beispiel kann für alle Ad-hoc-Abfragen verwendet werden. Lassen Sie uns die gespeicherte Prozedur „sp_helpdb“ ausführen, wie unten gezeigt.

$SqlConnection = New-Object System.Data.SqlClient.SqlConnection
$SqlConnection.ConnectionString = "Server=HOME\SQLEXPRESS;Database=master;Integrated Security=True"
$SqlCmd = New-Object System.Data.SqlClient.SqlCommand
$SqlCmd.CommandText = "sp_helpdb"
$SqlCmd.Connection = $SqlConnection
$SqlAdapter = New-Object System.Data.SqlClient.SqlDataAdapter
$SqlAdapter.SelectCommand = $SqlCmd
$DataSet = New-Object System.Data.DataSet
$SqlAdapter.Fill($DataSet)
$SqlConnection.Close()
$DataSet.Tables[0]

Answer 2

Hier ist eine Funktion, die ich benutze (leicht geschwärzt). Es ermöglicht Ein- und Ausgangsparameter. Ich habe nur unique und varchar-Typen implementiert, aber alle anderen Arten sind leicht hinzuzufügen. Wenn Sie parametrisierte gespeicherte Prozeduren (oder nur parametrisierte SQL ... dieser Code leicht zu, dass angepasst ist) verwenden, wird dies Ihr Leben viel einfacher machen.

, um die Funktion aufzurufen, müssen Sie eine Verbindung zum SQL-Server (zB $ conn)

  

$ res = exec-StoredProcedure -storedProcName 'stp_myProc' -Parameter @ {Param1 = "Hallo"; Param2 = 50} -outparams @ {ID = "unique"} $ conn

     

proc Ausgabe von zurückgegebene Objekt abrufen

     

$ res.data #dataset die Datentabellen enthält, die durch wählt zurückgegeben

     

$ res.outputparams.ID #output Parameter-ID (unique)

Die Funktion:

function exec-storedprocedure($storedProcName,  
        [hashtable] $parameters=@{},
        [hashtable] $outparams=@{},
        $conn,[switch]$help){ 

        function put-outputparameters($cmd, $outparams){
            foreach($outp in $outparams.Keys){
                $cmd.Parameters.Add("@$outp", (get-paramtype $outparams[$outp])).Direction=[System.Data.ParameterDirection]::Output
            }
        }
        function get-outputparameters($cmd,$outparams){
            foreach($p in $cmd.Parameters){
                if ($p.Direction -eq [System.Data.ParameterDirection]::Output){
                $outparams[$p.ParameterName.Replace("@","")]=$p.Value
                }
            }
        }

        function get-paramtype($typename,[switch]$help){
            switch ($typename){
                'uniqueidentifier' {[System.Data.SqlDbType]::UniqueIdentifier}
                'int' {[System.Data.SqlDbType]::Int}
                'xml' {[System.Data.SqlDbType]::Xml}
                'nvarchar' {[System.Data.SqlDbType]::NVarchar}
                default {[System.Data.SqlDbType]::Varchar}
            }
        }
        if ($help){
            $msg = @"
    Execute a sql statement.  Parameters are allowed.  
    Input parameters should be a dictionary of parameter names and values.
    Output parameters should be a dictionary of parameter names and types.
    Return value will usually be a list of datarows. 

    Usage: exec-query sql [inputparameters] [outputparameters] [conn] [-help]
    "@
            Write-Host $msg
            return
        }
        $close=($conn.State -eq [System.Data.ConnectionState]'Closed')
        if ($close) {
           $conn.Open()
        }

        $cmd=new-object system.Data.SqlClient.SqlCommand($sql,$conn)
        $cmd.CommandType=[System.Data.CommandType]'StoredProcedure'
        $cmd.CommandText=$storedProcName
        foreach($p in $parameters.Keys){
            $cmd.Parameters.AddWithValue("@$p",[string]$parameters[$p]).Direction=
                  [System.Data.ParameterDirection]::Input
        }

        put-outputparameters $cmd $outparams
        $ds=New-Object system.Data.DataSet
        $da=New-Object system.Data.SqlClient.SqlDataAdapter($cmd)
        [Void]$da.fill($ds)
        if ($close) {
           $conn.Close()
        }
        get-outputparameters $cmd $outparams

        return @{data=$ds;outputparams=$outparams}
    }

Answer 3

Hier ist eine Funktion, die ich SQL-Befehle auszuführen verwenden. Sie müssen nur $ sqlCommand.CommandText auf den Namen Ihres sproc und $ SqlCommand.CommandType zu CommandType.StoredProcedure ändern.

function execute-Sql{
    param($server, $db, $sql )
    $sqlConnection = new-object System.Data.SqlClient.SqlConnection
    $sqlConnection.ConnectionString = 'server=' + $server + ';integrated security=TRUE;database=' + $db 
    $sqlConnection.Open()
    $sqlCommand = new-object System.Data.SqlClient.SqlCommand
    $sqlCommand.CommandTimeout = 120
    $sqlCommand.Connection = $sqlConnection
    $sqlCommand.CommandText= $sql
    $text = $sql.Substring(0, 50)
    Write-Progress -Activity "Executing SQL" -Status "Executing SQL => $text..."
    Write-Host "Executing SQL => $text..."
    $result = $sqlCommand.ExecuteNonQuery()
    $sqlConnection.Close()
}

Answer 4

Verwenden Sie sqlcmd statt osql, wenn es sich um eine 2005-Datenbank

ist

Answer 5

Betrachten osql.exe (das Kommandozeilen-Tool für SQL Server) Aufruf als Parameter übergeben wird eine Textdatei für jede Zeile mit dem Aufruf der gespeicherten Prozedur geschrieben.

SQL Server bietet einige Baugruppen, die Bedienung mit dem Namen SMO sein könnte, die mit Powershell eine nahtlose Integration haben. Hier ist ein Artikel über die.

http://www.databasejournal.com/features/mssql/article .php / 3696731

Es gibt API-Methoden gespeicherte Prozeduren auszuführen, die ich denke, sind es wert, untersucht. Hier ist ein Startup-Beispiel:

http: //www.eggheadcafe .com / Software / aspnet / 29974894 / smo Lauf-a-speicher pro.aspx

Answer 6

I umfassen invoke-sqlcmd2.ps1 und write-datatable.ps1 von http://blogs.technet.com/b/heyscriptingguy/archive/2010/11/01/use-powershell-to-collect-server-data-and- schreiben-to-sql.aspx . Anrufe auf SQL-Befehle in Form auszuführen:
Invoke-sqlcmd2 -ServerInstance "<sql-server>" -Database <DB> -Query "truncate table <table>"
Ein Beispiel für den Inhalt der Datatable-Variablen in einer SQL-Tabelle zu schreiben wie folgt aussieht:
$logs = (get-item SQLSERVER:\sql\<server_path>).ReadErrorLog() Write-DataTable -ServerInstance "<sql-server>" -Database "<DB>" -TableName "<table>" -Data $logs
Ich finde diese nützlich, wenn dabei SQL Server-Datenbank-bezogene Powershell-Skripts als die daraus resultierenden Skripte sind sauber und gut lesbar.