ගබඩා කළ ක්‍රියා පටිපාටියක ප්‍රති results ල තාවකාලික වගුවකට ඇතුළත් කරන්න


1586

මම එය කරන්නේ SELECT * INTO [temp table] FROM [stored procedure]කෙසේද? නෑ FROM [Table]සහ අර්ථ තොරව [temp table]?

Selectසියලු දත්ත BusinessLineබවට tmpBusLineක්රියා දඩ.

select *
into tmpBusLine
from BusinessLine

මම උත්සාහ කරන්නේ එකම stored procedureදෙයකි , නමුත් දත්ත ලබා දෙන දත්ත භාවිතා කිරීම තරමක් සමාන නොවේ.

select *
into tmpBusLine
from
exec getBusinessLineHistory '16 Mar 2009'

නිමැවුම් පණිවිඩය:

Msg 156, 15 වන මට්ටම, රාජ්‍ය 1, 2 වන පේළිය 'exec' යන යතුරු පදය අසල වැරදි සින්ටැක්ස්.

නිමැවුම් ගබඩා කිරීමේ ක්‍රියාපටිපාටියට සමාන ව්‍යුහයක් සහිත තාවකාලික වගුවක් නිර්මාණය කිරීම සඳහා උදාහරණ කිහිපයක් මම කියවා ඇත්තෙමි, එය හොඳින් ක්‍රියාත්මක වේ, නමුත් කිසිදු තීරු සැපයීම නොකිරීම සතුටක්.


22
SELECT * INTO [TABLE NAME] සමඟ තීරු මුල් වගුවෙන් පිටපත් කර ඇති බැවින් ඔබ දන්නවා. ගබඩා කළ ක්‍රියා පටිපාටියකට එරෙහිව මා එකම දේ කළහොත් මෙය මට අවශ්‍ය දේම වේ.
ෆර්ඩීන්

2
බලන්න sommarskog.se/share_data.html සහ මගේ පශ්චාත් stackoverflow.com/questions/6215672/...
Triynko

7
"TmpBusLine වෙත * තෝරන්න" ස්ථිර වගුවක් නිර්මාණය කරන බව පෙන්වා දීමට අවශ්‍යය. ඔබට බොහෝ විට "#tmpBusLine වෙත * තෝරන්න" අවශ්‍ය වේ. මුල් පෝස්ටරය දැනටමත් මෙය සොයාගෙන ඇති බව මට විශ්වාසයි, නමුත් එය "තාවකාලික වගුවට තෝරන්න" සෙවීමේ ඉහළම
ප්‍රති result ලය වන

2
මෙය ආමන්ත්‍රණය කර තිබේද නැද්ද යන්න මම නොදනිමි, නමුත් ඔබ දෝෂය ඇතිවීමට හේතුව යතුරුපදයේ සිටය.
වෙස් පාමර්

9
මයික්‍රොසොෆ්ට් විසින් EXEC වෙතින් SELECT * INTO එකතු කළ යුතුය! කරුණාකර!
kjmerf

Answers:


704

මේ සඳහා ඔබට OPENROWSET භාවිතා කළ හැකිය . බලන්න. තාවකාලික බෙදාහැරුණු විමසුම් සක්‍රිය කිරීම සඳහා මම sp_configure කේතය ද ඇතුළත් කර ඇත්තෙමි.

CREATE PROC getBusinessLineHistory
AS
BEGIN
    SELECT * FROM sys.databases
END
GO

sp_configure 'Show Advanced Options', 1
GO
RECONFIGURE
GO
sp_configure 'Ad Hoc Distributed Queries', 1
GO
RECONFIGURE
GO

SELECT * INTO #MyTempTable FROM OPENROWSET('SQLNCLI', 'Server=(local)\SQL2008;Trusted_Connection=yes;',
     'EXEC getBusinessLineHistory')

SELECT * FROM #MyTempTable

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

38
මේසයකට ඇතුළු කිරීම සඳහා මෙය ටිකක් කරදරකාරී බවක් පෙනේ. කිරීමට බොහෝ වින්‍යාස කිරීම. මම එය උත්සාහ කළ විට "Msg 7357, 16 වන මට්ටම, රාජ්‍ය 2, 1 වන පේළිය" EXEC GetPartyAnalysisData 146 "වස්තුව සැකසිය නොහැක. OLE DB සැපයුම්කරු" SQLNCLI "සම්බන්ධිත සේවාදායකය සඳහා" (ශුන්‍ය) " තීරු හෝ වත්මන් පරිශීලකයාට එම වස්තුවට අවසර නොමැත. එබැවින් ඔබට සම්බන්ධිත සේවාදායකයක් සැකසිය යුතුය ...
ෆර්ඩීන්

10
ඔබට සම්බන්ධිත සේවාදායකයක් අවශ්‍ය නැත, නමුත් ඔබට සම්බන්ධතා නූල නිවැරදිව ලබා ගැනීමට අවශ්‍ය වනු ඇත ... තවද, දත්ත සමුදායේ නම සහ එස්පී හිමිකරු ඇතුළු ගබඩා කළ ක්‍රියා පටිපාටියට සම්පූර්ණ මාර්ගය නියම කරන්න.
මාර්ට් ඩබ්ලිව්

19
eeeeew! එකම සේවාදායකයට යොමු කිරීමක්ද? නපුරු. තාවකාලික වගුව අතින් සෑදීමට වඩා අනිවාර්යයෙන්ම වැඩි වැඩියෙන්
ටිම් ඇබෙල්

24
මෙය හැක් එකක් බව මම එකඟ වන අතර ඔබේ පිටුපස බිත්තියට විරුද්ධ නොවන්නේ නම් එය වළක්වා ගත යුතුය. Sp ශ්‍රිතයකට වෙනස් කිරීම වඩා හොඳ කෝණයක් විය හැකිය. IMHO.
ග්‍රෙග්

626

පළමුවෙන්ම තාවකාලික වගුව ප්‍රකාශයට පත් නොකර ඔබට එය කිරීමට අවශ්‍ය නම්, ගබඩා කළ ක්‍රියා පටිපාටියකට වඩා පරිශීලක අර්ථ දක්වන ලද ශ්‍රිතයක් නිර්මාණය කිරීමට උත්සාහ කළ හැකි අතර එම පරිශීලක අර්ථ දක්වන ලද ශ්‍රිතය වගුවක් ආපසු ලබා දෙන්න. විකල්පයක් ලෙස, ඔබට ගබඩා කළ පටිපාටිය භාවිතා කිරීමට අවශ්‍ය නම්, මේ වගේ දෙයක් උත්සාහ කරන්න:

CREATE TABLE #tmpBus
(
   COL1 INT,
   COL2 INT
)

INSERT INTO #tmpBus
Exec SpGetRecords 'Params'

172
මම හිතන්නේ කාරණය පැහැදිලිව ප්‍රකාශ නොකර ක්‍රමාංකය ජනනය කිරීමයි.
ක්‍රේග්

5
ඉහත සහ ආරොන් ඇල්ටන්ගේ විසඳුම අතර ඇති වෙනස කුමක්දැයි දැන ගැනීමට මම කැමැත්තෙමි. මෙය වඩා සරල බව පෙනේ, නමුත් වෙනත් ඇඟවුම් ගැන මට විශ්වාස නැත.
funkymushroom

11
මෙය ක්‍රියාත්මක වනු ඇති නමුත් ඔබ කවදා හෝ SpGetRecords ගබඩා කළ ක්‍රියා පටිපාටියට අමතර තීරු එකතු කළහොත් මෙය පුපුරා යනු ඇත.
බ්‍රැඩි හෝල්ට්

16
ඔබට ලැබෙන්නේ එක් ඇමතුම් තොගයකට එක් INSERT INTO EXEC පමණි. SpGetRecords සහ එය කැඳවන වෙනත් ඕනෑම ප්‍රෝක් එකක් මෙම ක්‍රමෝපාය ඔවුන්ගේ කේතයෙන් භාවිතා නොකරනු ඇත. මෙය SpGetRecords හි නඩත්තු කරන්නන් පුදුමයට පත් කළ හැකිය.
මැට් ස්ටීවන්සන්

33
මෙය කිසිසේත්ම ප්‍රශ්නයට පිළිතුරු නොදෙන අතර එය එතරම් ඉහළට ඔසවා ඇත්තේ මන්දැයි මට නොපෙනේ. OP පැහැදිලිවම ප්‍රකාශ කර ඇත්තේ “[තාවකාලික වගුව] නිර්වචනය නොකර” සහ ඔබේ පළමු පේළියේ තාවකාලික වගු ප්‍රකාශයක් සාදන්න.
නික්

297

SQL Server 2005 INSERT INTO ... EXECහි, ගබඩා කළ ක්‍රියා පටිපාටියක ප්‍රති result ලය වගුවකට ඇතුළත් කිරීමට ඔබට භාවිතා කළ හැකිය . සිට MSDN හි හි INSERTප්රලේඛනය (SQL Server 2000 සඳහා, ඇත්තෙන්ම):

--INSERT...EXECUTE procedure example
INSERT author_sales EXECUTE get_author_sales

124
මේ සඳහා කතෘ_සලේඛය ඉදිරියෙන් අර්ථ දැක්විය යුතුය. මම මෙය වළක්වා ගැනීමට උත්සාහ කරමි. ස්තූතියි.
ෆර්ඩීන්

5
මම බොහෝ දේ සිතුවෙමි. එතරම් ප්‍රයෝජනවත් මැස්සන් මත tmp වගු වලට ඇතුළු කිරීම, නමුත් ගබඩා කර ඇති ප්‍රොක් එකකින් ආපසු ලබාගත් දත්ත කට්ටල ව්‍යුහය දැන ගැනීමට අවශ්‍ය නම් එතරම් ප්‍රයෝජනවත් නොවේ. ඔබට උදව් කිරීමට ස්තූතියි.
ෆර්ඩීන්

3
මෙහි හොඳ ලිපියක් ඇත msdn.microsoft.com/en-us/library/aa175921.aspx
පොහොසත්

5
එකම ක්‍රමෝපාය භාවිතා කිරීම සඳහා, ඔබට පහත පරිදි පිටපතක් සෑදිය හැකිය: රියල් ටේබල් වෙතින් tempTable වෙත ඉහළ 0 * තෝරන්න ( stackoverflow.com/a/9206463/73794 )
මියන්

මම ඔබේ අදහස් දුටු විට @EvenMien මම මොහොතකට කලබල වෙලා ... නමුත් කනගාටුවට කරුණක් වන්නේ ඔබගේ proc ප්රතිඵල ඇත්තටම සැබෑ මේසය :( පිළිබිඹු නම් පමණක් ක්රියා කරන
BVernon

194

මෙය ඔබගේ ප්‍රශ්නයේ තරමක් වෙනස් කළ අනුවාදයකට පිළිතුරකි. පරිශීලක අර්ථ දක්වන ලද ශ්‍රිතයක් සඳහා ගබඩා කළ ක්‍රියා පටිපාටියක් භාවිතා කිරීම ඔබට අතහැර දැමිය හැකි නම්, ඔබට පේළිගත වටිනාකමක් ඇති පරිශීලක අර්ථ දක්වන ලද ශ්‍රිතයක් භාවිතා කළ හැකිය. මෙය අත්‍යවශ්‍යයෙන්ම ගබඩා කළ ක්‍රියා පටිපාටියකි (පරාමිතීන් ගනී) ප්‍රති result ල කට්ටලයක් ලෙස වගුවක් නැවත ලබා දෙයි; එබැවින් INTO ප්‍රකාශයක් සමඟ මනාව ස්ථානගත වනු ඇත.

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

උදාහරණයක් ලෙස, යම් කලාපයක් සඳහා ගනුදෙනුකරුවන්ගේ ලැයිස්තුවක් ලබා ගැනීම සඳහා ඔබට පේළි-වටිනාකමින් යුත් පරිශීලක අර්ථ දක්වන ලද ශ්‍රිතයක් ඇත:

CREATE FUNCTION CustomersByRegion 
(  
    @RegionID int  
)
RETURNS TABLE 
AS
RETURN 
  SELECT *
  FROM customers
  WHERE RegionID = @RegionID
GO

ඔබේ ප්‍රති results ල එවැනි දේ ලබා ගැනීමට ඔබට මෙම ශ්‍රිතය අමතන්න:

SELECT * FROM CustomersbyRegion(1)

නැතහොත් තෝරා ගැනීමක් කිරීමට:

SELECT * INTO CustList FROM CustomersbyRegion(1)

ඔබට තවමත් ගබඩා කළ ක්‍රියා පටිපාටියක් අවශ්‍ය නම්, ශ්‍රිතය එබඳු ලෙස ඔතා:

CREATE PROCEDURE uspCustomersByRegion 
(  
    @regionID int  
)
AS
BEGIN
     SELECT * FROM CustomersbyRegion(@regionID);
END
GO

අපේක්ෂිත ප්‍රති .ල ලබා ගැනීම සඳහා වඩාත්ම 'හැක්-අඩු' ක්‍රමය මෙය යැයි මම සිතමි. අතිරේක සංකූලතා නොමැතිව භාවිතා කිරීමට අදහස් කළ පරිදි එය දැනට පවතින අංග භාවිතා කරයි. ගබඩා කර ඇති ක්‍රියාපටිපාටිය තුළ පේළිගත අගය සහිත පරිශීලක අර්ථ දක්වන ලද ශ්‍රිතය කැදැල්ල කිරීමෙන් ඔබට ක්‍රියාකාරීත්වයට ක්‍රම දෙකකින් ප්‍රවේශය ලැබේ. ප්ලස්! සත්‍ය SQL කේතය සඳහා ඔබට ඇත්තේ එක් නඩත්තු ස්ථානයක් පමණි.

OPENROWSET භාවිතය යෝජනා කර ඇත, නමුත් OPENROWSET ශ්‍රිතය භාවිතා කිරීමට අදහස් කළේ මෙය නොවේ (පොත් ඔන්ලයින් වෙතින්):

OLE DB දත්ත ප්‍රභවයකින් දුරස්ථ දත්ත වෙත ප්‍රවේශ වීමට අවශ්‍ය සියලුම සම්බන්ධතා තොරතුරු ඇතුළත් වේ. මෙම ක්‍රමය සම්බන්ධිත සේවාදායකයක වගු වලට ප්‍රවේශ වීම සඳහා විකල්පයක් වන අතර OLE DB භාවිතා කරමින් දුරස්ථ දත්ත සම්බන්ධ කිරීම හා ප්‍රවේශ වීම එක් වරක්, තාවකාලික ක්‍රමයකි. OLE DB දත්ත ප්‍රභවයන් පිළිබඳ නිරන්තර යොමු කිරීම් සඳහා, ඒ වෙනුවට සම්බන්ධිත සේවාදායක භාවිතා කරන්න.

OPENROWSET භාවිතා කිරීමෙන් කාර්යය ඉටු වනු ඇත, නමුත් එය දේශීය සම්බන්ධතා විවෘත කිරීම සහ දත්ත සැකසීම සඳහා අමතර පොදු කාර්යයක් දැරීමට සිදුවේ. ආරක්ෂක අවදානමක් ඇති තාවකාලික විමසුම් අවසරයක් අවශ්‍ය බැවින් එය සෑම අවස්ථාවකම විකල්පයක් නොවිය හැකිය. එසේම, OPENROWSET ප්‍රවේශය මඟින් එක් ප්‍රති result ල කට්ටලයකට වඩා නැවත ලබා දෙන ගබඩා කළ ක්‍රියා පටිපාටි භාවිතා කිරීම වළක්වනු ඇත. එක් ගබඩා කළ ක්‍රියාපටිපාටියක් තුළ පරිශීලක අර්ථ දක්වන ලද කාර්යයන් කිහිපයක් පේළිගත කිරීම මඟින් මෙය සාක්ෂාත් කරගත හැකිය.


4
+1 වගු අගය කළ ශ්‍රිතයක් සුදුසු විසඳුමකි. සුළු අඩුපාඩු පිළිබඳව අප අවධානය යොමු කළ යුතුය: වගු අගය කළ ශ්‍රිතය අතිරේක දත්ත සමුදා වස්තුවක් වන අතර ඒ සඳහා වරප්‍රසාද ලබා දීම අවශ්‍ය විය හැකිය.
spencer7593

2
විසඳුමට ආදරය කරන්න. මා විසින් පහර දුන් එක් කුඩා ස්නැග් එකක් නම්, ගබඩා කර ඇති ක්‍රියා පටිපාටිය තුළ මගේ මේසයට එය තිබිය හැකි තැනට ඇණවුම් කළ නොහැකි වීමයි. හොඳයි, මම එය විසඳා ගන්නම්
mrwaim

5
තවත් එක්
ස්නැග් එකක්

7
මුල්ම ප්‍රශ්නය වන්නේ අපි තාවකාලික වගුවක් නිර්මාණය කරන්නේ කෙසේද යන්නයි. මෙය හොඳ රටාවකි, නමුත් මෙම ප්‍රශ්නයට
ආමන්ත්‍රණය නොකරයි

17
ග්‍රෙග්, මගේ පිළිතුරේ පළමු පේළියේ සඳහන් වන්නේ "මෙය ඔබගේ ප්‍රශ්නයේ තරමක් වෙනස් කළ අනුවාදයකට පිළිතුරකි." ඔබේ අදහස අතිරික්තය.
ක්‍රිස්ටියන් ලොරිස්

132
EXEC sp_serveroption 'YOURSERVERNAME', 'DATA ACCESS', TRUE

SELECT  *
INTO    #tmpTable
FROM    OPENQUERY(YOURSERVERNAME, 'EXEC db.schema.sproc 1')

2
"Msg 208, 16 වන මට්ටම, රාජ්ය 1, 1 වන පේළිය අවලංගු වස්තුවක නම 'tmpBusLine' ලබා ගන්න (බොහෝ විට එය ඉදිරිපස අර්ථ දක්වා නැති නිසා විය හැකිය)
ෆර්ඩීන්

1
Er ෆර්ඩ්ස්: සමාවෙන්න, ඔබේ ඉල්ලීම මුලදී තේරුණේ නැත. වෙනත් විසඳුමක් සමඟ යාවත්කාලීන කරන ලදි.
ක්වාස්නෝයි

26
විශිෂ්ට විසඳුමක්. එක් අවවාදයක්, ඔබට ඔබේ සේවාදායකයේ 'ඩේටා ඇක්සස්' සක්‍රීය කිරීමට අවශ්‍ය වනු ඇත: EXEC sp_serveroption 'TheServerName', 'DATA ACCESS', TRUE
jcollum

8
ඔබට සේවාදායකයට දුරස්ථ ප්‍රවේශයට ඉඩ දිය යුතුය. මෙය ආරක්ෂක විධිවිධාන ඇත.
බ්‍රේව් නිව්මාත්

7
ඉලක්කගත ගබඩා කර ඇති ක්‍රියා පටිපාටිය තාවකාලික වගු භාවිතා කරන්නේ නම් මෙය ක්‍රියාත්මක නොවේ
සල්

127

පහසුම විසඳුම:

CREATE TABLE #temp (...);

INSERT INTO #temp
EXEC [sproc];

ඔබ යෝජනා ක්‍රමය නොදන්නේ නම් ඔබට පහත සඳහන් දෑ කළ හැකිය. මෙම ක්‍රමයේදී දැඩි ආරක්ෂක අවදානම් ඇති බව කරුණාවෙන් සලකන්න.

SELECT * 
INTO #temp
FROM OPENROWSET('SQLNCLI', 
                'Server=localhost;Trusted_Connection=yes;', 
                'EXEC [db].[schema].[sproc]')

ආපසු ලබා දුන් ප්‍රති results ල තීරුව මා නොදන්නේ නම් ??? මම අදහස් කළේ තීරුව වෙනස් විය හැකිය. ඉතින් ප්‍රති result ලය තාවකාලික වගුවට ඇතුළත් කරන්නේ කෙසේද ???
ශෙඛර් ෂීට්

ඔබට OPENQUERY භාවිතා කළ හැකි නමුත් එය ආරක්ෂක දෝෂ සහිත බැවින් එය නිර්දේශ නොකරයි.
ටයිගර්ජ් 32

1
"ආපසු ලබා දුන් ප්‍රති results ල තීරුව මා නොදන්නේ නම්" එවිට ඔබට එය ඔබේ තර්කනයේ භාවිතා කළ නොහැක. දත්ත යනු කුමක්දැයි ඔබ නොදන්නේ නම් ඔබ එය භාවිතා කරන්නේ කෙසේද?
ඇඩ්‍රියන් ඩාවෙල්

DAdriaanDavel ඔබේ දත්ත (හොඳම පුහුණුව) ඔබ සැමවිටම දැන සිටිය යුතු බව මම ඔබ සමඟ එකඟ වෙමි, කෙසේ වෙතත් ඔහු පවසන දෙය නම් ස්ප්‍රොක් ගතික තීරු ලබා දෙන අවස්ථා ඇති අතර එම යෝජනා ක්‍රමය කෙබඳු වේදැයි ඔබ සැමවිටම නොදනී. එවැනි අවස්ථාවකදී, ඔබට මැස්සන් මත වගුවක් ඇතුළු කිරීමට සහ නිර්මාණය කිරීමට OPENROWSET භාවිතා කළ හැකිය. කෙසේ වෙතත්, මෙය සිදු කිරීමේදී පැහැදිලි ආරක්ෂක අවදානම් තිබේ ...
ටයිගර්ජ් 32

1
urenurettin සමහර විට ඔබ ගබඩා කර ඇති ක්‍රියා පටිපාටිය නැවත පැමිණෙන්නේ කුමක් දැයි ඔබ නොදනී. එවැනි අවස්ථාවක කුමක් සිදුවේද? ඔබ තාවකාලික වගුවක් සාදා ගන්නේ කෙසේද (ගබඩා කළ ක්‍රියා පටිපාටිය නැවත පැමිණෙන්නේ කුමක් දැයි ඔබ නොදන්නා විට) සහ ගබඩා කළ ක්‍රියා පටිපාටියකින් එයට ඇතුල් කරන්නේ කෙසේද?
ටයිගර්ජ් 32

106

ගබඩා කරන ලද ක්‍රියාපටිපාටිය මඟින් තීරු විශාල ප්‍රමාණයක් ලබා දෙන අතර ප්‍රති result ලය රඳවා ගැනීම සඳහා තාවකාලික වගුවක් අතින් "නිර්මාණය" කිරීමට ඔබට අවශ්‍ය නොවන විට, පහසුම ක්‍රමය වන්නේ ගබඩා කර ඇති ක්‍රියා පටිපාටියට ගොස් "තුළට" වගන්තියක් එක් කිරීමයි. අවසන් වරට ප්‍රකාශය තෝරා 1 = 0 වගන්තියට එක් කරන්න.

ගබඩා කළ ක්‍රියා පටිපාටිය එක් වරක් ක්‍රියාත්මක කර ආපසු ගොස් ඔබ එකතු කළ SQL කේතය ඉවත් කරන්න. දැන්, ගබඩා කළ ක්‍රියා පටිපාටියේ ප්‍රති .ලයට ගැලපෙන හිස් වගුවක් ඔබට ඇත. ඔබට තාවකාලික වගුවක් සඳහා "නිර්මාණය ලෙස ස්ක්‍රිප්ට් වගුව" හෝ එම වගුවට කෙලින්ම ඇතුළත් කළ හැකිය.


9
+1, විශිෂ්ට යෝජනාව. ඔබට ableTableCreate නමින් හැඳින්වෙන ස්ප්‍රොක් වෙත ඉක්මන් විකල්ප විචල්‍යයක් හෝ එකතු කළ හැකිය. ස්ප්රෝක් සැකසූ පසු එය වෙනස් කිරීම අවශ්ය නොවේ.
ඉයන් රොක්

1
otdotjoe ඔබ SELECT INTOතාවකාලික වගුවක් කර තාවකාලික වගුවෙන් සාදන පරිදි ස්ක්‍රිප්ට් වගුවක් කරනවාද? තාවකාලික වගු පෙන්වන tempdbනමුත් මට දකුණු ක්ලික් කිරීමක් කළ නොහැකි අතර නිර්මාණය කළ පිටපතක් කළ හැකිය. ඕනෑම උපකාරයක් අගය කරනු ලැබේ.
DotnetDude

2
OtDotNetDude ඔබට select ... into new_tableව්‍යංගයෙන් සත්‍ය වගුවක් සෑදිය හැකිය.
dotjoe

හිස් වගු ක්‍රමයෙන් දළ තීරු අර්ථ දැක්වීම ලබා ගන්න; අවසානයේදී '...' වෙනුවට නීත්‍යානුකූල TABLE_NAME ආදේශ කරන්න:declare @s varchar(max)='';select @s=@s+','+COLUMN_NAME+' '+DATA_TYPE+isnull('('+case CHARACTER_MAXIMUM_LENGTH when -1 then 'max' else cast(CHARACTER_MAXIMUM_LENGTH as varchar(10))end+')','')from INFORMATION_SCHEMA.COLUMNS where TABLE_NAME='...';select @s
user423430

හොඳම විසඳුම මෙයයි!
ලූකස් 925

66
declare @temp table
(
    name varchar(255),
    field varchar(255),
    filename varchar(255),
    filegroup varchar(255),
    size varchar(255),
    maxsize varchar(255),
    growth varchar(255),
    usage varchar(255)
);
INSERT @temp  Exec sp_helpfile;
select * from @temp;

3
OP මුල් ප්‍රශ්නයට ආමන්ත්‍රණය නොකරයි, මුලින් තාවකාලික වගුව අර්ථ දැක්වීම ඇතුළත් කිරීම සිදු කරයි.
t.durden

48

ඔබ ගබඩා කර ඇති ක්‍රියා පටිපාටිය දත්ත ලබා ගන්නේද නැතහොත් එය වෙනස් කරන්නේද? එය නැවත ලබා ගැනීම සඳහා පමණක් භාවිතා කරන්නේ නම්, ඔබට ගබඩා කර ඇති ක්‍රියා පටිපාටිය ශ්‍රිතයක් බවට පරිවර්තනය කර එය ප්‍රකාශයට පත් නොකර පොදු වගු ප්‍රකාශන (CTEs) භාවිතා කළ හැකිය.

with temp as (
    select * from dbo.fnFunctionName(10, 20)
)
select col1, col2 from temp

කෙසේ වෙතත්, CTE වෙතින් ලබා ගත යුතු ඕනෑම දෙයක් භාවිතා කළ යුත්තේ එක් ප්‍රකාශයකින් පමණි. ඔබට එය කළ නොහැකි with temp as ...අතර SQL පේළි කිහිපයකට පසුව එය භාවිතා කිරීමට උත්සාහ කරන්න. වඩාත් සංකීර්ණ විමසුම් සඳහා එක් ප්‍රකාශයකින් ඔබට බහු CTEs තිබිය හැකිය.

උදාහරණයක් වශයෙන්,

with temp1020 as (
    select id from dbo.fnFunctionName(10, 20)
),
temp2030 as (
    select id from dbo.fnFunctionName(20, 30)
)
select * from temp1020 
where id not in (select id from temp2030)

1
මේවා තාවකාලික වගු නොවේ, සීටීඊ ය. technet.microsoft.com/en-us/library/…
යූසර්

5
ස්තූතියි uyucer ... මම විශ්වාස කරනවා ඔවුන් එදා CTE ලෙස හැඳින්වූ බව මම දැන නොසිටි බව :)
SO User

48

ඔබ විසින් ගබඩා කර ඇති ප්‍රොකයේ ප්‍රති results ල වගුව අතින් "වගුව සාදන්න" ප්‍රකාශය ටයිප් කිරීමට තරම් සංකීර්ණ නම්, ඔබට විවෘත හෝ විවෘතව භාවිතා කළ නොහැකි නම්, ඔබට තීරු සහ දත්ත වර්ග ලැයිස්තුවක් ජනනය කිරීමට ඔබට sp_help භාවිතා කළ හැකිය. ඔබට තීරු ලැයිස්තුවක් ලැබුණු පසු, එය ඔබගේ අවශ්‍යතාවයට සරිලන පරිදි ආකෘතිකරණය කිරීම පමණි.

පියවර 1: ප්‍රතිදාන විමසුමට "# ටෙම්ප්" වෙත එක් කරන්න (උදා: [...] සිට # ටෙම්ප් එකට [...] තෝරන්න).

පහසුම ක්‍රමය වන්නේ ප්‍රොකයේ නිමැවුම් විමසුම කෙලින්ම සංස්කරණය කිරීමයි. ඔබට ගබඩා කළ ප්‍රස්ථාරය වෙනස් කළ නොහැකි නම්, ඔබට නව විමසුම් කවුළුවකට අන්තර්ගතය පිටපත් කර එහි විමසුම වෙනස් කළ හැකිය.

පියවර 2: තාවකාලික වගුව මත sp_help ධාවනය කරන්න. (උදා: "exec tempdb..sp_help #temp")

තාවකාලික වගුව නිර්මාණය කිරීමෙන් පසු, තීරු සහ දත්ත වර්ග වර්ග ලැයිස්තුවක් ලබා ගැනීම සඳහා තාවකාලික වගුව මත sp_help ධාවනය කරන්න.

පියවර 3: දත්ත තීරු සහ වර්ග නිර්මාණ වගු ප්‍රකාශයකට පිටපත් කරන්න

මා සතුව එක්සෙල් පත්රයක් ඇත, එය sp_help හි ප්‍රතිදානය "වගුවක් සාදන්න" ප්‍රකාශයකට සංයුති කිරීමට භාවිතා කරයි. ඔබට මනස්කාන්ත කිසිවක් අවශ්‍ය නැත, ඔබේ SQL සංස්කාරකයට පිටපත් කර අලවන්න. ගබඩා කළ ක්‍රියාපටිපාටියේ ප්‍රති results ල ඇතුළත් කිරීමට ඔබට භාවිතා කළ හැකි "වගුවක් සාදන්න #x [...]" හෝ "tablex වගුව ප්‍රකාශ කරන්න [...]" ප්‍රකාශයක් තැනීමට තීරු නම්, ප්‍රමාණ සහ වර්ග භාවිතා කරන්න.

පියවර 4: අලුතින් සාදන ලද වගුවට ඇතුළු කරන්න

දැන් ඔබට මෙම ත්‍රෙඩ් එකේ විස්තර කර ඇති අනෙක් විසඳුම් මෙන් විමසුමක් ඇත.

DECLARE @t TABLE 
(
   --these columns were copied from sp_help
   COL1 INT,
   COL2 INT   
)

INSERT INTO @t 
Exec spMyProc 

තාවකාලික වගුවක් ( #temp) වගු විචල්‍යයක් ( @temp) බවට පරිවර්තනය කිරීමට ද මෙම තාක්ෂණය භාවිතා කළ හැකිය . මෙය create tableඔබ විසින්ම ප්‍රකාශය ලිවීමට වඩා වැඩි පියවරක් විය හැකි නමුත්, විශාල ක්‍රියාදාමයන්හි යතුරු ලියනය සහ දත්ත වර්ගයේ නොගැලපීම් වැනි අතින් සිදුවන දෝෂයන් වළක්වයි. යතුරු ලියනයක නිදොස් කිරීම සඳහා විමසුම මුලින් ලිවීමට වඩා වැඩි කාලයක් ගතවනු ඇත.


37

OPENROWSET ඔබට ගැටළු ඇති කරන්නේ නම්, 2012 සිට තවත් ක්‍රමයක් තිබේ; මෙහි සඳහන් කර ඇති පරිදි sys.dm_exec_describe_first_result_set_for_object භාවිතා කරන්න: තීරු නම් සහ ගබඩා කළ ක්‍රියා පටිපාටියක වර්ග ලබා ගන්න?

පළමුව, තාවකාලික වගුව සඳහා SQL ජනනය කිරීම සඳහා මෙම ගබඩා කළ ක්‍රියා පටිපාටිය සාදන්න:

CREATE PROCEDURE dbo.usp_GetStoredProcTableDefinition(
    @ProcedureName  nvarchar(128),
    @TableName      nvarchar(128),
    @SQL            nvarchar(max) OUTPUT
)
AS
SET @SQL = 'CREATE TABLE ' + @tableName + ' ('

SELECT @SQL = @SQL + '['+name +'] '+ system_type_name +''  + ','
        FROM sys.dm_exec_describe_first_result_set_for_object
        (
          OBJECT_ID(@ProcedureName), 
          NULL
        );

--Remove trailing comma
SET @SQL = SUBSTRING(@SQL,0,LEN(@SQL))    
SET @SQL =  @SQL +')'

ක්රියා පටිපාටිය භාවිතා කිරීම සඳහා, එය පහත ආකාරයෙන් අමතන්න:

DECLARE     @SQL    NVARCHAR(MAX)

exec dbo.usp_GetStoredProcTableDefinition
    @ProcedureName='dbo.usp_YourProcedure',
    @TableName='##YourGlobalTempTable',@SQL = @SQL OUTPUT

INSERT INTO ##YourGlobalTempTable
EXEC    [dbo].usp_YourProcedure

select * from ##YourGlobalTempTable

මම ගෝලීය තාවකාලික වගුවක් භාවිතා කරන බව සලකන්න. එයට හේතුව ගතික SQL ධාවනය කිරීම සඳහා EXEC භාවිතා කිරීම තමන්ගේම සැසියක් නිර්මාණය කරන බැවින් සාමාන්‍ය තාවකාලික වගුවක් ඕනෑම පසු කේතයකට පරිබාහිර වනු ඇත. ගෝලීය තාවකාලික වගුවක් ගැටළුවක් නම්, ඔබට සාමාන්‍ය තාවකාලික වගුවක් භාවිතා කළ හැකිය , නමුත් පසුව එන ඕනෑම SQL ගතික විය යුතුය, එනම් EXEC ප්‍රකාශය මඟින් ක්‍රියාත්මක වේ.


4
ඔබට වගුව නිර්මාණය කිරීමට අමතක විය @SQL.
ටිස්පේ

32

ක්වාස්නෝයි මාව එහි බොහෝ දුරට තැබුවා, නමුත් එක් දෙයක් අතුරුදහන් විය:

**** ගබඩා කළ ක්‍රියා පටිපාටියේ පරාමිතීන් භාවිතා කිරීමට මට අවශ්‍ය විය. ****

මෙය සිදුවීමට OPENQUERY ඉඩ නොදේ:

ඒ නිසා මම පද්ධතිය වැඩ කිරීමට ක්‍රමයක් සොයා ගත්තා පමණක් නොව වගු අර්ථ දැක්වීම එතරම් දෘඩ කර ගත යුතු නැති අතර ගබඩා කළ වෙනත් ක්‍රියා පටිපාටියක් තුළ එය නැවත අර්ථ දැක්විය යුතුය (ඇත්ත වශයෙන්ම එය කැඩී යා හැකි අවස්ථාවක් ගන්න)!

ඔව්, ඔබට ගතිකව (දිගු ලෙස මේසය නිර්වචනය ව්යාජ varaiables සමග OPENQUERY ප්රකාශය භාවිත කිරීම මගින් ආචිත පටිපාටිය සිට ආපසු නිර්මාණය කළ හැකිය නැත ප්රතිඵල SET ක්ෂේත්ර සංඛ්යාව සමාන නැවත හොඳ දත්ත සමඟ දත්ත කාණ්ඩය ලෙස ද එම තනතුර දී).

වගුව නිර්මාණය කළ පසු, ඔබට දවස පුරා තාවකාලික වගුව තුළට ක්‍රියාත්මක කළ ක්‍රියා පටිපාටිය භාවිතා කළ හැකිය.


සටහන් කිරීමට (ඉහත දක්වා ඇති පරිදි) ඔබ දත්ත ප්‍රවේශය සක්‍රීය කළ යුතුය,

EXEC sp_serveroption 'MYSERVERNAME', 'DATA ACCESS', TRUE

කේතය:

declare @locCompanyId varchar(8)
declare @locDateOne datetime
declare @locDateTwo datetime

set @locDateOne = '2/11/2010'
set @locDateTwo = getdate()

--Build temporary table (based on bogus variable values)
--because we just want the table definition and
--since openquery does not allow variable definitions...
--I am going to use bogus variables to get the table defintion.

select * into #tempCoAttendanceRpt20100211
FROM OPENQUERY(DBASESERVER,
  'EXEC DATABASE.dbo.Proc_MyStoredProc 1,"2/1/2010","2/15/2010 3:00 pm"')

set @locCompanyId = '7753231'

insert into #tempCoAttendanceRpt20100211
EXEC DATABASE.dbo.Proc_MyStoredProc @locCompanyId,@locDateOne,@locDateTwo

set @locCompanyId = '9872231'

insert into #tempCoAttendanceRpt20100211
EXEC DATABASE.dbo.Proc_MyStoredProc @locCompanyId,@locDateOne,@locDateTwo

select * from #tempCoAttendanceRpt20100211
drop table #tempCoAttendanceRpt20100211

මුලින් ලබා දුන් තොරතුරු වලට ස්තූතියි ... ඔව්, අවසාන වශයෙන් වෙනත් ගබඩා කළ ක්‍රියා පටිපාටියකින් හෝ දත්ත ගබඩාවක දත්ත භාවිතා කරන විට මේ සියලු ව්‍යාජ (දැඩි) වගු නිර්වචන මා විසින් නිර්මාණය කළ යුතු නැත , ඔව් ඔබට පරාමිතීන් ද භාවිතා කළ හැකිය.

විමර්ශන ටැග් සොයන්න:

  • SQL 2005 තාවකාලික වගුවට ගබඩා කර ඇති ක්‍රියා පටිපාටිය

  • ගබඩා කළ ක්‍රියා පටිපාටිය සහ විචල්‍යයන් සහිත විවෘත විමසුම 2005

  • විචල්යයන් සහිත විවෘත විමසුම

  • ගබඩා කළ ක්‍රියා පටිපාටිය තාවකාලික වගුවට ක්‍රියාත්මක කරන්න

යාවත්කාලීන කිරීම: මෙය තාවකාලික වගු සමඟ ක්‍රියා නොකරනු ඇත, එබැවින් මට තාවකාලික වගුව අතින් නිර්මාණය කිරීමට සිදු විය.

විශාල දැනුම්දීම : මෙය තාවකාලික වගු සමඟ ක්‍රියා නොකරනු ඇත , http://www.sommarskog.se/share_data.html#OPENQUERY

යොමුව: ඊළඟ කාරණය වන්නේ LOCALSERVER යන්න අර්ථ දැක්වීමයි. එය උදාහරණයේ යතුරු පදයක් මෙන් පෙනුනද ඇත්ත වශයෙන්ම එය නමක් පමණි. ඔබ එය කරන්නේ මෙයයි:

sp_addlinkedserver @server = 'LOCALSERVER',  @srvproduct = '',
                   @provider = 'SQLOLEDB', @datasrc = @@servername

සම්බන්ධිත සේවාදායකයක් නිර්මාණය කිරීම සඳහා, ඔබට වෙනත් සේවාදායකයෙකුගේ අවසරය තිබිය යුතුය, නැතහොත් ඕනෑම ස්ථාවර සේවාදායක භූමිකාවක සාමාජිකයෙකු විය යුතුය sysadmin හෝ setupadmin.

OPENQUERY SQL සේවාදායකයට නව සම්බන්ධතාවයක් විවෘත කරයි. මෙයට යම් ඇඟවුම් තිබේ:

OPENQUERY සමඟ ඔබ අමතන ක්‍රියාපටිපාටියට වත්මන් සම්බන්ධතාවයේ සාදන ලද තාවකාලික වගු යොමු කළ නොහැක.

නව සම්බන්ධතාවයට තමන්ගේම පෙරනිමි දත්ත සමුදායක් ඇත (sp_addlinkedserver සමඟ අර්ථ දක්වා ඇත, පෙරනිමිය ප්‍රධාන වේ), එබැවින් සියලු වස්තු පිරිවිතරයන්ට දත්ත සමුදා නාමයක් ඇතුළත් විය යුතුය.

ඔබට විවෘත ගනුදෙනුවක් තිබේ නම් සහ ඔබ OPENQUERY අමතන විට අගුල් තබාගෙන සිටී නම්, කැඳවූ ක්‍රියා පටිපාටියට ඔබ අගුළු දැමූ දේට ප්‍රවේශ විය නොහැක. එනම්, ඔබ පරෙස්සම් නොවන්නේ නම් ඔබ ඔබව අවහිර කරනු ඇත.

සම්බන්ධ කිරීම නොමිලේ නොවේ, එබැවින් කාර්ය සාධන ද .ුවමක් ඇත.


1
ඔබගේ සේවාදායකයේ නම ඔබ නොදන්නේ නම්, භාවිතා කරන්න SELECT @@SERVERNAME. ඔබට ද භාවිතා කළ හැකියEXEC sp_serveroption @@SERVERNAME, 'DATA ACCESS', TRUE
කොන්ටැන්ගෝ

26

ඔබට SQL 2012 හෝ ඊට වැඩි ප්‍රමාණයක් ලැබීමට තරම් වාසනාවන්ත නම්, ඔබට භාවිතා කළ හැකිය dm_exec_describe_first_result_set_for_object

මම දැන් ගොට්න් විසින් සපයන ලද SQL සංස්කරණය කර ඇත. ස්තූතියි ගොට්න්.

මෙය ක්‍රියාපටිපාටියේ නමට සමාන ගෝලීය තාවකාලික වගුවක් නිර්මාණය කරයි. තාවකාලික වගුව පසුව අවශ්‍ය පරිදි භාවිතා කළ හැකිය. නැවත ක්‍රියාත්මක කිරීමට පෙර එය අතහැර දැමීමට අමතක නොකරන්න.

    declare @procname nvarchar(255) = 'myProcedure',
            @sql nvarchar(max) 

    set @sql = 'create table ##' + @procname + ' ('
    begin
            select      @sql = @sql + '[' + r.name + '] ' +  r.system_type_name + ','
            from        sys.procedures AS p
            cross apply sys.dm_exec_describe_first_result_set_for_object(p.object_id, 0) AS r
            where       p.name = @procname

            set @sql = substring(@sql,1,len(@sql)-1) + ')'
            execute (@sql)
            execute('insert ##' + @procname + ' exec ' + @procname)
    end

1
විශිෂ්ටයි! එක් ප්‍රකාශයක් පමණි: ගබඩා කළ ක්‍රියා පටිපාටි සඳහා ඔබට මෙය කිරීමට අවශ්‍ය නම් sys.all_objectsඒ වෙනුවට භාවිතා sys.proceduresකරන්න.
ගර්ට් ආර්නෝල්ඩ්

2
පොලිස් අධිකාරී ඒ තුළ තාවකාලික වගු භාවිතා කරන්නේ නම් මෙය ද අසාර්ථක වනු ඇත. (නමුත් මෙය ඔබගේ අවි ගබඩාවේ
ප්‍රොක් එකක් ලෙස තබා ගැනීම පහසුය

23

මෙම ගබඩා කර ඇති කාර්යය කරන්නේ:

CREATE PROCEDURE [dbo].[ExecIntoTable]
(
    @tableName          NVARCHAR(256),
    @storedProcWithParameters   NVARCHAR(MAX)
)
AS
BEGIN
    DECLARE @driver         VARCHAR(10)
    DECLARE @connectionString   NVARCHAR(600)
    DECLARE @sql            NVARCHAR(MAX)
    DECLARE @rowsetSql      NVARCHAR(MAX)

    SET @driver = '''SQLNCLI'''

    SET @connectionString = 
        '''server=' + 
            CAST(SERVERPROPERTY('ServerName') AS NVARCHAR(256)) + 
            COALESCE('\' + CAST(SERVERPROPERTY('InstanceName') AS NVARCHAR(256)), '') + 
        ';trusted_connection=yes'''

    SET @rowsetSql = '''EXEC ' + REPLACE(@storedProcWithParameters, '''', '''''') + ''''

    SET @sql = '
SELECT
    *
INTO 
    ' + @tableName + ' 
FROM
    OPENROWSET(' + @driver + ',' + @connectionString + ',' + @rowsetSql + ')'

    EXEC (@sql)
END
GO

මෙය සුළු වශයෙන් ප්‍රතිනිර්මාණය කිරීමකි: ගබඩා කළ ක්‍රියා පටිපාටියේ ප්‍රති resultsමේසය තුළට ඇතුළු කරන්න .

ඔබට එය තාවකාලික වගුවක් සමඟ වැඩ කිරීමට අවශ්‍ය නම් ඔබට ##GLOBALමේසයක් භාවිතා කර පසුව එය අතහැර දැමිය යුතුය.


17

ගබඩා කරන ලද ක්‍රියා පටිපාටියක පළමු වාර්තා කට්ටලය තාවකාලික වගුවකට ඇතුළත් කිරීම සඳහා ඔබ පහත සඳහන් දෑ දැනගත යුතුය:

  1. තාවකාලික වගුවකට ඇතුළත් කළ හැක්කේ ගබඩා කළ ක්‍රියා පටිපාටියේ පළමු පේළිය පමණි
  2. ගබඩා කළ ක්‍රියා පටිපාටිය ගතික T-SQL ප්‍රකාශය ක්‍රියාත්මක නොකළ යුතුය ( sp_executesql)
  3. ඔබ මුලින්ම තාවකාලික වගුවේ ව්‍යුහය අර්ථ දැක්විය යුතුය

ඉහත සඳහන් සීමාවන් ලෙස පෙනේ, නමුත් IMHO එය මනාව අර්ථවත් කරයි - ඔබ භාවිතා කරන්නේ නම් ඔබට sp_executesqlවරක් තීරු දෙකක් සහ දහයකට වරක් ආපසු ලබා දිය හැකි අතර, ඔබට බහු ප්‍රති result ල කට්ටල තිබේ නම්, ඔබට ඒවා වගු කිහිපයකට ඇතුළු කළ නොහැක - ඔබට උපරිම ලෙස ඇතුළත් කළ හැකිය එක් T-SQL ප්‍රකාශයක වගු දෙකක (භාවිතා කරමින්)OUTPUT වගන්තිය ප්‍රේරක නොමැත).

එබැවින්, ප්රශ්නය ප්රධාන වශයෙන් EXEC ... INTO ...ප්රකාශය සිදු කිරීමට පෙර තාවකාලික වගු ව්යුහය නිර්වචනය කරන්නේ කෙසේද යන්නයි .

පළමුවැන්න සමඟ වැඩ කරන OBJECT_IDඅතර දෙවන හා තෙවනුව තාවකාලික විමසුම් සමඟ ද ක්‍රියා කරයි. ඔබට එකවර CROSS APPLYබහු ක්‍රියා පටිපාටි සඳහා තාවකාලික වගු අර්ථ දැක්වීම් භාවිතා කළ හැකි බැවින් sp වෙනුවට DMV භාවිතා කිරීමට මම කැමැත්තෙමි .

SELECT p.name, r.* 
FROM sys.procedures AS p
CROSS APPLY sys.dm_exec_describe_first_result_set_for_object(p.object_id, 0) AS r;

එසේම, system_type_nameක්ෂේත්‍රය ඉතා ප්‍රයෝජනවත් විය හැකි බැවින් අවධානය යොමු කරන්න . එය තීරුවේ සම්පූර්ණ අර්ථ දැක්වීම ගබඩා කරයි. උදාහරණයක් වශයෙන්:

smalldatetime
nvarchar(max)
uniqueidentifier
nvarchar(1000)
real
smalldatetime
decimal(18,2)

වගු අර්ථ දැක්වීම නිර්මාණය කිරීම සඳහා ඔබට එය බොහෝ විට සෘජුවම භාවිතා කළ හැකිය.

එබැවින්, බොහෝ අවස්ථාවන්හිදී (ගබඩා කර ඇති ක්‍රියා පටිපාටිය ඇතැම් නිර්ණායකයන්ට ගැලපෙන්නේ නම්) ඔබට එවැනි ගැටළු විසඳීම සඳහා පහසුවෙන් ගතික ප්‍රකාශ ගොඩනගා ගත හැකිය (තාවකාලික වගුව සාදන්න, ගබඩා කළ ක්‍රියා පටිපාටියේ ප්‍රති result ලය එහි ඇතුළත් කරන්න, දත්ත සමඟ ඔබට අවශ්‍ය දේ කරන්න) .


සටහන, ගතික T-SQL ප්‍රකාශයන් ක්‍රියාත්මක කරන විට හෝ ගබඩා කළ ක්‍රියා පටිපාටියේ තාවකාලික වගු වැනි සමහර අවස්ථාවල පළමු ප්‍රති result ල සැකසීමට ඉහත වස්තු අසමත් වන බව සලකන්න .


සීමාවන් පිළිබඳ ප්‍රායෝගික නිරීක්‍ෂණය: ඉහත ප්‍රවේශය වෙනත් sp හි භාවිතා කරමින් ගතිකව නිර්මාණය කරන ලද තාවකාලික වගුව සඳහා ඔබට යම් sp හි ප්‍රතිදානය ඇතුළත් කිරීමට සිදුවුවහොත් (එය SP_LEVEL_1 ලෙස හැඳින්වීමට ඉඩ දෙන්න), ඔබට මෙම SP_LEVEL_1 ප්‍රතිදානය සඳහා එකම උපක්‍රමයක් කළ නොහැක. SP_LEVEL_2
nahab

17
  1. මම පහත දැක්වෙන ක්‍රමෝපායන් සහ දත්ත සමඟ වගුවක් නිර්මාණය කරමි.
  2. ගබඩා කළ පටිපාටියක් සාදන්න.
  3. මගේ ක්‍රියා පටිපාටියේ ප්‍රති result ලය කුමක්දැයි දැන් මම දනිමි, එබැවින් මම පහත විමසුම සිදු කරමි.

    CREATE TABLE [dbo].[tblTestingTree](
        [Id] [int] IDENTITY(1,1) NOT NULL,
        [ParentId] [int] NULL,
        [IsLeft] [bit] NULL,
        [IsRight] [bit] NULL,
    CONSTRAINT [PK_tblTestingTree] PRIMARY KEY CLUSTERED
    (
        [Id] ASC
    ) WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    ) ON [PRIMARY]
    GO
    SET IDENTITY_INSERT [dbo].[tblTestingTree] ON
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (1, NULL, NULL, NULL)
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (2, 1, 1, NULL)
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (3, 1, NULL, 1)
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (4, 2, 1, NULL)
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (5, 2, NULL, 1)
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (6, 3, 1, NULL)
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (7, 3, NULL, 1)
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (8, 4, 1, NULL)
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (9, 4, NULL, 1)
    INSERT [dbo].[tblTestingTree] ([Id], [ParentId], [IsLeft], [IsRight]) VALUES (10, 5, 1, NULL)
    
    SET IDENTITY_INSERT [dbo].[tblTestingTree] OFF

    වටිනාකම් (10, 5, 1, NULL) IDENTITY_INSERT [dbo] සකසන්න. [TblTestingTree] සක්‍රීයයි

    create procedure GetDate
    as
    begin
        select Id,ParentId from tblTestingTree
    end
    
    create table tbltemp
    (
        id int,
        ParentId int
    )
    insert into tbltemp
    exec GetDate
    
    select * from tbltemp;

15

විමසුමේ පරාමිතිය නොමැති නම්, OpenQueryවෙනත් භාවිතා කරන්නOpenRowset .

මූලික දෙය නම් ගබඩා කළ ක්‍රියා පටිපාටියට අනුව ක්‍රමෝපායන් නිර්මාණය කර එම වගුවට ඇතුළත් කිරීමයි. උදා:

DECLARE @abc TABLE(
                  RequisitionTypeSourceTypeID INT
                , RequisitionTypeID INT
                , RequisitionSourcingTypeID INT
                , AutoDistOverride INT
                , AllowManagerToWithdrawDistributedReq INT
                , ResumeRequired INT
                , WarnSupplierOnDNRReqSubmission  INT
                , MSPApprovalReqd INT
                , EnableMSPSupplierCounterOffer INT
                , RequireVendorToAcceptOffer INT
                , UseCertification INT
                , UseCompetency INT
                , RequireRequisitionTemplate INT
                , CreatedByID INT
                , CreatedDate DATE
                , ModifiedByID INT
                , ModifiedDate DATE
                , UseCandidateScheduledHours INT
                , WeekEndingDayOfWeekID INT
                , AllowAutoEnroll INT
                )
INSERT INTO @abc
EXEC [dbo].[usp_MySp] 726,3
SELECT * FROM @abc

13

කේතය

CREATE TABLE #T1
(
    col1 INT NOT NULL,
    col2 NCHAR(50) NOT NULL,
    col3 TEXT NOT NULL,
    col4 DATETIME NULL,
    col5 NCHAR(50) NULL,
    col6 CHAR(2) NULL,
    col6 NCHAR(100) NULL,
    col7 INT NULL,
    col8 NCHAR(50) NULL,
    col9 DATETIME NULL,
    col10 DATETIME NULL
)

DECLARE @Para1 int
DECLARE @Para2 varchar(32)
DECLARE @Para3 varchar(100)
DECLARE @Para4 varchar(15)
DECLARE @Para5 varchar (12)
DECLARE @Para6 varchar(1)
DECLARE @Para7 varchar(1)


SET @Para1 = 1025
SET @Para2 = N'6as54fsd56f46sd4f65sd'
SET @Para3 = N'XXXX\UserName'
SET @Para4 = N'127.0.0.1'
SET @Para5 = N'XXXXXXX'
SET @Para6 = N'X'
SET @Para7 = N'X'

INSERT INTO #T1
(
    col1,
    col2,
    col3,
    col4,
    col5,
    col6,
    col6,
    col7,
    col8,
    col9,
    col10,
)
EXEC [dbo].[usp_ProcedureName] @Para1, @Para2, @Para3, @Para4, @Para5, @Para6, @Para6

මම හිතනවා මේක උදව් වෙයි කියලා. කරුණාකර සුදුසු පරිදි සුදුසුකම් ලබා ගන්න.


11

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

ගබඩා කර ඇති ක්‍රියා පටිපාටියට පිවිසීම සඳහා රූප වර්ග පරාමිතියක් භාවිතා කිරීමට සබැඳිය යෝජනා කරයි . ඉන්පසු ගබඩා කරන ලද ක්‍රියා පටිපාටියේදී, රූපය මුල් දත්ත අඩංගු වගු විචල්‍යයක් බවට පරිවර්තනය වේ.

සමහර විට මෙය තාවකාලික වගුවක් සමඟ භාවිතා කළ හැකි ක්‍රමයක් තිබේ.


4
Sql2008 සහ පසුව වගු අගය පරාමිතීන් හඳුන්වාදීමත් සමඟ මෙය තවදුරටත් අවශ්‍ය නොවේ . ඉහත සබැඳියේ සඳහන් කර ඇති පරිදි බයිට් බවට පරිවර්තනය කිරීම සමඟ දැන් ඔබට .net දත්ත කට්ටලයක් හෝ දත්ත සමුදායක් වස්තුවක් ගබඩා කළ පටිපාටියකට කෙලින්ම යැවිය හැකිය
EndlessSpace

10

මටත් එම ගැටලුවටම මුහුණ දීමට සිදු වූ අතර පාවුල්ගේ යෝජනාවෙන් මම මේ සඳහා කළ දේ මෙන්න . මෙහි ප්‍රධාන කොටස වන්නේ NEWID()බහු පරිශීලකයින් එකවර ගබඩා ක්‍රියා පටිපාටි / ස්ක්‍රිප්ට් ධාවනය නොකිරීමට භාවිතා කිරීමයි, ගෝලීය තාවකාලික වගුව සඳහා ඇති වේදනාව.

DECLARE @sql varchar(max) = '', 
@tmp_global_table varchar(255) = '##global_tmp_' + CONVERT(varchar(36), NEWID())
SET @sql = @sql + 'select * into [' + @tmp_global_table + '] from YOURTABLE'
EXEC(@sql)

EXEC('SELECT * FROM [' + @tmp_global_table + ']')

9

තවත් ක්‍රමයක් නම් වර්ගයක් නිර්මාණය කර PIPELINED භාවිතා කර ඔබේ වස්තුව ආපසු යැවීමයි. කෙසේ වෙතත් මෙය තීරු දැන ගැනීමට සීමා වේ. නමුත් එය කිරීමට හැකි වීමේ වාසිය ඇත:

SELECT * 
FROM TABLE(CAST(f$my_functions('8028767') AS my_tab_type))

මේ කුමක් ද? මෙම ප්‍රශ්නය ගැන SQL සේවාදායකය සමඟ කිසිදු සම්බන්ධයක් ඇති බවක් නොපෙනේ
මාටින් ස්මිත්

8

එය සරල පියවර 2 ක ක්‍රියාවලියකි: - තාවකාලික වගුවක් සාදන්න - තාවකාලික වගුවට ඇතුළු කරන්න.

එකම දේ කිරීමට කේතය:

CREATE TABLE #tempTable (Column1 int, Column2 varchar(max));
INSERT INTO #tempTable 
EXEC [app].[Sproc_name]
@param1 = 1,
@param2 =2;

6

අවට සොයා බැලීමෙන් පසු , ගබඩා කළ ක්‍රියා පටිපාටියේ ප්‍රති result ල අර්ථ දැක්වීමේ සාමාන්‍ය ක්‍රමයක් භාවිතා නොකර OPENROWSETහෝ OPENQUERYභාවිතා නොකර ගබඩා කර ඇති ඕනෑම ක්‍රියා පටිපාටියක් සඳහා ගතිකව තාවකාලික වගුවක් නිර්මාණය කිරීමට මම ක්‍රමයක් සොයා ගතිමි .

SQL සේවාදායකයට sp_describe_first_result_setඕනෑම ක්‍රියා පටිපාටියේ ප්‍රති .ල කට්ටලයක් ලබා දිය හැකි බයිට්-ඉන් ප්‍රොක් ඇත. මෙම ක්‍රියාපටිපාටියේ ප්‍රති results ල වලින් මම ක්‍රමලේඛ වගුවක් සාදන ලද අතර සියලු ක්ෂේත්‍රය අතින් සකස් කළ හැකිය.

declare @procname varchar(100) = 'PROCEDURENAME' -- your procedure name
declare @param varchar(max) = '''2019-06-06''' -- your parameters 
declare @execstr nvarchar(max) = N'exec ' + @procname
declare @qry nvarchar(max)

-- Schema table to store the result from sp_describe_first_result_set.
create table #d
(is_hidden  bit  NULL, column_ordinal   int  NULL, name sysname NULL, is_nullable   bit  NULL, system_type_id   int  NULL, system_type_name nvarchar(256) NULL,
max_length  smallint  NULL, precision   tinyint  NULL,  scale   tinyint  NULL,  collation_name  sysname NULL, user_type_id  int NULL, user_type_database    sysname NULL,
user_type_schema    sysname NULL,user_type_name sysname NULL,assembly_qualified_type_name   nvarchar(4000),xml_collection_id    int NULL,xml_collection_database    sysname NULL,
xml_collection_schema   sysname NULL,xml_collection_name    sysname NULL,is_xml_document    bit  NULL,is_case_sensitive bit  NULL,is_fixed_length_clr_type  bit  NULL,
source_server   sysname NULL,source_database    sysname NULL,source_schema  sysname NULL,source_table   sysname NULL,source_column  sysname NULL,is_identity_column bit NULL,
is_part_of_unique_key   bit NULL,is_updateable  bit NULL,is_computed_column bit NULL,is_sparse_column_set   bit NULL,ordinal_in_order_by_list   smallint NULL,
order_by_list_length    smallint NULL,order_by_is_descending    smallint NULL,tds_type_id   int  NULL,tds_length    int  NULL,tds_collation_id  int NULL,
tds_collation_sort_id   tinyint NULL)


-- Get result set definition of your procedure
insert into #d
EXEC sp_describe_first_result_set @exestr, NULL, 0

-- Create a query to generate and populate a global temp table from above results
select 
@qry = 'Create table ##t(' +
stuff(  
    (select ',' + name + ' '+ system_type_name + ' NULL'
    from #d d For XML Path, TYPE)
    .value(N'.[1]', N'nvarchar(max)')
, 1,1,'')
+ ')

insert into ##t 
Exec '+@procname+' ' + @param

Exec sp_executesql @qry

-- Use below global temp table to query the data as you may
select * from ##t

-- **WARNING** Don't forget to drop the global temp table ##t.
--drop table ##t
drop table #d 

SQL සේවාදායක අනුවාදය මත සංවර්ධනය කර පරීක්ෂා කර ඇත - Microsoft SQL Server 2016 (RTM) - 13.0.1601.5 (ගොඩනැගීම 17134 :)

ඔබ භාවිතා කරන ඔබගේ SQL සේවාදායක අනුවාදය සඳහා අවශ්‍ය යෝජනා ක්‍රමය වෙනස් කළ හැකිය (අවශ්‍ය නම්).


4

සම්මත කර ඇති පරාමිතීන් ඔබ දන්නේ නම් සහ ඔබට sp_configure සෑදීමට ප්‍රවේශය නොමැති නම්, මෙම පරාමිතීන් සමඟ ගබඩා කළ ක්‍රියා පටිපාටිය සංස්කරණය කරන්න, එය ## ගෝලීය වගුවක ගබඩා කළ හැකිය.


4

SQL සේවාදායකය 2014+ හි මෙය කළ හැකිය. බහු වගු සඳහා යමෙකු මෙය කළ හැකි ක්‍රමයක් සොයා ගන්නේ නම් මම ඒ ගැන දැන ගැනීමට කැමතියි.

DECLARE @storedProcname NVARCHAR(MAX) = ''
SET @storedProcname = 'myStoredProc'

DECLARE @strSQL AS VARCHAR(MAX) = 'CREATE TABLE myTableName '

SELECT @strSQL = @strSQL+STUFF((
SELECT ',' +name+' ' + system_type_name 
FROM sys.dm_exec_describe_first_result_set_for_object (OBJECT_ID(@storedProcname),0)
FOR XML PATH('')
),1,1,'(') + ')'

EXEC (@strSQL)

INSERT INTO myTableName

EXEC ('myStoredProc @param1=1, @param2=2')

SELECT * FROM myTableName

DROP TABLE myTableName

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

ඩයිනමික් SQL සමඟ ද ක්‍රියා කරන මෙහි ප්‍රභේද තිබේ.


2

ප්‍රශ්නයට වසර කිහිපයක් ප්‍රමාද වූ නමුත් ඉක්මන් හා අපිරිසිදු කේත උත්පාදනය සඳහා මට මේ වගේ දෙයක් අවශ්‍ය විය. අනෙක් අය ප්‍රකාශ කර ඇති පරිදි තාවකාලික වගුව ඉදිරියෙන් නිර්වචනය කිරීම පහසු යැයි මම විශ්වාස කරමි, නමුත් මෙම ක්‍රමය සරල ගබඩා කළ ක්‍රියා පටිපාටි විමසුම් හෝ වර්ග සංඛ්‍යා ලේඛන සඳහා ක්‍රියා කළ යුතුය.

මෙය මඳක් සංවර්‍ධනය වනු ඇත, නමුත් එය මෙහි දායකයින්ගෙන් මෙන්ම පෝල් වයිට්ගේ විසඳුම ඩී.බී.ඒ. ස්ටැක් එක්ස්චේන්ජ් වෙතින් ලබා ගනී. . නැවතත්, මෙම ප්‍රවේශය නැවත අවධාරණය කිරීමට සහ උදාහරණ බහු පරිශීලක පරිසරයක ක්‍රියාවලි සඳහා නිර්මාණය කර නොමැත. මෙම අවස්ථාවෙහිදී, කේත උත්පාදක සැකිලි ක්‍රියාවලියක් මඟින් යොමු කිරීම සඳහා ගෝලීය තාවකාලික වගුවක කෙටි කාලයක් සඳහා වගු අර්ථ දැක්වීම සකසා ඇත.

පෝල් වයිට්ගේ පිළිතුරේ ඇති එම්එස්ඩීඑන් සබැඳිය වෙත යාමට ඔබට අවශ්‍ය විය හැකි බැවින් මම මෙය සම්පූර්ණයෙන් අත්හදා බලා නැත. මෙය SQL 2012 සහ ඊට ඉහළ සඳහා අදාළ වේ.

මුලින්ම ගබඩා කර ඇති ක්‍රියාපටිපාටිය භාවිතා කරන්න sp_describe_first_result_set එය ඔරකල්ගේ විස්තරයට සමාන වේ.

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

තාවකාලික වගු අර්ථ දැක්වීම නිර්මාණය කිරීම සඳහා තෝරා ගැනීමට එක් ක්ෂේත්‍රයක් ආපසු ලබා දෙන කාර්යයන් බිඳ දැමීම සඳහා මම ගබඩා කළ ප්‍රොක් එකක් නිර්මාණය කළෙමි.

CREATE OR ALTER PROCEDURE [dbo].[sp_GetTableDefinitionFromSqlBatch_DescribeFirstResultSet]
(
     @sql NVARCHAR(4000)
    ,@table_name VARCHAR(100)
    ,@TableDefinition NVARCHAR(MAX) OUTPUT
)
AS
BEGIN
    SET NOCOUNT ON
    DECLARE @TempTableDefinition NVARCHAR(MAX)
    DECLARE @NewLine NVARCHAR(4) = CHAR(13)+CHAR(10)

    DECLARE @ResultDefinition TABLE (  --The View Definition per MSDN
      is_hidden         bit NOT NULL
    , column_ordinal    int NOT NULL
    , [name]            sysname NULL
    , is_nullable       bit NOT NULL
    , system_type_id    int NOT NULL
    , system_type_name  nvarchar(256) NULL
    , max_length        smallint NOT NULL
    , [precision]       tinyint NOT NULL
    , scale             tinyint NOT NULL
    , collation_name    sysname NULL    
    , user_type_id      int NULL
    , user_type_database    sysname NULL    
    , user_type_schema  sysname NULL
    , user_type_name    sysname NULL    
    , assembly_qualified_type_name      nvarchar(4000)  
    , xml_collection_id         int NULL
    , xml_collection_database   sysname NULL    
    , xml_collection_schema     sysname NULL    
    , xml_collection_name       sysname NULL
    , is_xml_document           bit NOT NULL            
    , is_case_sensitive         bit NOT NULL            
    , is_fixed_length_clr_type  bit NOT NULL    
    , source_server             sysname NULL            
    , source_database           sysname NULL
    , source_schema             sysname NULL
    , source_table              sysname NULL
    , source_column             sysname NULL
    , is_identity_column        bit NULL
    , is_part_of_unique_key     bit NULL
    , is_updateable             bit NULL
    , is_computed_column        bit NULL
    , is_sparse_column_set      bit NULL
    , ordinal_in_order_by_list  smallint NULL   
    , order_by_is_descending    smallint NULL   
    , order_by_list_length      smallint NULL
    , tds_type_id               int NOT NULL
    , tds_length                int NOT NULL
    , tds_collation_id          int NULL
    , tds_collation_sort_id     tinyint NULL
    )

    --Insert the description into table variable    
    INSERT @ResultDefinition
    EXEC sp_describe_first_result_set @sql

    --Now Build the string to create the table via union select statement
    ;WITH STMT AS (
        SELECT N'CREATE TABLE ' + @table_name + N' (' AS TextVal
        UNION ALL

        SELECT 
         CONCAT(
                CASE column_ordinal
                    WHEN 1 THEN '     ' ELSE '   , ' END  --Determines if comma should precede
                , QUOTENAME([name]) , '   ', system_type_name  -- Column Name and SQL TYPE
                ,CASE is_nullable 
                    WHEN 0 THEN '   NOT NULL' ELSE '   NULL' END --NULLABLE CONSTRAINT          
               ) AS TextVal
        FROM @ResultDefinition WHERE is_hidden = 0  -- May not be needed
        UNION ALL

        SELECT N');' + @NewLine
    ) 

    --Now Combine the rows to a single String
    SELECT @TempTableDefinition = COALESCE (@TempTableDefinition + @NewLine + TextVal, TextVal) FROM STMT

    SELECT @TableDefinition = @TempTableDefinition
END

සංසිද්ධිය නම් ඔබට ගෝලීය වගුවක් භාවිතා කිරීමට අවශ්‍යය, නමුත් ඔබ එය අද්විතීය ලෙස සෑදිය යුතුය, එවිට ගැටුමක් ගැන කරදර නොවී ඔබට නිතරම එයින් ඉවත් වී නිර්මාණය කළ හැකිය.
උදාහරණයේ දී මම ගෝලීය විචල්‍යය සඳහා මාර්ගෝපදේශයක් (FE264BF5_9C32_438F_8462_8A5DC8DEE49E) භාවිතා කළෙමි.

DECLARE @sql NVARCHAR(4000) = N'SELECT @@SERVERNAME as ServerName, GETDATE() AS Today;'
DECLARE @GlobalTempTable VARCHAR(100) = N'##FE264BF5_9C32_438F_8462_8A5DC8DEE49E_MyTempTable'

--@sql can be a stored procedure name like dbo.foo without parameters

DECLARE @TableDef NVARCHAR(MAX)

DROP TABLE IF EXISTS #MyTempTable
DROP TABLE IF EXISTS ##FE264BF5_9C32_438F_8462_8A5DC8DEE49E_MyTempTable

EXEC [dbo].[sp_GetTableDefinitionFromSqlBatch_DescribeFirstResultSet] 
    @sql, @GlobalTempTable, @TableDef OUTPUT

--Creates the global table ##FE264BF5_9C32_438F_8462_8A5DC8DEE49E_MyTempTable
EXEC sp_executesql @TableDef 

--Now Call the stored procedure, SQL Statement with Params etc.
INSERT ##FE264BF5_9C32_438F_8462_8A5DC8DEE49E_MyTempTable
    EXEC sp_executesql @sql 

--Select the results into your undefined Temp Table from the Global Table
SELECT * 
INTO #MyTempTable
FROM ##FE264BF5_9C32_438F_8462_8A5DC8DEE49E_MyTempTable

SELECT * FROM #MyTempTable

DROP TABLE IF EXISTS #MyTempTable
DROP TABLE IF EXISTS ##FE264BF5_9C32_438F_8462_8A5DC8DEE49E_MyTempTable

නැවතත්, මම එය පරීක්ෂා කර ඇත්තේ සරල ගබඩා කළ ක්‍රියා පටිපාටි විමසුම් සහ සරල විමසුම් සමඟ පමණි, එවිට ඔබේ සැතපුම් ගණන වෙනස් විය හැකිය. මෙය යමෙකුට උපකාරී වේ යැයි සිතමි.


1

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

GO
create procedure #TempTableForSP(@tableId int, @procedureId int)  
as   
begin  
    declare @tableName varchar(max) =  (select name  
                                        from tempdb.sys.tables 
                                        where object_id = @tableId
                                        );    
    declare @tsql nvarchar(max);    
    declare @tempId nvarchar(max) = newid();      
    set @tsql = '    
    declare @drop nvarchar(max) = (select  ''alter table tempdb.dbo.' + @tableName 
            +  ' drop column ''  + quotename(c.name) + '';''+ char(10)  
                                   from tempdb.sys.columns c   
                                   where c.object_id =  ' + 
                                         cast(@tableId as varchar(max)) + '  
                                   for xml path('''')  
                                  )    
    alter table tempdb.dbo.' + @tableName + ' add ' + QUOTENAME(@tempId) + ' int;
    exec sp_executeSQL @drop;    
    declare @add nvarchar(max) = (    
                                select ''alter table ' + @tableName 
                                      + ' add '' + name 
                                      + '' '' + system_type_name 
                           + case when d.is_nullable=1 then '' null '' else '''' end 
                                      + char(10)   
                              from sys.dm_exec_describe_first_result_set_for_object(' 
                               + cast(@procedureId as varchar(max)) + ', 0) d  
                                order by column_ordinal  
                                for xml path(''''))    

    execute sp_executeSQL  @add;    
    alter table '  + @tableName + ' drop column ' + quotename(@tempId) + '  ';      
    execute sp_executeSQL @tsql;  
end         
GO

create table #exampleTable (pk int);

declare @tableId int = object_Id('tempdb..#exampleTable')
declare @procedureId int = object_id('examplestoredProcedure')

exec #TempTableForSP @tableId, @procedureId;

insert into #exampleTable
exec examplestoredProcedure

ගබඩා කළ ක්‍රියාපටිපාටියේ ප්‍රති results ල තීරණය කිරීමට sys.dm_exec_describe_first_result_set_for_object ට නොහැකි නම් මෙය ක්‍රියාත්මක නොවන බව සලකන්න (උදාහරණයක් ලෙස එය තාවකාලික වගුවක් භාවිතා කරන්නේ නම්).


1

මෙන්න පරාමිතීන් සහිත මගේ T-SQL

sp_configure 'Show Advanced Options', 1
GO
RECONFIGURE
GO

sp_configure 'Ad Hoc Distributed Queries', 1
GO
RECONFIGURE
GO

DECLARE @param1 int = 1, @param2 int = 2
DECLARE @SQLStr varchar(max) = 'SELECT * INTO #MyTempTable
                                FROM OPENROWSET(''SQLNCLI'',  
''Server=ServerName;Database=DbName;Trusted_Connection=yes'',
''exec StoredProcedureName '+ CAST(@param1 AS varchar(15)) +','+ CAST(@param2 AS varchar(15)) +''') AS a ;
 select * from #MyTempTable;
 drop table #MyTempTable        
';
EXECUTE(@SQLStr);

0

ඔබ ගතික SQL ට තාවකාලික වගුවක් සෑදීමට ඉඩ දෙන්නේ නම්, මෙම වගුව ඩයිනමික් SQL සම්බන්ධතාවයට අයත් වේ, ඔබේ ගබඩා කළ ක්‍රියා පටිපාටිය කැඳවනු ලබන සම්බන්ධතාවයට වඩා වෙනස්ව.

DECLARE @COMMA_SEPARATED_KEYS varchar(MAX);
DROP TABLE IF EXISTS KV;
CREATE TABLE KV (id_person int, mykey varchar(30), myvalue int);
INSERT INTO KV VALUES
(1, 'age', 16),
(1, 'weight', 63),
(1, 'height', 175),
(2, 'age', 26),
(2, 'weight', 83),
(2, 'height', 185);
WITH cte(mykey) AS (
    SELECT DISTINCT mykey FROM KV
) 
SELECT @COMMA_SEPARATED_KEYS=STRING_AGG(mykey,',') FROM cte;
SELECT @COMMA_SEPARATED_KEYS AS keys;

රූප විස්තරය මෙහි ඇතුළත් කරන්න

DECLARE @ExecuteExpression varchar(MAX);

DROP TABLE IF EXISTS #Pivoted;

SET @ExecuteExpression = N'
SELECT * 
INTO #Pivoted
FROM
(
    SELECT
        mykey,
        myvalue,
        id_person
    FROM KV
) AS t
PIVOT(
    MAX(t.myvalue) 
    FOR mykey IN (COMMA_SEPARATED_KEYS)
) AS pivot_table;
';

SET @ExecuteExpression = REPLACE(@ExecuteExpression, 'COMMA_SEPARATED_KEYS', @COMMA_SEPARATED_KEYS);

EXEC(@ExecuteExpression);

SELECT * FROM #Pivoted;

Msg 208, 16 වන මට්ටම, රාජ්‍ය 0 අවලංගු වස්තු නම '#Pivoted'. මෙයට හේතුව #Pivoted ඩයිනමික් SQL සම්බන්ධතාවයට අයත් වීමයි. එබැවින් අවසාන උපදෙස්

SELECT * FROM #Pivoted

අසමත් වේ.

මෙම ගැටළුවට මුහුණ නොදෙන එක් ක්‍රමයක් නම්, #Pivoted පිළිබඳ සියලු යොමු කිරීම් ගතික විමසුම තුළම සිදු කර ඇති බවට වග බලා ගැනීමයි:

DECLARE @COMMA_SEPARATED_KEYS varchar(MAX);
DROP TABLE IF EXISTS KV;
CREATE TABLE KV (id_person int, mykey varchar(30), myvalue int);
INSERT INTO KV VALUES
(1, 'age', 16),
(1, 'weight', 63),
(1, 'height', 175),
(2, 'age', 26),
(2, 'weight', 83),
(2, 'height', 185);
WITH cte(mykey) AS (
    SELECT DISTINCT mykey FROM KV
) 
SELECT @COMMA_SEPARATED_KEYS=STRING_AGG(mykey,',') FROM cte;
SELECT @COMMA_SEPARATED_KEYS AS keys;


DECLARE @ExecuteExpression varchar(MAX);

DROP TABLE IF EXISTS #Pivoted;

SET @ExecuteExpression = N'
SELECT * 
INTO #Pivoted
FROM
(
    SELECT
        mykey,
        myvalue,
        id_person
    FROM KV
) AS t
PIVOT(
    MAX(t.myvalue) 
    FOR mykey IN (COMMA_SEPARATED_KEYS)
) AS pivot_table;
SELECT * FROM #Pivoted;
';

SET @ExecuteExpression = REPLACE(@ExecuteExpression, 'COMMA_SEPARATED_KEYS', @COMMA_SEPARATED_KEYS);

EXEC(@ExecuteExpression);

රූප විස්තරය මෙහි ඇතුළත් කරන්න


-5

මම පහත සඳහන් දේ කරන්නෙමි

  1. UDF (වගු අගය UDF) සාදන්න (SP බවට පරිවර්තනය කරන්න).

  2. select * into #tmpBusLine from dbo.UDF_getBusinessLineHistory '16 Mar 2009'


2
ඔබේ පළමු පියවර තැබීමට යම් බාධාවක් තිබිය හැකිය. උදාහරණයක් ලෙස මුල් පොලිස් අධිකාරී තාවකාලික වගු භාවිතා කරන්නේ නම්. UDF වලට තාවකාලික වගු භාවිතා කළ නොහැක.
යූසර්
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.