Selezionare le righe di cui eseguire la migrazione tramite una funzione di filtro (Estensione database)Select rows to migrate by using a filter function (Stretch Database)

QUESTO ARGOMENTO SI APPLICA A:sìSQL Server (a partire dalla versione 2016)noDatabase SQL di AzurenoAzure SQL Data WarehousenoParallel Data WarehouseTHIS TOPIC APPLIES TO: yesSQL Server (starting with 2016)noAzure SQL DatabasenoAzure SQL Data Warehouse noParallel Data Warehouse

Se i dati usati meno di frequente vengono archiviati in una tabella separata, è possibile configurare Estensione database per eseguire la migrazione dell'intera tabella.If you store cold data in a separate table, you can configure Stretch Database to migrate the entire table. Se invece la tabella contiene dati usati più di frequente e dati usati meno di frequente, è possibile specificare un predicato del filtro per selezionare le righe di cui eseguire la migrazione.If your table contains both hot and cold data, on the other hand, you can specify a filter predicate to select the rows to migrate. Il predicato del filtro è una funzione inline con valori di tabella.The filter predicate is an inline table-valued function. Questo argomento illustra come scrivere una funzione inline con valori di tabella per selezionare le righe di cui eseguire la migrazione.This topic describes how to write an inline table-valued function to select rows to migrate.

Importante

Se si specifica una funzione di filtro dalle prestazioni scarse, anche la migrazione dei dati avrà prestazioni scarse.If you provide a filter function that performs poorly, data migration also performs poorly. Estensione database applica la funzione di filtro alla tabella usando l'operatore CROSS APPLY.Stretch Database applies the filter function to the table by using the CROSS APPLY operator.

Se non si specifica una funzione di filtro, viene eseguita la migrazione dell'intera tabella.If you don't specify a filter function, the entire table is migrated.

Quando si esegue l'Abilitazione guidata del database per l'estensione, è possibile eseguire la migrazione di un'intera tabella oppure specificare una funzione di filtro semplice nella procedura guidata.When you run the Enable Database for Stretch Wizard, you can migrate an entire table or you can specify a simple filter function in the wizard. Se si vuole usare un tipo diverso di funzione di filtro per selezionare le righe di cui eseguire la migrazione, effettuare una delle seguenti operazioni.If you want to use a different type of filter function to select rows to migrate, do one of the following things.

  • Uscire dalla procedura guidata ed eseguire l'istruzione ALTER TABLE per abilitare l'Estensione per la tabella e specificare una funzione di filtro.Exit the wizard and run the ALTER TABLE statement to enable Stretch for the table and to specify a filter function.

  • Eseguire l'istruzione ALTER TABLE per specificare una funzione di filtro dopo l'uscita dalla procedura guidata.Run the ALTER TABLE statement to specify a filter function after you exit the wizard.

    La sintassi di ALTER TABLE per l'aggiunta di una funzione è descritta più avanti in questo argomento.The ALTER TABLE syntax for adding a function is described later in this topic.

Requisiti di base per la funzione di filtroBasic requirements for the filter function

La funzione inline con valori di tabella necessaria per un predicato del filtro di Estensione database è simile alla seguente.The inline table-valued function required for a Stretch Database filter predicate looks like the following example.

CREATE FUNCTION dbo.fn_stretchpredicate(@column1 datatype1, @column2 datatype2 [, ...n])  
RETURNS TABLE  
WITH SCHEMABINDING   
AS   
RETURN  SELECT 1 AS is_eligible  
        WHERE <predicate>  

I parametri della funzione devono essere identificatori delle colonne della tabella.The parameters for the function have to be identifiers for columns from the table.

L'associazione allo schema è necessaria per evitare l'eliminazione o la modifica delle colonne usate dalla funzione di filtro.Schema binding is required to prevent columns that are used by the filter function from being dropped or altered.

Valore restituitoReturn value

Se la funzione restituisce un risultato non vuoto, la riga è idonea per la migrazione.If the function returns a non-empty result, the row is eligible to be migrated. In caso contrario, ovvero se la funzione non restituisce un risultato, la riga non è idonea per la migrazione.Otherwise - that is, if the function doesn't return a result - the row is not eligible to be migrated.

CondizioniConditions

Il <predicato> può essere costituito da una singola condizione oppure da più condizioni unite tramite l'operatore logico AND.The <predicate> can consist of one condition, or of multiple conditions joined with the AND logical operator.

<predicate> ::= <condition> [ AND <condition> ] [ ...n ]  

Ogni condizione può essere costituita a sua volta da una singola condizione primitiva o da più condizioni primitive unite tramite l'operatore logico OR.Each condition in turn can consist of one primitive condition, or of multiple primitive conditions joined with the OR logical operator.

<condition> ::= <primitive_condition> [ OR <primitive_condition> ] [ ...n ]  

Condizioni primitivePrimitive conditions

Una condizione di primitiva può eseguire uno dei confronti seguenti.A primitive condition can do one of the following comparisons.

<primitive_condition> ::=   
{  
<function_parameter> <comparison_operator> constant  
| <function_parameter> { IS NULL | IS NOT NULL }  
| <function_parameter> IN ( constant [ ,...n ] )  
}  
  • Confrontare un parametro di funzione con un'espressione costante.Compare a function parameter to a constant expression. Ad esempio, @column1 < 1000.For example, @column1 < 1000.

    Ecco un esempio che controlla se il valore di una colonna date è < 1/1/2016.Here's an example that checks whether the value of a date column is < 1/1/2016.

    CREATE FUNCTION dbo.fn_stretchpredicate(@column1 datetime)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE @column1 < CONVERT(datetime, '1/1/2016', 101)  
    GO  
    
    ALTER TABLE stretch_table_name SET ( REMOTE_DATA_ARCHIVE = ON (  
        FILTER_PREDICATE = dbo.fn_stretchpredicate(date),  
        MIGRATION_STATE = OUTBOUND  
    ) )  
    
  • Applicare l'operatore IS NULL o IS NOT NULL a un parametro di funzione.Apply the IS NULL or IS NOT NULL operator to a function parameter.

  • Usare l'operatore IN per confrontare un parametro di funzione con un elenco di valori costanti.Use the IN operator to compare a function parameter to a list of constant values.

    Ecco un esempio che controlla se il valore di una colonna shipment_status è IN (N'Completed', N'Returned', N'Cancelled').Here's an example that checks whether the value of a shipment_status column is IN (N'Completed', N'Returned', N'Cancelled').

    CREATE FUNCTION dbo.fn_stretchpredicate(@column1 nvarchar(15))  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE @column1 IN (N'Completed', N'Returned', N'Cancelled')  
    GO  
    
    ALTER TABLE table1 SET ( REMOTE_DATA_ARCHIVE = ON (  
        FILTER_PREDICATE = dbo.fn_stretchpredicate(shipment_status),  
        MIGRATION_STATE = OUTBOUND  
    ) )  
    

Operatori di confrontoComparison operators

Sono supportati gli operatori di confronto seguenti.The following comparison operators are supported.

<, <=, >, >=, =, <>, !=, !<, !>

<comparison_operator> ::= { < | <= | > | >= | = | <> | != | !< | !> }  

Espressioni costantiConstant expressions

Le costanti usate in una funzione di filtro possono essere costituite da qualsiasi espressione deterministica che può essere valutata quando si definisce la funzione.The constants that you use in a filter function can be any deterministic expression that can be evaluated when you define the function. Le espressioni costanti possono contenere gli elementi seguenti.Constant expressions can contain the following things.

  • Valori letterali.Literals. Ad esempio, N’abc’, 123.For example, N’abc’, 123.

  • Espressioni algebriche.Algebraic expressions. Ad esempio, 123 + 456.For example, 123 + 456.

  • Funzioni deterministiche.Deterministic functions. Ad esempio, SQRT(900).For example, SQRT(900).

  • Conversioni deterministiche che usano CAST o CONVERT.Deterministic conversions that use CAST or CONVERT. Ad esempio, CONVERT(datetime, '1/1/2016', 101).For example, CONVERT(datetime, '1/1/2016', 101).

Altre espressioniOther expressions

È possibile usare gli operatori BETWEEN e NOT BETWEEN se la funzione risultante è conforme alle regole descritte qui dopo la sostituzione degli operatori BETWEEN e NOT BETWEEN con le espressioni AND e OR equivalenti.You can use the BETWEEN and NOT BETWEEN operators if the resulting function conforms to the rules described here after you replace the BETWEEN and NOT BETWEEN operators with the equivalent AND and OR expressions.

Non è possibile usare sottoquery o funzioni non deterministiche, ad esempio RAND() o GETDATE().You can't use subqueries or non-deterministic functions such as RAND() or GETDATE().

Aggiungere una funzione di filtro a una tabellaAdd a filter function to a table

Per aggiungere una funzione di filtro a una tabella, eseguire l'istruzione ALTER TABLE e specificare una funzione inline con valori di tabella esistente come valore del parametro FILTER_PREDICATE .Add a filter function to a table by running the ALTER TABLE statement and specifying an existing inline table-valued function as the value of the FILTER_PREDICATE parameter. Esempio:For example:

ALTER TABLE stretch_table_name SET ( REMOTE_DATA_ARCHIVE = ON (  
    FILTER_PREDICATE = dbo.fn_stretchpredicate(column1, column2),  
    MIGRATION_STATE = <desired_migration_state>  
) )  

Dopo aver associato la funzione alla tabella come predicato, si verifica quanto segue.After you bind the function to the table as a predicate, the following things are true.

  • Alla migrazione di dati successiva, viene eseguita la migrazione soltanto delle righe per le quali la funzione restituisce un valore non vuoto.The next time data migration occurs, only the rows for which the function returns a non-empty value are migrated.

  • Le colonne usate dalla funzione sono associate allo schema.The columns used by the function are schema bound. Non è possibile modificare le colonne fino a quando una tabella usa la funzione come predicato del filtro.You can't alter these columns as long as a table is using the function as its filter predicate.

    Non è possibile eliminare la funzione inline con valori di tabella fino a quando una tabella usa la funzione come predicato del filtro.You can't drop the inline table-valued function as long as a table is using the function as its filter predicate.

Suggerimento

Per migliorare le prestazioni della funzione di filtro, creare un indice per le colonne usate dalla funzione.To improve the performance of the filter function, create an index on the columns used by the function.

Passaggio di nomi di colonna alla funzione di filtroPassing column names to the filter function

Quando si assegna una funzione di filtro a una tabella, specificare nomi in una parte per le colonne passate alla funzione di filtro.When you assign a filter function to a table, specify the column names passed to the filter function with a one-part name. Se quando si passano i nomi di colonna si specificano nomi in tre parti, le query successive sulla tabella con estensione abilitata avranno esito negativo.If you specify a three-part name when you pass the column names, subsequent queries against the Stretch-enabled table will fail.

Se, come illustrato nell'esempio seguente, si specifica un nome di colonna in tre parti, l'istruzione verrà eseguita correttamente, ma le query successive sulla tabella avranno esito negativo.For example, if you specify a three-part column name as shown in the following example, the statement will run successfully, but subsequent queries against the table will fail.

ALTER TABLE SensorTelemetry 
  SET ( REMOTE_DATA_ARCHIVE = ON (
    FILTER_PREDICATE=dbo.fn_stretchpredicate(dbo.SensorTelemetry.ScanDate),
    MIGRATION_STATE = OUTBOUND )
  )

Specificare invece la funzione di filtro con un nome di colonna in una sola parte, come illustrato nell'esempio seguente.Instead, specify the filter function with a one-part column name as shown in the following example.

ALTER TABLE SensorTelemetry 
  SET ( REMOTE_DATA_ARCHIVE = ON  (
    FILTER_PREDICATE=dbo.fn_stretchpredicate(ScanDate),
    MIGRATION_STATE = OUTBOUND )
  )

Aggiungere una funzione di filtro dopo l'esecuzione della procedura guidataAdd a filter function after running the Wizard

Se si vuole usare una funzione che non è possibile creare nell' Abilitazione guidata del database per l'estensione , è possibile eseguire l'istruzione ALTER TABLE per specificare una funzione, dopo l'uscita dalla procedura guidata.If you want use a function that you can't create in the Enable Database for Stretch Wizard, you can run the ALTER TABLE statement to specify a function after you exit the wizard. Prima di applicare una funzione, tuttavia, è necessario interrompere la migrazione dei dati in corso e ripristinare i dati migrati.Before you can apply a function, however, you have to stop the data migration that's already in progress and bring back migrated data. Per altre informazioni sul perché è necessario, vedere Sostituire una funzione di filtro esistente.(For more info about why this is necessary, see Replace an existing filter function.)

  1. Invertire la direzione della migrazione e ripristinare i dati già migrati.Reverse the direction of migration and bring back the data already migrated. Non è possibile annullare questa operazione dopo l'avvio.You can't cancel this operation after it starts. In Azure, poi, i trasferimenti di dati in uscita (traffico in uscita) sono soggetti ad addebito.You also incur costs on Azure for outbound data transfers (egress). Per altre informazioni, vedere Dettagli prezzi dei trasferimenti di dati.For more info, see How Azure pricing works.

    ALTER TABLE <table name>  
        SET ( REMOTE_DATA_ARCHIVE ( MIGRATION_STATE = INBOUND ) ) ;   
    
  2. Attendere il completamento della migrazione.Wait for migration to finish. È possibile controllare lo stato in Monitoraggio dell'estensione database da SQL Server Management Studio, oppure è possibile eseguire query sulla vista sys.dm_db_rda_migration_status .You can check the status in Stretch Database Monitor from SQL Server Management Studio, or you can query the sys.dm_db_rda_migration_status view. Per altre informazioni, vedere Monitor and troubleshoot data migration (Monitoraggio e risoluzione dei problemi della migrazione dei dati) o sys.dm_db_rda_migration_status.For more info, see Monitor and troubleshoot data migration or sys.dm_db_rda_migration_status.

  3. Creare la funzione di filtro che si vuole applicare alla tabella.Create the filter function that you want to apply to the table.

  4. Aggiungere la funzione alla tabella e riavviare la migrazione dei dati in Azure.Add the function to the table and restart data migration to Azure.

    ALTER TABLE <table name>  
        SET ( REMOTE_DATA_ARCHIVE  
            (           
                FILTER_PREDICATE = <predicate>,  
                MIGRATION_STATE = OUTBOUND  
            )  
            );   
    

Filtrare le righe in base alla dataFilter rows by date

L'esempio seguente esegue la migrazione delle righe in cui la colonna date contiene un valore precedente all'1 gennaio 2016.The following example migrates rows where the date column contains a value earlier than January 1, 2016.

-- Filter by date  
--  
CREATE FUNCTION dbo.fn_stretch_by_date(@date datetime2)  
RETURNS TABLE  
WITH SCHEMABINDING   
AS   
       RETURN SELECT 1 AS is_eligible WHERE @date < CONVERT(datetime2, '1/1/2016', 101)  
GO  

Filtrare le righe in base al valore della colonna statusFilter rows by the value in a status column

L'esempio seguente esegue la migrazione delle righe in cui la colonna status contiene uno dei valori specificati.The following example migrates rows where the status column contains one of the specified values.

-- Filter by status column  
--  
CREATE FUNCTION dbo.fn_stretch_by_status(@status nvarchar(128))  
RETURNS TABLE  
WITH SCHEMABINDING   
AS   
       RETURN SELECT 1 AS is_eligible WHERE @status IN (N'Completed', N'Returned', N'Cancelled')  
GO  

Filtrare le righe usando una finestra temporale scorrevoleFilter rows by using a sliding window

Per filtrare le righe usando una finestra temporale scorrevole, tenere presente i requisiti seguenti per la funzione di filtro.To filter rows by using a sliding window, keep in mind the following requirements for the filter function.

  • La funzione deve essere deterministica.The function has to be deterministic. Di conseguenza, non è possibile creare una funzione che ricalcola automaticamente la finestra temporale scorrevole col passare del tempo.Therefore you can't create a function that automatically recalculates the sliding window as time passes.

  • La funzione usa l'associazione allo schema.The function uses schema binding. Per questo motivo non è possibile limitarsi ad aggiornare la funzione "sul posto" chiamando ogni giorno l'istruzione ALTER FUNCTION per spostare la finestra temporale scorrevole.Therefore you can't simply update the function "in place" every day by calling ALTER FUNCTION to move the sliding window.

    Iniziare con una funzione di filtro come quella dell'esempio seguente, che esegue la migrazione delle righe in cui la colonna systemEndTime contiene un valore precedente al 1° gennaio 2016.Start with a filter function like the following example, which migrates rows where the systemEndTime column contains a value earlier than January 1, 2016.

CREATE FUNCTION dbo.fn_StretchBySystemEndTime20160101(@systemEndTime datetime2)   
RETURNS TABLE   
WITH SCHEMABINDING    
AS    
RETURN SELECT 1 AS is_eligible   
  WHERE @systemEndTime < CONVERT(datetime2, '2016-01-01T00:00:00', 101) ;  

Applicare la funzione di filtro alla tabella.Apply the filter function to the table.

ALTER TABLE <table name>   
SET (   
        REMOTE_DATA_ARCHIVE = ON   
                (   
                        FILTER_PREDICATE = dbo.fn_StretchBySystemEndTime20160101(SysEndTime)  
                                , MIGRATION_STATE = OUTBOUND   
                )  
        )   
;  

Quando si vuole aggiornare la finestra temporale scorrevole, eseguire le operazioni seguenti.When you want to update the sliding window, do the following things.

  1. Creare una nuova funzione che specifica la nuova finestra temporale scorrevole.Create a new function that specifies the new sliding window. L'esempio seguente seleziona le date precedenti al 2 gennaio 2016 anziché all'1 gennaio 2016.The following example selects dates earlier than January 2, 2016, instead of January 1, 2016.

  2. Sostituire la funzione di filtro precedente con quella nuova chiamando ALTER TABLE, come illustrato nell'esempio seguente.Replace the previous filter function with the new one by calling ALTER TABLE, as shown in the following example.

  3. Facoltativamente, eliminare la precedente funzione di filtro non più in uso chiamando DROP FUNCTION.Optionally, drop the previous filter function that you're no longer using by calling DROP FUNCTION. Questo passaggio non è illustrato nell'esempio.(This step is not shown in the example.)

BEGIN TRAN  
GO  
        /*(1) Create new predicate function definition */  
        CREATE FUNCTION dbo.fn_StretchBySystemEndTime20160102(@systemEndTime datetime2)  
        RETURNS TABLE  
        WITH SCHEMABINDING   
        AS   
        RETURN SELECT 1 AS is_eligible  
               WHERE @systemEndTime < CONVERT(datetime2,'2016-01-02T00:00:00', 101)  
        GO  

        /*(2) Set the new function as the filter predicate */  
        ALTER TABLE <table name>  
        SET   
        (  
               REMOTE_DATA_ARCHIVE = ON  
               (  
                       FILTER_PREDICATE = dbo.fn_StretchBySystemEndTime20160102(SysEndTime),  
                       MIGRATION_STATE = OUTBOUND  
               )  
        )   
COMMIT ;  

Altri esempi di funzioni di filtro valideMore examples of valid filter functions

  • L'esempio seguente unisce due condizioni primitive usando l'operatore logico AND.The following example combines two primitive conditions by using the AND logical operator.

    CREATE FUNCTION dbo.fn_stretchpredicate((@column1 datetime, @column2 nvarchar(15))  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
      WHERE @column1 < N'20150101' AND @column2 IN (N'Completed', N'Returned', N'Cancelled')  
    GO  
    
    ALTER TABLE table1 SET ( REMOTE_DATA_ARCHIVE = ON (  
        FILTER_PREDICATE = dbo.fn_stretchpredicate(date, shipment_status),  
        MIGRATION_STATE = OUTBOUND  
    ) )  
    
  • L'esempio seguente usa diverse condizioni e una conversione deterministica con CONVERT.The following example uses several conditions and a deterministic conversion with CONVERT.

    CREATE FUNCTION dbo.fn_stretchpredicate_example1(@column1 datetime, @column2 int, @column3 nvarchar)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
        WHERE @column1 < CONVERT(datetime, '1/1/2015', 101) AND (@column2 < -100 OR @column2 > 100 OR @column2 IS NULL) AND @column3 IN (N'Completed', N'Returned', N'Cancelled')  
    GO  
    
  • L'esempio seguente usa funzioni e operatori matematici.The following example uses mathematical operators and functions.

    CREATE FUNCTION dbo.fn_stretchpredicate_example2(@column1 float)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE @column1 < SQRT(400) + 10  
    GO  
    
  • L'esempio seguente usa gli operatori BETWEEN e NOT BETWEEN.The following example uses the BETWEEN and NOT BETWEEN operators. Questo utilizzo è valido poiché la funzione risultante è conforme alle regole descritte qui dopo aver sostituito gli operatori BETWEEN e NOT BETWEEN con le espressioni AND e OR equivalenti.This usage is valid because the resulting function conforms to the rules described here after you replace the BETWEEN and NOT BETWEEN operators with the equivalent AND and OR expressions.

    CREATE FUNCTION dbo.fn_stretchpredicate_example3(@column1 int, @column2 int)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE @column1 BETWEEN 0 AND 100  
                AND (@column2 NOT BETWEEN 200 AND 300 OR @column1 = 50)  
    GO  
    

    La funzione precedente è equivalente alla funzione riportata di seguito dopo la sostituzione degli operatori BETWEEN e NOT BETWEEN con le espressioni AND e OR equivalenti.The preceding function is equivalent to the following function after you replace the BETWEEN and NOT BETWEEN operators with the equivalent AND and OR expressions.

    CREATE FUNCTION dbo.fn_stretchpredicate_example4(@column1 int, @column2 int)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE @column1 >= 0 AND @column1 <= 100 AND (@column2 < 200 OR @column2 > 300 OR @column1 = 50)  
    GO  
    

Esempi di funzioni di filtro non valideExamples of filter functions that aren't valid

  • La funzione seguente non è valida perché contiene una conversione non deterministica.The following function isn't valid because it contains a non-deterministic conversion.

    CREATE FUNCTION dbo.fn_example5(@column1 datetime)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE @column1 < CONVERT(datetime, '1/1/2016')  
    GO  
    
  • La funzione seguente non è valida perché contiene una chiamata di funzione non deterministica.The following function isn't valid because it contains a non-deterministic function call.

    CREATE FUNCTION dbo.fn_example6(@column1 datetime)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE @column1 < DATEADD(day, -60, GETDATE())  
    GO  
    
  • La funzione seguente non è valida perché contiene una sottoquery.The following function isn't valid because it contains a subquery.

    CREATE FUNCTION dbo.fn_example7(@column1 int)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE @column1 IN (SELECT SupplierID FROM Supplier WHERE Status = 'Defunct')  
    GO  
    
  • Le funzioni seguenti non sono valide perché le espressioni che usano operatori algebrici o funzioni predefinite devono restituire una costante quando si definisce la funzione.The following functions aren't valid because expressions that use algebraic operators or built-in functions must evaluate to a constant when you define the function. Non è possibile includere riferimenti a colonne nelle espressioni algebriche o nelle chiamate di funzione.You can't include column references in algebraic expressions or function calls.

    CREATE FUNCTION dbo.fn_example8(@column1 int)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE @column1 % 2 =  0  
    GO  
    
    CREATE FUNCTION dbo.fn_example9(@column1 int)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE SQRT(@column1) = 30  
    GO  
    
  • La funzione seguente non è valida perché viola le regole descritte qui dopo la sostituzione dell'operatore BETWEEN con l'espressione AND equivalente.The following function isn't valid because it violates the rules described here after you replace the BETWEEN operator with the equivalent AND expression.

    CREATE FUNCTION dbo.fn_example10(@column1 int, @column2 int)  
    RETURNS TABLE  
    WITH SCHEMABINDING  
    AS  
    RETURN  SELECT 1 AS is_eligible  
            WHERE (@column1 BETWEEN 1 AND 200 OR @column1 = 300) AND @column2 > 1000  
    GO  
    

    La funzione precedente è equivalente alla funzione riportata di seguito dopo la sostituzione dell'operatore BETWEEN con l'espressione AND equivalente.The preceding function is equivalent to the following function after you replace the BETWEEN operator with the equivalent AND expression. Questa funzione non è valida perché le condizioni primitive possono usare solo l'operatore logico OR.This function isn't valid because primitive conditions can only use the OR logical operator.

    CREATE FUNCTION dbo.fn_example11(@column1 int, @column2 int)  
    RETURNS TABLE  
    WITH SCHEMABINDING   
    AS   
    RETURN  SELECT 1 AS is_eligible  
            WHERE (@column1 >= 1 AND @column1 <= 200 OR @column1 = 300) AND @column2 > 1000  
    GO  
    

Come viene applicata la funzione di filtro da Estensione databaseHow Stretch Database applies the filter function

Estensione database applica la funzione di filtro alla tabella e individua le righe idonee usando l'operatore CROSS APPLY.Stretch Database applies the filter function to the table and determines eligible rows by using the CROSS APPLY operator. Esempio:For example:

SELECT * FROM stretch_table_name CROSS APPLY fn_stretchpredicate(column1, column2)  

Se la funzione restituisce un risultato non vuoto per la riga, la riga è idonea per la migrazione.If the function returns a non-empty result for the row, the row is eligible to be migrated.

Sostituire una funzione di filtro esistenteReplace an existing filter function

Per sostituire una funzione di filtro specificata in precedenza, eseguire di nuovo l'istruzione ALTER TABLE e specificare un valore nuovo per il parametro FILTER_PREDICATE .You can replace a previously specified filter function by running the ALTER TABLE statement again and specifying a new value for the FILTER_PREDICATE parameter. Esempio:For example:

ALTER TABLE stretch_table_name SET ( REMOTE_DATA_ARCHIVE = ON (  
    FILTER_PREDICATE = dbo.fn_stretchpredicate2(column1, column2),  
    MIGRATION_STATE = <desired_migration_state>  

La nuova funzione inline con valori di tabella ha i requisiti seguenti.The new inline table-valued function has the following requirements.

  • La nuova funzione deve essere meno restrittiva rispetto alla funzione precedente.The new function has to be less restrictive than the previous function.

  • Tutti gli operatori presenti nella funzione precedente devono essere presente nella nuova funzione.All the operators that existed in the old function must exist in the new function.

  • La nuova funzione non può contenere operatori che non sono presenti nella funzione precedente.The new function can't contain operators that don’t exist in the old function.

  • Non è possibile modificare l'ordine degli argomenti degli operatori.The order of operator arguments can't change.

  • Solo i valori costanti che fanno parte di un confronto <, <=, >, >= possono essere modificati in modo da rendere meno restrittiva la funzione.Only constant values that are part of a <, <=, >, >= comparison can be changed in a way that makes the function less restrictive.

Esempio di sostituzione validaExample of a valid replacement

Si supponga che la funzione seguente sia la funzione di filtro corrente.Assume that the following function is the current filter function.

CREATE FUNCTION dbo.fn_stretchpredicate_old(@column1 datetime, @column2 int)  
RETURNS TABLE  
WITH SCHEMABINDING   
AS   
RETURN  SELECT 1 AS is_eligible  
        WHERE @column1 < CONVERT(datetime, '1/1/2016', 101)  
            AND (@column2 < -100 OR @column2 > 100)  
GO  

La funzione seguente è una sostituzione valida perché la nuova costante di data, che specifica una data limite successiva, rende meno restrittiva la funzione.The following function is a valid replacement because the new date constant (which specifies a later cutoff date) makes the function less restrictive.

CREATE FUNCTION dbo.fn_stretchpredicate_new(@column1 datetime, @column2 int)  
RETURNS TABLE  
WITH SCHEMABINDING   
AS   
RETURN  SELECT 1 AS is_eligible  
        WHERE @column1 < CONVERT(datetime, '2/1/2016', 101)  
            AND (@column2 < -50 OR @column2 > 50)  
GO  

Esempi di sostituzioni non valideExamples of replacements that aren't valid

La funzione seguente non è una sostituzione valida perché la nuova costante di data, che specifica una data limite precedente, non rende meno restrittiva la funzione.The following function isn't a valid replacement because the new date constant (which specifies an earlier cutoff date) doesn't make the function less restrictive.

CREATE FUNCTION dbo.fn_notvalidreplacement_1(@column1 datetime, @column2 int)  
RETURNS TABLE  
WITH SCHEMABINDING   
AS   
RETURN  SELECT 1 AS is_eligible  
        WHERE @column1 < CONVERT(datetime, '1/1/2015', 101)  
            AND (@column2 < -100 OR @column2 > 100)  
GO  

La funzione seguente non è una sostituzione valida perché uno degli operatori di confronto è stato rimosso.The following function isn't a valid replacement because one of the comparison operators has been removed.

CREATE FUNCTION dbo.fn_notvalidreplacement_2(@column1 datetime, @column2 int)  
RETURNS TABLE  
WITH SCHEMABINDING   
AS   
RETURN  SELECT 1 AS is_eligible  
        WHERE @column1 < CONVERT(datetime, '1/1/2016', 101)  
            AND (@column2 < -50)  
GO  

La funzione seguente non è una sostituzione valida perché è stata aggiunta una nuova condizione con l'operatore logico AND.The following function isn't a valid replacement because a new condition has been added with the AND logical operator.

CREATE FUNCTION dbo.fn_notvalidreplacement_3(@column1 datetime, @column2 int)  
RETURNS TABLE  
WITH SCHEMABINDING   
AS   
RETURN  SELECT 1 AS is_eligible  
        WHERE @column1 < CONVERT(datetime, '1/1/2016', 101)  
            AND (@column2 < -100 OR @column2 > 100)  
            AND (@column2 <> 0)  
GO  

Rimuovere una funzione di filtro da una tabellaRemove a filter function from a table

Per eseguire la migrazione dell'intera tabella anziché delle righe selezionate, rimuovere la funzione esistente impostando FILTER_PREDICATE su null.To migrate the entire table instead of selected rows, remove the existing function by setting FILTER_PREDICATE to null. Esempio:For example:

ALTER TABLE stretch_table_name SET ( REMOTE_DATA_ARCHIVE = ON (  
    FILTER_PREDICATE = NULL,  
    MIGRATION_STATE = <desired_migration_state>  
) )  

Dopo aver rimosso la funzione di filtro, tutte le righe della tabella sono idonee per la migrazione.After you remove the filter function, all rows in the table are eligible for migration. Di conseguenza, è possibile specificare una funzione di filtro per la stessa tabella in un secondo momento solo se si recuperano prima tutti i dati remoti della tabella da Azure.As a result, you cannot specify a filter function for the same table later unless you bring back all the remote data for the table from Azure first. Questa restrizione ha lo scopo di evitare che quando si specifica una nuova funzione di filtro le righe non idonee per la migrazione siano già state migrate in Azure.This restriction exists to avoid the situation where rows that are not eligible for migration when you provide a new filter function have already been migrated to Azure.

Controllare la funzione di filtro applicata a una tabellaCheck the filter function applied to a table

Per controllare la funzione di filtro applicata a una tabella, aprire la vista del catalogo sys.remote_data_archive_tables e controllare il valore per la colonna filter_predicate .To check the filter function applied to a table, open the catalog view sys.remote_data_archive_tables and check the value of the filter_predicate column. Se il valore è null, l'intera tabella è idonea per l'archiviazione.If the value is null, the entire table is eligible for archiving. Per altre info, vedere sys.remote_data_archive_tables (Transact-SQL).For more info, see sys.remote_data_archive_tables (Transact-SQL).

Note sulla sicurezza per le funzioni di filtroSecurity notes for filter functions

Un account compromesso con privilegi db_owner può eseguire le operazioni seguenti.A compromised account with db_owner privileges can do the following things.

  • Creare e applicare una funzione con valori di tabella che usa grandi quantità di risorse del server o rimane in attesa per un lungo periodo, risultando in un risultante in un attacco Denial of Service.Create and apply a table-valued function that consumes large amounts of server resources or waits for an extended period resulting in a denial of service.

  • Creare e applicare una funzione con valori di tabella che rende possibile dedurre il contenuto di una tabella per la quale all'utente è stato esplicitamente negato l'accesso in lettura.Create and apply a table-valued function that makes it possible to infer the content of a table for which the user has been explicitly denied read access.

Vedere ancheSee Also

ALTER TABLE (Transact-SQL)ALTER TABLE (Transact-SQL)