ඇතුළත් කළ පේළියේ අනන්‍යතාවය ලබා ගැනීමට හොඳම ක්‍රමය කුමක්ද?

IDENTITYඇතුළත් කළ පේළිය ලබා ගැනීමට හොඳම ක්‍රමය කුමක්ද?

මම දන්නවා @@IDENTITY හා IDENT_CURRENTහා SCOPE_IDENTITYනමුත්, එක් එක් අනුයුක්ත වාසි සහ අවාසි තේරෙන්නේ නැහැ.

කරුණාකර යමෙකුට වෙනස්කම් පැහැදිලි කළ හැකිද?

• @@IDENTITYවත්මන් සැසියේ ඕනෑම වගුවක් සඳහා ජනනය කරන ලද අවසාන අනන්‍යතා අගය, සියලු විෂය පථයන් හරහා ලබා දෙයි. ඔබ මෙහි පරෙස්සම් විය යුතුය , මන්ද එය විෂය පථයන් හරහා ය. ඔබගේ වර්තමාන ප්‍රකාශය වෙනුවට ප්‍රේරකයකින් ඔබට වටිනාකමක් ලබා ගත හැකිය.

• SCOPE_IDENTITY()වත්මන් සැසියේ ඕනෑම වගුවක් සඳහා ජනනය කරන ලද අවසාන අනන්‍යතා අගය සහ වත්මන් විෂය පථය ලබා දෙයි. සාමාන්යයෙන් ඔබට භාවිතා කිරීමට අවශ්ය දේ .

• IDENT_CURRENT('tableName')ඕනෑම සැසියක සහ ඕනෑම විෂය පථයක නිශ්චිත වගුවක් සඳහා ජනනය කරන ලද අවසාන අනන්‍යතා අගය ලබා දෙයි. ඉහත දෙක ඔබට අවශ්‍ය දේ නොවන්නේ නම් ( ඉතා කලාතුරකිනි ) ඔබට වටිනාකම අවශ්‍ය කුමන වගුවෙන්ද යන්න සඳහන් කිරීමට මෙය ඔබට ඉඩ දෙයි . එසේම, @ ගයි ස්ටාර්බක් සඳහන් කළ පරිදි, "ඔබ වාර්තාවක් ඇතුළත් නොකළ වගුවක් සඳහා වත්මන් හැඳුනුම් වටිනාකම ලබා ගැනීමට අවශ්‍ය නම් ඔබට මෙය භාවිතා කළ හැකිය."

• මෙම OUTPUTවගන්තිය පිළිබඳ INSERTප්රකාශයක් ඔබ ඇතුළත් කළ බව එම ප්රකාශය හරහා සෑම පේළිය ප්රවේශ ඉඩ ඇත. එය නිශ්චිත ප්‍රකාශයට විෂය පථය කර ඇති බැවින්, එය ඉහත සඳහන් අනෙක් කාර්යයන්ට වඩා සරල ය. කෙසේ වෙතත්, එය තව ටිකක් වාචිකය (ඔබට වගු විචල්‍ය / තාවකාලික වගුවකට ඇතුළු කර එය විමසිය යුතුය) තවද එය ප්‍රකාශය පෙරළා දැමූ දෝෂ සහිත අවස්ථාවකදී පවා ප්‍රති results ල ලබා දේ. ඔබේ විමසුම සමාන්තර ක්‍රියාත්මක කිරීමේ සැලැස්මක් භාවිතා කරන්නේ නම් , අනන්‍යතාවය ලබා ගැනීම සඳහා සහතික කළ හැකි එකම ක්‍රමය මෙයයි (සමාන්තරකරණය අක්‍රිය කිරීම කෙටි). කෙසේ වෙතත්, එය ප්‍රේරකයට පෙර ක්‍රියාත්මක වන අතර ප්‍රේරක ජනනය කළ අගයන් ආපසු ලබා දීමට භාවිතා කළ නොහැක.

ඇතුළත් කළ හැඳුනුම්පත නැවත ලබා ගැනීමේ ආරක්ෂිතම හා නිවැරදි ක්‍රමය වනුයේ ප්‍රතිදාන වගන්තිය භාවිතා කරනු ඇතැයි මම විශ්වාස කරමි.

උදාහරණයක් ලෙස (පහත දැක්වෙන කරුණු වලින් ගනු ලැබේ MSDN ලිපියෙන් ගත්)

USE AdventureWorks2008R2;
GO
DECLARE @MyTableVar table( NewScrapReasonID smallint,
                           Name varchar(50),
                           ModifiedDate datetime);
INSERT Production.ScrapReason
    OUTPUT INSERTED.ScrapReasonID, INSERTED.Name, INSERTED.ModifiedDate
        INTO @MyTableVar
VALUES (N'Operator error', GETDATE());

--Display the result set of the table variable.
SELECT NewScrapReasonID, Name, ModifiedDate FROM @MyTableVar;
--Display the result set of the table.
SELECT ScrapReasonID, Name, ModifiedDate 
FROM Production.ScrapReason;
GO

මම කියන්නේ අනිත් කොල්ලන්ට වගේමයි, ඒ නිසා හැමෝම නිවැරදියි, මම උත්සාහ කරන්නේ එය වඩාත් පැහැදිලි කිරීමටයි.

@@IDENTITY ඔබේ සේවාදායකයාගේ සම්බන්ධතාවය මඟින් දත්ත ගබඩාවට ඇතුළත් කළ අවසන් දෙයෙහි හැඳුනුම්පත නැවත ලබා දෙයි.
බොහෝ විට මෙය හොඳින් ක්‍රියාත්මක වේ, නමුත් සමහර විට ප්‍රේරකයක් ගොස් ඔබ නොදන්නා නව පේළියක් ඇතුල් කරනු ඇත, ඔබට අවශ්‍ය පේළිය වෙනුවට මෙම නව පේළියෙන් හැඳුනුම්පත ලැබෙනු ඇත.

SCOPE_IDENTITY()මෙම ගැටළුව විසඳයි. එය ඔබ එවූ SQL කේතයේ අවසන් වරට ඇතුළත් කළ හැඳුනුම්පත ලබා දෙයි දත්ත ගබඩාවට . ප්‍රේරක ගොස් අමතර පේළි නිර්මාණය කරන්නේ නම්, ඒවා වැරදි අගයක් ආපසු ලබා නොදෙනු ඇත. හුරේ

IDENT_CURRENTඕනෑම අයෙකු විසින් ඇතුළත් කළ අවසන් හැඳුනුම්පත ආපසු ලබා දෙයි. අනපේක්ෂිත වේලාවක වෙනත් පේළියක් ඇතුළු කිරීමට වෙනත් යෙදුමක් සිදුවුවහොත්, ඔබේ පේළිය වෙනුවට එම පේළියේ හැඳුනුම්පත ඔබට ලැබෙනු ඇත.

ඔබට එය ආරක්ෂිතව සෙල්ලම් කිරීමට අවශ්‍ය නම්, සෑම විටම භාවිතා කරන්න SCOPE_IDENTITY(). ඔබ පසුව රැඳී සිටිමින් @@IDENTITYයමෙකු පසුව ප්‍රේරකයක් එක් කිරීමට තීරණය කළහොත් , ඔබගේ සියලු කේත කැඩී යනු ඇත.

අලුතින් ඇතුළත් කළ පේළියක අනන්‍යතාවය ලබා ගැනීම සඳහා හොඳම (කියවන්න: ආරක්ෂිත) ක්‍රමය වන්නේ outputවගන්තිය භාවිතා කිරීමෙනි :

create table TableWithIdentity
           ( IdentityColumnName int identity(1, 1) not null primary key,
             ... )

-- type of this table's column must match the type of the
-- identity column of the table you'll be inserting into
declare @IdentityOutput table ( ID int )

insert TableWithIdentity
     ( ... )
output inserted.IdentityColumnName into @IdentityOutput
values
     ( ... )

select @IdentityValue = (select ID from @IdentityOutput)

එකතු කරන්න

SELECT CAST(scope_identity() AS int);

ඔබගේ ඇතුළත් කිරීමේ SQL ප්‍රකාශයේ අවසානය දක්වා

NewId = command.ExecuteScalar()

එය ලබා ගනී.

ඔබ ආයතන රාමුව භාවිතා කරන විට, එය අභ්‍යන්තරව OUTPUTඅළුතින් ඇතුළු කරන ලද හැඳුනුම්පත් අගය ආපසු ලබා දීමට තාක්ෂණය භාවිතා කරයි

DECLARE @generated_keys table([Id] uniqueidentifier)

INSERT INTO TurboEncabulators(StatorSlots)
OUTPUT inserted.TurboEncabulatorID INTO @generated_keys
VALUES('Malleable logarithmic casing');

SELECT t.[TurboEncabulatorID ]
FROM @generated_keys AS g 
   JOIN dbo.TurboEncabulators AS t 
   ON g.Id = t.TurboEncabulatorID 
WHERE @@ROWCOUNT > 0

ප්‍රතිදාන ප්‍රති results ල තාවකාලික වගු විචල්‍යයක ගබඩා කර ඇති අතර, නැවත මේසයට සම්බන්ධ වී පේළි අගය මේසයෙන් පිටතට ගෙන එයි.

සටහන: ඊඑෆ් අභ්‍යන්තරික කාලානුරූපී වගුවට නැවත සැබෑ වගුවට සම්බන්ධ වන්නේ මන්දැයි මා දන්නේ නැත (කුමන තත්වයන් යටතේ දෙදෙනා නොගැලපේ).

නමුත් ඊඑෆ් කරන්නේ එයයි.

මෙම තාක්ෂණය ( OUTPUT) ලබා ගත හැක්කේ SQL Server 2008 හෝ නවතම ඒවා මත පමණි.

සංස්කරණය කරන්න - සම්බන්ධ වීමට හේතුව

හුදෙක් OUTPUTඅගයන් භාවිතා කරනවාට වඩා, ආයතන රාමුව මුල් වගුවට සම්බන්ධ වීමට හේතුව, rowversionඅලුතින් ඇතුළත් කළ පේළියක් ලබා ගැනීම සඳහා ඊඑෆ් ද මෙම තාක්ෂණය භාවිතා කරන බැවිනි .

ඔබ විසින් ඔබගේ ආයතනයක් රාමුව ආකෘති සර්ව සුභවාදී සමගාමී භාවිතා කළ හැකි භාවිතා Timestampවිශේෂණය: ^🕗

public class TurboEncabulator
{
   public String StatorSlots)

   [Timestamp]
   public byte[] RowVersion { get; set; }
}

ඔබ මෙය කරන විට, ආයතන රාමුවට rowversionඅලුතින් ඇතුළත් කළ පේළිය අවශ්‍ය වේ:

DECLARE @generated_keys table([Id] uniqueidentifier)

INSERT INTO TurboEncabulators(StatorSlots)
OUTPUT inserted.TurboEncabulatorID INTO @generated_keys
VALUES('Malleable logarithmic casing');

SELECT t.[TurboEncabulatorID], t.[RowVersion]
FROM @generated_keys AS g 
   JOIN dbo.TurboEncabulators AS t 
   ON g.Id = t.TurboEncabulatorID 
WHERE @@ROWCOUNT > 0

මෙය ලබා ගැනීම සඳහා Timetsampඔබට වගන්තියක් භාවිතා කළ නොහැකOUTPUT .

එයට හේතුව මේසය මත ප්‍රේරකයක් තිබේ නම්, Timestampඔබ පිටවන ඕනෑම දෙයක් වැරදියි:

• ආරම්භක ඇතුළු කිරීම. කාලරාමුව: 1
• OUTPUT වගන්තිය මඟින් කාලරාමුව ප්‍රතිදානය කරයි: 1
• ප්‍රේරකය පේළිය වෙනස් කරයි. කාලරාමුව: 2

ඔබ මේසය මත ප්‍රේරකයක් ඇත්නම් ආපසු ලබා දුන් කාලරාමුව කිසි විටෙකත් නිවැරදි නොවේ. එබැවින් ඔබ වෙනම භාවිතා කළ යුතුයSELECT .

ඔබ වැරදි පේළියකට ගොදුරු වීමට කැමති වුවද, වෙනමම සිදු කිරීමට ඇති අනෙක් හේතුව SELECTනම් ඔබට rowversionවගු විචල්‍යයකට පිටවිය නොහැකි වීමයි :

DECLARE @generated_keys table([Id] uniqueidentifier, [Rowversion] timestamp)

INSERT INTO TurboEncabulators(StatorSlots)
OUTPUT inserted.TurboEncabulatorID, inserted.Rowversion INTO @generated_keys
VALUES('Malleable logarithmic casing');

එය කිරීමට තුන්වන හේතුව සමමිතිය සඳහා ය. UPDATEප්‍රේරකයක් සමඟ මේසයක් මත ක්‍රියා කරන විට , ඔබට වගන්තියක් භාවිතා කළ නොහැකOUTPUT . UPDATEසමඟ උත්සාහ කිරීමට OUTPUTසහාය නොදක්වන අතර එය දෝෂයක් ලබා දෙනු ඇත:

• ප්‍රේරකයක් මේසය මත ඇති විට OUTPUT වගන්තිය සමඟ UPDATE භාවිතා කළ නොහැක

එය කළ හැකි එකම ක්‍රමය පසු විපරම් SELECTප්‍රකාශයක් පමණි:

UPDATE TurboEncabulators
SET StatorSlots = 'Lotus-O deltoid type'
WHERE ((TurboEncabulatorID = 1) AND (RowVersion = 792))

SELECT RowVersion
FROM TurboEncabulators
WHERE @@ROWCOUNT > 0 AND TurboEncabulatorID = 1

MSDN

@@ IDENTITY, SCOPE_IDENTITY, සහ IDENT_CURRENT සමාන කාර්යයන් වන අතර ඒවා වගුවක IDENTITY තීරුවට ඇතුළත් කළ අවසන් අගය නැවත ලබා දේ.

Session IDENTITY සහ SCOPE_IDENTITY වත්මන් සැසියේ ඕනෑම වගුවක ජනනය කරන ලද අවසාන අනන්‍යතා අගය ලබා දෙනු ඇත. කෙසේ වෙතත්, SCOPE_IDENTITY අගය ලබා දෙන්නේ වත්මන් විෂය පථය තුළ පමණි; Ent IDENTITY නිශ්චිත විෂය පථයකට සීමා නොවේ.

IDENT_CURRENT විෂය පථය සහ සැසිය අනුව සීමා නොවේ; එය නිශ්චිත වගුවකට සීමා වේ. IDENT_CURRENT ඕනෑම සැසියක සහ ඕනෑම විෂය පථයක නිශ්චිත වගුවක් සඳහා ජනනය කරන ලද අනන්‍යතා අගය ලබා දෙයි. වැඩි විස්තර සඳහා, IDENT_CURRENT බලන්න.

• IDENT_CURRENT යනු වගුවක් තර්කයක් ලෙස ගන්නා ශ්‍රිතයකි.
• @@ ඔබට මේසය මත ප්‍රේරකයක් ඇති විට IDENTITY ව්‍යාකූල ප්‍රති result ල ලබා දෙනු ඇත
• SCOPE_IDENTITY බොහෝ විට ඔබේ වීරයා වේ.

@@ අනන්යතාව , ඇතුළු වත්මන් SQL සම්බන්ධතාවය භාවිතා කරමින් පසුගිය අනන්යතාවය වේ. ඔබගේ නව වාර්තාව සඳහා ඇතුළත් කර ඇති අනන්‍යතාවය අවශ්‍ය වන, ඇතුළු කළ ගබඩා කළ ක්‍රියා පටිපාටියකින් ආපසු යාමට මෙය හොඳ අගයක් වන අතර, පසුව තවත් පේළි එකතු කර ඇත්දැයි නොසලකන්න.

SCOPE_IDENTITY යනු වත්මන් SQL සම්බන්ධතාවය භාවිතයෙන් ඇතුළු කරන ලද අවසාන අනන්‍යතාවය වන අතර, වර්තමාන විෂය පථය තුළ - එනම්, ඔබේ ඇතුළත් කිරීමෙන් පසු ප්‍රේරකයක් මත පදනම්ව දෙවන හැඳුනුම්පතක් ඇතුළත් කර ඇත්නම්, එය SCOPE_IDENTITY හි පිළිබිඹු නොවනු ඇත, ඔබ සිදු කළ ඇතුළු කිරීම පමණි . අවංකවම, මට මෙය භාවිතා කිරීමට හේතුවක් නැත.

IDENT_CURRENT (වගු නාමය ) යනු සම්බන්ධතාවය හෝ විෂය පථය නොසලකා ඇතුළත් කළ අවසන් අනන්‍යතාවයයි. ඔබ වාර්තාවක් ඇතුළත් කර නොමැති වගුවක් සඳහා වත්මන් IDENTITY අගය ලබා ගැනීමට අවශ්‍ය නම් ඔබට මෙය භාවිතා කළ හැකිය.

මට SQL සේවාදායකයේ වෙනත් සංස්කරණ සමඟ කතා කළ නොහැක, නමුත් 2012 දී ප්‍රතිදානය කිරීම කෙලින්ම ක්‍රියා කරයි. ඔබට තාවකාලික මේසයක් සමඟ කරදර වීමට අවශ්‍ය නැත.

INSERT INTO MyTable
OUTPUT INSERTED.ID
VALUES (...)

මාර්ගය වන විට, පේළි කිහිපයක් ඇතුළත් කිරීමේදී මෙම තාක්ෂණය ද ක්රියා කරයි.

INSERT INTO MyTable
OUTPUT INSERTED.ID
VALUES
    (...),
    (...),
    (...)

ප්‍රතිදානය

ID
2
3
4

සෑම විටම විෂය පථය () ​​භාවිතා කරන්න, වෙනත් කිසිවක් අවශ්‍ය නොවේ.

ඔබ ඇතුළු කරන පේළි වල අනන්‍යතාවය සහතික කිරීමට තවත් ක්‍රමයක් නම් අනන්‍යතා අගයන් නියම කර SET IDENTITY_INSERT ONපසුව භාවිතා කිරීමයි OFF. අනන්‍යතා අගයන් යනු කුමක්දැයි ඔබ හරියටම දන්නා බව මෙය සහතික කරයි! අගයන් භාවිතයේ නොමැති තාක් කල් ඔබට මෙම අගයන් අනන්‍යතා තීරුවට ඇතුළු කළ හැකිය.

CREATE TABLE #foo 
  ( 
     fooid   INT IDENTITY NOT NULL, 
     fooname VARCHAR(20) 
  ) 

SELECT @@Identity            AS [@@Identity], 
       Scope_identity()      AS [SCOPE_IDENTITY()], 
       Ident_current('#Foo') AS [IDENT_CURRENT] 

SET IDENTITY_INSERT #foo ON 

INSERT INTO #foo 
            (fooid, 
             fooname) 
VALUES      (1, 
             'one'), 
            (2, 
             'Two') 

SET IDENTITY_INSERT #foo OFF 

SELECT @@Identity            AS [@@Identity], 
       Scope_identity()      AS [SCOPE_IDENTITY()], 
       Ident_current('#Foo') AS [IDENT_CURRENT] 

INSERT INTO #foo 
            (fooname) 
VALUES      ('Three') 

SELECT @@Identity            AS [@@Identity], 
       Scope_identity()      AS [SCOPE_IDENTITY()], 
       Ident_current('#Foo') AS [IDENT_CURRENT] 

-- YOU CAN INSERT  
SET IDENTITY_INSERT #foo ON 

INSERT INTO #foo 
            (fooid, 
             fooname) 
VALUES      (10, 
             'Ten'), 
            (11, 
             'Eleven') 

SET IDENTITY_INSERT #foo OFF 

SELECT @@Identity            AS [@@Identity], 
       Scope_identity()      AS [SCOPE_IDENTITY()], 
       Ident_current('#Foo') AS [IDENT_CURRENT] 

SELECT * 
FROM   #foo 

ඔබ වෙනත් ප්‍රභවයකින් දත්ත පූරණය කරන්නේ නම් හෝ දත්ත සමුදායන් දෙකකින් දත්ත ඒකාබද්ධ කරන්නේ නම් මෙය ඉතා ප්‍රයෝජනවත් තාක්‍ෂණයකි.

A එකක් සාදා uuidඑය තීරුවකට ඇතුළු කරන්න. එවිට ඔබට පහසුවෙන් ඔබේ පේළිය uuid සමඟ හඳුනාගත හැකිය. ඔබට ක්‍රියාත්මක කළ හැකි එකම 100% වැඩ කරන විසඳුම එයයි. අනෙක් සියලුම විසඳුම් ඉතා සංකීර්ණ හෝ එකම අවස්ථා වලදී ක්‍රියා නොකරයි. උදා:

1) පේළිය සාදන්න

INSERT INTO table (uuid, name, street, zip) 
        VALUES ('2f802845-447b-4caa-8783-2086a0a8d437', 'Peter', 'Mainstreet 7', '88888');

2) සාදන ලද පේළිය ලබා ගන්න

SELECT * FROM table WHERE uuid='2f802845-447b-4caa-8783-2086a0a8d437';

මෙය පැරණි නූලක් වුවද, මෙය කිරීමට නව ක්‍රමයක් ඇත, එමඟින් සේවාදායකය නැවත පණගැන්වීමෙන් පසු අනන්‍යතා අගයන්හි ඇති හිඩැස් වැනි SQL සේවාදායකයේ පැරණි අනුවාදවල IDENTITY තීරුවේ ඇති සමහර අන්තරායන් මඟහරවා ගත හැකිය . අනුපිළිවෙල SQL Server 2016 හි ලබා ගත හැකි අතර ඉදිරියට යන නවතම ක්‍රමය වන්නේ TSQL භාවිතා කරමින් අනුක්‍රමික වස්තුවක් නිර්මාණය කිරීමයි. මෙය SQL සේවාදායකයේ ඔබේම සංඛ්‍යා අනුක්‍රමික වස්තුවක් නිර්මාණය කිරීමට සහ එය වැඩි වන ආකාරය පාලනය කිරීමට ඔබට ඉඩ සලසයි.

මෙන්න උදාහරණයක්:

CREATE SEQUENCE CountBy1  
    START WITH 1  
    INCREMENT BY 1 ;  
GO  

ඊළඟ අනුක්‍රමික හැඳුනුම්පත ලබා ගැනීම සඳහා TSQL හි ඔබ පහත සඳහන් දෑ කරනු ඇත:

SELECT NEXT VALUE FOR CountBy1 AS SequenceID
GO

CREATE SEQUENCE සහ NEXT VALUE FOR සඳහා සබැඳි මෙන්න

ඔබගේ ඇතුළත් කිරීමේ ප්‍රකාශයෙන් පසුව ඔබට මෙය එකතු කළ යුතුය. දත්ත ඇතුළු කරන වගුවේ නම ගැන වග බලා ගන්න.ඔබගේ ඇතුල් කිරීමේ ප්‍රකාශය මඟින් ඔබට පේළිය බලපාන්නේ නැති තැනට වත්මන් පේළිය ලැබෙනු ඇත.

IDENT_CURRENT('tableName')