แแก แกแขแแขแแ แแ แแก แฌแแแแแ แแ แแฅแขแแแฃแแ แแ แแซแฆแแแแแ แฉแแแก แกแแแฌแฃแฎแแ แ แแกแขแแ แแแก
แแแแแแแแ Zero Touch PROD RDS-แแกแแแแก (MS SQL), แ แแแแแก แจแแกแแฎแแแแช แแแแแ แฉแแแแ แงแฃแ แ แแฃแแฃแแแแแ, แแแแแแแแ แแ แแแแแขแแชแแ (POC - Proof Of Concept) แแแขแแแแขแแแแชแแแก แจแแกแแฎแแ: powershell แกแแ แแแขแแแแก แแแแ แแแ. แแ แแแแแขแแชแแแก แจแแแแแ, แ แแชแ แแจแคแแแแแ แ, แแแฎแแแแ แซแแแแแแฃแแ แแแแแแแกแแแแขแแแ แฉแแฅแ แ, แแแแฃแฌแงแแแขแแ แแแแแแแกแแแแขแแแแ แแแแแแแแ แแ, แแแแฎแ แแก - แแก แงแแแแแคแแ แ แแแ แแแ, แแแแ แแ แแฎแแแแ แแแแแแแแแฃแ แ แแแแแแแแแก แแแแ, แงแแแแ แฉแแแแ แฏแแแแแแกแแก แแแแ แแฃแจแแแแก Linux-แแ!
แแก แจแแกแแซแแแแแแแ? แแแฆแแ แแกแแแ แแแแแ, แแแแฃแ แ DBA Windows-แแก แฅแแแจ แแ แแแแฉแแ แแ แแก Powershell-แแก แกแแชแฎแแจแ Linux-แแก แฅแแแจ? แแก แแ แแ แแก แกแแกแขแแแ?
แขแแฅแแแแแแแแแแก แแ แฃแชแแแฃแ แแแแแแแแชแแแจแ แแแแแฌแแ แฉแแซแแ แแ. แ แ แแฅแแ แฃแแแ, แฉแแแแ 30+ แกแแ แแแขแแ แจแแฌแงแแแขแ แแฃแจแแแแ. แฉแแแแ แแแกแแแแแ แแ, แแ แ แกแแแฃแจแแ แแฆแแจแ แแแแแฎแแ แฎแ แงแแแแแคแ แแก แแแแแกแฌแแ แแแ. แแฌแแ แชแฎแแ แแแแแแ. แแแจ, แ แ แแ แแแแแแแแ แจแแแซแแแแ แจแแแฎแแแแ Powershell แกแแ แแแขแแแแก Windows-แแแ Linux-แแ แแแแแขแแแแกแแก?
sqlcmd vs Invoke-SqlCmd
แแแแ แแแแแชแแ แจแแแแฎแกแแแแ แแแ แจแแ แแก แแแแแแ แ แแแแกแฎแแแแแแ. แแแ แแ แซแแแแ แแแแฃแแแแฃแ แ sqlcmd แแก แแกแแแ แแฃแจแแแแก Linux-แแก แฅแแแจ, แแแแฅแแแก แแแแแขแฃแ แ แคแฃแแฅแชแแแแแ แแแแ. แฉแแแ แแแแแแชแแแ แจแแแแแฎแแแก -Q-แก แจแแกแแกแ แฃแแแแแแ, แจแแงแแแแแก แคแแแแก -i แแ แแแแแแแแแแก -o. แแแแ แแ แคแแแแแแแก แกแแฎแแแแแ, แ แ แแฅแแ แฃแแแ, แฎแแแแ แ แแแแกแขแ แแก แแแ แซแแแแแแ แแ. แแฃ แแงแแแแแ -i, แแแจแแ แคแแแแจแ แฉแแฌแแ แแ แแแแแก:
GO
EXIT
แแฃ แแแแแก แแ แแ แแก EXIT, แแแจแแ sqlcmd แแแแแ แซแแแแแก แจแแงแแแแแก แแแแแแแแก, แแ แแฃ แแแ แ แแแกแแแ แแ แ GO, แแแจแแ แแแแ แแ แซแแแแแ แแ แแแฃแจแแแแแก. แแแแแแแแแแ แคแแแแ แจแแแชแแแก แงแแแแ แแแแแแแแแแก, แแ แฉแแแแแก, แจแแขแงแแแแแแแแแก, แแแญแแแแก แแ แ.แจ.
Invoke-SqlCmd แแฌแแ แแแแแก แจแแแแแก แ แแแแ แช DataSet, DataTables แแ DataRows. แแแแขแแ, แแฃ แแแ แขแแแ แจแแ แฉแแแแก แจแแแแแก แแแแแฃแจแแแแแ, แจแแแแซแแแแ แแแแแแงแแแแ sqlcmd, แแแกแ แแแแแแฃแจแแแแแแก แแแแแแแแแแแแก แจแแแแแ, แแแแฅแแแก แจแแฃแซแแแแแแแ แ แแแแ แ แแฃแแ แแแแแขแแแ: แแแแกแแแแแก แแ แกแแแแแก Invoke-SqlCmd. แแแแ แแ แแ แแฃแแแก แแกแแแ แแฅแแก แแแแแกแ แฎแฃแแ แแแแแ:
- แแฃ แคแแแแก แแแแแฃแแแแแแแ แแแก แแแจแแแแแแ -InputFile, แแแจแแ แแแกแแแ แแ แแ แแก แกแแญแแ แ, แฃแคแ แ แแแขแแช, แแก แแฌแแ แแแแแก แกแแแขแแฅแกแฃแ แจแแชแแแแแก
- - OutputFile แแ แ, แแ แซแแแแแ แแแ แฃแแแแก แจแแแแแก, แ แแแแ แช แแแแแฅแขแ
- แกแแ แแแ แแก แแแแแแแแแกแแแแก แแ แ แกแแแขแแฅแกแแ: -ServerInstance -แแแแฎแแแ แแแแแก แกแแฎแแแ -แแแ แแแ -แแแแแชแแแแ แแแแ แแ แแแจแแแแแแ -ConnectionString. แฃแชแแแฃแ แแ แกแแแแแ แแกแแ, แ แแ แแแ แแแ แจแแแแฎแแแแแจแ แจแแฃแซแแแแแแแ 1433-แแก แแแ แแ แกแฎแแ แแแ แขแแก แแแแแแแแ.
- แขแแฅแกแขแแก แแแแแแแแแแ, แแแ แแคแแ PRINT, แ แแแแแแช แฃแแ แแแแ "แแแญแแ แแแแ" sqlcmdแแแแกแแแแก Invoke-SqlCmd
แแ แแแแแแแ - แแ แ แแช แแแแแแ แแ:
แกแแแแ แแฃแแแ แแฅแแแแก Linux-แก แแ แแฅแแก แแก cmdlet!
แแ แแก แแ แแก แแแแแแ แ แแ แแแแแแ. แแฎแแแแ แแแ แขแจแ แแก cmdlet
แชแแแแแ แฉแแแแชแแแแแ
sqlcmd แแฅแแก แชแแแแแแก แฉแแแแชแแแแแ -v-แแก แแแแแงแแแแแแ, แแแแแแแแแ แแกแ:
# $conn ัะพะดะตัะถะธั ะฝะฐัะฐะปะพ ะบะพะผะฐะฝะดั sqlcmd
$cmd = $conn + " -i D:appsSlaveJobsKillSpid.sql -o killspid.res
-v spid =`"" + $spid + "`" -v age =`"" + $age + "`""
Invoke-Expression $cmd
SQL แกแแ แแแขแจแ แฉแแแ แแแงแแแแแ แฉแแแแชแแแแแแแก:
set @spid=$(spid)
set @age=$(age)
แแกแ แ แแ, แแฅ แแ แแก. * nix-แจแ แชแแแแแ แฉแแแแชแแแแแ แแ แแฃแจแแแแก... แฒแแ แแแแขแ แ -v แฃแแฃแแแแแแงแ. แฃ Invoke-SqlCmd แฃแแฃแแแแแแงแ -แชแแแแแแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแแ แแแแขแ แ, แ แแแแแแช แแแแกแแแฆแแ แแแก แแแแแ แชแแแแแแแก, แแแแแ แแ แแแฃแแแ, แฉแแแแชแแแแแแแ แแแแแ แแฃแจแแแแก - แจแแแแซแแแแ แแแแแแงแแแแ แแแแแกแแแแ แ แชแแแแแ Shell-แแแ. แแฃแแชแ, แแ แแแแแฌแงแแแแแฃแแ แแแงแแแ แชแแแแแแแแ แแ แแแแแแฌแงแแแขแ, แกแแแ แแแ แแ แแงแแคแแแแงแแแ แแแแแแแแแแฃแแ แแแแแ แแ แแแแแฅแแแแ แฃแฎแแจแแ แแ แแ แแแแขแแฃแแแ, แ แแแแแ SQL แกแแ แแแขแแแ แแแแแแ:
# prepend the parameters
"declare @age int, @spid int" | Add-Content "q.sql"
"set @spid=" + $spid | Add-Content "q.sql"
"set @age=" + $age | Add-Content "q.sql"
foreach ($line in Get-Content "Sqlserver/Automation/KillSpid.sql") {
$line | Add-Content "q.sql"
}
$cmd = "/opt/mssql-tools/bin/" + $conn + " -i q.sql -o res.log"
แแก, แ แแแแ แช แแแกแแแ, แแ แแก แขแแกแขแ แฃแแแ Unix-แแก แแแ แกแแแแแ.
แคแแแแแแแก แแขแแแ แแแ
Windows-แแก แแแ แกแแแจแ, แแแแแกแแแแ แแแแ แแชแแแก แแแ แแฎแแแ แแฃแแแขแ: แฉแแแ แแแแฃแจแแแ sqlcmd, แแแแแฆแแ แ แแแแ แกแแฎแแก แจแแฃแ แแชแฎแงแแคแ แแแแแแแแแแ แคแแแแจแ, แแแแแแแแ แแ แแก แคแแแแ แแฃแแแขแแก แคแแ แคแแขแแแ. แกแแแแแแแแ แแ, SQL แกแแ แแแ แ แแฃแจแแแแแ แแแแแ แกแแ แแแ แแ, แ แแแแ แช แฏแแแแแแกแ, แแกแ แแแแแแแ:
CREATE procedure AuditUpload
@id int, @filename varchar(256)
as
set nocount on
declare @sql varchar(max)
CREATE TABLE #multi (filer NVARCHAR(MAX))
set @sql='BULK INSERT #multi FROM '''+@filename
+''' WITH (ROWTERMINATOR = '' '',CODEPAGE = ''ACP'')'
exec (@sql)
select @sql=filer from #multi
update JenkinsAudit set multiliner=@sql where ID=@id
return
แแแ แแแแ, แฉแแแ แแแแแแแแ แแงแแแแแแ BCP แคแแแแก แแ แแแแแแกแแแ แแแก แแฃแแแขแแก แชแฎแ แแแแก nvarchar(max) แแแแจแ. แ แ แแฅแแ แฃแแแ, แแแแแ แแก แกแแกแขแแแ แแแแจแแแ, แ แแแแแ SQL แกแแ แแแ แแก แแแชแแแแ แแ แแแแแฆแ RDS, แแ BULK INSERT แกแแแ แแแ แแ แแฃแจแแแแก UNC-แแก แกแแจแฃแแแแแแ แคแแแแแ แแฅแกแแแฃแแแฃแ แ แแแแแแแแแก แแชแแแแแแแก แแแแ, แแ RDS-แแ แแก แแแแแแแ แแแแฌแแ แฃแแแ. แแแแแแแแแ. แแกแ แ แแ, แแ แแแแแแฌแงแแแขแ แจแแแชแแแแ แกแแกแขแแแแก แแแแแแแ, แจแแแแแแฎแ แแฃแแแขแแก แกแขแ แแฅแแแ:
CREATE TABLE AuditOut (
ID int NULL,
TextLine nvarchar(max) NULL,
n int IDENTITY(1,1) PRIMARY KEY
)
แแ แฉแแฌแแ แแ แแ แชแฎแ แแแจแ แแกแ:
function WriteAudit([string]$Filename, [string]$ConnStr,
[string]$Tabname, [string]$Jobname)
{
# get $lastid of the last execution -- ะฟัะพัะบะธะฟะฐะฝะพ ะดะปั ััะฐััะธ
#create grid and populate it with data from file
$audit = Get-Content $Filename
$DT = new-object Data.DataTable
$COL1 = new-object Data.DataColumn;
$COL1.ColumnName = "ID";
$COL1.DataType = [System.Type]::GetType("System.Int32")
$COL2 = new-object Data.DataColumn;
$COL2.ColumnName = "TextLine";
$COL2.DataType = [System.Type]::GetType("System.String")
$DT.Columns.Add($COL1)
$DT.Columns.Add($COL2)
foreach ($line in $audit)
{
$DR = $dt.NewRow()
$DR.Item("ID") = $lastid
$DR.Item("TextLine") = $line
$DT.Rows.Add($DR)
}
# write it to table
$conn=new-object System.Data.SqlClient.SQLConnection
$conn.ConnectionString = $ConnStr
$conn.Open()
$bulkCopy = new-object ("Data.SqlClient.SqlBulkCopy") $ConnStr
$bulkCopy.DestinationTableName = $Tabname
$bulkCopy.BatchSize = 50000
$bulkCopy.BulkCopyTimeout = 0
$bulkCopy.WriteToServer($DT)
$conn.Close()
}
แแแแขแแแขแแก แจแแกแแ แฉแแแแ, แแฅแแแ แฃแแแ แแแ แฉแแแ ID-แแ, แแ แฉแแแแ แแแแแแแแแแ แแแแ n (แแแแแขแฃแ แแแ).
แจแแแแแ แกแขแแขแแแจแ แแ แฃแคแ แ แแแขแแแฃแ แแ แแแแแแฎแแแแ, แแฃ แ แแแแ แฃแ แแแแ แแฅแแแแแแก แแก แงแแแแแคแแ แ แฏแแแแแแกแแแ.
แฌแงแแ แ: www.habr.com