CREATE FUNCTION (Transact-SQL)CREATE FUNCTION (Transact-SQL)

SI APPLICA A: sìSQL Server (a partire dalla versione 2008) sìDatabase SQL di Azure noAzure SQL Data Warehouse noParallel Data Warehouse APPLIES TO: yesSQL Server (starting with 2008) yesAzure SQL Database noAzure SQL Data Warehouse noParallel Data Warehouse

Crea una funzione definita dall'utente in SQL ServerSQL Server e nel Database SQL di AzureAzure SQL Database.Creates a user-defined function in SQL ServerSQL Server and Database SQL di AzureAzure SQL Database. Una funzione definita dall'utente è una routine Transact-SQLTransact-SQL o Common Language Runtime (CLR) tramite cui vengono accettati parametri, viene effettuata un'azione, ad esempio un calcolo complesso, e viene restituito il risultato di tale azione sotto forma di valore.A user-defined function is a Transact-SQLTransact-SQL or common language runtime (CLR) routine that accepts parameters, performs an action, such as a complex calculation, and returns the result of that action as a value. Il valore restituito può essere un valore scalare (singolo) o una tabella.The return value can either be a scalar (single) value or a table. Utilizzare questa istruzione per creare una routine riutilizzabile che può essere utilizzata in queste modalità:Use this statement to create a reusable routine that can be used in these ways:

  • Nelle istruzioni Transact-SQLTransact-SQL, ad esempio SELECT.In Transact-SQLTransact-SQL statements such as SELECT

  • Nelle applicazioni che chiamano la funzione.In applications calling the function

  • Nella definizione di un'altra funzione definita dall'utente.In the definition of another user-defined function

  • Per parametrizzare una vista o per migliorare le funzionalità di una vista indicizzata.To parameterize a view or improve the functionality of an indexed view

  • Per definire una colonna di una tabella.To define a column in a table

  • Per definire un vincolo CHECK su una colonna.To define a CHECK constraint on a column

  • Per sostituire una stored procedure.To replace a stored procedure

  • Usare una funzione inline come predicato di filtro per un criterio di sicurezzaUse an inline function as a filter predicate for a security policy

Nota

In questo argomento viene illustrata l'integrazione di CLR di .NET Framework in SQL ServerSQL Server.The integration of .NET Framework CLR into SQL ServerSQL Server is discussed in this topic. L'integrazione di CLR non si applica a Database SQL di AzureAzure SQL Database.CLR integration does not apply to Database SQL di AzureAzure SQL Database.

Nota

Per SQL Data WarehouseSQL Data Warehouse, vedere CREATE FUNCTION (SQL Data Warehouse).For SQL Data WarehouseSQL Data Warehouse, see CREATE FUNCTION (SQL Data Warehouse).

Icona di collegamento a un argomentoConvenzioni della sintassi Transact-SQLTopic link icon Transact-SQL Syntax Conventions

SintassiSyntax

-- Transact-SQL Scalar Function Syntax  
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name   
( [ { @parameter_name [ AS ][ type_schema_name. ] parameter_data_type   
    [ = default ] [ READONLY ] }   
    [ ,...n ]  
  ]  
)  
RETURNS return_data_type  
    [ WITH <function_option> [ ,...n ] ]  
    [ AS ]  
    BEGIN   
        function_body   
        RETURN scalar_expression  
    END  
[ ; ]  
-- Transact-SQL Inline Table-Valued Function Syntax   
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name   
( [ { @parameter_name [ AS ] [ type_schema_name. ] parameter_data_type   
    [ = default ] [ READONLY ] }   
    [ ,...n ]  
  ]  
)  
RETURNS TABLE  
    [ WITH <function_option> [ ,...n ] ]  
    [ AS ]  
    RETURN [ ( ] select_stmt [ ) ]  
[ ; ]  
  
-- Transact-SQL Multi-Statement Table-Valued Function Syntax  
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name   
( [ { @parameter_name [ AS ] [ type_schema_name. ] parameter_data_type   
    [ = default ] [READONLY] }   
    [ ,...n ]  
  ]  
)  
RETURNS @return_variable TABLE <table_type_definition>  
    [ WITH <function_option> [ ,...n ] ]  
    [ AS ]  
    BEGIN   
        function_body   
        RETURN  
    END  
[ ; ]  
  
-- Transact-SQL Function Clauses   
<function_option>::=   
{  
    [ ENCRYPTION ]  
  | [ SCHEMABINDING ]  
  | [ RETURNS NULL ON NULL INPUT | CALLED ON NULL INPUT ]  
  | [ EXECUTE_AS_Clause ]  
  | [ INLINE = { ON | OFF }]  
}  
  
<table_type_definition>:: =   
( { <column_definition> <column_constraint>   
  | <computed_column_definition> }   
    [ <table_constraint> ] [ ,...n ]  
)   
<column_definition>::=  
{  
    { column_name data_type }  
    [ [ DEFAULT constant_expression ]   
      [ COLLATE collation_name ] | [ ROWGUIDCOL ]  
    ]  
    | [ IDENTITY [ (seed , increment ) ] ]  
    [ <column_constraint> [ ...n ] ]   
}  
  
<column_constraint>::=   
{  
    [ NULL | NOT NULL ]   
    { PRIMARY KEY | UNIQUE }  
      [ CLUSTERED | NONCLUSTERED ]   
      [ WITH FILLFACTOR = fillfactor   
        | WITH ( < index_option > [ , ...n ] )  
      [ ON { filegroup | "default" } ]  
  | [ CHECK ( logical_expression ) ] [ ,...n ]  
}  
  
<computed_column_definition>::=  
column_name AS computed_column_expression   
  
<table_constraint>::=  
{   
    { PRIMARY KEY | UNIQUE }  
      [ CLUSTERED | NONCLUSTERED ]   
      ( column_name [ ASC | DESC ] [ ,...n ] )  
        [ WITH FILLFACTOR = fillfactor   
        | WITH ( <index_option> [ , ...n ] )  
  | [ CHECK ( logical_expression ) ] [ ,...n ]  
}  
  
<index_option>::=  
{   
    PAD_INDEX = { ON | OFF }   
  | FILLFACTOR = fillfactor   
  | IGNORE_DUP_KEY = { ON | OFF }  
  | STATISTICS_NORECOMPUTE = { ON | OFF }   
  | ALLOW_ROW_LOCKS = { ON | OFF }  
  | ALLOW_PAGE_LOCKS ={ ON | OFF }   
}  
-- CLR Scalar Function Syntax  
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name   
( { @parameter_name [AS] [ type_schema_name. ] parameter_data_type   
    [ = default ] }   
    [ ,...n ]  
)  
RETURNS { return_data_type }  
    [ WITH <clr_function_option> [ ,...n ] ]  
    [ AS ] EXTERNAL NAME <method_specifier>  
[ ; ]  
-- CLR Table-Valued Function Syntax  
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name   
( { @parameter_name [AS] [ type_schema_name. ] parameter_data_type   
    [ = default ] }   
    [ ,...n ]  
)  
RETURNS TABLE <clr_table_type_definition>   
    [ WITH <clr_function_option> [ ,...n ] ]  
    [ ORDER ( <order_clause> ) ]  
    [ AS ] EXTERNAL NAME <method_specifier>  
[ ; ]  
-- CLR Function Clauses  
<order_clause> ::=   
{  
   <column_name_in_clr_table_type_definition>  
   [ ASC | DESC ]   
} [ ,...n]   
  
<method_specifier>::=  
    assembly_name.class_name.method_name  
  
<clr_function_option>::=  
}  
    [ RETURNS NULL ON NULL INPUT | CALLED ON NULL INPUT ]  
  | [ EXECUTE_AS_Clause ]  
}  
  
<clr_table_type_definition>::=   
( { column_name data_type } [ ,...n ] )  
  
-- In-Memory OLTP: Syntax for natively compiled, scalar user-defined function  
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name   
 ( [ { @parameter_name [ AS ][ type_schema_name. ] parameter_data_type   
    [ NULL | NOT NULL ] [ = default ] [ READONLY ] }   
    [ ,...n ]   
  ]   
)   
RETURNS return_data_type  
     WITH <function_option> [ ,...n ]   
    [ AS ]   
    BEGIN ATOMIC WITH (set_option [ ,... n ])   
        function_body   
        RETURN scalar_expression  
    END  
  
<function_option>::=   
{  
  |  NATIVE_COMPILATION   
  |  SCHEMABINDING   
  | [ EXECUTE_AS_Clause ]   
  | [ RETURNS NULL ON NULL INPUT | CALLED ON NULL INPUT ]   
}  
  

ArgomentiArguments

OR ALTEROR ALTER
Si applica a: SQL ServerSQL Server (da SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP1 a SQL Server 2017SQL Server 2017) e Database SQL di AzureAzure SQL DatabaseApplies to: SQL ServerSQL Server ( SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP1 through SQL Server 2017SQL Server 2017) and Database SQL di AzureAzure SQL Database

Modifica la funzione in modo condizionale solo se esiste già.Conditionally alters the function only if it already exists.

Nota

Sintassi [OR ALTER] facoltativa per CLR è disponibile a partire da SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP1 CU1.Optional [OR ALTER] syntax for CLR is available starting with SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP1 CU1.

schema_nameschema_name
Nome dello schema a cui appartiene la funzione definita dall'utente.Is the name of the schema to which the user-defined function belongs.

function_namefunction_name
Nome della funzione definita dall'utente.Is the name of the user-defined function. I nomi di funzione devono essere conformi alle regole per gli identificatori e devono essere univoci all'interno del database e rispetto al relativo schema.Function names must comply with the rules for identifiers and must be unique within the database and to its schema.

Nota

È necessario apporre le parentesi dopo il nome della funzione anche se non viene specificato alcun parametro.Parentheses are required after the function name even if a parameter is not specified.

@parameter_name@parameter_name
Parametro della funzione definita dall'utente.Is a parameter in the user-defined function. È possibile dichiarare uno o più parametri.One or more parameters can be declared.

Una funzione può avere al massimo 2.100 parametri.A function can have a maximum of 2,100 parameters. Il valore di ciascun parametro dichiarato deve essere specificato dall'utente quando viene eseguita la funzione, a meno che non venga definito un valore predefinito per tale parametro.The value of each declared parameter must be supplied by the user when the function is executed, unless a default for the parameter is defined.

Specificare un nome di parametro utilizzando come primo carattere il simbolo di chiocciola (@).Specify a parameter name by using an at sign (@) as the first character. I nomi di parametro devono essere conformi alle regole per gli identificatori.The parameter name must comply with the rules for identifiers. I parametri sono locali rispetto alla funzione. È pertanto possibile utilizzare gli stessi nomi di parametro in altre funzioni.Parameters are local to the function; the same parameter names can be used in other functions. I parametri possono rappresentare solo costanti, non nomi di tabella, di colonna o di altri oggetti di database.Parameters can take the place only of constants; they cannot be used instead of table names, column names, or the names of other database objects.

Nota

ANSI_WARNINGS non viene applicata quando vengono passati parametri a una stored procedure, una funzione definita dall'utente oppure in caso di dichiarazione e impostazione delle variabili in un'istruzione batch.ANSI_WARNINGS is not honored when you pass parameters in a stored procedure, user-defined function, or when you declare and set variables in a batch statement. Se, ad esempio, la variabile viene definita come char(3) e quindi impostata su un valore maggiore di tre caratteri, i dati verranno troncati alle dimensioni definite e l'istruzione INSERT o UPDATE avrà esito positivo.For example, if a variable is defined as char(3), and then set to a value larger than three characters, the data is truncated to the defined size and the INSERT or UPDATE statement succeeds.

[ type_schema_name.[ type_schema_name. ] parameter_data_type] parameter_data_type
Tipo di dati del parametro e, facoltativamente, lo schema a cui appartiene.Is the parameter data type, and optionally the schema to which it belongs. Per le funzioni Transact-SQLTransact-SQL sono consentiti tutti i tipi di dati, compresi i tipi CLR definiti dall'utente e i tipi di tabella definiti dall'utente, eccetto il tipo di dati timestamp.For Transact-SQLTransact-SQL functions, all data types, including CLR user-defined types and user-defined table types, are allowed except the timestamp data type. Per le funzioni CLR sono consentiti tutti i tipi di dati, inclusi i tipi CLR definiti dall'utente, eccetto i tipi di dati text, ntext, image, i tipi di dati definiti dall'utente e timestamp.For CLR functions, all data types, including CLR user-defined types, are allowed except text, ntext, image, user-defined table types and timestamp data types. Non è possibile specificare i tipi non scalari,cursor e table, come tipo di dati dei parametri nelle funzioni Transact-SQLTransact-SQL o CLR.The nonscalar types, cursor and table, cannot be specified as a parameter data type in either Transact-SQLTransact-SQL or CLR functions.

Se type_schema_name non viene specificato, Motore di databaseDatabase Engine cerca scalar_parameter_data_type nell'ordine seguente:If type_schema_name is not specified, the Motore di databaseDatabase Engine looks for the scalar_parameter_data_type in the following order:

  • Schema contenente i nomi dei tipi di dati di sistema di SQL ServerSQL Server.The schema that contains the names of SQL ServerSQL Server system data types.
  • Schema predefinito dell'utente corrente nel database corrente.The default schema of the current user in the current database.
  • Schema dbo nel database corrente.The dbo schema in the current database.

[ =default ][ =default ]
Valore predefinito del parametro.Is a default value for the parameter. Se viene definito un valore default, è possibile eseguire la funzione senza specificare un valore per il parametro corrispondente a tale valore.If a default value is defined, the function can be executed without specifying a value for that parameter.

Nota

È possibile specificare parametri predefiniti per le funzioni CLR, ad eccezione dei tipi di dati varchar(max) e varbinary(max).Default parameter values can be specified for CLR functions except for the varchar(max) and varbinary(max) data types.

Se a un parametro della funzione è associato un valore predefinito, alla chiamata della funzione è necessario specificare la parola chiave DEFAULT per recuperare il valore predefinito.When a parameter of the function has a default value, the keyword DEFAULT must be specified when the function is called to retrieve the default value. Questo comportamento risulta diverso dall'utilizzo di parametri con valore predefinito nelle stored procedure in cui l'omissione del parametro implica l'utilizzo del valore predefinito.This behavior is different from using parameters with default values in stored procedures in which omitting the parameter also implies the default value. Tuttavia, la parola chiave DEFAULT non è richiesta in caso di richiamo di una funzione scalare tramite l'istruzione EXECUTE.However, the DEFAULT keyword is not required when invoking a scalar function by using the EXECUTE statement.

READONLYREADONLY
Viene indicato che il parametro non può essere aggiornato o modificato all'interno della definizione della funzione.Indicates that the parameter cannot be updated or modified within the definition of the function. Se il tipo di parametro è un tipo di tabella definito dall'utente, deve essere specificata la parola chiave READONLY.If the parameter type is a user-defined table type, READONLY should be specified.

return_data_typereturn_data_type
Valore restituito di una funzione scalare definita dall'utente.Is the return value of a scalar user-defined function. Per le funzioni Transact-SQLTransact-SQL sono consentiti tutti i tipi di dati, compresi i tipi CLR definiti dall'utente, eccetto il tipo di dati timestamp.For Transact-SQLTransact-SQL functions, all data types, including CLR user-defined types, are allowed except the timestamp data type. Per le funzioni CLR, sono consentiti tutti i tipi di dati, compresi i tipi CLR definiti dall'utente, eccetto i tipi di dati text, ntext, image e timestamp.For CLR functions, all data types, including CLR user-defined types, are allowed except the text, ntext, image, and timestamp data types. Non è possibile specificare un tipo non scalare,cursor o table, come tipo di dati restituito nelle funzioni Transact-SQLTransact-SQL o CLR.The nonscalar types, cursor and table, cannot be specified as a return data type in either Transact-SQLTransact-SQL or CLR functions.

function_bodyfunction_body
Specifica che una serie di istruzioni Transact-SQLTransact-SQL, che nel loro complesso non producono alcun effetto collaterale, ad esempio la modifica di una tabella, definisce il valore della funzione.Specifies that a series of Transact-SQLTransact-SQL statements, which together do not produce a side effect such as modifying a table, define the value of the function. function_body viene usato solo in funzioni scalari e funzioni con valori di tabella con istruzioni multiple.function_body is used only in scalar functions and multi-statement table-valued functions (MSTVFs).

Nelle funzioni scalari function_body corrisponde a una serie di istruzioni Transact-SQLTransact-SQL che in combinazione restituiscono un valore scalare.In scalar functions, function_body is a series of Transact-SQLTransact-SQL statements that together evaluate to a scalar value.

Nelle funzioni con valori di tabella con istruzioni multiple function_body corrisponde a una serie di istruzioni Transact-SQLTransact-SQL che popolano una variabile restituita TABLE.In MSTVFs, function_body is a series of Transact-SQLTransact-SQL statements that populate a TABLE return variable.

scalar_expressionscalar_expression
Specifica il valore scalare restituito dalla funzione scalare.Specifies the scalar value that the scalar function returns.

TABLETABLE
Specifica che il valore restituito della funzione con valori di tabella è una tabella.Specifies that the return value of the table-valued function (TVF) is a table. Alle funzioni con valori di tabella è possibile passare solo costanti e @local_variables.Only constants and @local_variables can be passed to TVFs.

Nelle funzioni inline con valori di tabella il valore restituito TABLE viene definito tramite una sola istruzione SELECT.In inline TVFs, the TABLE return value is defined through a single SELECT statement. Alle funzioni inline non sono associate variabili restituite.Inline functions do not have associated return variables.

Nelle funzioni con valori di tabella con istruzioni multiple @*@return_variable* è una variabile TABLE usata per l'archiviazione e l'accumulo delle righe da restituire come valore della funzione.In MSTVFs, @return_variable is a TABLE variable, used to store and accumulate the rows that should be returned as the value of the function. È possibile specificare @ return_variable solo per le funzioni Transact-SQLTransact-SQL e non per le funzioni CLR.@return_variable can be specified only for Transact-SQLTransact-SQL functions and not for CLR functions.

select_stmtselect_stmt
Istruzione SELECT che definisce il valore restituito di una funzione inline con valori di tabella.Is the single SELECT statement that defines the return value of an inline table-valued function (TVF).

ORDER (<order_clause>) specifica l'ordine in base a cui vengono restituiti i risultati dalla funzione con valori di tabella.ORDER (<order_clause>) Specifies the order in which results are being returned from the table-valued function. Per altre informazioni, vedere la sezione "Uso dell'ordinamento nelle funzioni CLR con valori di tabella" più avanti in questo argomento.For more information, see the section, "Using Sort Order in CLR Table-valued Functions", later in this topic.

EXTERNAL NAME <method_specifier> assembly_name.class_name.method_name EXTERNAL NAME <method_specifier> assembly_name.class_name.method_name
Si applica a: SQL ServerSQL Server (da SQL Server 2008SQL Server 2008 SP1 a SQL Server 2017SQL Server 2017)Applies to: SQL ServerSQL Server ( SQL Server 2008SQL Server 2008 SP1 through SQL Server 2017SQL Server 2017)

Specifica l'assembly e il metodo a cui dovrà fare riferimento il nome della funzione creata.Specifies the assembly and method to which the created function name shall refer.

  • assembly_name: deve corrispondere a un valore nella colonna name diassembly_name - must match a value in the name column of
    SELECT * FROM sys.assemblies;.SELECT * FROM sys.assemblies;.
    Si tratta del nome usato nell'istruzione CREATE ASSEMBLY.This is the name that was used on the CREATE ASSEMBLY statement.

  • class_name: deve corrispondere a un valore nella colonna assembly_name diclass_name - must match a value in the assembly_name column of
    SELECT * FROM sys.assembly_modules;.SELECT * FROM sys.assembly_modules;.
    Spesso il valore contiene un punto incorporato.Often the value contains an embedded period or dot. In tal caso, la sintassi Transact-SQL richiede che il valore venga racchiuso tra parentesi quadre [ ] o tra virgolette doppie "".In such cases the Transact-SQL syntax requires that the value be bounded with a pair of straight brackets [], or with a pair of double quotation marks "".

  • method_name: deve corrispondere a un valore nella colonna method_name dimethod_name - must match a value in the method_name column of
    SELECT * FROM sys.assembly_modules;.SELECT * FROM sys.assembly_modules;.
    Il metodo deve essere statico.The method must be static.

In un tipico esempio di MyFood.DLL, in cui tutti i tipi sono nello spazio dei nomi MyFood, il valore EXTERNAL NAME potrebbe essere:In a typical example, for MyFood.DLL, in which all types are in the MyFood namespace, the EXTERNAL NAME value could be:
MyFood.[MyFood.MyClass].MyStaticMethod

Nota

Per impostazione predefinita, SQL ServerSQL Server non può eseguire il codice CLR.By default, SQL ServerSQL Server cannot execute CLR code. È possibile creare, modificare ed eliminare gli oggetti di database che fanno riferimento a moduli CLR; tuttavia non è possibile eseguire questi riferimenti in SQL ServerSQL Server finché non viene abilitata l'opzione clr enabled option.You can create, modify, and drop database objects that reference common language runtime modules; however, you cannot execute these references in SQL ServerSQL Server until you enable the clr enabled option. Per abilitare questa opzione, usare sp_configure.To enable this option, use sp_configure.

Nota

Questa opzione non è disponibile in un database indipendente.This option is not available in a contained database.

< table_type_definition*>* ( { <column_definition> <column_constraint> | <computed_column_definition> } [ <table_constraint> ] [ ,...n ] ) Definisce il tipo di dati table per una funzione Transact-SQLTransact-SQL.< table_type_definition*>* ( { <column_definition> <column_constraint> | <computed_column_definition> } [ <table_constraint> ] [ ,...n ] ) Defines the table data type for a Transact-SQLTransact-SQL function. La dichiarazione di tabella include definizioni di colonna, nonché vincoli di colonna o tabella.The table declaration includes column definitions and column or table constraints. La tabella viene sempre inserita nel filegroup primario.The table is always put in the primary filegroup.

< clr_table_type_definition > ( { column_name**data_type } [ ,...n ] )< clr_table_type_definition > ( { column_name**data_type } [ ,...n ] )
Si applica a: SQL ServerSQL Server (da SQL Server 2008SQL Server 2008 SP1 a SQL Server 2017SQL Server 2017) e a Database SQL di AzureAzure SQL Database (anteprima in alcune aree).Applies to: SQL ServerSQL Server ( SQL Server 2008SQL Server 2008 SP1 through SQL Server 2017SQL Server 2017) and Database SQL di AzureAzure SQL Database (Preview in some regions).

Definisce i tipi di dati della tabella per una funzione CLR.Defines the table data types for a CLR function. La dichiarazione di tabella include solo nomi di colonna e tipi di dati.The table declaration includes only column names and data types. La tabella viene sempre inserita nel filegroup primario.The table is always put in the primary filegroup.

NULL|NOT NULLNULL|NOT NULL
Supportato solo per funzioni definite dall'utente scalari compilate in modo nativo.Supported only for natively compiled, scalar user-defined functions. Per altre informazioni, vedere Funzioni scalari definite dall'utente per OLTP in memoria.For more information, see Scalar User-Defined Functions for In-Memory OLTP.

NATIVE_COMPILATIONNATIVE_COMPILATION
Indica se una funzione definita dall'utente è compilata in modo nativo.Indicates whether a user-defined function is natively compiled. Questo argomento è obbligatorio per funzioni definite dall'utente scalari compilate in modo nativo.This argument is required for natively compiled, scalar user-defined functions.

BEGIN ATOMIC WITHBEGIN ATOMIC WITH
Supportato solo per funzioni definite dall'utente scalari compilate in modo nativo. Obbligatorio.Supported only for natively compiled, scalar user-defined functions, and is required. Per altre informazioni, vedere Atomic Blocks.For more information, see Atomic Blocks.

SCHEMABINDINGSCHEMABINDING
L'argomento SCHEMABINDING è obbligatorio per funzioni definite dall'utente scalari compilate in modo nativo.The SCHEMABINDING argument is required for natively compiled, scalar user-defined functions.

EXECUTE ASEXECUTE AS
EXECUTE AS è obbligatorio per funzioni definite dall'utente scalari compilate in modo nativo.EXECUTE AS is required for natively compiled, scalar user-defined functions.

<function_option>::= and <clr_function_option>::=<function_option>::= and <clr_function_option>::=

Specifica che la funzione includerà una o più delle opzioni seguenti.Specifies that the function will have one or more of the following options.

ENCRYPTIONENCRYPTION
Si applica a: SQL ServerSQL Server (da SQL Server 2008SQL Server 2008 SP1 a SQL Server 2017SQL Server 2017)Applies to: SQL ServerSQL Server ( SQL Server 2008SQL Server 2008 SP1 through SQL Server 2017SQL Server 2017)

Indica che il testo originale dell'istruzione CREATE FUNCTION verrà convertito da Motore di databaseDatabase Engine in un formato offuscato.Indicates that the Motore di databaseDatabase Engine will convert the original text of the CREATE FUNCTION statement to an obfuscated format. L'output dell'offuscamento non è visibile direttamente nelle viste del catalogo.The output of the obfuscation is not directly visible in any catalog views. Gli utenti che non hanno accesso a tabelle di sistema o file del database non possono recuperare il testo offuscato.Users that have no access to system tables or database files cannot retrieve the obfuscated text. Il testo è tuttavia disponibile per gli utenti con privilegi che consentono l'accesso alle tabelle di sistema attraverso la porta DAC o l'accesso diretto a file del database.However, the text will be available to privileged users that can either access system tables over the DAC port or directly access database files. Gli utenti in grado di collegare un debugger al processo del server possono inoltre recuperare la procedura originale dalla memoria in fase di esecuzione.Also, users that can attach a debugger to the server process can retrieve the original procedure from memory at runtime. Per altre informazioni sull'accesso ai metadati di sistema, vedere Configurazione della visibilità dei metadati.For more information about accessing system metadata, see Metadata Visibility Configuration.

Tramite questa opzione è possibile evitare la pubblicazione della funzione come parte della replica di SQL ServerSQL Server.Using this option prevents the function from being published as part of SQL ServerSQL Server replication. Questa opzione non può essere specificata per le funzioni CLR.This option cannot be specified for CLR functions.

SCHEMABINDINGSCHEMABINDING
Specifica che la funzione è associata agli oggetti di database a cui fa riferimento.Specifies that the function is bound to the database objects that it references. Quando la clausola SCHEMABINDING viene specificata, non è possibile apportare agli oggetti di base modifiche che hanno effetto sulla definizione della funzione.When SCHEMABINDING is specified, the base objects cannot be modified in a way that would affect the function definition. È necessario prima modificare o eliminare la definizione della funzione per rimuovere le dipendenze dall'oggetto da modificare.The function definition itself must first be modified or dropped to remove dependencies on the object that is to be modified.

L'associazione della funzione agli oggetti cui fa riferimento viene rimossa solo quando viene eseguita una delle azioni seguenti:The binding of the function to the objects it references is removed only when one of the following actions occurs:

  • La funzione viene eliminata.The function is dropped.

  • La funzione viene modificata tramite l'istruzione ALTER senza specificare l'opzione SCHEMABINDING.The function is modified by using the ALTER statement with the SCHEMABINDING option not specified.

Una funzione può essere associata a uno schema solo se vengono soddisfatte le condizioni seguenti:A function can be schema bound only if the following conditions are true:

  • Si tratta di una funzione Transact-SQLTransact-SQL.The function is a Transact-SQLTransact-SQL function.

  • Le funzioni definite dall'utente e le viste a cui la funzione fa riferimento sono anch'esse associate a uno schema.The user-defined functions and views referenced by the function are also schema-bound.

  • Per i riferimenti agli oggetti, nella funzione viene utilizzato un nome in due parti.The objects referenced by the function are referenced using a two-part name.

  • La funzione e gli oggetti a cui fa riferimento appartengono allo stesso database.The function and the objects it references belong to the same database.

  • L'utente che ha eseguito l'istruzione CREATE FUNCTION dispone dell'autorizzazione REFERENCES per gli oggetti di database a cui la funzione fa riferimento.The user who executed the CREATE FUNCTION statement has REFERENCES permission on the database objects that the function references.

RETURNS NULL ON NULL INPUT | CALLED ON NULL INPUTRETURNS NULL ON NULL INPUT | CALLED ON NULL INPUT
Specifica l'attributo OnNULLCall di una funzione scalare.Specifies the OnNULLCall attribute of a scalar function. Se omesso, viene utilizzata l'opzione CALLED ON NULL INPUT per impostazione predefinita.If not specified, CALLED ON NULL INPUT is implied by default. Ciò significa che viene eseguito il corpo della funzione anche se come argomento viene passato NULL.This means that the function body executes even if NULL is passed as an argument.

Se in una funzione CLR si specifica l'opzione RETURNS NULL ON NULL INPUT, SQL ServerSQL Server restituisce NULL se uno qualsiasi degli argomenti ricevuti è NULL senza effettivamente richiamare il corpo della funzione.If RETURNS NULL ON NULL INPUT is specified in a CLR function, it indicates that SQL ServerSQL Server can return NULL when any of the arguments it receives is NULL, without actually invoking the body of the function. Se per il metodo di una funzione CLR specificato in <method_specifier> è stato definito un attributo personalizzato impostato su RETURNS NULL ON NULL INPUT, ma l'istruzione CREATE FUNCTION include CALLED ON NULL INPUT, l'istruzione CREATE FUNCTION risulta prioritaria.If the method of a CLR function specified in <method_specifier> already has a custom attribute that indicates RETURNS NULL ON NULL INPUT, but the CREATE FUNCTION statement indicates CALLED ON NULL INPUT, the CREATE FUNCTION statement takes precedence. Non è possibile specificare l'attributo OnNULLCall per le funzioni CLR con valori di tabella.The OnNULLCall attribute cannot be specified for CLR table-valued functions.

Clausola EXECUTE ASEXECUTE AS Clause
Specifica il contesto di sicurezza nel quale viene eseguita la funzione definita dall'utente.Specifies the security context under which the user-defined function is executed. Sarà pertanto possibile controllare l'account utente utilizzato da SQL ServerSQL Server per convalidare le autorizzazioni per qualsiasi oggetto di database a cui la funzione fa riferimento.Therefore, you can control which user account SQL ServerSQL Server uses to validate permissions on any database objects that are referenced by the function.

Nota

Non è possibile specificare la clausola EXECUTE AS per le funzioni inline con valori di tabella.EXECUTE AS cannot be specified for inline table-valued functions.

Per altre informazioni, vedere Clausola EXECUTE AS (Transact-SQL).For more information, see EXECUTE AS Clause (Transact-SQL).

INLINE = { ON | OFF }INLINE = { ON | OFF }
Specifica se questa funzione scalare definita dall'utente deve essere impostata come inline.Specifies whether this scalar UDF should be inlined or not. Questa clausola è applicabile solo alle funzioni scalari definite dall'utente.This clause applies only to scalar user-defined functions. La clausola INLINE non è obbligatoria.The INLINE clause is not mandatory. Se la clausola INLINE viene omessa, viene automaticamente impostata su ON/OFF in base al fatto che possa essere eseguito l'inline della funzione.If INLINE clause is not specified, it is automatically set to ON/OFF based on whether the UDF is inlineable. Se viene specificato INLINE=ON ma la funzione definita dall'utente non è idonea per l'inlining, viene generato un errore.If INLINE=ON is specified but the UDF is found to be non-inlineable, an error will be thrown. Per altre informazioni, vedere Inlining di funzioni definite dall'utente scalari.For more information, see Scalar UDF Inlining.

< column_definition >::=< column_definition >::=

Definisce il tipo di dati della tabella.Defines the table data type. La dichiarazione di tabella include definizioni di colonna e vincoli.The table declaration includes column definitions and constraints. Per le funzioni CLR, è possibile specificare solo column_name e data_type.For CLR functions, only column_name and data_type can be specified.

column_namecolumn_name
Nome di una colonna della tabella.Is the name of a column in the table. I nomi delle colonne devono essere conformi alle regole per gli identificatori e devono essere univoci nella tabella.Column names must comply with the rules for identifiers and must be unique in the table. column_name può essere costituito da un numero di caratteri compreso tra 1 e 128.column_name can consist of 1 through 128 characters.

data_typedata_type
Specifica il tipo di dati della colonna.Specifies the column data type. Per le funzioni Transact-SQLTransact-SQL sono consentiti tutti i tipi di dati, compresi i tipi CLR definiti dall'utente, eccetto il tipo di dati timestamp.For Transact-SQLTransact-SQL functions, all data types, including CLR user-defined types, are allowed except timestamp. Per le funzioni CLR sono consentiti tutti i tipi di dati, compresi i tipi CLR definiti dall'utente, eccetto i tipi di dati text, ntext, image, char, varchar, varchar(max) e timestamp. Non è possibile specificare il tipo non scalare cursor come tipo di dati di colonna nelle funzioni Transact-SQLTransact-SQL o CLR.For CLR functions, all data types, including CLR user-defined types, are allowed except text, ntext, image, char, varchar, varchar(max), and timestamp.The nonscalar type cursor cannot be specified as a column data type in either Transact-SQLTransact-SQL or CLR functions.

DEFAULT constant_expressionDEFAULT constant_expression
Specifica il valore assegnato alla colonna quando non viene specificato un valore in modo esplicito durante un inserimento.Specifies the value provided for the column when a value is not explicitly supplied during an insert. constant_expression è una costante, un valore NULL o il valore di una funzione di sistema.constant_expression is a constant, NULL, or a system function value. Le definizioni dell'opzione DEFAULT possono essere applicate a qualsiasi colonna eccetto quelle che includono la proprietà IDENTITY.DEFAULT definitions can be applied to any column except those that have the IDENTITY property. Non è possibile specificare l'opzione DEFAULT per le funzioni CLR con valori di tabella.DEFAULT cannot be specified for CLR table-valued functions.

COLLATE collation_nameCOLLATE collation_name
Specifica le regole di confronto per la colonna.Specifies the collation for the column. Se viene omesso, alla colonna vengono assegnate le regole di confronto predefinite del database.If not specified, the column is assigned the default collation of the database. È possibile usare nomi di regole di confronto di Windows o SQL.Collation name can be either a Windows collation name or a SQL collation name. Per un elenco di regole di confronto e altre informazioni su queste, vedere Windows_collation_name & (Transact-SQL) e Nome delle regole di confronto di SQL Server (Transact-SQL).For a list of and more information about collations, see Windows Collation Name (Transact-SQL) and SQL Server Collation Name (Transact-SQL).

La clausola COLLATE consente di modificare le regole di confronto solo per le colonne con tipo di dati char, varchar, nchar e nvarchar.The COLLATE clause can be used to change the collations only of columns of the char, varchar, nchar, and nvarchar data types.

Nota

Non è possibile specificare la clausola COLLATE per le funzioni CLR con valori di tabella.COLLATE cannot be specified for CLR table-valued functions.

ROWGUIDCOLROWGUIDCOL
Indica che la nuova colonna è un identificatore univoco di riga globale.Indicates that the new column is a row globally unique identifier column. È possibile designare come colonna ROWGUIDCOL una sola colonna di tipo uniqueidentifier per ogni tabella.Only one uniqueidentifier column per table can be designated as the ROWGUIDCOL column. La proprietà ROWGUIDCOL può essere assegnata solo a una colonna uniqueidentifier.The ROWGUIDCOL property can be assigned only to a uniqueidentifier column.

La proprietà ROWGUIDCOL non impone l'univocità dei valori archiviati nella colonnaThe ROWGUIDCOL property does not enforce uniqueness of the values stored in the column. e non genera automaticamente valori per le nuove righe inserite nella tabella.It also does not automatically generate values for new rows inserted into the table. Per generare valori univoci per ogni colonna, utilizzare la funzione NEWID nelle istruzioni INSERT.To generate unique values for each column, use the NEWID function on INSERT statements. È possibile specificare un valore predefinito. Non è tuttavia possibile specificare l'opzione NEWID come valore predefinito.A default value can be specified; however, NEWID cannot be specified as the default.

IDENTITYIDENTITY
Indica che la nuova colonna è una colonna Identity.Indicates that the new column is an identity column. Quando si aggiunge una nuova riga alla tabella, SQL ServerSQL Server assegna alla colonna un valore univoco e incrementale.When a new row is added to the table, SQL ServerSQL Server provides a unique, incremental value for the column. Le colonne Identity vengono comunemente utilizzate in combinazione con vincoli PRIMARY KEY e svolgono la funzione di identificatore di riga univoco per la tabella.Identity columns are typically used together with PRIMARY KEY constraints to serve as the unique row identifier for the table. La proprietà IDENTITY può essere assegnata a colonne tinyint, smallint, int, bigint, decimal(p,0) o numeric(p,0).The IDENTITY property can be assigned to tinyint, smallint, int, bigint, decimal(p,0), or numeric(p,0) columns. Ogni tabella può includere una sola colonna Identity.Only one identity column can be created per table. Non è consentito associare valori predefiniti e vincoli DEFAULT alle colonne Identity.Bound defaults and DEFAULT constraints cannot be used with an identity column. È necessario specificare sia il valore di seed che di increment oppure è possibile omettere entrambi questi valori.You must specify both the seed and increment or neither. In questo secondo caso, il valore predefinito è (1,1).If neither is specified, the default is (1,1).

Non è possibile specificare l'opzione IDENTITY per le funzioni CLR con valori di tabella.IDENTITY cannot be specified for CLR table-valued functions.

seedseed
Valore intero da assegnare alla prima riga della tabella.Is the integer value to be assigned to the first row in the table.

incrementincrement
Valore intero da aggiungere al valore seed per le righe successive della tabella.Is the integer value to add to the seed value for successive rows in the table.

< column_constraint >::= and < table_constraint>::=< column_constraint >::= and < table_constraint>::=

Definisce il vincolo per una colonna o tabella specificata.Defines the constraint for a specified column or table. Per le funzioni CLR l'unico tipo di vincolo consentito è NULL.For CLR functions, the only constraint type allowed is NULL. I vincoli denominati non sono consentiti.Named constraints are not allowed.

NULL | NOT NULLNULL | NOT NULL
Determina se i valori Null sono supportati nella colonna.Determines whether null values are allowed in the column. L'opzione NULL non è esattamente un vincolo, ma può essere specificata allo stesso modo di NOT NULL.NULL is not strictly a constraint but can be specified just like NOT NULL. Non è possibile specificare l'opzione NOT NULL per le funzioni CLR con valori di tabella.NOT NULL cannot be specified for CLR table-valued functions.

PRIMARY KEYPRIMARY KEY
Vincolo che impone l'integrità di entità per una colonna specificata tramite un indice univoco.Is a constraint that enforces entity integrity for a specified column through a unique index. Nelle funzioni definite dall'utente con valori di tabella, il vincolo PRIMARY KEY può essere creato solo su una colonna per tabella.In table-valued user-defined functions, the PRIMARY KEY constraint can be created on only one column per table. Non è possibile specificare il vincolo PRIMARY KEY per le funzioni CLR con valori di tabella.PRIMARY KEY cannot be specified for CLR table-valued functions.

UNIQUEUNIQUE
Vincolo che impone l'integrità di entità per una o più colonne specificate tramite un indice univoco.Is a constraint that provides entity integrity for a specified column or columns through a unique index. Una tabella può includere più vincoli UNIQUE.A table can have multiple UNIQUE constraints. Non è possibile specificare il vincolo UNIQUE per le funzioni CLR con valori di tabella.UNIQUE cannot be specified for CLR table-valued functions.

CLUSTERED | NONCLUSTEREDCLUSTERED | NONCLUSTERED
Definisce la creazione di un indice cluster o non cluster per il vincolo PRIMARY KEY o UNIQUE.Indicate that a clustered or a nonclustered index is created for the PRIMARY KEY or UNIQUE constraint. I vincoli PRIMARY KEY usano l'opzione CLUSTERED, mentre i vincoli UNIQUE usano l'opzione NONCLUSTERED.PRIMARY KEY constraints use CLUSTERED, and UNIQUE constraints use NONCLUSTERED.

L'opzione CLUSTERED può essere specificata solo per un vincolo.CLUSTERED can be specified for only one constraint. Se per un vincolo UNIQUE si specifica CLUSTERED e viene specificato anche un vincolo PRIMARY KEY, quest'ultimo usano l'opzione NONCLUSTERED.If CLUSTERED is specified for a UNIQUE constraint and a PRIMARY KEY constraint is also specified, the PRIMARY KEY uses NONCLUSTERED.

Non è possibile specificare le opzioni CLUSTERED e NON CLUSTERED per le funzioni CLR con valori di tabella.CLUSTERED and NONCLUSTERED cannot be specified for CLR table-valued functions.

CHECKCHECK
Vincolo che impone l'integrità di dominio tramite la limitazione dei valori che è possibile inserire in una o più colonne.Is a constraint that enforces domain integrity by limiting the possible values that can be entered into a column or columns. Non è possibile specificare i vincoli CHECK per le funzioni CLR con valori di tabella.CHECK constraints cannot be specified for CLR table-valued functions.

logical_expressionlogical_expression
Espressione logica che restituisce TRUE o FALSE.Is a logical expression that returns TRUE or FALSE.

<computed_column_definition>::=<computed_column_definition>::=

Specifica una colonna calcolata.Specifies a computed column. Per altre informazioni sulle colonne calcolate, vedere CREATE TABLE (Transact-SQL).For more information about computed columns, see CREATE TABLE (Transact-SQL).

column_namecolumn_name
Nome della colonna calcolata.Is the name of the computed column.

computed_column_expressioncomputed_column_expression
Espressione che definisce il valore di una colonna calcolata.Is an expression that defines the value of a computed column.

<index_option>::=<index_option>::=

Specifica le opzioni per l'indice PRIMARY KEY o UNIQUE.Specifies the index options for the PRIMARY KEY or UNIQUE index. Per altre informazioni sulle opzioni per gli indici, vedere CREATE INDEX (Transact-SQL).For more information about index options, see CREATE INDEX (Transact-SQL).

PAD_INDEX = { ON | OFF }PAD_INDEX = { ON | OFF }
Specifica il riempimento dell'indice.Specifies index padding. Il valore predefinito è OFF.The default is OFF.

FILLFACTOR = fillfactorFILLFACTOR = fillfactor
Specifica una percentuale indicante il livello di riempimento del livello foglia di ogni pagina di indice applicato dal Motore di databaseDatabase Engine durante la creazione o la modifica dell'indice.Specifies a percentage that indicates how full the Motore di databaseDatabase Engine should make the leaf level of each index page during index creation or change. fillfactor deve essere un valore intero compreso tra 1 e 100.fillfactor must be an integer value from 1 to 100. Il valore predefinito è 0.The default is 0.

IGNORE_DUP_KEY = { ON | OFF }IGNORE_DUP_KEY = { ON | OFF }
Specifica l'errore restituito quando un'operazione di inserimento tenta di inserire valori di chiave duplicati in un indice univoco.Specifies the error response when an insert operation attempts to insert duplicate key values into a unique index. L'opzione IGNORE_DUP_KEY viene applicata solo alle operazioni di inserimento eseguite dopo la creazione o la ricompilazione dell'indice.The IGNORE_DUP_KEY option applies only to insert operations after the index is created or rebuilt. Il valore predefinito è OFF.The default is OFF.

STATISTICS_NORECOMPUTE = { ON | OFF }STATISTICS_NORECOMPUTE = { ON | OFF }
Specifica se le statistiche di distribuzione vengono ricalcolate.Specifies whether distribution statistics are recomputed. Il valore predefinito è OFF.The default is OFF.

ALLOW_ROW_LOCKS = { ON | OFF }ALLOW_ROW_LOCKS = { ON | OFF }
Specifica se sono consentiti blocchi di riga.Specifies whether row locks are allowed. Il valore predefinito è ON.The default is ON.

ALLOW_PAGE_LOCKS = { ON | OFF }ALLOW_PAGE_LOCKS = { ON | OFF }
Specifica se sono consentiti blocchi a livello di pagina.Specifies whether page locks are allowed. Il valore predefinito è ON.The default is ON.

Procedure consigliateBest Practices

Se una funzione definita dall'utente non viene creata tramite la clausola SCHEMABINDING, le modifiche apportate agli oggetti sottostanti possono influire sulla definizione della funzione e generare risultati imprevisti quando viene richiamata.If a user-defined function is not created with the SCHEMABINDING clause, changes that are made to underlying objects can affect the definition of the function and produce unexpected results when it is invoked. È consigliabile implementare uno dei metodi seguenti per assicurarsi che la funzione non diventi obsoleta in seguito a modifiche degli oggetti sottostanti:We recommend that you implement one of the following methods to ensure that the function does not become outdated because of changes to its underlying objects:

  • Specificare la clausola WITH SCHEMABINDING quando si crea la funzione.Specify the WITH SCHEMABINDING clause when you are creating the function. In questo modo, gli oggetti a cui si fa riferimento nella definizione della funzione possono essere modificati solo se viene modificata anche la funzione.This ensures that the objects referenced in the function definition cannot be modified unless the function is also modified.

  • Eseguire la stored procedure sp_refreshsqlmodule dopo avere modificato qualsiasi oggetto specificato nella definizione della funzione.Execute the sp_refreshsqlmodule stored procedure after modifying any object that is specified in the definition of the function.

Importante

Per altre informazioni e considerazioni sulle prestazioni delle funzioni inline con valori di tabella e delle funzioni con valori di tabella con istruzioni multiple, vedere Creare funzioni definite dall'utente (Motore di database).For more information and performance considerations about inline table-valued functions (inline TVFs) and multi-statement table-valued functions (MSTVFs), see Create User-defined Functions (Database Engine).

Tipi di datiData Types

Se si specificano parametri in una funzione CLR, essi dovranno essere di tipo SQL ServerSQL Server come precedentemente definito per scalar_parameter_data_type.If parameters are specified in a CLR function, they should be SQL ServerSQL Server types as defined previously for scalar_parameter_data_type. Per informazioni sul confronto tra i tipi di dati di sistema di SQL ServerSQL Server e i tipi di dati di integrazione CLR oppure i tipi di dati CLR di .NET Framework.NET Framework, vedere Mapping dei dati dei parametri CLR.For information about comparing SQL ServerSQL Server system data types to CLR integration data types or .NET Framework.NET Framework common language runtime data types, see Mapping CLR Parameter Data.

Perché SQL ServerSQL Server faccia riferimento al metodo corretto in caso di un sovraccarico a livello di classe, è necessario che il metodo specificato in <method_specifier>:For SQL ServerSQL Server to reference the correct method when it is overloaded in a class, the method indicated in <method_specifier> must have the following characteristics:

  • Riceva lo stesso numero di parametri specificati in [ ,...n ].Receive the same number of parameters as specified in [ ,...n ].

  • Riceva tutti i parametri in base al valore e non in base al riferimento.Receive all the parameters by value, not by reference.

  • Utilizzi tipi di parametro compatibili con quelli specificati nella funzione SQL ServerSQL Server.Use parameter types that are compatible with those specified in the SQL ServerSQL Server function.

Se il tipo di dati restituito della funzione CLR specifica un tipo tabella (RETURNS TABLE), il tipo di dati restituito del metodo specificato in <method_specifier> deve essere IEnumerator o IEnumerable. Si presuppone che l'interfaccia venga implementata dall'autore della funzione.If the return data type of the CLR function specifies a table type (RETURNS TABLE), the return data type of the method in <method_specifier> should be of type IEnumerator or IEnumerable, and it is assumed that the interface is implemented by the creator of the function. A differenza delle funzioni Transact-SQLTransact-SQL, le funzioni CLR non possono includere vincoli PRIMARY KEY, UNIQUE o CHECK in <table_type_definition>.Unlike Transact-SQLTransact-SQL functions, CLR functions cannot include PRIMARY KEY, UNIQUE, or CHECK constraints in <table_type_definition>. I tipi di dati delle colonne specificati in <table_type_definition> devono corrispondere ai tipi delle rispettive colonne del set di risultati restituito dal metodo specificato in <method_specifier> in fase di esecuzione.The data types of columns specified in <table_type_definition> must match the types of the corresponding columns of the result set returned by the method in <method_specifier> at execution time. Questa verifica del tipo non viene eseguita al momento della creazione della funzione.This type-checking is not performed at the time the function is created.

Per altre informazioni sulla programmazione delle funzioni CLR, vedere Funzioni CLR definite dall'utente.For more information about how to program CLR functions, see CLR User-Defined Functions.

Osservazioni generaliGeneral Remarks

È possibile richiamare funzioni scalari laddove vengono usate espressioni scalari.Scalar functions can be invoked where scalar expressions are used. Sono incluse le colonne calcolate e le definizioni dei vincoli CHECK.This includes computed columns and CHECK constraint definitions. Le funzioni scalari possono essere eseguite anche tramite l'uso dell'istruzione EXECUTE.Scalar functions can also be executed by using the EXECUTE statement. È necessario richiamare funzioni scalari usando almeno il nome in due parti della funzione (.).Scalar functions must be invoked by using at least the two-part name of the function (.). Per altre informazioni sui nomi a più parti, vedere Convenzioni della sintassi Transact-SQL (Transact-SQL).For more information about multipart names, see Transact-SQL Syntax Conventions (Transact-SQL). Le funzioni con valori di tabella possono essere richiamate laddove sono consentite le espressioni di tabella nella clausola FROM delle istruzioni SELECT, INSERT, UPDATE, o DELETE.Table-valued functions can be invoked where table expressions are allowed in the FROM clause of SELECT, INSERT, UPDATE, or DELETE statements. Per altre informazioni, vedere Eseguire funzioni definite dall'utente.For more information, see Execute User-defined Functions.

InteroperabilitàInteroperability

In una funzione le istruzioni seguenti sono valide:The following statements are valid in a function:

  • Istruzioni di assegnazione.Assignment statements.

  • Istruzioni per il controllo di flusso, ad eccezione delle istruzioni TRY...CATCH.Control-of-Flow statements except TRY...CATCH statements.

  • Istruzioni DECLARE che definiscono le variabili dati locali e i cursori locali.DECLARE statements defining local data variables and local cursors.

  • Istruzioni SELECT contenenti gli elenchi di selezione con espressioni che assegnano valori alle variabili locali.SELECT statements that contain select lists with expressions that assign values to local variables.

  • Operazioni di cursore che fanno riferimento a cursori locali dichiarati, aperti, chiusi e deallocati nella funzione.Cursor operations referencing local cursors that are declared, opened, closed, and deallocated in the function. Sono consentite solo istruzioni FETCH che assegnano valori alle variabili locali tramite la clausola INTO. Non sono consentite istruzioni FETCH che restituiscono dati al client.Only FETCH statements that assign values to local variables using the INTO clause are allowed; FETCH statements that return data to the client are not allowed.

  • Istruzioni INSERT, UPDATE e DELETE che modificano le variabili di tabella locali.INSERT, UPDATE, and DELETE statements modifying local table variables.

  • Istruzioni EXECUTE che chiamano stored procedure estese.EXECUTE statements calling extended stored procedures.

Per altre informazioni, vedere Creare funzioni definite dall'utente (Motore di database).For more information, see Create User-defined Functions (Database Engine).

Interoperabilità delle colonne calcolateComputed Column Interoperability

Le funzioni presentano le proprietà seguenti.Functions have the following properties. I valori di tali proprietà determinano se le funzioni sono utilizzabili nelle colonne calcolate che possono essere persistenti o indicizzate.The values of these properties determine whether functions can be used in computed columns that can be persisted or indexed.

ProprietàProperty DescrizioneDescription NoteNotes
IsDeterministicIsDeterministic La funzione è deterministica o non deterministica.Function is deterministic or nondeterministic. L'accesso ai dati locali è consentito nelle funzioni deterministiche.Local data access is allowed in deterministic functions. Ad esempio, le funzioni che restituiscono sempre lo stesso valore ogni volta che vengono richiamate utilizzando un set specifico di valori di input e con lo stesso stato del database vengono definite funzioni deterministiche.For example, functions that always return the same result any time they are called by using a specific set of input values and with the same state of the database would be labeled deterministic.
IsPreciseIsPrecise La funzione è precisa o imprecisa.Function is precise or imprecise. Le funzioni imprecise includono operazioni quali le operazioni a virgola mobile.Imprecise functions contain operations such as floating point operations.
IsSystemVerifiedIsSystemVerified Le proprietà relative alla precisione e le proprietà deterministiche della funzione possono essere verificate tramite SQL ServerSQL Server.The precision and determinism properties of the function can be verified by SQL ServerSQL Server.
SystemDataAccessSystemDataAccess La funzione accede ai dati di sistema (cataloghi di sistema o tabelle di sistema virtuali) nell'istanza locale di SQL ServerSQL Server.Function accesses system data (system catalogs or virtual system tables) in the local instance of SQL ServerSQL Server.
UserDataAccessUserDataAccess La funzione accede ai dati utente nell'istanza locale di SQL ServerSQL Server.Function accesses user data in the local instance of SQL ServerSQL Server. Include le tabelle definite dall'utente e le tabelle temporanee, ma non le variabili di tabella.Includes user-defined tables and temp tables, but not table variables.

Le proprietà relative alla precisione e le proprietà deterministiche delle funzioni Transact-SQLTransact-SQL vengono definite automaticamente da SQL ServerSQL Server.The precision and determinism properties of Transact-SQLTransact-SQL functions are determined automatically by SQL ServerSQL Server. Le proprietà relative all'accesso ai dati e le proprietà deterministiche delle funzioni CLR possono essere specificate dall'utente.The data access and determinism properties of CLR functions can be specified by the user. Per altre informazioni, vedere Panoramica degli attributi personalizzati dell'integrazione con CLR.For more information, see Overview of CLR Integration Custom Attributes.

Per visualizzare i valori correnti di queste proprietà, usare OBJECTPROPERTYEX.To display the current values for these properties, use OBJECTPROPERTYEX.

Importante

Le funzioni devono essere create con SCHEMABINDING per essere deterministiche.Functions must be created with SCHEMABINDING to be deterministic.

È possibile utilizzare una colonna calcolata che richiama una funzione definita dall'utente in un indice se per le proprietà della funzione definita dall'utente sono stati impostati i valori seguenti:A computed column that invokes a user-defined function can be used in an index when the user-defined function has the following property values:

  • IsDeterministic = trueIsDeterministic = true
  • IsSystemVerified = true (a meno che la colonna calcolata non sia persistente)IsSystemVerified = true (unless the computed column is persisted)
  • UserDataAccess = falseUserDataAccess = false
  • SystemDataAccess = falseSystemDataAccess = false

Per altre informazioni, vedere Indici per le colonne calcolate.For more information, see Indexes on Computed Columns.

Chiamata di stored procedure estese da funzioniCalling Extended Stored Procedures from Functions

Una stored procedure estesa, quando viene richiamata dall'interno di una funzione, non può restituire set di risultati al client.The extended stored procedure, when it is called from inside a function, cannot return result sets to the client. Le API ODS che restituiscono set di risultati al client restituiscono FAIL.Any ODS APIs that return result sets to the client will return FAIL. La stored procedure estesa può riconnettersi a un'istanza di SQL ServerSQL Server, tuttavia è necessario che non partecipi alla stessa transazione della funzione che l'ha richiamata.The extended stored procedure could connect back to an instance of SQL ServerSQL Server; however, it should not try to join the same transaction as the function that invoked the extended stored procedure.

In modo analogo a una chiamata eseguita dall'interno di un batch o di una stored procedure, la stored procedure estesa viene eseguita nel contesto dell'account di sicurezza di Windows in base a cui SQL ServerSQL Server è in esecuzione.Similar to invocations from a batch or stored procedure, the extended stored procedure will be executed in the context of the Windows security account under which SQL ServerSQL Server is running. È importante che il proprietario della stored procedure prenda in considerazione questo fattore quando concede l'autorizzazione EXECUTE agli utenti.The owner of the stored procedure should consider this when giving EXECUTE permission on it to users.

Limitazioni e restrizioniLimitations and Restrictions

Non è possibile utilizzare funzioni definite dall'utente per eseguire azioni che modificano lo stato del database.User-defined functions cannot be used to perform actions that modify the database state.

Le funzioni definite dall'utente non possono contenere una clausola OUTPUT INTO che ha una tabella come destinazione.User-defined functions cannot contain an OUTPUT INTO clause that has a table as its target.

Nella definizione di una funzione Service BrokerService Broker definita dall'utente non è possibile includere le istruzioni di Transact-SQLTransact-SQL seguenti:The following Service BrokerService Broker statements cannot be included in the definition of a Transact-SQLTransact-SQL user-defined function:

  • BEGIN DIALOG CONVERSATION

  • END CONVERSATION

  • GET CONVERSATION GROUP

  • MOVE CONVERSATION

  • RECEIVE

  • SEND

È possibile nidificare le funzioni definite dall'utente, ovvero una funzione definita dall'utente ne può richiamare un'altra.User-defined functions can be nested; that is, one user-defined function can call another. Il livello di nidificazione aumenta all'avvio della funzione richiamata e diminuisce al termine dell'esecuzione della funzione.The nesting level is incremented when the called function starts execution, and decremented when the called function finishes execution. Le funzioni definite dall'utente possono essere nidificate fino a un massimo di 32 livelli.User-defined functions can be nested up to 32 levels. Se viene superato il livello massimo di nidificazioni, l'intera sequenza di funzioni chiamanti ha esito negativo.Exceeding the maximum levels of nesting causes the whole calling function chain to fail. Qualsiasi riferimento al codice gestito presente in una funzione Transact-SQLTransact-SQL definita dall'utente viene considerato come un livello nel contesto del limite di 32 livelli di nidificazione.Any reference to managed code from a Transact-SQLTransact-SQL user-defined function counts as one level against the 32-level nesting limit. I metodi richiamati da codice gestito non vengono inclusi nel conteggio per questo limite.Methods invoked from within managed code do not count against this limit.

Utilizzo dell'ordinamento nelle funzioni CLR con valori di tabellaUsing Sort Order in CLR Table-valued Functions

Quando si usa la clausola ORDER in funzioni CLR con valori di tabella, attenersi alle linee guida seguenti:When using the ORDER clause in CLR table-valued functions, follow these guidelines:

  • È necessario assicurarsi che i risultati siano ordinati sempre in base all'ordine specificato.You must ensure that results are always ordered in the specified order. Se i risultati non sono nell'ordine specificato, in SQL ServerSQL Server verrà generato un messaggio di errore quando viene eseguita la query.If the results are not in the specified order, SQL ServerSQL Server will generate an error message when the query is executed.

  • Se è specificata una clausola ORDER, l'output della funzione con valori di tabella deve essere ordinato in base alle regole di confronto della colonna (esplicite o implicite).If an ORDER clause is specified, the output of the table-valued function must be sorted according to the collation of the column (explicit or implicit). Se, ad esempio, le regole di confronto della colonna sono impostate per il cinese (in base a quanto specificato nella DDL per la funzione con valori di tabella o ottenuto dalle regole di confronto del database), i risultati restituiti devono essere ordinati in base alle regole di ordinamento per il cinese.For example, if the column collation is Chinese (either specified in the DDL for the table-valued function or obtained from the database collation), the returned results must be sorted according to Chinese sorting rules.

  • La clausola SQL ServerSQL Server, se specificata, viene sempre verificata da ORDER quando vengono restituiti i risultati, indipendentemente dal fatto che venga usata da Query Processor per eseguire altre ottimizzazioni.The ORDER clause, if specified, is always verified by SQL ServerSQL Server while returning results, whether or not it is used by the query processor to perform further optimizations. Usare la clausola ORDER solo se si è certi che sia utile per Query Processor.Only use the ORDER clause if you know it is useful to the query processor.

  • Query Processor di SQL ServerSQL Server usa automaticamente la clausola ORDER nei casi seguenti:The SQL ServerSQL Server query processor takes advantage of the ORDER clause automatically in following cases:

    • Query di inserimento in cui la clausola ORDER è compatibile con un indice.Insert queries where the ORDER clause is compatible with an index.

    • Clausole ORDER BY compatibili con la clausola ORDER.ORDER BY clauses that are compatible with the ORDER clause.

    • Aggregazioni, in cui GROUP BY è compatibile con la clausola ORDER.Aggregates, where GROUP BY is compatible with ORDER clause.

    • Aggregazioni DISTINCT in cui le colonne distinte sono compatibili con la clausola ORDER.DISTINCT aggregates where the distinct columns are compatible with the ORDER clause.

La clausola ORDER non garantisce risultati ordinati quando viene eseguita una query SELECT, a meno che nella query non venga specificata anche la clausola ORDER BY.The ORDER clause does not guarantee ordered results when a SELECT query is executed, unless ORDER BY is also specified in the query. Vedere sys.function_order_columns (Transact-SQL) per informazioni su come eseguire una query relativa alle colonne incluse nell'ordinamento per le funzioni con valori di tabella.See sys.function_order_columns (Transact-SQL) for information on how to query for columns included in the sort-order for table-valued functions.

MetadatiMetadata

Nella tabella seguente vengono elencate le viste del catalogo di sistema utilizzate per restituire i metadati sulle funzioni definite dall'utente.The following table lists the system catalog views that you can use to return metadata about user-defined functions.

Vista di sistemaSystem View DescrizioneDescription
sys.sql_modulessys.sql_modules Vedere l'esempio E nella sezione Esempi riportata più avanti.See example E in the Examples section below.
sys.assembly_modulessys.assembly_modules Visualizza le informazioni sulle funzioni CLR definite dall'utente.Displays information about CLR user-defined functions.
sys.parameterssys.parameters Visualizza le informazioni sui parametri definiti nelle funzioni definite dall'utente.Displays information about the parameters defined in user-defined functions.
sys.sql_expression_dependenciessys.sql_expression_dependencies Visualizza gli oggetti sottostanti a cui fa riferimento una funzione.Displays the underlying objects referenced by a function.

AutorizzazioniPermissions

È necessario disporre dell'autorizzazione CREATE FUNCTION nel database e dell'autorizzazione ALTER per lo schema in cui la funzione è in fase di creazione.Requires CREATE FUNCTION permission in the database and ALTER permission on the schema in which the function is being created. Se per la funzione viene specificato un tipo definito dall'utente, è necessario disporre dell'autorizzazione EXECUTE per tale tipo.If the function specifies a user-defined type, requires EXECUTE permission on the type.

EsempiExamples

Nota

Per altri esempi e considerazioni sulle prestazioni delle funzioni definite dall'utente, vedere Creare funzioni definite dall'utente (Motore di database).For more examples and performance considerations about UDFs, see Create User-defined Functions (Database Engine).

A.A. Utilizzo di una funzione definita dall'utente a valori scalari per il calcolo della settimana ISOUsing a scalar-valued user-defined function that calculates the ISO week

Nell'esempio seguente viene creata la funzione definita dall'utente ISOweek.The following example creates the user-defined function ISOweek. Questa funzione calcola il numero di settimana ISO in base a un argomento di data specificato.This function takes a date argument and calculates the ISO week number. Per consentire alla funzione di eseguire il calcolo correttamente, è necessario richiamare SET DATEFIRST 1 prima della funzione.For this function to calculate correctly, SET DATEFIRST 1 must be invoked before the function is called.

L'esempio illustra anche l'uso della clausola EXECUTE AS per specificare il contesto di protezione in cui è possibile eseguire una stored procedure.The example also shows using the EXECUTE AS clause to specify the security context in which a stored procedure can be executed. Nell'esempio, l'opzione CALLER specifica che la procedura verrà eseguita nel contesto dell'utente che l'ha richiamata.In the example, the option CALLER specifies that the procedure will be executed in the context of the user that calls it. Le altre opzioni che è possibile specificare sono SELF, OWNER e user_name.The other options that you can specify are SELF, OWNER, and user_name.

Di seguito è riportata la chiamata della funzione,Here is the function call. in cui DATEFIRST è impostato su 1.Notice that DATEFIRST is set to 1.

CREATE FUNCTION dbo.ISOweek (@DATE datetime)  
RETURNS int  
WITH EXECUTE AS CALLER  
AS  
BEGIN  
     DECLARE @ISOweek int;  
     SET @ISOweek= DATEPART(wk,@DATE)+1  
          -DATEPART(wk,CAST(DATEPART(yy,@DATE) as CHAR(4))+'0104');  
--Special cases: Jan 1-3 may belong to the previous year  
     IF (@ISOweek=0)   
          SET @ISOweek=dbo.ISOweek(CAST(DATEPART(yy,@DATE)-1   
               AS CHAR(4))+'12'+ CAST(24+DATEPART(DAY,@DATE) AS CHAR(2)))+1;  
--Special case: Dec 29-31 may belong to the next year  
     IF ((DATEPART(mm,@DATE)=12) AND   
          ((DATEPART(dd,@DATE)-DATEPART(dw,@DATE))>= 28))  
          SET @ISOweek=1;  
     RETURN(@ISOweek);  
END;  
GO  
SET DATEFIRST 1;  
SELECT dbo.ISOweek(CONVERT(DATETIME,'12/26/2004',101)) AS 'ISO Week';  

Set di risultati:Here is the result set.

ISO Week  
----------------  
52  

B.B. Creazione di una funzione inline con valori di tabellaCreating an inline table-valued function

Nell'esempio seguente viene restituita una funzione con valori di tabella inline nel database AdventureWorks2012AdventureWorks2012.The following example returns an inline table-valued function in the AdventureWorks2012AdventureWorks2012 database. Vengono restituite tre colonne ProductID, Name e il valore aggregato dei totali da inizio anno per negozio come YTD Totalper ogni prodotto venduto al negozio.It returns three columns ProductID, Name and the aggregate of year-to-date totals by store as YTD Total for each product sold to the store.

CREATE FUNCTION Sales.ufn_SalesByStore (@storeid int)  
RETURNS TABLE  
AS  
RETURN   
(  
    SELECT P.ProductID, P.Name, SUM(SD.LineTotal) AS 'Total'  
    FROM Production.Product AS P   
    JOIN Sales.SalesOrderDetail AS SD ON SD.ProductID = P.ProductID  
    JOIN Sales.SalesOrderHeader AS SH ON SH.SalesOrderID = SD.SalesOrderID  
    JOIN Sales.Customer AS C ON SH.CustomerID = C.CustomerID  
    WHERE C.StoreID = @storeid  
    GROUP BY P.ProductID, P.Name  
);  
GO  

Per richiamare la funzione, eseguire la query seguente.To invoke the function, run this query.

SELECT * FROM Sales.ufn_SalesByStore (602);  

C.C. Creazione di una funzione a istruzioni multiple con valori di tabellaCreating a multi-statement table-valued function

Nell'esempio seguente viene creata la funzione con valori di tabella fn_FindReports(InEmpID) nel database AdventureWorks2012.The following example creates the table-valued function fn_FindReports(InEmpID) in the AdventureWorks2012 database. Se si specifica un ID dipendente valido, la funzione restituisce una tabella che include tutti i dipendenti che hanno rapporti diretti o indiretti con il dipendente specificato.When supplied with a valid employee ID, the function returns a table that corresponds to all the employees that report to the employee either directly or indirectly. La funzione utilizza un'espressione di tabella comune ricorsiva (CTE, Common Table Expression) per restituire l'elenco gerarchico dei dipendenti.The function uses a recursive common table expression (CTE) to produce the hierarchical list of employees. Per altre informazioni sulle espressioni CTE ricorsive, vedere WITH common_table_expression (Transact-SQL).For more information about recursive CTEs, see WITH common_table_expression (Transact-SQL).

CREATE FUNCTION dbo.ufn_FindReports (@InEmpID INTEGER)  
RETURNS @retFindReports TABLE   
(  
    EmployeeID int primary key NOT NULL,  
    FirstName nvarchar(255) NOT NULL,  
    LastName nvarchar(255) NOT NULL,  
    JobTitle nvarchar(50) NOT NULL,  
    RecursionLevel int NOT NULL  
)  
--Returns a result set that lists all the employees who report to the   
--specific employee directly or indirectly.*/  
AS  
BEGIN  
WITH EMP_cte(EmployeeID, OrganizationNode, FirstName, LastName, JobTitle, RecursionLevel) -- CTE name and columns  
    AS (  
        -- Get the initial list of Employees for Manager n
        SELECT e.BusinessEntityID, e.OrganizationNode, p.FirstName, p.LastName, e.JobTitle, 0   
        FROM HumanResources.Employee e   
INNER JOIN Person.Person p   
ON p.BusinessEntityID = e.BusinessEntityID  
        WHERE e.BusinessEntityID = @InEmpID  
        UNION ALL  
        -- Join recursive member to anchor
        SELECT e.BusinessEntityID, e.OrganizationNode, p.FirstName, p.LastName, e.JobTitle, RecursionLevel + 1   
        FROM HumanResources.Employee e   
            INNER JOIN EMP_cte  
            ON e.OrganizationNode.GetAncestor(1) = EMP_cte.OrganizationNode  
INNER JOIN Person.Person p   
ON p.BusinessEntityID = e.BusinessEntityID  
        )  
-- copy the required columns to the result of the function   
   INSERT @retFindReports  
   SELECT EmployeeID, FirstName, LastName, JobTitle, RecursionLevel  
   FROM EMP_cte   
   RETURN  
END;  
GO  
-- Example invocation  
SELECT EmployeeID, FirstName, LastName, JobTitle, RecursionLevel  
FROM dbo.ufn_FindReports(1);   
  
GO  

D.D. Creazione di una funzione CLRCreating a CLR function

L'esempio crea la funzione CLR len_s,The example creates CLR function len_s. ma prima che venga effettivamente creata la funzione, l'assembly SurrogateStringFunction.dll viene registrato nel database locale.Before the function is created, the assembly SurrogateStringFunction.dll is registered in the local database.

Si applica a: SQL ServerSQL Server (da SQL Server 2008SQL Server 2008 SP1 a SQL Server 2017SQL Server 2017)Applies to: SQL ServerSQL Server ( SQL Server 2008SQL Server 2008 SP1 through SQL Server 2017SQL Server 2017)

DECLARE @SamplesPath nvarchar(1024);  
-- You may have to modify the value of this variable if you have  
-- installed the sample in a location other than the default location.  
SELECT @SamplesPath = REPLACE(physical_name, 'Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\master.mdf', 
                                              'Microsoft SQL Server\130\Samples\Engine\Programmability\CLR\')   
    FROM master.sys.database_files   
    WHERE name = 'master';  
  
CREATE ASSEMBLY [SurrogateStringFunction]  
FROM @SamplesPath + 'StringManipulate\CS\StringManipulate\bin\debug\SurrogateStringFunction.dll'  
WITH PERMISSION_SET = EXTERNAL_ACCESS;  
GO  
  
CREATE FUNCTION [dbo].[len_s] (@str nvarchar(4000))  
RETURNS bigint  
AS EXTERNAL NAME [SurrogateStringFunction].[Microsoft.Samples.SqlServer.SurrogateStringFunction].[LenS];  
GO  

Per un esempio relativo alla creazione di una funzione CLR con valori di tabella, vedere Funzioni CLR con valori di tabella.For an example of how to create a CLR table-valued function, see CLR Table-Valued Functions.

E.E. Visualizzazione della definizione di funzioni Transact-SQLTransact-SQL definite dall'utenteDisplaying the definition of Transact-SQLTransact-SQL user-defined functions

SELECT definition, type   
FROM sys.sql_modules AS m  
JOIN sys.objects AS o ON m.object_id = o.object_id   
    AND type IN ('FN', 'IF', 'TF');  
GO  

La definizione delle funzioni create tramite l'opzione ENCRYPTION non possono essere visualizzate tramite la vista sys.sql_modules. Vengono tuttavia visualizzate altre informazioni sulle funzioni crittografate.The definition of functions created by using the ENCRYPTION option cannot be viewed by using sys.sql_modules; however, other information about the encrypted functions is displayed.

Vedere ancheSee Also

Creare funzioni definite dall'utente (Motore di database) Create User-defined Functions (Database Engine)
ALTER FUNCTION (Transact-SQL) ALTER FUNCTION (Transact-SQL)
DROP FUNCTION (Transact-SQL) DROP FUNCTION (Transact-SQL)
OBJECTPROPERTYEX (Transact-SQL) OBJECTPROPERTYEX (Transact-SQL)
sys.sql_modules (Transact-SQL) sys.sql_modules (Transact-SQL)
sys.assembly_modules (Transact-SQL) sys.assembly_modules (Transact-SQL)
EXECUTE (Transact-SQL) EXECUTE (Transact-SQL)
Funzioni CLR definite dall'utente CLR User-Defined Functions
EVENTDATA (Transact-SQL) EVENTDATA (Transact-SQL)
CREATE SECURITY POLICY (Transact-SQL)CREATE SECURITY POLICY (Transact-SQL)