Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
L'esecuzione di operazioni ALTER nelle tabelle ottimizzate per la memoria non è supportata. Sono incluse operazioni come la modifica del bucket_count, l'aggiunta o la rimozione di un indice e l'aggiunta o la rimozione di una colonna. In questo argomento vengono fornite linee guida su come aggiornare le tabelle ottimizzate per la memoria.
Aggiornamento della definizione di una tabella Memory-Optimized
Per aggiornare la definizione di una tabella ottimizzata per la memoria è necessario creare una nuova tabella con la definizione di tabella aggiornata, copiare i dati nella nuova tabella e iniziare a usare la nuova tabella. A meno che la tabella non sia di sola lettura, è necessario arrestare il carico di lavoro nella tabella per assicurarsi che non vengano apportate modifiche alla tabella mentre viene eseguita la copia dei dati.
Nella procedura seguente vengono descritti i passaggi necessari per aggiornare una tabella. In questo esempio l'aggiornamento aggiunge un indice. Questa procedura mantiene il nome della tabella e richiede due operazioni di copia dei dati: una volta in una tabella temporanea e una volta nella nuova tabella. La modifica del bucket_count di un indice o l'aggiunta o la rimozione di una colonna viene eseguita nello stesso modo.
Fermare il carico di lavoro sul tavolo.
Generare script per la tabella e aggiungere il nuovo indice allo script.
Generare script per gli oggetti associati a schema (principalmente stored procedure compilate in modo nativo) che fanno riferimento a T e alle relative autorizzazioni.
Gli oggetti associati a schema che fanno riferimento alla tabella sono disponibili usando la query seguente:
declare @t nvarchar(255) = N'<table name>' select r.referencing_schema_name, r.referencing_entity_name from sys.dm_sql_referencing_entities (@t, 'OBJECT') as r join sys.sql_modules m on r.referencing_id=m.object_id where r.is_caller_dependent = 0 and m.is_schema_bound=1;È possibile creare script per le autorizzazioni di una stored procedure usando il codice Transact-SQL seguente:
declare @sp nvarchar(255) = N'<procedure name>' declare @permissions nvarchar(max) = N'' select @permissions += dp.state_desc + N' ' + dp.permission_name + N' ON ' + quotename(schema_name(o.schema_id)) + N'.' + quotename(o.name) + N' TO ' + quotename(u.name) + N'; ' + char(13) from sys.database_permissions as dp join sys.database_principals as u on u.principal_id = dp.grantee_principal_id join sys.objects as o on o.object_id = dp.major_id where dp.class = 1 /* object */ and dp.minor_id = 0 and o.object_id=object_id(@sp); select @permissionsCreare una copia della tabella e copiare i dati dalla tabella originale alla copia della tabella. La copia può essere creata usando il codice Transact-SQL1 seguente.
select * into dbo.T_copy from dbo.TSe la memoria disponibile è sufficiente,
T_copypotrebbe essere una tabella ottimizzata per la memoria, che rende la copia dei dati più veloce.2Eliminare gli oggetti associati a schema che fanno riferimento alla tabella originale.
Eliminare la tabella originale.
Creare la nuova tabella (
T) con lo script contenente il nuovo indice.Copiare i dati da
T_copyaT.Ricreare gli oggetti associati allo schema di riferimento e applicare le autorizzazioni.
Avvia il carico di lavoro su
T.
1 Si noti che T_copy è persistente su disco in questo esempio. Se è disponibile un backup di T , T_copy può essere una tabella temporanea o non durevole.
2 Deve essere presente memoria sufficiente per T_copy. La memoria non viene liberata immediatamente su DROP TABLE. Se T_copy è ottimizzato per la memoria, è necessario disporre di memoria sufficiente per due copie aggiuntive di T. Se T_copy è una tabella basata su disco, è sufficiente avere memoria solo per una copia aggiuntiva di T poiché il garbage collector deve recuperare dopo aver eliminato la versione precedente di T.
Modifica dello schema (PowerShell)
Gli script di PowerShell seguenti preparano e generano le modifiche dello schema tramite script per la tabella e le autorizzazioni associate.
prepare_schema_change.ps1 <serverName> <databaseName> <schemaName> <tableName>
Questo script accetta come argomenti una tabella e scrive l'oggetto e le relative autorizzazioni e fa riferimento agli oggetti associati allo schema e alle relative autorizzazioni nella cartella corrente. Per aggiornare lo schema della tabella di input vengono generati un totale di 7 script:
Copiare i dati in una tabella temporanea (heap).
Eliminare gli oggetti associati a schema che fanno riferimento alla tabella.
Lascia cadere la tabella.
Ricreare la tabella con il nuovo schema e riapplicare le autorizzazioni.
Copiare dati dalla tabella temporanea alla tabella ricreata.
Ricreare gli oggetti associati a schema che fanno riferimento alla tabella e alle relative autorizzazioni.
Eliminare la tabella temporanea.
Lo script per il passaggio 4 deve essere aggiornato in modo da riflettere le modifiche dello schema desiderate. Se sono presenti modifiche nelle colonne della tabella, gli script per i passaggi 5 (copiare dati dalla tabella temporanea) e 6 (ricreare le stored procedure) devono essere aggiornati in base alle esigenze.
# Prepare for schema changes by scripting out the table, as well as associated permissions
# Usage: prepare_schema_change.ps1 server_name db_name schema_name table_name
# stop execution once an error occurs
$ErrorActionPreference="Stop"
if($args.Count -le 3)
{
throw "Usage prepare_schema_change.ps1 server_name db_name schema_name table_name"
}
$servername = $args[0]
$database = $args[1]
$schema = $args[2]
$object = $args[3]
$object_heap = "$object$(Get-Random)"
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SMO") | Out-Null
$server = New-Object ("Microsoft.SqlServer.Management.SMO.Server") ($servername)
$scripter = New-Object ("Microsoft.SqlServer.Management.SMO.Scripter") ($server)
## initialize table variable
$tableUrn = $server.Databases[$database].Tables[$object, $schema]
if($tableUrn.Count -eq 0)
{
throw "Table or database not found"
}
## initialize scripting object
$scriptingOptions = New-Object ("Microsoft.SqlServer.Management.SMO.ScriptingOptions")
$scriptingOptions.Permissions = $True
$scriptingOptions.ScriptDrops = $True
$scripter.Options = $scriptingOptions;
Write-Host "(1) Scripting SELECT INTO $object_heap for table [$object] to 1_copy_to_heap_for_$schema`_$object.sql"
Echo "SELECT * INTO $schema.$object_heap FROM $schema.$object WITH (SNAPSHOT)" | Out-File "1_copy_to_heap_$schema`_$object.sql";
Write-Host "--done--"
Write-Host ""
Write-Host "(2) Scripting DROP for procs schema-bound to [$object] 2_drop_procs_$schema`_$object.sql"
## query referencing schema-bound objects
$dt = $server.Databases[$database].ExecuteWithResults("select r.referencing_schema_name, r.referencing_entity_name
from sys.dm_sql_referencing_entities ('$schema.$object', 'OBJECT') as r join sys.sql_modules m on r.referencing_id=m.object_id
where r.is_caller_dependent = 0 and m.is_schema_bound=1;")
## initialize out file
Echo "" | Out-File "2_drop_procs_$schema`_$object.sql"
## loop through schema-bound objects
ForEach ($t In $dt.Tables)
{
ForEach ($r In $t.Rows)
{
## script object
$so = $server.Databases[$database].StoredProcedures[$r[1], $r[0]]
$scripter.Script($so) | Out-File -Append "2_drop_procs_$schema`_$object.sql"
}
}
Write-Host "--done--"
Write-Host ""
Write-Host "(3) Scripting DROP table for [$object] to 3_drop_table_$schema`_$object.sql"
$scripter.Script($tableUrn) | Out-File "3_drop_table_$schema`_$object.sql";
Write-Host "--done--"
Write-Host ""
## now script creates
$scriptingOptions.ScriptDrops = $False
Write-Host "(4) Scripting CREATE table and permissions for [$object] to !please_edit_4_create_table_$schema`_$object.sql"
Write-Host "***** rename this script to 4_create_table.sql after completing the updates to the schema"
$scripter.Script($tableUrn) | Out-File "!please_edit_4_create_table_$schema`_$object.sql";
Write-Host "--done--"
Write-Host ""
Write-Host "(5) Scripting INSERT INTO table from heap and UPDATE STATISTICS for [$object] to 5_copy_from_heap_$schema`_$object.sql"
Write-Host "[update this script if columns are added to or removed from the table]"
Echo "INSERT INTO [$schema].[$object] SELECT * FROM [$schema].[$object_heap]; UPDATE STATISTICS [$schema].[$object] WITH FULLSCAN, NORECOMPUTE" | Out-File "5_copy_from_heap_$schema`_$object.sql";
Write-Host "--done--"
Write-Host ""
Write-Host "(6) Scripting CREATE PROC and permissions for procedures schema-bound to [$object] to 6_create_procs_$schema`_$object.sql"
Write-Host "[update the procedure definitions if columns are renamed or removed]"
## initialize out file
Echo "" | Out-File "6_create_procs_$schema`_$object.sql"
## loop through schema-bound objects
ForEach ($t In $dt.Tables)
{
ForEach ($r In $t.Rows)
{
## script the schema-bound object
$so = $server.Databases[$database].StoredProcedures[$r[1], $r[0]]
ForEach($s In $scripter.Script($so))
{
Echo $s | Out-File -Append "6_create_procs_$schema`_$object.sql"
Echo "GO" | Out-File -Append "6_create_procs_$schema`_$object.sql"
}
}
}
Write-Host "--done--"
Write-Host ""
Write-Host "(7) Scripting DROP $object_heap to 7_drop_heap_$schema`_$object.sql"
Echo "DROP TABLE $schema.$object_heap" | Out-File "7_drop_heap_$schema`_$object.sql";
Write-Host "--done--"
Write-Host ""
Lo script di PowerShell seguente esegue le modifiche dello schema di cui è stato eseguito lo script nell'esempio precedente. Questo script accetta come argomento una tabella ed esegue gli script di modifica dello schema generati per tale tabella e le stored procedure associate.
Utilizzo: execute_schema_change.ps1 server_name**db_nameschema_nametable_name
# stop execution once an error occurs
$ErrorActionPreference="Stop"
if($args.Count -le 3)
{
throw "Usage execute_schema_change.ps1 server_name db_name schema_name table_name"
}
$servername = $args[0]
$database = $args[1]
$schema = $args[2]
$object = $args[3]
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.SMO") | Out-Null
$server = New-Object ("Microsoft.SqlServer.Management.SMO.Server") ($servername)
$database = $server.Databases[$database]
$table = $database.Tables[$object, $schema]
if($table.Count -eq 0)
{
throw "Table or database not found"
}
$1 = Get-Item "1_copy_to_heap_$schema`_$object.sql"
$2 = Get-Item "2_drop_procs_$schema`_$object.sql"
$3 = Get-Item "3_drop_table_$schema`_$object.sql"
$4 = Get-Item "4_create_table_$schema`_$object.sql"
$5 = Get-Item "5_copy_from_heap_$schema`_$object.sql"
$6 = Get-Item "6_create_procs_$schema`_$object.sql"
$7 = Get-Item "7_drop_heap_$schema`_$object.sql"
Write-Host "(1) Running SELECT INTO heap for table [$object] from 1_copy_to_heap_for_$schema`_$object.sql"
$database.ExecuteNonQuery("$(Echo $1.OpenText().ReadToEnd())")
Write-Host "--done--"
Write-Host ""
Write-Host "(2) Running DROP for procs schema-bound from [$object] 2_drop_procs_$schema`_$object.sql"
$database.ExecuteNonQuery("$(Echo $2.OpenText().ReadToEnd())")
Write-Host "--done--"
Write-Host ""
Write-Host "(3) Running DROP table for [$object] to 4_drop_table_$schema`_$object.sql"
$database.ExecuteNonQuery("$(Echo $3.OpenText().ReadToEnd())")
Write-Host "--done--"
Write-Host ""
Write-Host "(4) Running CREATE table and permissions for [$object] from 4_create_table_$schema`_$object.sql"
$database.ExecuteNonQuery("$(Echo $4.OpenText().ReadToEnd())")
Write-Host "--done--"
Write-Host ""
Write-Host "(5) Running INSERT INTO table from heap for [$object] and UPDATE STATISTICS from 5_copy_from_heap_$schema`_$object.sql"
$database.ExecuteNonQuery("$(Echo $5.OpenText().ReadToEnd())")
Write-Host "--done--"
Write-Host ""
Write-Host "(6) Running CREATE PROC and permissions for procedures schema-bound to [$object] from 6_create_procs_$schema`_$object.sql"
$database.ExecuteNonQuery("$(Echo $6.OpenText().ReadToEnd())")
Write-Host "--done--"
Write-Host ""
Write-Host "(7) Running DROP heap from 7_drop_heap_$schema`_$object.sql"
$database.ExecuteNonQuery("$(Echo $7.OpenText().ReadToEnd())")
Write-Host "--done--"
Write-Host ""