Linux-ൽ Powershell-ൽ നിന്ന് MS SQL-ൽ പ്രവർത്തിക്കുന്നു

ഈ ലേഖനം തികച്ചും പ്രായോഗികവും എന്റെ സങ്കടകരമായ കഥയ്ക്ക് സമർപ്പിക്കുന്നതുമാണ്

തയ്യാറെടുക്കുന്നു സീറോ ടച്ച് PROD RDS (MS SQL) ന് വേണ്ടി, ഞങ്ങളുടെ എല്ലാ കാതുകളും മുഴങ്ങുന്ന, ഞാൻ ഓട്ടോമേഷന്റെ ഒരു അവതരണം (POC - പ്രൂഫ് ഓഫ് കൺസെപ്റ്റ്) നടത്തി: ഒരു കൂട്ടം പവർഷെൽ സ്ക്രിപ്റ്റുകൾ. അവതരണത്തിനുശേഷം, കൊടുങ്കാറ്റുള്ള, നീണ്ട കരഘോഷം നിലച്ചപ്പോൾ, നിലക്കാത്ത കരഘോഷമായി മാറിയപ്പോൾ, അവർ എന്നോട് പറഞ്ഞു - ഇതെല്ലാം നല്ലതാണ്, പക്ഷേ പ്രത്യയശാസ്ത്രപരമായ കാരണങ്ങളാൽ മാത്രം, ഞങ്ങളുടെ എല്ലാ ജെങ്കിൻസ് അടിമകളും ലിനക്സിൽ പ്രവർത്തിക്കുന്നു!

ഇത് സാധ്യമാണോ? വിന്ഡോസിന് താഴെ നിന്ന് അത്തരമൊരു ഊഷ്മളമായ ലാമ്പ് ഡിബിഎ എടുത്ത് ലിനക്സിന് കീഴിലുള്ള പവർഷെല്ലിന്റെ ചൂടിൽ ഒട്ടിക്കണോ? ഇത് ക്രൂരതയല്ലേ?

സാങ്കേതികവിദ്യകളുടെ ഈ വിചിത്രമായ സംയോജനത്തിൽ എനിക്ക് മുഴുകേണ്ടിവന്നു. തീർച്ചയായും, എന്റെ എല്ലാ 30+ സ്ക്രിപ്റ്റുകളും പ്രവർത്തിക്കുന്നത് നിർത്തി. എന്നെ അത്ഭുതപ്പെടുത്തിക്കൊണ്ട്, ഒരു പ്രവൃത്തി ദിവസം കൊണ്ട് എല്ലാം ശരിയാക്കാൻ എനിക്ക് കഴിഞ്ഞു. ഞാൻ ചൂടുള്ള അന്വേഷണത്തിലാണ് എഴുതുന്നത്. അതിനാൽ, വിൻഡോസിൽ നിന്ന് ലിനക്സിലേക്ക് പവർഷെൽ സ്ക്രിപ്റ്റുകൾ കൈമാറുമ്പോൾ നിങ്ങൾക്ക് എന്ത് അപകടങ്ങൾ നേരിടാനാകും?

sqlcmd vs ഇൻവോക്ക്-SqlCmd

അവ തമ്മിലുള്ള പ്രധാന വ്യത്യാസം ഞാൻ നിങ്ങളെ ഓർമ്മിപ്പിക്കട്ടെ. നല്ല പഴയ യൂട്ടിലിറ്റി sqlcmd ഏതാണ്ട് സമാനമായ പ്രവർത്തനക്ഷമതയോടെ ഇത് Linux-ന്റെ കീഴിൽ പ്രവർത്തിക്കുന്നു. -Q എക്സിക്യൂട്ട് ചെയ്യാനുള്ള ചോദ്യം, ഇൻപുട്ട് ഫയൽ -i ആയി, ഔട്ട്പുട്ട് -o എന്നിങ്ങനെ. എന്നാൽ ഫയലിന്റെ പേരുകൾ തീർച്ചയായും കേസ് സെൻസിറ്റീവ് ആണ്. നിങ്ങൾ -i ഉപയോഗിക്കുകയാണെങ്കിൽ, ഫയലിൽ അവസാനം എഴുതുക:

GO
EXIT

അവസാനം എക്സിറ്റ് ഇല്ലെങ്കിൽ, ഇൻപുട്ടിനായി കാത്തിരിക്കാൻ sqlcmd തുടരും, മുമ്പാണെങ്കിൽ പുറത്ത് ചെയ്യില്ല GO, അപ്പോൾ അവസാന കമാൻഡ് പ്രവർത്തിക്കില്ല. ഔട്ട്‌പുട്ട് ഫയലിൽ എല്ലാ ഔട്ട്‌പുട്ട്, തിരഞ്ഞെടുത്തവ, സന്ദേശങ്ങൾ, പ്രിന്റ് മുതലായവ അടങ്ങിയിരിക്കുന്നു.

Invoke-SqlCmd ഒരു DataSet, DataTables അല്ലെങ്കിൽ DataRows ആയി ഫലം നൽകുന്നു. അതിനാൽ, നിങ്ങൾ ഒരു ലളിതമായ തിരഞ്ഞെടുപ്പിന്റെ ഫലം പ്രോസസ്സ് ചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം sqlcmd, അതിന്റെ ഔട്ട്‌പുട്ട് പാഴ്‌സ് ചെയ്‌താൽ, സങ്കീർണ്ണമായ എന്തെങ്കിലും കണ്ടെത്തുന്നത് മിക്കവാറും അസാധ്യമാണ്: ഇതിനായി ഉണ്ട് Invoke-SqlCmd. എന്നാൽ ഈ ടീമിന് അവരുടേതായ തമാശകളും ഉണ്ട്:

• നിങ്ങൾ ഒരു ഫയൽ അവൾക്ക് കൈമാറുകയാണെങ്കിൽ -ഇൻപുട്ട് ഫയൽ, പിന്നെ പുറത്ത് ആവശ്യമില്ല, മാത്രമല്ല, ഇത് ഒരു വാക്യഘടന പിശക് സൃഷ്ടിക്കുന്നു
• -ഔട്ട്പുട്ട് ഫയൽ ഇല്ല, കമാൻഡ് നിങ്ങൾക്ക് ഫലം ഒരു ഒബ്ജക്റ്റായി നൽകുന്നു
• ഒരു സെർവർ വ്യക്തമാക്കുന്നതിന് രണ്ട് വാക്യഘടനകളുണ്ട്: -ServerInstance -Username -Password -Database വഴിയും -കണക്ഷൻസ്ട്രിംഗ്. വിചിത്രമെന്നു പറയട്ടെ, ആദ്യ സന്ദർഭത്തിൽ 1433 അല്ലാതെ മറ്റൊരു പോർട്ട് വ്യക്തമാക്കാൻ കഴിയില്ല.
• ടെക്സ്റ്റ് ഔട്ട്പുട്ട്, പ്രിന്റ് എന്ന് ടൈപ്പ് ചെയ്യുക, അത് "പിടിച്ചു" 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)

അതുകൊണ്ട് ഇതാ. *നിക്സിൽ വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷനുകൾ പ്രവർത്തിക്കുന്നില്ല. പരാമീറ്റർ -v അവഗണിച്ചു. യു Invoke-SqlCmd അവഗണിച്ചു - വേരിയബിളുകൾ. വേരിയബിളുകൾ തന്നെ വ്യക്തമാക്കുന്ന പരാമീറ്റർ അവഗണിക്കപ്പെടുമെങ്കിലും, പകരം വയ്ക്കുന്നത് സ്വയം പ്രവർത്തിക്കുന്നു - നിങ്ങൾക്ക് ഷെല്ലിൽ നിന്ന് ഏത് വേരിയബിളും ഉപയോഗിക്കാം. എന്നിരുന്നാലും, വേരിയബിളുകളിൽ ഞാൻ അസ്വസ്ഥനായി, അവയെ ആശ്രയിക്കേണ്ടെന്ന് തീരുമാനിച്ചു, കൂടാതെ 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"

നിങ്ങൾ മനസ്സിലാക്കുന്നതുപോലെ, യുണിക്സ് പതിപ്പിൽ നിന്നുള്ള ഒരു പരീക്ഷണമാണിത്.

ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുന്നു

വിൻഡോസ് പതിപ്പിൽ, ഏത് പ്രവർത്തനവും ഒരു ഓഡിറ്റിനൊപ്പം ഉണ്ടായിരുന്നു: ഞങ്ങൾ 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 ലഭിച്ചു, കൂടാതെ ഒരു ഫയലിൽ എക്സ്ക്ലൂസീവ് ലോക്ക് എടുക്കാനുള്ള ശ്രമം കാരണം ബൾക്ക് 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() 
  }  

ഉള്ളടക്കം തിരഞ്ഞെടുക്കുന്നതിന്, നിങ്ങൾ ഐഡി പ്രകാരം തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്, n (ഐഡന്റിറ്റി) എന്ന ക്രമത്തിൽ തിരഞ്ഞെടുക്കുക.

ഇതെല്ലാം ജെൻകിൻസുമായി എങ്ങനെ ഇടപഴകുന്നു എന്നതിനെക്കുറിച്ച് അടുത്ത ലേഖനത്തിൽ ഞാൻ കൂടുതൽ വിശദമായി പോകും.

അവലംബം: www.habr.com