Megjegyzés
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhat bejelentkezni vagy módosítani a címtárat.
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhatja módosítani a címtárat.
A következőkre vonatkozik:SQL Server
Azure SQL Database
Felügyelt Azure SQL-példány
SQL-adatbázis a Microsoft Fabric-ben
Létrehoz egy felhasználó által definiált függvényt (UDF), amely egy Transact-SQL vagy közös nyelvi futtatókörnyezet (CLR) rutin. A felhasználó által definiált függvények elfogadják a paramétereket, végrehajtanak egy műveletet, például egy összetett számítást, és értékként adják vissza a művelet eredményét. A visszatérési érték lehet skaláris (egyetlen) érték vagy tábla.
A következő módokon használható újrafelhasználható T-SQL-rutin létrehozásához használható CREATE FUNCTION
:
- Az olyan Transact-SQL kijelentésekben, mint például
SELECT
- A függvényt meghívó alkalmazásokban
- Egy másik felhasználó által definiált függvény definíciójában
- Nézet paraméterezése vagy indexelt nézet működésének javítása
- Oszlop definiálása egy táblában
- Kényszer definiálása
CHECK
oszlopon - Tárolt eljárás cseréje
- Beágyazott függvény használata biztonsági házirend szűrőpredikátumaként
NET-keretrendszer CLR SQL Server integrációját ebben a cikkben tárgyaljuk. A CLR-integráció nem vonatkozik a Azure SQL Database.
Megjegyzés:
A Microsoft Fabric Data Warehouse vagy az Azure Synapse Analytics esetében lásd a CREATE FÜGGVÉNYt (Az Azure Synapse Analytics és a Microsoft Fabric) című témakört.
Jótanács
Megadhatja CREATE OR ALTER FUNCTION
, hogy egy új függvényt hozzon létre, ha az adott név nem létezik, vagy egy meglévő függvényt módosít egyetlen utasításban.
Transact-SQL szintaxis konvenciók
Szemantika
A skaláris függvények szintaxisa Transact-SQL.
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name
( [ { @parameter_name [ AS ] [ type_schema_name. ] parameter_data_type [ NULL ]
[ = default ] [ READONLY ] }
[ , ...n ]
]
)
RETURNS return_data_type
[ WITH <function_option> [ , ...n ] ]
[ AS ]
BEGIN
function_body
RETURN scalar_expression
END
[ ; ]
Transact-SQL beágyazott táblaértékű függvények szintaxisa.
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name
( [ { @parameter_name [ AS ] [ type_schema_name. ] parameter_data_type [ NULL ]
[ = default ] [ READONLY ] }
[ , ...n ]
]
)
RETURNS TABLE
[ WITH <function_option> [ , ...n ] ]
[ AS ]
RETURN [ ( ] select_stmt [ ) ]
[ ; ]
A többutasításos táblaértékű függvények szintaxisa Transact-SQL.
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name
( [ { @parameter_name [ AS ] [ type_schema_name. ] parameter_data_type [ NULL ]
[ = default ] [ READONLY ] }
[ , ...n ]
]
)
RETURNS @return_variable TABLE <table_type_definition>
[ WITH <function_option> [ , ...n ] ]
[ AS ]
BEGIN
function_body
RETURN
END
[ ; ]
A Transact-SQL függvényzáradékok szintaxisa.
<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 }
}
A CLR skaláris függvények szintaxisa.
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name
( { @parameter_name [ AS ] [ type_schema_name. ] parameter_data_type [ NULL ]
[ = default ] }
[ , ...n ]
)
RETURNS { return_data_type }
[ WITH <clr_function_option> [ , ...n ] ]
[ AS ] EXTERNAL NAME <method_specifier>
[ ; ]
A CLR táblaértékű függvények szintaxisa.
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name
( { @parameter_name [ AS ] [ type_schema_name. ] parameter_data_type [ NULL ]
[ = default ] }
[ , ...n ]
)
RETURNS TABLE <clr_table_type_definition>
[ WITH <clr_function_option> [ , ...n ] ]
[ ORDER ( <order_clause> ) ]
[ AS ] EXTERNAL NAME <method_specifier>
[ ; ]
A CLR függvényzáradékok szintaxisa.
<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 ] )
Natív módon lefordított, skaláris, felhasználó által definiált függvények memóriában tárolt OLTP-szintaxisa.
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 ]
}
Érvek
VAGY ALTER
A következőkre vonatkozik: SQL Server 2016 (13.x) SP 1 és újabb verziók, valamint Azure SQL Database.
Csak akkor módosítja feltételesen a függvényt, ha már létezik.
A CLR-hez opcionális OR ALTER
szintaxis érhető el, a SQL Server 2016 (13.x) SP 1 CU 1-től kezdődően.
schema_name
Annak a sémának a neve, amelyhez a felhasználó által definiált függvény tartozik.
function_name
A felhasználó által definiált függvény neve. A függvényneveknek meg kell felelniük az azonosítókra vonatkozó szabályoknak, és egyedinek kell lenniük az adatbázison és annak sémáján belül.
A függvény neve után zárójelekre van szükség, még akkor is, ha nincs megadva paraméter.
@parameter_name
A felhasználó által definiált függvény paramétere. Egy vagy több paraméter deklarálható.
Egy függvény legfeljebb 2 100 paraméterrel rendelkezhet. Az egyes deklarált paraméterek értékét a felhasználónak kell megadnia a függvény végrehajtásakor, kivéve, ha a paraméter alapértelmezett értéke van megadva.
Adja meg a paraméter nevét egy kukac jel (@) első karakterként. A paraméter nevének meg kell felelnie az azonosítókra vonatkozó szabályoknak. A paraméterek a függvényhez kapcsolódnak; Ugyanezek a paraméternevek más függvényekben is használhatók. A paraméterek csak az állandók helyébe léphetnek; Nem használhatók táblanevek, oszlopnevek vagy más adatbázis-objektumok nevei helyett.
ANSI_WARNINGS
nem teljesül, ha paramétereket ad át egy tárolt eljárásban, felhasználó által definiált függvényben, vagy ha változókat deklarál és állít be egy batch utasításban. Ha például egy változó karakter(3), majd három karakternél nagyobb értékre van beállítva, az adatok csonkolódnak a meghatározott méretre, és a INSERT
vagy UPDATE
utasítás sikeres lesz.
[ type_schema_name. ] parameter_data_type
A paraméter adattípusa, és opcionálisan az a séma, amelyhez tartozik. A Transact-SQL függvények esetében az időbélyegző adattípus kivételével minden adattípus engedélyezett, beleértve a CLR felhasználó által definiált típusokat és a felhasználó által definiált táblatípusokat is. A CLR-függvények esetében minden adattípus, beleértve a CLR felhasználó által definiált típusokat is, engedélyezett, kivéve a szöveget, az ntextet, a képet, a felhasználó által definiált táblatípusokat és az időbélyegző adattípusokat. A nem skaláris típusok, a kurzor és a tábla nem adhatók meg paraméteradattípusként sem a Transact-SQL, sem a CLR-függvényekben.
Ha type_schema_name nincs megadva, az adatbázismotor a következő sorrendben keresi meg:scalar_parameter_data_type
- A rendszeradattípusok nevét SQL Server tartalmazó séma.
- Az aktuális felhasználó alapértelmezett sémája az aktuális adatbázisban.
- Az aktuális adatbázis
dbo
sémája.
[ = alapértelmezett ]
A paraméter alapértelmezett értéke. Ha alapértelmezett érték van megadva, a függvény a paraméter értékének megadása nélkül is végrehajtható.
A CLR-függvényekhez alapértelmezett paraméterértékek adhatók meg, kivéve a varchar(max) és a varbinary(max) adattípusokat.
Ha a függvény egyik paramétere alapértelmezett értékkel rendelkezik, a kulcsszót DEFAULT
meg kell adni, amikor a függvényt meghívja az alapértelmezett érték lekéréséhez. Ez a viselkedés eltér az alapértelmezett értékekkel rendelkező paraméterek tárolt eljárásokban való használatától, amelyekben a paraméter kihagyása az alapértelmezett értéket is magában foglalja. A DEFAULT
kulcsszó azonban nem kötelező, ha skaláris függvényt hív meg az EXECUTE
utasítás használatával.
CSAK OLVASHATÓ
Azt jelzi, hogy a paraméter nem frissíthető vagy módosítható a függvény definícióján belül.
READONLY
a felhasználó által definiált táblatípus-paraméterekhez (TVP-k) szükséges, és más paramétertípushoz nem használható.
return_data_type
Egy skaláris, felhasználó által definiált függvény visszatérési értéke. A Transact-SQL függvények esetében az időbélyegző adattípus kivételével minden adattípus engedélyezett, beleértve a CLR felhasználó által definiált típusokat is. A CLR-függvények esetében minden adattípus, beleértve a CLR felhasználó által definiált típusokat is, engedélyezett, kivéve a szöveg,az ntext, a kép és az időbélyegző adattípusokat. A nem skaláris típusok, a kurzor és a tábla nem adhatók meg visszatérési adattípusként sem a Transact-SQL, sem a CLR-függvényekben.
function_body
Megadja, hogy Transact-SQL utasítások sorozata, amelyek együttesen nem okoznak mellékhatást, például egy tábla módosítását, határozzák meg a függvény értékét. function_body csak skaláris függvényekben és többutasításos táblaértékű függvényekben (MSTVF) használatos.
A skaláris függvényekben a function_body Transact-SQL utasítások sorozata, amelyek együttesen egy skaláris értéket értékelnek ki.
Az MSTVF-ekben a function_body Transact-SQL utasítások sorozata, amelyek feltöltenek egy TABLE
visszatérési változót.
scalar_expression
Megadja a skaláris függvény által visszaadott skaláris értéket.
ASZTAL
Megadja, hogy a táblaértékű függvény (TVF) visszatérési értéke tábla. Csak az állandók és a @local_variables adhatók át a TVF-eknek.
A beágyazott TVF-ekben a TABLE
visszatérési érték egyetlen SELECT
utasítással van meghatározva. A beágyazott függvények nem rendelkeznek társított visszatérési változókkal.
A többutas táblaértékű függvényekben (MSTVF-ek) @return_variable egy TABLE
változó, amely a függvény értékeként visszaadandó sorok tárolására és felhalmozására szolgál.
@
return_variable csak Transact-SQL funkciókhoz adható meg, CLR-funkciókhoz nem.
select_stmt
A beágyazott táblaértékű függvény (TVF) visszatérési értékét meghatározó egyetlen SELECT
utasítás.
VÉGZÉS (<order_clause)>
Megadja az eredmények visszaadásának sorrendjét a táblaértékű függvényből. További információt a cikk későbbi, Rendezési sorrend használata CLR-táblaértékű függvényekben című szakaszában talál.
KÜLSŐ NÉV <method_specifier>assembly_name.class_name. method_name
A következőkre vonatkozik: SQL Server 2008 (10.0.x) SP 1 és újabb verziók.
Megadja azt a szerelvényt és metódust, amelyre a létrehozott függvény neve hivatkozik.
assembly_name - meg kell egyeznie a
name
.SELECT * FROM sys.assemblies;
A nyilatkozatban használt
CREATE ASSEMBLY
név.class_name - meg kell egyeznie a
assembly_name
.SELECT * FROM sys.assembly_modules;
Az érték gyakran tartalmaz beágyazott pontot vagy pontot. Ilyen esetekben a Transact-SQL szintaxisa megköveteli, hogy az értéket szögletes zárójel (
[]
) vagy dupla idézőjel ()""
határolja.method_name - meg kell egyeznie a
method_name
.SELECT * FROM sys.assembly_modules;
A módszernek statikusnak kell lennie.
Egy tipikus példában MyFood.dll
, amelyben minden típus a MyFood
névtérben található, az EXTERNAL NAME
érték lehet MyFood.[MyFood.MyClass].MyStaticMethod
.
Alapértelmezés szerint a SQL Server nem tudja végrehajtani a CLR-kódot. Létrehozhat, módosíthat és eldobhat olyan adatbázis-objektumokat, amelyek gyakori nyelvi futtatókörnyezet-modulokra hivatkoznak. Ezeket a hivatkozásokat azonban nem hajthatja végre a SQL Server, amíg nem engedélyezi a clr engedélyezve beállítást. A beállítás engedélyezéséhez használja a sp_configure. Ez a beállítás nem érhető el egy tartalmazott adatbázisban.
<table_type_definition> ( { <column_definition><column_constraint | <computed_column_definition> } [ <table_constraint> ] [ , ... n ] )
Meghatározza egy Transact-SQL függvény tábla adattípusát. A tábladeklaráció oszlopdefiníciókat és oszlop- vagy táblakorlátozásokat tartalmaz. A tábla mindig az elsődleges fájlcsoportba kerül.
<clr_table_type_definition> ( { column_namedata_type } [ , ... n ] )
A következőkre vonatkozik: SQL Server 2008 (10.0.x) SP 1 és újabb verziók, valamint Azure SQL Database (előzetes verzió egyes régiókban).
Meghatározza a CLR-függvény táblaadattípusait. A tábladeklaráció csak oszlopneveket és adattípusokat tartalmaz. A tábla mindig az elsődleges fájlcsoportba kerül.
NULL | NOT NULL
Csak natív módon lefordított, skaláris, felhasználó által definiált függvények esetén támogatott. További információ: Skaláris User-Defined függvények In-Memory OLTP-hez.
NATIVE_COMPILATION
Azt jelzi, hogy egy felhasználó által definiált függvény natív módon van-e lefordítva. Ez az argumentum natív módon lefordított, skaláris, felhasználó által definiált függvényekhez szükséges.
KEZDJE AZ ATOMIC-OT
Natív módon lefordított, felhasználó által definiált skaláris függvényekhez szükséges és csak támogatott. További információ: Atomi blokkok a natív eljárásokban.
SÉMAKÖTÉS
Az SCHEMABINDING
argumentum natív módon lefordított, skaláris, felhasználó által definiált függvényekhez szükséges.
VÉGREHAJTÁS MÁSKÉNT
EXECUTE AS
natív módon lefordított, skaláris, felhasználó által definiált függvényekhez szükséges.
<function_option> ::= és <clr_function_option> ::=
Megadja, hogy a függvény az alábbi lehetőségek közül egyet vagy többet tartalmazzon.
TITKOSÍTÁS
A következőkre vonatkozik: SQL Server 2008 (10.0.x) SP 1 és újabb verziók.
Azt jelzi, hogy az adatbázismotor az utasítás eredeti szövegét CREATE FUNCTION
homályos formátumba konvertálja. Az elhomályosítás kimenete nem látható közvetlenül egyetlen katalógusnézetben sem. Azok a felhasználók, akik nem férnek hozzá a rendszertáblákhoz vagy az adatbázisfájlokhoz, nem tudják lekérni az elrejtett szöveget. A szöveg azonban elérhető a kiemelt felhasználók számára, akik vagy az adatbázis-rendszergazdák diagnosztikai kapcsolatán keresztül férhetnek hozzá a rendszertáblákhoz, vagy közvetlenül hozzáférhetnek az adatbázisfájlokhoz. Azok a felhasználók is, akik hibakeresőt csatolhatnak a kiszolgálói folyamathoz, futásidőben lekérhetik az eredeti eljárást a memóriából. A rendszer metaadatainak elérésével kapcsolatos további információkért lásd: Metaadatok láthatóságának konfigurálása.
Ezzel a beállítással megakadályozható a függvény közzététele az SQL Server replikáció részeként. Ez a beállítás nem adható meg CLR-függvényekhez.
SÉMAKÖTÉS
Megadja, hogy a függvény az általa hivatkozott adatbázis-objektumokhoz legyen kötve. Ha SCHEMABINDING
meg van adva, az alapobjektumok nem módosíthatók oly módon, hogy az hatással legyen a függvény definíciójára. Magát a függvénydefiníciót először módosítani kell vagy el kell dobni, hogy eltávolítsa a módosítani kívánt objektumtól való függőségeket.
A függvény hivatkozási objektumokhoz való kötése csak akkor törlődik, ha az alábbi műveletek valamelyike történik:
- A funkció megszűnik.
- A függvény az utasítás használatával
ALTER
módosul, és azSCHEMABINDING
opció nincs megadva.
Egy függvény csak akkor lehet sémakötésű, ha az alábbi feltételek teljesülnek:
- A függvény Transact-SQL függvény.
- A függvény által hivatkozott felhasználó által definiált függvények és nézetek szintén sémakötésűek.
- A függvény által hivatkozott objektumokra kétrészes névvel hivatkoznak.
- A függvény és az általa hivatkozott objektumok ugyanahhoz az adatbázishoz tartoznak.
- Az utasítást
CREATE FUNCTION
végrehajtó felhasználó engedéllyel rendelkezikREFERENCES
a függvény által hivatkozott adatbázis-objektumokhoz.
NULL ÉRTÉKET AD VISSZA NULL BEMENETRE | NULL BEMENETRE HÍVOTT
Megadja egy OnNULLCall
skaláris függvény attribútumát. Ha nincs megadva, alapértelmezés CALLED ON NULL INPUT
szerint implikált. Más szóval, a függvény törzse akkor is végrehajtható, ha NULL
argumentumként van átadva.
Ha RETURNS NULL ON NULL INPUT
egy CLR-függvényben meg van adva, az azt jelzi, hogy SQL Server akkor tud visszaadni NULL
, ha a kapott argumentumok bármelyike , NULL
anélkül, hogy ténylegesen meghívná a függvény törzsét. Ha egy CLR-függvény <method_specifier>
metódusa már rendelkezik olyan egyéni attribútummal, amely jelziRETURNS NULL ON NULL INPUT
, hogy , de az CREATE FUNCTION
utasítás azt jelziCALLED ON NULL INPUT
, hogy az utasítás elsőbbséget élvez.CREATE FUNCTION
Az OnNULLCall
attribútum nem adható meg CLR-táblaértékű függvényekhez.
VÉGREHAJTÁS MÁSKÉNT
Megadja azt a biztonsági környezetet, amelyben a felhasználó által definiált függvény végrehajtásra kerül. Ezért szabályozhatja, hogy az SQL Server melyik felhasználói fiókot használja a függvény által hivatkozott adatbázis-objektumok engedélyeinek érvényesítéséhez.
EXECUTE AS
nem adható meg beágyazott táblaértékű függvényekhez.
További információ: „EXECUTE AS” záradék (Transact-SQL).
BEÁGYAZOTT = { BE | KI }
A következőkre vonatkozik: SQL Server 2019 (15.x) és újabb verziók, valamint Azure SQL Database.
Megadja, hogy a skaláris UDF be kell-e ágyazottnak lennie vagy sem. Ez a záradék csak skaláris, felhasználó által definiált függvényekre vonatkozik. A INLINE
záradék nem kötelező. Ha a INLINE
záradék nincs megadva, a rendszer automatikusan beállítja ON
, hogy OFF
az UDF beágyazható-e. Ha INLINE = ON
meg van adva, de az UDF nem beágyazható, a rendszer hibát jelez. További információ: Skaláris UDF-formázási.
< > column_definition ::=
Meghatározza a tábla adattípusát. A tábladeklaráció oszlopdefiníciókat és korlátozásokat tartalmaz. CLR-függvények esetén csak column_name és data_type adható meg.
column_name
A táblázat egyik oszlopának neve. Az oszlopneveknek meg kell felelniük az azonosítókra vonatkozó szabályoknak, és egyedinek kell lenniük a táblában. column_name 1–128 karakterből állhat.
data_type
Megadja az oszlop adattípusát. A Transact-SQL függvények esetében az időbélyegző kivételével minden adattípus, beleértve a CLR felhasználó által definiált típusokat is. A CLR-függvények esetében minden adattípus engedélyezett, beleértve a CLR felhasználó által definiált típusokat is, kivéve a text, az ntext, az image, a char, a varchar, a varchar(max) és az időbélyegzőt. A nem skaláris típusú kurzor nem adható meg oszlopadattípusként sem a Transact-SQL, sem a CLR-függvényekben.
ALAPÉRTELMEZETT constant_expression
Az oszlophoz megadott értéket adja meg, ha egy érték nincs explicit módon megadva a beszúrás során.
constant_expression egy állandó, NULL
vagy egy rendszerfüggvény értéke.
DEFAULT
A definíciók bármely oszlopra alkalmazhatók, kivéve azokat, amelyek rendelkeznek a tulajdonsággal IDENTITY
.
DEFAULT
nem adható meg CLR-táblaértékű függvényekhez.
COLLATION_NAME RENDEZÉSE
Megadja az oszlop rendezési adatait. Ha nincs megadva, az oszlophoz az adatbázis alapértelmezett rendezése lesz hozzárendelve. A rendezés neve lehet Windows-rendezési név vagy SQL-rendezés neve. A rendezések listáját és további információit a Windows rendezési neve (Transact-SQL) és az SQL Server rendezési neve (Transact-SQL) című témakörben találja.
A COLLATE
záradék csak a char, varchar, nchar és nvarchar adattípusok oszlopainak rendezésére használható.
COLLATE
nem adható meg CLR-táblaértékű függvényekhez.
ROWGUIDCOL
Azt jelzi, hogy az új oszlop egy sor globálisan egyedi azonosító oszlopa. Táblánként csak egy uniqueidentifier oszlop jelölhető ki oszlopként ROWGUIDCOL
. A ROWGUIDCOL
tulajdonság csak egy uniqueidentifier oszlophoz rendelhető hozzá.
A ROWGUIDCOL
tulajdonság nem kényszeríti ki az oszlopban tárolt értékek egyediségét. Emellett nem generál automatikusan értékeket a táblázatba beszúrt új sorokhoz. Az egyes oszlopokhoz egyedi értékek létrehozásához használja az NEWID
utasítások függvényét INSERT
. Megadható egy alapértelmezett érték; azonban NEWID
nem adható meg alapértelmezettként.
IDENTITÁS
Azt jelzi, hogy az új oszlop egy identitásoszlop. Amikor új sort ad hozzá a táblához, az SQL Server egyedi, növekményes értéket biztosít az oszlophoz. Az identitásoszlopokat általában korlátozásokkal PRIMARY KEY
együtt használják a tábla egyedi sorazonosítójaként. A IDENTITY
tulajdonság tinyint, smallint, int, bigint, decimal(p,0) vagy numeric(p,0) oszlopokhoz rendelhető. Táblánként csak egy identitásoszlop hozható létre. A kötött alapértelmezett értékek és DEFAULT
korlátozások nem használhatók identitásoszloppal. Meg kell adnia a magot és a növekményt is, vagy egyiket sem. Ha egyik sincs megadva, az alapértelmezett érték (1,1).
IDENTITY
nem adható meg CLR-táblaértékű függvényekhez.
vetőmag
A táblázat első sorához rendelendő egész szám.
növekményes
A tábla egymást követő sorainak kezdőértékéhez hozzáadandó egész szám.
<column_constraint> ::= és <table_constraint> ::=
Meghatározza egy adott oszlop vagy tábla korlátját. CLR-függvények esetén az egyetlen megengedett kényszertípus a NULL
. Az elnevezett korlátozások nem engedélyezettek.
NULL | NOT NULL
Meghatározza, hogy a null értékek megengedettek-e az oszlopban.
NULL
nem szigorúan korlátozás, de ugyanúgy megadható, mint .NOT NULL
NOT NULL
nem adható meg CLR-táblaértékű függvényekhez.
ELSŐDLEGES KULCS
Olyan korlátozás, amely egy adott oszlop entitásintegritását egy egyedi indexen keresztül kényszeríti ki. A tábla értékű, felhasználó által definiált függvényekben a PRIMARY KEY
korlátozás táblánként csak egy oszlopon hozható létre.
PRIMARY KEY
nem adható meg CLR-táblaértékű függvényekhez.
EGYEDÜLÁLLÓ
Olyan korlátozás, amely egy adott oszlop vagy oszlop entitásintegritást biztosít egy egyedi indexen keresztül. Egy táblának több UNIQUE
megkötése is lehet.
UNIQUE
nem adható meg CLR-táblaértékű függvényekhez.
FÜRTÖZÖTT | NEMCLUSTERED
Jelezze, hogy fürtözött vagy nem fürtözött index jön létre a PRIMARY KEY
vagy UNIQUE
korlátozáshoz.
PRIMARY KEY
megkötések használata CLUSTERED
, és UNIQUE
kényszerek használata NONCLUSTERED
.
CLUSTERED
csak egy korlátozáshoz adható meg. Ha CLUSTERED
meg van adva egy UNIQUE
korlátozáshoz, és egy PRIMARY KEY
korlátozás is meg van adva, akkor a PRIMARY KEY
.NONCLUSTERED
CLUSTERED
és NONCLUSTERED
nem adható meg CLR-táblaértékű függvényekhez.
ELLENŐRIZ
Olyan kényszer, amely a tartomány integritását kényszeríti ki az oszlopokba vagy oszlopokba beírható lehetséges értékek korlátozásával.
CHECK
a CLR-táblaértékű függvényekhez nem adhatók meg megkötések.
logical_expression
Logikai kifejezés, amely a TRUE
vagy .FALSE
< > computed_column_definition ::=
Számított oszlopot ad meg. További információ a számított oszlopokról: TÁBLA LÉTREHOZÁSA (Transact-SQL).
column_name
A számított oszlop neve.
computed_column_expression
Egy számított oszlop értékét meghatározó kifejezés.
< > index_option ::=
Megadja a PRIMARY KEY
vagy UNIQUE
index indexelési beállításait. További információ az indexelési lehetőségekről: INDEX LÉTREHOZÁSA (Transact-SQL).
PAD_INDEX = { ON | KI }
Az indexek kitöltését adja meg. Az alapértelmezett érték a OFF
.
FILLFACTOR = fillfactor
Megadja azt a százalékot, amely azt jelzi, hogy az adatbázismotor mennyire töltse fel az egyes indexoldalak levélszintjét az index létrehozása vagy módosítása során. A fillfactor értékének 1 és 100 közötti egész számnak kell lennie. Az alapértelmezett érték 0.
IGNORE_DUP_KEY = { ON | KI }
Megadja a hibaválaszt, amikor egy beszúrási művelet ismétlődő kulcsértékeket próbál beszúrni egy egyedi indexbe. A IGNORE_DUP_KEY
beállítás csak az index létrehozása vagy újraépítése után történő beszúrási műveletekre vonatkozik. Az alapértelmezett érték a OFF
.
STATISTICS_NORECOMPUTE = { ON | KI }
Megadja, hogy az eloszlási statisztikák újraszámításra kerüljenek-e. Az alapértelmezett érték a OFF
.
ALLOW_ROW_LOCKS = { ON | KI }
Megadja, hogy engedélyezettek-e a sorzárolások. Az alapértelmezett érték a ON
.
ALLOW_PAGE_LOCKS = { ON | KI }
Megadja, hogy engedélyezettek-e az oldalzárolások. Az alapértelmezett érték a ON
.
Ajánlott eljárások
Ha nem jön létre felhasználó által definiált függvény a SCHEMABINDING
záradékkal, a mögöttes objektumokon végrehajtott módosítások hatással lehetnek a függvény definíciójára, és váratlan eredményeket hozhatnak létre a meghívásakor. Javasoljuk, hogy az alábbi módszerek egyikét alkalmazza annak biztosítására, hogy a függvény ne váljon elavulttá a mögöttes objektumok változásai miatt:
Adja meg a záradékot
WITH SCHEMABINDING
a függvény létrehozásakor. Ez a beállítás biztosítja, hogy a függvénydefinícióban hivatkozott objektumok ne módosíthatók, kivéve, ha a függvény is módosul.Hajtsa végre a sp_refreshsqlmodule tárolt eljárást a függvény definíciójában megadott objektumok módosítása után.
A beágyazott táblaértékű függvényekkel (beágyazott TVF-ekkel) és a többutasításos táblaértékű függvényekkel (MSTVF-ekkel) kapcsolatos további információkért és teljesítménnyel kapcsolatos szempontokért lásd: Felhasználó által definiált függvények létrehozása (adatbázismotor).
Adattípusok
Ha a paraméterek meg vannak adva egy CLR-függvényben, akkor azoknak SQL Server típusoknak kell lenniük a scalar_parameter_data_type korábban meghatározottak szerint. További információ az SQL Server rendszeradattípusok és a CLR-integrációs adattípusok vagy a .NET-keretrendszer közös nyelvi futásidejű adattípusainak összehasonlításáról: CLR-paraméteradatok leképezése.
Ahhoz, hogy SQL Server a megfelelő metódusra hivatkozzon, amikor túlterhelt egy osztályban, a következő <method_specifier>
jellemzőkkel kell rendelkeznie:
- Ugyanannyi paramétert kapjon, mint amennyit a
[ , ...n ]
. - Az összes paramétert érték szerint kapja meg, ne hivatkozás alapján.
- Használjon olyan paramétertípusokat, amelyek kompatibilisek a SQL Server függvényben megadott típusokkal.
Ha a CLR függvény visszatérési adattípusa táblatípust ()RETURNS TABLE
ad meg, akkor a metódus <method_specifier>
visszatérési adattípusának vagy típusúnak IEnumerator
IEnumerable
kell lennie, és feltételezi, hogy a felületet a függvény létrehozója valósította meg. A Transact-SQL függvényektől eltérően a CLR-függvények nem tartalmazhatnak PRIMARY KEY
, , UNIQUE
vagy CHECK
megkötéseket a <table_type_definition>
. A megadott <table_type_definition>
oszlopok adattípusainak meg kell egyezniük a metódus <method_specifier>
által a végrehajtáskor visszaadott eredményhalmaz megfelelő oszlopainak típusaival. Ez a típusellenőrzés nem történik meg a függvény létrehozásakor.
A CLR-függvények programozásával kapcsolatos további információkért lásd: CLR User-Defined függvények.
Megjegyzések
A skaláris függvények skaláris kifejezések használata esetén hívhatók meg, amelyek közé tartoznak a számított oszlopok és CHECK
a megkötési definíciók. A skaláris függvények az EXECUTE (Transact-SQL) utasítással is végrehajthatók. A skaláris függvényeket legalább a függvény kétrészes nevének (<schema>.<function>
) használatával kell meghívni. A többrészes nevekről további információt a Transact-SQL Szintaktikai konvenciók (Transact-SQL) című témakörben talál. A táblaértékű függvények akkor hívhatók meg, ha a táblakifejezések engedélyezettek a FROM
, , vagy SELECT
INSERT
utasítások záradékábanUPDATE
DELETE
. További információ: Felhasználó által definiált függvények végrehajtása.
Interoperabilitás
A következő utasítások érvényesek egy függvényben:
- Hozzárendelési utasítások.
- Folyamatirányítási utasítások, kivéve
TRY...CATCH
az utasításokat. -
DECLARE
Helyi adatváltozókat és helyi kurzorokat meghatározó utasítások. -
SELECT
olyan utasításokat, amelyek olyan kifejezéseket tartalmaznak, amelyek értékeket rendelnek a helyi változókhoz. - A függvényben deklarált, megnyitott, bezárt és felszabadított helyi kurzorokra hivatkozó kurzorműveletek. Csak
FETCH
azok az utasítások engedélyezettek, amelyek a záradék használatávalINTO
helyi változókhoz rendelnek értékeket;FETCH
az ügyfeleknek adatokat visszaadó utasítások nem engedélyezettek. -
INSERT
,UPDATE
és aDELETE
helyi táblaváltozókat módosító utasításokat. -
EXECUTE
kiterjesztett tárolt eljárásokat hívó utasítások.
További információ: Felhasználó által definiált függvények létrehozása (adatbázismotor).
Számított oszlopok együttműködési képessége
A függvények a következő tulajdonságokkal rendelkeznek. Ezeknek a tulajdonságoknak az értékei határozzák meg, hogy a függvények használhatók-e olyan számított oszlopokban, amelyek megőrzhetők vagy indexelhetők.
Ingatlan | Leírás | Jegyzetek |
---|---|---|
IsDeterministic |
A függvény determinisztikus vagy nem determinisztikus. | A helyi adathozzáférés determinisztikus függvényekben engedélyezett. Például azok a függvények, amelyek mindig ugyanazt az eredményt adják vissza, amikor egy adott bemeneti értékkészlettel hívják meg őket, és az adatbázis azonos állapotával rendelkeznek, determinisztikusnak lesznek címkézve. |
IsPrecise |
A funkció pontos vagy pontatlan. | A pontatlan függvények olyan műveleteket tartalmaznak, mint a lebegőpontos műveletek. |
IsSystemVerified |
A függvény pontossági és determinizmusi tulajdonságait az SQL Server ellenőrizheti. | |
SystemDataAccess |
A függvény hozzáfér a rendszeradatokhoz (rendszerkatalógusokhoz vagy virtuális rendszertáblákhoz) a SQL Server helyi példányában. | |
UserDataAccess |
A függvény a SQL Server helyi példányában fér hozzá a felhasználói adatokhoz. | Tartalmazza a felhasználó által definiált táblákat és az ideiglenes táblákat, de a táblaváltozókat nem. |
A Transact-SQL függvények pontossági és determinizmusi tulajdonságait az SQL Server automatikusan határozza meg. A CLR-függvények adathozzáférési és determinizmusi tulajdonságait a felhasználó adhatja meg. További információ: CLR-integráció: egyéni attribútumok CLR-rutinokhoz.
A tulajdonságok aktuális értékeinek megjelenítéséhez használja az OBJEKTUMTULAJDONSÁGEX (Transact-SQL) parancsot.
Fontos
A függvényeket determinisztikusnak kell létrehozni SCHEMABINDING
.
A felhasználó által definiált függvényt meghívó számított oszlop akkor használható egy indexben, ha a felhasználó által definiált függvény a következő tulajdonságértékekkel rendelkezik:
-
IsDeterministic
vantrue
-
IsSystemVerified
istrue
(kivéve, ha a számított oszlop megmarad) -
UserDataAccess
vanfalse
-
SystemDataAccess
vanfalse
A számított oszlopok indexeiről további információkért lásd a éshivatkozást.
Kiterjesztett tárolt eljárások hívása függvényekből
A kiterjesztett tárolt eljárás egy függvényen belülről hívja meg, és nem tud eredményhalmazokat visszaadni az ügyfélnek. Minden olyan ODS API, amely eredményhalmazokat ad vissza az ügyfélnek, visszaadja FAIL
a . A kiterjesztett tárolt eljárás visszacsatlakozhat a SQL Server egy példányához; Azonban nem szabad ugyanahhoz a tranzakcióhoz csatlakoznia, mint a kiterjesztett tárolt eljárást meghívó függvény.
A kötegből vagy tárolt eljárásból származó hívásokhoz hasonlóan a kiterjesztett tárolt eljárás annak a Windows biztonsági fióknak a kontextusában történik, amely alatt SQL Server fut. A tárolt eljárás tulajdonosának figyelembe kell vennie ezt a forgatókönyvet, amikor engedélyt ad EXECUTE
a felhasználóknak.
Korlátozások
A felhasználó által definiált függvények nem használhatók az adatbázis állapotát módosító műveletek végrehajtására.
A felhasználó által definiált függvények nem tartalmazhatnak olyan OUTPUT INTO
záradékot, amelynek célja egy tábla.
A következő Service Broker utasítások nem szerepelhetnek egy Transact-SQL felhasználó által definiált függvény definíciójában:
BEGIN DIALOG CONVERSATION
END CONVERSATION
GET CONVERSATION GROUP
MOVE CONVERSATION
RECEIVE
SEND
A felhasználó által definiált függvények beágyazhatók; vagyis egy felhasználó által definiált függvény meghívhat egy másikat. A beágyazási szint növekszik, amikor a hívott függvény elkezdi a végrehajtást, és csökken, amikor a hívott függvény befejezi a végrehajtást. A felhasználó által definiált függvények legfeljebb 32 szintbe ágyazhatók. Ha túllépi a beágyazás maximális szintjét, a teljes hívófüggvénylánc meghiúsul. A Transact-SQL felhasználó által definiált függvényekből származó felügyelt kódra való hivatkozás egy szintnek számít a 32 szintű beágyazási korláttal szemben. A felügyelt kódból meghívott metódusok nem számítanak bele ebbe a korlátba.
Rendezési sorrend használata CLR táblázatértékű függvényekben
Ha a záradékot ORDER
CLR-táblaértékű függvényekben használja, kövesse az alábbi irányelveket:
Gondoskodnia kell arról, hogy az eredmények mindig a megadott sorrendben legyenek rendezve. Ha az eredmények nem a megadott sorrendben vannak, SQL Server hibaüzenetet generál a lekérdezés végrehajtásakor.
Ha egy
ORDER
záradék meg van adva, a táblaértékű függvény kimenetét az oszlop (explicit vagy implicit) rendezése szerint kell rendezni. Ha például az oszloprendezés kínai, a visszaadott eredményeket a kínai rendezési szabályok szerint kell rendezni. (A rendezés vagy a táblaértékű függvény DDL-jében van megadva, vagy az adatbázis-rendezésből származik.)SQL Server mindig ellenőrzi a záradékot
ORDER
, ha meg van adva, miközben eredményeket ad vissza, függetlenül attól, hogy a lekérdezésfeldolgozó használja-e azt további optimalizálások végrehajtására. Csak akkor használja a záradékotORDER
, ha tudja, hogy hasznos a lekérdezésfeldolgozó számára.A SQL Server lekérdezésfeldolgozó automatikusan kihasználja a záradék előnyeit
ORDER
a következő esetekben:- Szúrjon be olyan lekérdezéseket, ahol a
ORDER
záradék kompatibilis egy indexszel. -
ORDER BY
záradékokkal összeegyeztethetőORDER
záradékok. - Aggregátumok, ahol
GROUP BY
összeegyeztethető aORDER
záradékkal. -
DISTINCT
összesítések, ahol a különböző oszlopok kompatibilisek aORDER
záradékkal.
- Szúrjon be olyan lekérdezéseket, ahol a
A ORDER
záradék nem garantálja a rendezett eredményeket a SELECT
lekérdezés végrehajtásakor, kivéve, ha ORDER BY
a lekérdezésben is meg van adva. A táblaértékű függvények rendezési sorrendjében szereplő oszlopok lekérdezésével kapcsolatos információkért lásd: sys.function_order_columns (Transact-SQL).
Metaadatok
Az alábbi táblázat felsorolja azokat a rendszerkatalógus-nézeteket, amelyek segítségével a felhasználó által definiált függvények metaadatait adhatja vissza.
Rendszernézet | Leírás |
---|---|
sys.sql_modulok | Lásd az E példát a Példák szakaszban. |
sys.assembly_modules | Információkat jelenít meg a CLR felhasználó által definiált funkcióiról. |
sys.paraméterek | Információkat jelenít meg a felhasználó által definiált függvényekben definiált paraméterekről. |
sys.sql_kifejezés_függőségek | Megjeleníti a függvény által hivatkozott mögöttes objektumokat. |
Engedélyek
CREATE FUNCTION
engedélyt igényel az adatbázisban, és ALTER
engedélyt arra a sémára, amelyben a függvény létrejön. Ha a függvény felhasználó által definiált típust ad meg, EXECUTE
engedély szükséges a típushoz.
Példák
Az UDF-ekkel kapcsolatos további példákért és teljesítménnyel kapcsolatos szempontokért lásd: Felhasználó által definiált függvények létrehozása (adatbázismotor).
Egy. Skaláris értékű felhasználó által definiált függvény használata, amely kiszámítja az ISO hetet
Az alábbi példa létrehozza a felhasználó által definiált függvényt ISOweek
. Ez a függvény egy dátum argumentumot vesz fel, és kiszámítja az ISO hét számát. Ahhoz, hogy ez a függvény helyesen számítson, SET DATEFIRST 1
a függvény meghívása előtt meg kell hívni.
A példa azt is bemutatja, hogy az EXECUTE AS záradék (Transact-SQL) záradékot használja annak a biztonsági környezetnek a megadásához, amelyben a tárolt eljárás végrehajtható. A példában a beállítás CALLER
azt adja meg, hogy az eljárás az azt meghívó felhasználó környezetében legyen végrehajtva. A további megadható beállítások a SELF
, OWNER
a , és a user_name.
Itt van a függvényhívás.
DATEFIRST
1
értékre van állítva.
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';
Itt van az eredmények összessége.
ISO Week
----------------
52
B. Beágyazott táblaértékű függvény létrehozása
Az alábbi példa egy beágyazott táblaértékű függvényt ad vissza az AdventureWorks2022 adatbázisban. Három oszlopot ProductID
ad vissza, Name
, és az üzletnek YTD Total
értékesített összes termék éves összegének összesítését adja vissza.
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
INNER JOIN Sales.SalesOrderDetail AS SD ON SD.ProductID = P.ProductID
INNER JOIN Sales.SalesOrderHeader AS SH ON SH.SalesOrderID = SD.SalesOrderID
INNER JOIN Sales.Customer AS C ON SH.CustomerID = C.CustomerID
WHERE C.StoreID = @storeid
GROUP BY P.ProductID, P.Name
);
GO
A függvény meghívásához futtassa ezt a lekérdezést.
SELECT * FROM Sales.ufn_SalesByStore (602);
C. Többutasításos táblaértékű függvény létrehozása
Az alábbi példa létrehozza a táblaértékű függvényt fn_FindReports(InEmpID)
az AdventureWorks2022
adatbázisban. Érvényes alkalmazotti azonosító esetén a függvény egy táblát ad vissza, amely megfelel az összes olyan alkalmazottnak, aki közvetlenül vagy közvetve jelentést tesz az alkalmazottnak. A függvény egy rekurzív közös táblakifejezést (CTE) használ az alkalmazottak hierarchikus listájának előállításához. A rekurzív CTE-kkel kapcsolatos további információkért lásd: WITH common_table_expression (Transact-SQL).
CREATE FUNCTION dbo.ufn_FindReports (@InEmpID INT)
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,
OrganizationNode = ISNULL(e.OrganizationNode, CAST('/' AS HIERARCHYID)),
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. CLR-függvény létrehozása
A példa CLR-függvényt len_s
hoz létre. A függvény létrehozása előtt a szerelvény SurrogateStringFunction.dll
regisztrálva lesz a helyi adatbázisban.
A következőkre vonatkozik: SQL Server 2008 (10.0.x) SP 1 és újabb verziók.
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
A CLR táblaértékű függvények létrehozására vonatkozó példát a CLR Table-Valued függvények című témakörben talál.
E. Felhasználó által definiált függvények definíciójának megjelenítése
SELECT DEFINITION,
type
FROM sys.sql_modules AS m
INNER JOIN sys.objects AS o
ON m.object_id = o.object_id
AND type IN ('FN', 'IF', 'TF');
GO
A beállítással létrehozott ENCRYPTION
függvények definíciója nem tekinthető meg a használatával sys.sql_modules
, de a titkosított függvényekkel kapcsolatos egyéb információk megjelennek.
Kapcsolódó tartalom
- Felhasználó által definiált függvények (adatbázismotor) létrehozása
- ALTER FÜGGVÉNY (Transact-SQL)
- DROP függvény (Transact-SQL)
- OBJECTPROPERTYEX (Transact-SQL)
- sys.sql_modulok (Transact-SQL)
- sys.assembly_modules (Transact-SQL)
- EXECUTE (Transact-SQL)
- CLR User-Defined függvények
- ESEMÉNYADATOK (Transact-SQL)
- BIZTONSÁGI SZABÁLYZAT LÉTREHOZÁSA (Transact-SQL)