Transact-SQL Syntax ConventionsCreates a user-defined function in SQL Data Warehouse A user-defined function is a SQL Data Warehouse Transact\-SQL routine that accepts parameters, performs an action, such as a complex calculation, and returns the result of that action as a value. The return value must be a scalar (single) value. Use this statement to create a reusable routine that can be used in these ways:
In Transact\-SQL statements such as SELECT
In applications calling the function
In the definition of another user-defined function
To define a CHECK constraint on a column
To replace a stored procedure
Transact-SQL Syntax Conventions
--Transact-SQL Scalar Function Syntax
CREATE FUNCTION [ schema_name. ] function_name
( [ { @parameter_name [ AS ] parameter_data_type
[ = default ] }
[ ,...n ]
]
)
RETURNS return_data_type
[ WITH <function_option> [ ,...n ] ]
[ AS ]
BEGIN
function_body
RETURN scalar_expression
END
[ ; ]
<function_option>::=
{
[ SCHEMABINDING ]
| [ RETURNS NULL ON NULL INPUT | CALLED ON NULL INPUT ]
}
schema_name
Is the name of the schema to which the user-defined function belongs.
function_name
Is the name of the user-defined function. Function names must comply with the rules for identifiers and must be unique within the database and to its schema.
[!NOTE]
Parentheses are required after the function name even if a parameter is not specified.
@*parameter_name*
Is a parameter in the user-defined function. One or more parameters can be declared.
A function can have a maximum of 2,100 parameters. 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.
Specify a parameter name by using an at sign (@) as the first character. The parameter name must comply with the rules for identifiers. Parameters are local to the function; the same parameter names can be used in other functions. 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.
[!NOTE]
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. 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.
parameter_data_type
Is the parameter data type. For Transact\-SQL functions, all scalar data types supported in Transact\-SQL SQL Data Warehouse are allowed. The timestamp (rowversion) data type is not a supported type.
[ =default ]
Is a default value for the parameter. If a default value is defined, the function can be executed without specifying a value for that parameter.
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. This behavior is different from using parameters with default values in stored procedures in which omitting the parameter also implies the default value.
return_data_type
Is the return value of a scalar user-defined function. For Transact\-SQL functions, all scalar data types supported in Transact\-SQL SQL Data Warehouse are allowed. The timestamp (rowversion) data type is not a supported type. The cursor and table nonscalar types are not allowed.
function_body
Series of Transact\-SQL statements. The function_body cannot contain a SELECT statement and cannot reference database data. The function_body cannot reference tables or views. The function body can call other deterministic functions but cannot call nondeterministic functions.
In scalar functions, function_body is a series of Transact\-SQL statements that together evaluate to a scalar value.
scalar_expression
Specifies the scalar value that the scalar function returns.
<function_option>::=
Specifies that the function will have one or more of the following options.
SCHEMABINDING
Specifies that the function is bound to the database objects that it references. When SCHEMABINDING is specified, the base objects cannot be modified in a way that would affect the function definition. The function definition itself must first be modified or dropped to remove dependencies on the object that is to be modified.
The binding of the function to the objects it references is removed only when one of the following actions occurs:
The function is dropped.
The function is modified by using the ALTER statement with the SCHEMABINDING option not specified.
A function can be schema bound only if the following conditions are true:
Any user-defined functions referenced by the function are also schema-bound.
The functions and other UDFs referenced by the function are referenced using a one-part or two-part name.
Only built-in functions and other UDFs in the same database can be referenced within the body of UDFs.
The user who executed the CREATE FUNCTION statement has REFERENCES permission on the database objects that the function references.
To remove SCHEMABINDING use ALTER
RETURNS NULL ON NULL INPUT | CALLED ON NULL INPUT
Specifies the OnNULLCall attribute of a scalar-valued function. If not specified, CALLED ON NULL INPUT is implied by default. This means that the function body executes even if NULL is passed as an argument.
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. 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:
The following statements are valid in a function:
Assignment statements.
Control-of-Flow statements except TRY…CATCH statements.
DECLARE statements defining local data variables.
User-defined functions cannot be used to perform actions that modify the database state.
User-defined functions can be nested; that is, one user-defined function can call another. The nesting level is incremented when the called function starts execution, and decremented when the called function finishes execution. User-defined functions can be nested up to 32 levels. Exceeding the maximum levels of nesting causes the whole calling function chain to fail.
This section lists the system catalog views that you can use to return metadata about user-defined functions.
sys.sql_modules : Displays the definition of Transact\-SQL user-defined functions. For example:
SELECT definition, type
FROM sys.sql_modules AS m
JOIN sys.objects AS o
ON m.object_id = o.object_id
AND type = ('FN');
GO
sys.parameters : Displays information about the parameters defined in user-defined functions.
sys.sql_expression_dependencies : Displays the underlying objects referenced by a function.
Requires CREATE FUNCTION permission in the database and ALTER permission on the schema in which the function is being created.
This simple function takes a int data type as an input, and returns a decimal(10,2) data type as an output.
CREATE FUNCTION dbo.ConvertInput (@MyValueIn int)
RETURNS decimal(10,2)
AS
BEGIN
DECLARE @MyValueOut int;
SET @MyValueOut= CAST( @MyValueIn AS decimal(10,2));
RETURN(@MyValueOut);
END;
GO
SELECT dbo.ConvertInput(15) AS 'ConvertedValue'; ALTER FUNCTION (SQL Server PDW)
DROP FUNCTION (SQL Server PDW)