CREATE FÜGGVÉNY (Transact-SQL)

2025-06-28

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 az SCHEMABINDING 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 rendelkezik REFERENCES 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 , NULLané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ó, NULLvagy 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. NULLnem 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 IEnumeratorIEnumerablekell 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, , UNIQUEvagy 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 SELECTINSERT utasítások záradékábanUPDATEDELETE. 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ával INTO helyi változókhoz rendelnek értékeket; FETCH az ügyfeleknek adatokat visszaadó utasítások nem engedélyezettek.
INSERT, UPDATEés a DELETE 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 van true
IsSystemVerified is true (kivéve, ha a számított oszlop megmarad)
UserDataAccess van false
SystemDataAccess van false

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 FAILa . 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ékot ORDER , 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ő a ORDER záradékkal.
- DISTINCT összesítések, ahol a különböző oszlopok kompatibilisek a ORDER záradékkal.

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, OWNERa , é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 ProductIDad 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_shoz 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.

Megosztás a következőn keresztül:

CREATE FÜGGVÉNY (Transact-SQL)

Szemantika

Érvek

VAGY ALTER

schema_name

function_name

@parameter_name

[ type_schema_name. ] parameter_data_type

[ = alapértelmezett ]

CSAK OLVASHATÓ

return_data_type

function_body

scalar_expression

ASZTAL

select_stmt

VÉGZÉS (<order_clause)>

KÜLSŐ NÉV <method_specifier>assembly_name.class_name. method_name

<table_type_definition> ( { <column_definition><column_constraint | <computed_column_definition> } [ <table_constraint> ] [ , ... n ] )

<clr_table_type_definition> ( { column_namedata_type } [ , ... n ] )

NULL | NOT NULL

NATIVE_COMPILATION

KEZDJE AZ ATOMIC-OT

SÉMAKÖTÉS

VÉGREHAJTÁS MÁSKÉNT

<function_option> ::= és <clr_function_option> ::=

TITKOSÍTÁS

SÉMAKÖTÉS

NULL ÉRTÉKET AD VISSZA NULL BEMENETRE | NULL BEMENETRE HÍVOTT

VÉGREHAJTÁS MÁSKÉNT

BEÁGYAZOTT = { BE | KI }

< > column_definition ::=

column_name

data_type

ALAPÉRTELMEZETT constant_expression

COLLATION_NAME RENDEZÉSE

ROWGUIDCOL

IDENTITÁS

vetőmag

növekményes

<column_constraint> ::= és <table_constraint> ::=

NULL | NOT NULL

ELSŐDLEGES KULCS

EGYEDÜLÁLLÓ

FÜRTÖZÖTT | NEMCLUSTERED

ELLENŐRIZ

logical_expression

< > computed_column_definition ::=

column_name

computed_column_expression

< > index_option ::=

PAD_INDEX = { ON | KI }

FILLFACTOR = fillfactor

IGNORE_DUP_KEY = { ON | KI }

STATISTICS_NORECOMPUTE = { ON | KI }

ALLOW_ROW_LOCKS = { ON | KI }

ALLOW_PAGE_LOCKS = { ON | KI }

Ajánlott eljárások

Adattípusok

Megjegyzések

Interoperabilitás

Számított oszlopok együttműködési képessége

Kiterjesztett tárolt eljárások hívása függvényekből

Korlátozások

Rendezési sorrend használata CLR táblázatértékű függvényekben

Metaadatok

Engedélyek

Példák

Egy. Skaláris értékű felhasználó által definiált függvény használata, amely kiszámítja az ISO hetet

B. Beágyazott táblaértékű függvény létrehozása

C. Többutasításos táblaértékű függvény létrehozása

D. CLR-függvény létrehozása

E. Felhasználó által definiált függvények definíciójának megjelenítése

Kapcsolódó tartalom

Visszajelzés

További források