sql server - SQL सर्वर में एक temp तालिका और तालिका चर के बीच क्या अंतर है?




sql-server temp-tables (8)

किस परिदृश्य में एक दूसरे को निष्पादित करता है?

छोटी सारणी (1000 पंक्तियों से कम) के लिए एक अस्थायी चर का उपयोग करें, अन्यथा एक temp तालिका का उपयोग करें।

SQL सर्वर 2005 में, हम temp टेबल को दो तरीकों से बना सकते हैं:

declare @tmp table (Col1 int, Col2 int);

या

create table #tmp (Col1 int, Col2 int);

इन दोनों के बीच मतभेद क्या हैं? मैंने विवादित राय पढ़ी हैं कि @tmp अभी भी tempdb का उपयोग करता है, या अगर सबकुछ स्मृति में होता है।

किस परिदृश्य में एक दूसरे को निष्पादित करता है?


  1. टेम्प तालिका: डेटा बनाने और बैक अप लेने के लिए एक टेम्प तालिका आसान है।

    सारणी परिवर्तनीय: लेकिन तालिका परिवर्तक में प्रयास होता है जब हम आम तौर पर सामान्य टेबल बनाते हैं।

  2. Temp तालिका: Temp तालिका परिणाम एकाधिक उपयोगकर्ताओं द्वारा उपयोग किया जा सकता है।

    तालिका चर: लेकिन तालिका चर का उपयोग केवल वर्तमान उपयोगकर्ता द्वारा किया जा सकता है।

  3. टेम्प तालिका: Temp तालिका tempdb में संग्रहीत किया जाएगा। यह नेटवर्क यातायात बना देगा। जब हमारे पास temp तालिका में बड़ा डेटा होता है तो उसे डेटाबेस में काम करना पड़ता है। एक प्रदर्शन मुद्दा मौजूद होगा।

    तालिका चर: लेकिन एक तालिका चर कुछ डेटा के लिए भौतिक स्मृति में संग्रहीत करेगा, उसके बाद जब आकार बढ़ता है तो इसे tempdb में ले जाया जाएगा।

  4. Temp तालिका: Temp तालिका सभी डीडीएल संचालन कर सकते हैं। यह इंडेक्स, ड्रॉप, बदलना इत्यादि बनाने की इजाजत देता है ..,

    तालिका परिवर्तनीय: जबकि तालिका चर डीडीएल संचालन करने की अनुमति नहीं देगा। लेकिन तालिका चर हमें केवल क्लस्टर सूचकांक बनाने की अनुमति देता है।

  5. टेम्प तालिका: वर्तमान सत्र या वैश्विक के लिए टेम्प तालिका का उपयोग किया जा सकता है। ताकि एक से अधिक उपयोगकर्ता सत्र तालिका में परिणामों का उपयोग कर सकें।

    तालिका चर: लेकिन तालिका चर का उपयोग उस कार्यक्रम तक किया जा सकता है। (संग्रहीत प्रक्रिया)

  6. Temp तालिका: Temp चर लेनदेन का उपयोग नहीं कर सकते हैं। जब हम temp तालिका के साथ डीएमएल संचालन करते हैं तो यह रोलबैक हो सकता है या लेनदेन कर सकता है।

    तालिका चर: लेकिन हम टेबल चर के लिए यह नहीं कर सकते हैं।

  7. टेम्प तालिका: कार्य अस्थायी चर का उपयोग नहीं कर सकते हैं। अधिक से अधिक हम कार्यों में डीएमएल ऑपरेशन नहीं कर सकते हैं।

    तालिका चर: लेकिन फ़ंक्शन हमें तालिका चर का उपयोग करने की अनुमति देता है। लेकिन टेबल वैरिएबल का उपयोग करके हम ऐसा कर सकते हैं।

  8. Temp तालिका: संग्रहीत प्रक्रिया प्रत्येक उप अनुक्रम कॉल के लिए temp चर का उपयोग करते समय पुनर्मूल्यांकन (उसी निष्पादन योजना का उपयोग नहीं कर सकता) कर देगा।

    तालिका परिवर्तनीय: जबकि तालिका चर ऐसा नहीं करेगा।


अस्थायी सारणी (#tmp) और तालिका चर (@tmp) के बीच कुछ अंतर हैं, हालांकि tempdb का उपयोग करना उनमें से एक नहीं है, जैसा कि नीचे दिए गए एमएसडीएन लिंक में लिखा गया है।

अंगूठे के नियम के रूप में, डेटा के छोटे से मध्यम मात्रा और सरल उपयोग परिदृश्यों के लिए आपको तालिका चर का उपयोग करना चाहिए। (यह निश्चित रूप से बहुत सारे अपवादों के साथ एक व्यापक व्यापक दिशानिर्देश है - नीचे देखें और लेखों का पालन करें।)

उनके बीच चयन करते समय विचार करने के लिए कुछ बिंदु:

  • अस्थायी सारणी वास्तविक सारणी हैं ताकि आप इंडेक्स बनाना आदि जैसी चीजें कर सकें। यदि आपके पास बड़ी मात्रा में डेटा है जिसके लिए इंडेक्स द्वारा एक्सेस करना तेज़ होगा तो अस्थायी टेबल एक अच्छा विकल्प होगा।

  • तालिका चर में प्राथमिक कुंजी या अद्वितीय बाधाओं का उपयोग करके अनुक्रमणिका हो सकती है। (यदि आप एक गैर-अद्वितीय इंडेक्स चाहते हैं तो केवल प्राथमिक कुंजी कॉलम को अद्वितीय बाधा में अंतिम कॉलम के रूप में शामिल करें। यदि आपके पास कोई अनन्य कॉलम नहीं है, तो आप पहचान कॉलम का उपयोग कर सकते हैं।) SQL 2014 में गैर-अद्वितीय इंडेक्स भी हैं

  • तालिका चर लेनदेन में भाग नहीं लेते हैं और SELECT NOLOCK साथ निहित हैं। लेन-देन व्यवहार बहुत उपयोगी हो सकता है, उदाहरण के लिए यदि आप प्रक्रिया के माध्यम से मिडवे को रोलवे करना चाहते हैं तो उस लेनदेन के दौरान आबादी वाले टेबल वैरिएबल अभी भी पॉप्युलेट हो जाएंगे!

  • टेम्प्लेट टेबल का परिणाम संग्रहीत प्रक्रियाओं को संभवतः फिर से सम्मिलित किया जा सकता है। तालिका चर नहीं होगा।

  • आप SELECT INTO का उपयोग करके एक अस्थायी तालिका बना सकते हैं, जो लिखने के लिए तेज़ हो सकता है (विज्ञापन-प्रसार पूछताछ के लिए अच्छा) और समय के साथ बदलते डेटाटाइप से निपटने की अनुमति दे सकता है, क्योंकि आपको अपनी अस्थायी तालिका संरचना को पहले से परिभाषित करने की आवश्यकता नहीं है।

  • आप टेबल वैरिएबल को फ़ंक्शंस से वापस पास कर सकते हैं, जिससे आप तर्क को अधिक आसान और पुन: उपयोग कर सकते हैं (उदाहरण के लिए किसी स्ट्रिंग को कुछ मनमाने ढंग से डिलीमीटर पर एक स्ट्रिंग को विभाजित करने के लिए फ़ंक्शन बनाएं)।

  • उपयोगकर्ता परिभाषित कार्यों के भीतर तालिका चर का उपयोग करना उन कार्यों को अधिक व्यापक रूप से उपयोग करने में सक्षम बनाता है (विवरण के लिए फ़ंक्शन दस्तावेज़ बनाएं देखें)। यदि आप कोई फ़ंक्शन लिख रहे हैं तो आपको टेम्पलेट टेबल पर तालिका चर का उपयोग करना चाहिए जब तक कि अन्यथा कोई अनिवार्य आवश्यकता न हो।

  • Tempdb में दोनों तालिका चर और temp तालिकाओं को संग्रहीत किया जाता है। लेकिन तालिका चर (2005 से) वर्तमान डेटाबेस बनाम temp टेबल के संयोजन के लिए डिफ़ॉल्ट है जो tempdb ( ref ) का डिफ़ॉल्ट संयोजन लेता है। इसका मतलब है कि अगर आप temp टेबल का उपयोग करते हैं तो आपके कोलेबेशन समस्याओं से अवगत होना चाहिए और आपके डीबी collation tempdb के लिए अलग है, जिससे आप अपने डेटाबेस में डेटा के साथ temp तालिका में डेटा की तुलना करना चाहते हैं।

  • ग्लोबल टेम्प टेबल्स (## tmp) सभी सत्रों और उपयोगकर्ताओं के लिए उपलब्ध एक और प्रकार की अस्थायी तालिका है।

कुछ और पढ़ रहे हैं:


आप सभी के लिए जो मिथक पर विश्वास करते हैं कि अस्थायी चर केवल स्मृति में हैं

सबसे पहले, टेबल वैरिएबल आवश्यक स्मृति निवासी नहीं है। मेमोरी प्रेशर के तहत, टेबल वैरिएबल से संबंधित पेज tempdb पर धकेल दिए जा सकते हैं।

यहां आलेख पढ़ें: http://blogs.msdn.com/sqlserverstorageengine/archive/2008/03/30/sql-server-table-variable-vs-local-temporary-table.aspx


उद्धरण से लिया गया; पेशेवर एसक्यूएल सर्वर 2012 आंतरिक और समस्या निवारण

आंकड़े temp टेबल और तालिका चर के बीच बड़ा अंतर यह है कि तालिका चर पर आंकड़े नहीं बनाए जाते हैं। इसमें दो प्रमुख परिणाम हैं, जिनमें से सबसे पहले यह है कि क्वेरी ऑप्टिमाइज़र किसी तालिका चर में पंक्तियों की संख्या के लिए एक फिक्स्ड अनुमान का उपयोग करता है, चाहे वह डेटा हो। इसके अलावा, डेटा जोड़ना या निकालना अनुमान को नहीं बदलता है।

इंडेक्स आप तालिका चर पर इंडेक्स नहीं बना सकते हैं हालांकि आप बाधाएं बना सकते हैं। इसका मतलब है कि प्राथमिक कुंजी या अद्वितीय बाधाओं को बनाकर, आप तालिका चर पर इंडेक्स (जैसे बाधाओं का समर्थन करने के लिए बनाए गए हैं) हो सकते हैं। यहां तक ​​कि यदि आपके पास बाधाएं हैं, और इसलिए इंडेक्स में आंकड़े होंगे, तो क्वेरी का संकलन तब किया जाएगा जब क्वेरी संकलित की जाती है क्योंकि वे संकलन समय पर मौजूद नहीं होंगे, न ही वे पुनर्मूल्यांकन का कारण बनेंगे।

स्कीमा संशोधन स्कीमा संशोधन अस्थायी तालिकाओं पर संभव है लेकिन तालिका चर पर नहीं। हालांकि अस्थायी तालिकाओं पर स्कीमा मोडिफ़ी केशन संभव हैं, इनका उपयोग करने से बचें क्योंकि वे टेबल का उपयोग करने वाले बयानों के पुनर्मूल्यांकन का कारण बनते हैं।

टेबल VARIABLES स्मृति में नहीं बनाया गया है

एक आम गलतफहमी है कि तालिका चर इन-मेमोरी संरचनाएं हैं और जैसे अस्थायी तालिकाओं से तेज़ी से प्रदर्शन करेंगे । एक डीएमवी के लिए धन्यवाद sys कहा जाता है। डीएम _ डीबी _ सत्र _ स्पेस _ उपयोग, जो सत्र द्वारा tempdb उपयोग दिखाता है, आप साबित कर सकते हैं कि यह मामला नहीं है । डीएमवी को साफ़ करने के लिए SQL सर्वर को पुनरारंभ करने के बाद, निम्न स्क्रिप्ट को confi rm पर चलाएं कि आपका सत्र _ आईडी उपयोगकर्ता _ ऑब्जेक्ट्स _ alloc _ पृष्ठ _ गिनती के लिए 0 देता है:

SELECT session_id,
database_id,
user_objects_alloc_page_count
FROM sys.dm_db_session_space_usage
WHERE session_id > 50 ;

अब आप एक कॉलम के साथ एक अस्थायी तालिका बनाने के लिए निम्न स्क्रिप्ट चलाकर एक अस्थायी तालिका का उपयोग कर सकते हैं और इसे एक पंक्ति के साथ पॉप्युलेट कर सकते हैं:

CREATE TABLE #TempTable ( ID INT ) ;
INSERT INTO #TempTable ( ID )
VALUES ( 1 ) ;
GO
SELECT session_id,
database_id,
user_objects_alloc_page_count
FROM sys.dm_db_session_space_usage
WHERE session_id > 50 ;

मेरे सर्वर पर परिणाम इंगित करते हैं कि तालिका tempdb में एक पृष्ठ आवंटित की गई थी। अब एक ही स्क्रिप्ट चलाएं लेकिन इस बार एक टेबल वैरिएबल का उपयोग करें:

DECLARE @TempTable TABLE ( ID INT ) ;
INSERT INTO @TempTable ( ID )
VALUES ( 1 ) ;
GO
SELECT session_id,
database_id,
user_objects_alloc_page_count
FROM sys.dm_db_session_space_usage
WHERE session_id > 50 ;

किस का उपयोग करना है?

चाहे आप अस्थायी तालिकाओं या तालिका चर का उपयोग करते हैं, पूरी तरह से परीक्षण करके तय किया जाना चाहिए, लेकिन डिफ़ॉल्ट रूप से अस्थायी तालिकाओं की तरफ झुकना सबसे अच्छा है क्योंकि बहुत कम चीजें गलत हो सकती हैं

मैंने ग्राहकों को तालिका चर का उपयोग करके कोड विकसित किया है क्योंकि वे पंक्तियों की एक छोटी राशि से निपट रहे थे, और यह एक अस्थायी तालिका से तेज था, लेकिन कुछ साल बाद तालिका चर में सैकड़ों हजार पंक्तियां थीं और प्रदर्शन भयानक था , इसलिए जब आप अपना निर्णय लेते हैं तो कुछ क्षमता योजना बनाने की कोशिश करें और अनुमति दें!


एक और अंतर:

एक तालिका var केवल उस प्रक्रिया के भीतर बयान से पहुंचा जा सकता है जो इसे बनाता है, न कि उस प्रक्रिया या नेस्टेड गतिशील एसक्यूएल (निष्पादन या sp_executesql के माध्यम से) की अन्य प्रक्रियाओं से नहीं।

एक अस्थायी तालिका के दायरे, दूसरी तरफ, प्रक्रियाओं और नेस्टेड गतिशील एसक्यूएल में कोड शामिल है।

यदि आपकी प्रक्रिया द्वारा बनाई गई तालिका अन्य कॉल की गई प्रक्रियाओं या गतिशील एसक्यूएल से सुलभ होनी चाहिए, तो आपको एक temp तालिका का उपयोग करना होगा। जटिल परिस्थितियों में यह बहुत आसान हो सकता है।


स्वीकार्य उत्तर में केवल दावा को देखते हुए कि तालिका चर लॉगिंग में भाग नहीं लेते हैं।

ऐसा आमतौर पर असत्य लगता है कि लॉगिंग की मात्रा में कोई अंतर है (कम से कम तालिका में खुद को insert / update / delete ऑपरेशन के लिए हालांकि मुझे पता चला है कि संग्रहीत प्रक्रियाओं में कैश किए गए अस्थायी वस्तुओं के लिए इस संबंध में कुछ छोटा अंतर है अतिरिक्त सिस्टम टेबल अद्यतन)।

मैंने निम्नलिखित कार्यों के लिए @table_variable और #temp तालिका दोनों के खिलाफ लॉगिंग व्यवहार को देखा।

  1. सफल सम्मिलित करें
  2. मल्टी रो डालें जहां बाधा उल्लंघन के कारण कथन वापस आ गया था।
  3. अद्यतन करें
  4. हटाना
  5. पुनःआवंटन

लेनदेन लॉग रिकॉर्ड सभी परिचालनों के लिए लगभग समान थे।

तालिका परिवर्तनीय संस्करण में वास्तव में कुछ अतिरिक्त लॉग प्रविष्टियां हैं क्योंकि इसे sys.syssingleobjrefs बेस तालिका में (और बाद में हटा दिया गया) प्रविष्टि मिलती है लेकिन कुल मिलाकर कुछ कम बाइट लॉग इन होते थे क्योंकि तालिका चर के आंतरिक नाम 236 कम बाइट्स का उपभोग करते हैं #temp टेबल (118 कम nvarchar अक्षर) के लिए।

पुन: उत्पन्न करने के लिए पूर्ण स्क्रिप्ट (एकल उपयोगकर्ता मोड में शुरू होने वाले इंस्टेंस पर सबसे अच्छा रन और sqlcmd मोड का उपयोग करके)

:setvar tablename "@T" 
:setvar tablescript "DECLARE @T TABLE"

/*
 --Uncomment this section to test a #temp table
:setvar tablename "#T" 
:setvar tablescript "CREATE TABLE #T"
*/

USE tempdb 
GO    
CHECKPOINT

DECLARE @LSN NVARCHAR(25)

SELECT @LSN = MAX([Current LSN])
FROM fn_dblog(null, null) 


EXEC(N'BEGIN TRAN StartBatch
SAVE TRAN StartBatch
COMMIT

$(tablescript)
(
[4CA996AC-C7E1-48B5-B48A-E721E7A435F0] INT PRIMARY KEY DEFAULT 0,
InRowFiller char(7000) DEFAULT ''A'',
OffRowFiller varchar(8000) DEFAULT REPLICATE(''B'',8000),
LOBFiller varchar(max) DEFAULT REPLICATE(cast(''C'' as varchar(max)),10000)
)


BEGIN TRAN InsertFirstRow
SAVE TRAN InsertFirstRow
COMMIT

INSERT INTO $(tablename)
DEFAULT VALUES

BEGIN TRAN Insert9Rows
SAVE TRAN Insert9Rows
COMMIT


INSERT INTO $(tablename) ([4CA996AC-C7E1-48B5-B48A-E721E7A435F0])
SELECT TOP 9 ROW_NUMBER() OVER (ORDER BY (SELECT 0))
FROM sys.all_columns

BEGIN TRAN InsertFailure
SAVE TRAN InsertFailure
COMMIT


/*Try and Insert 10 rows, the 10th one will cause a constraint violation*/
BEGIN TRY
INSERT INTO $(tablename) ([4CA996AC-C7E1-48B5-B48A-E721E7A435F0])
SELECT TOP (10) (10 + ROW_NUMBER() OVER (ORDER BY (SELECT 0))) % 20
FROM sys.all_columns
END TRY
BEGIN CATCH
PRINT ERROR_MESSAGE()
END CATCH

BEGIN TRAN Update10Rows
SAVE TRAN Update10Rows
COMMIT

UPDATE $(tablename)
SET InRowFiller = LOWER(InRowFiller),
    OffRowFiller  =LOWER(OffRowFiller),
    LOBFiller  =LOWER(LOBFiller)


BEGIN TRAN Delete10Rows
SAVE TRAN Delete10Rows
COMMIT

DELETE FROM  $(tablename)
BEGIN TRAN AfterDelete
SAVE TRAN AfterDelete
COMMIT

BEGIN TRAN EndBatch
SAVE TRAN EndBatch
COMMIT')


DECLARE @LSN_HEX NVARCHAR(25) = 
        CAST(CAST(CONVERT(varbinary,SUBSTRING(@LSN, 1, 8),2) AS INT) AS VARCHAR) + ':' +
        CAST(CAST(CONVERT(varbinary,SUBSTRING(@LSN, 10, 8),2) AS INT) AS VARCHAR) + ':' +
        CAST(CAST(CONVERT(varbinary,SUBSTRING(@LSN, 19, 4),2) AS INT) AS VARCHAR)        

SELECT 
    [Operation],
    [Context],
    [AllocUnitName],
    [Transaction Name],
    [Description]
FROM   fn_dblog(@LSN_HEX, null) AS D
WHERE  [Current LSN] > @LSN  

SELECT CASE
         WHEN GROUPING(Operation) = 1 THEN 'Total'
         ELSE Operation
       END AS Operation,
       Context,
       AllocUnitName,
       COALESCE(SUM([Log Record Length]), 0) AS [Size in Bytes],
       COUNT(*)                              AS Cnt
FROM   fn_dblog(@LSN_HEX, null) AS D
WHERE  [Current LSN] > @LSN  
GROUP BY GROUPING SETS((Operation, Context, AllocUnitName),())

परिणाम

+-----------------------+--------------------+---------------------------+---------------+------+---------------+------+------------------+
|                       |                    |                           |             @TV      |             #TV      |                  |
+-----------------------+--------------------+---------------------------+---------------+------+---------------+------+------------------+
| Operation             | Context            | AllocUnitName             | Size in Bytes | Cnt  | Size in Bytes | Cnt  | Difference Bytes |
+-----------------------+--------------------+---------------------------+---------------+------+---------------+------+------------------+
| LOP_ABORT_XACT        | LCX_NULL           |                           | 52            | 1    | 52            | 1    |                  |
| LOP_BEGIN_XACT        | LCX_NULL           |                           | 6056          | 50   | 6056          | 50   |                  |
| LOP_COMMIT_XACT       | LCX_NULL           |                           | 2548          | 49   | 2548          | 49   |                  |
| LOP_COUNT_DELTA       | LCX_CLUSTERED      | sys.sysallocunits.clust   | 624           | 3    | 624           | 3    |                  |
| LOP_COUNT_DELTA       | LCX_CLUSTERED      | sys.sysrowsets.clust      | 208           | 1    | 208           | 1    |                  |
| LOP_COUNT_DELTA       | LCX_CLUSTERED      | sys.sysrscols.clst        | 832           | 4    | 832           | 4    |                  |
| LOP_CREATE_ALLOCCHAIN | LCX_NULL           |                           | 120           | 3    | 120           | 3    |                  |
| LOP_DELETE_ROWS       | LCX_INDEX_INTERIOR | Unknown Alloc Unit        | 720           | 9    | 720           | 9    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysallocunits.clust   | 444           | 3    | 444           | 3    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysallocunits.nc      | 276           | 3    | 276           | 3    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.syscolpars.clst       | 628           | 4    | 628           | 4    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.syscolpars.nc         | 484           | 4    | 484           | 4    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysidxstats.clst      | 176           | 1    | 176           | 1    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysidxstats.nc        | 144           | 1    | 144           | 1    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysiscols.clst        | 100           | 1    | 100           | 1    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysiscols.nc1         | 88            | 1    | 88            | 1    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysobjvalues.clst     | 596           | 5    | 596           | 5    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysrowsets.clust      | 132           | 1    | 132           | 1    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysrscols.clst        | 528           | 4    | 528           | 4    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysschobjs.clst       | 1040          | 6    | 1276          | 6    | 236              |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysschobjs.nc1        | 820           | 6    | 1060          | 6    | 240              |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysschobjs.nc2        | 820           | 6    | 1060          | 6    | 240              |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.sysschobjs.nc3        | 480           | 6    | 480           | 6    |                  |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.syssingleobjrefs.clst | 96            | 1    |               |      | -96              |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | sys.syssingleobjrefs.nc1  | 88            | 1    |               |      | -88              |
| LOP_DELETE_ROWS       | LCX_MARK_AS_GHOST  | Unknown Alloc Unit        | 72092         | 19   | 72092         | 19   |                  |
| LOP_DELETE_ROWS       | LCX_TEXT_MIX       | Unknown Alloc Unit        | 16348         | 37   | 16348         | 37   |                  |
| LOP_FORMAT_PAGE       | LCX_HEAP           | Unknown Alloc Unit        | 1596          | 19   | 1596          | 19   |                  |
| LOP_FORMAT_PAGE       | LCX_IAM            | Unknown Alloc Unit        | 252           | 3    | 252           | 3    |                  |
| LOP_FORMAT_PAGE       | LCX_INDEX_INTERIOR | Unknown Alloc Unit        | 84            | 1    | 84            | 1    |                  |
| LOP_FORMAT_PAGE       | LCX_TEXT_MIX       | Unknown Alloc Unit        | 4788          | 57   | 4788          | 57   |                  |
| LOP_HOBT_DDL          | LCX_NULL           |                           | 108           | 3    | 108           | 3    |                  |
| LOP_HOBT_DELTA        | LCX_NULL           |                           | 9600          | 150  | 9600          | 150  |                  |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | sys.sysallocunits.clust   | 456           | 3    | 456           | 3    |                  |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | sys.syscolpars.clst       | 644           | 4    | 644           | 4    |                  |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | sys.sysidxstats.clst      | 180           | 1    | 180           | 1    |                  |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | sys.sysiscols.clst        | 104           | 1    | 104           | 1    |                  |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | sys.sysobjvalues.clst     | 616           | 5    | 616           | 5    |                  |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | sys.sysrowsets.clust      | 136           | 1    | 136           | 1    |                  |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | sys.sysrscols.clst        | 544           | 4    | 544           | 4    |                  |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | sys.sysschobjs.clst       | 1064          | 6    | 1300          | 6    | 236              |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | sys.syssingleobjrefs.clst | 100           | 1    |               |      | -100             |
| LOP_INSERT_ROWS       | LCX_CLUSTERED      | Unknown Alloc Unit        | 135888        | 19   | 135888        | 19   |                  |
| LOP_INSERT_ROWS       | LCX_INDEX_INTERIOR | Unknown Alloc Unit        | 1596          | 19   | 1596          | 19   |                  |
| LOP_INSERT_ROWS       | LCX_INDEX_LEAF     | sys.sysallocunits.nc      | 288           | 3    | 288           | 3    |                  |
| LOP_INSERT_ROWS       | LCX_INDEX_LEAF     | sys.syscolpars.nc         | 500           | 4    | 500           | 4    |                  |
| LOP_INSERT_ROWS       | LCX_INDEX_LEAF     | sys.sysidxstats.nc        | 148           | 1    | 148           | 1    |                  |
| LOP_INSERT_ROWS       | LCX_INDEX_LEAF     | sys.sysiscols.nc1         | 92            | 1    | 92            | 1    |                  |
| LOP_INSERT_ROWS       | LCX_INDEX_LEAF     | sys.sysschobjs.nc1        | 844           | 6    | 1084          | 6    | 240              |
| LOP_INSERT_ROWS       | LCX_INDEX_LEAF     | sys.sysschobjs.nc2        | 844           | 6    | 1084          | 6    | 240              |
| LOP_INSERT_ROWS       | LCX_INDEX_LEAF     | sys.sysschobjs.nc3        | 504           | 6    | 504           | 6    |                  |
| LOP_INSERT_ROWS       | LCX_INDEX_LEAF     | sys.syssingleobjrefs.nc1  | 92            | 1    |               |      | -92              |
| LOP_INSERT_ROWS       | LCX_TEXT_MIX       | Unknown Alloc Unit        | 5112          | 71   | 5112          | 71   |                  |
| LOP_MARK_SAVEPOINT    | LCX_NULL           |                           | 508           | 8    | 508           | 8    |                  |
| LOP_MODIFY_COLUMNS    | LCX_CLUSTERED      | Unknown Alloc Unit        | 1560          | 10   | 1560          | 10   |                  |
| LOP_MODIFY_HEADER     | LCX_HEAP           | Unknown Alloc Unit        | 3780          | 45   | 3780          | 45   |                  |
| LOP_MODIFY_ROW        | LCX_CLUSTERED      | sys.syscolpars.clst       | 384           | 4    | 384           | 4    |                  |
| LOP_MODIFY_ROW        | LCX_CLUSTERED      | sys.sysidxstats.clst      | 100           | 1    | 100           | 1    |                  |
| LOP_MODIFY_ROW        | LCX_CLUSTERED      | sys.sysrowsets.clust      | 92            | 1    | 92            | 1    |                  |
| LOP_MODIFY_ROW        | LCX_CLUSTERED      | sys.sysschobjs.clst       | 1144          | 13   | 1144          | 13   |                  |
| LOP_MODIFY_ROW        | LCX_IAM            | Unknown Alloc Unit        | 4224          | 48   | 4224          | 48   |                  |
| LOP_MODIFY_ROW        | LCX_PFS            | Unknown Alloc Unit        | 13632         | 169  | 13632         | 169  |                  |
| LOP_MODIFY_ROW        | LCX_TEXT_MIX       | Unknown Alloc Unit        | 108640        | 120  | 108640        | 120  |                  |
| LOP_ROOT_CHANGE       | LCX_CLUSTERED      | sys.sysallocunits.clust   | 960           | 10   | 960           | 10   |                  |
| LOP_SET_BITS          | LCX_GAM            | Unknown Alloc Unit        | 1200          | 20   | 1200          | 20   |                  |
| LOP_SET_BITS          | LCX_IAM            | Unknown Alloc Unit        | 1080          | 18   | 1080          | 18   |                  |
| LOP_SET_BITS          | LCX_SGAM           | Unknown Alloc Unit        | 120           | 2    | 120           | 2    |                  |
| LOP_SHRINK_NOOP       | LCX_NULL           |                           |               |      | 32            | 1    | 32               |
+-----------------------+--------------------+---------------------------+---------------+------+---------------+------+------------------+
| Total                 |                    |                           | 410144        | 1095 | 411232        | 1092 | 1088             |
+-----------------------+--------------------+---------------------------+---------------+------+---------------+------+------------------+

अस्थायी तालिका

अस्थायी तालिका वास्तविक टेबल की तरह व्यवहार करती है लेकिन रन टाइम पर बनाई गई है। इसका काम असली टेबल के समान है। हम लगभग हर परिचालन कर सकते हैं जो वास्तविक तालिकाओं में संभव है। हम अस्थायी सारणी पर ALTER, CREATE, DROP जैसे डीडीएल स्टेटमेंट का उपयोग कर सकते हैं।

सृजन के बाद अस्थायी तालिका की संरचना में कोई भी बदलाव संभव है। सिस्टम डेटाबेस के डेटाबेस "tempdb" डेटाबेस में संग्रहीत अस्थायी तालिका।

अस्थायी तालिका लेनदेन, लॉगिंग या लॉकिंग में भाग लेती है। उस कारण से यह तालिका परिवर्तनीय से धीमा है।

तालिका परिवर्तनीय

यह परिवर्तनीय है लेकिन एक टेबल की तरह काम करते हैं। यह Tempdb डेटाबेस में भी स्मृति में नहीं बनाया गया है। तालिका परिवर्तनीय केवल बैच या संग्रहीत प्रक्रिया क्षेत्र में उपलब्ध है। आपको टेबल वेरिएबल ड्रॉप करने की आवश्यकता नहीं है, बैच और स्टोर प्रक्रिया निष्पादन प्रक्रिया पूरी होने पर यह स्वचालित रूप से गिरा दिया जाता है

तालिका परिवर्तनीय समर्थन प्राथमिक कुंजी, निर्माण समय पर पहचान। लेकिन यह गैर-क्लस्टर सूचकांक का समर्थन नहीं करता है। घोषणा के बाद प्राथमिक कुंजी, पहचान आप उन्हें संशोधित नहीं कर सकते हैं।

तालिका चर लेनदेन, लॉगिंग या लॉकिंग में भाग नहीं लेते हैं। लेन-देन, लॉगिंग और लॉकिंग तालिका चर के लिए प्रभाव नहीं है।

अधिक जानकारी के लिए इस लेख को पढ़ें - http://goo.gl/GXtXqz





table-variable