टी-एसक्यूएल संग्रहित प्रक्रियाओं में गतिशील रूप से टेबल कैसे बनाएं?

आप टेबल वेरिएबल का उपयोग कर रहे हैं यानी आपको टेबल घोषित करना चाहिए। यह एक अस्थायी तालिका नहीं है।

आप इस तरह एक अस्थायी तालिका बनाते हैं:

CREATE TABLE #customer
(
     Name varchar(32) not null
)

आप इस तरह एक टेबल वैरिएबल घोषित करते हैं:

DECLARE @Customer TABLE
(
      Name varchar(32) not null
)

ध्यान दें कि एक अस्थायी तालिका को # का उपयोग करके घोषित किया जाता है और एक तालिका चर को @ का उपयोग करके घोषित किया जाता है। तालिका चर और अस्थायी तालिकाओं के बीच अंतर के बारे में पढ़ें।

अद्यतन करें:

नीचे आपकी टिप्पणी के आधार पर आप वास्तव में एक संग्रहित प्रक्रिया में टेबल बनाने की कोशिश कर रहे हैं। इसके लिए आपको डायनेमिक एसक्यूएल का इस्तेमाल करना होगा। मूल रूप से गतिशील एसक्यूएल आपको एक स्ट्रिंग के रूप में एक एसक्यूएल स्टेटमेंट बनाने और फिर इसे निष्पादित करने की अनुमति देता है। यह एकमात्र तरीका है जिससे आप संग्रहीत कार्यविधि में तालिका बना पाएंगे। मैं आपको दिखाने जा रहा हूं कि कैसे और फिर चर्चा करें कि यह आम तौर पर एक अच्छा विचार क्यों नहीं है।

अब एक साधारण उदाहरण के लिए (मैंने इस कोड का परीक्षण नहीं किया है, लेकिन यह आपको यह कैसे करना है इसका एक अच्छा संकेत देना चाहिए):

CREATE PROCEDURE sproc_BuildTable 
    @TableName NVARCHAR(128)
   ,@Column1Name NVARCHAR(32)
   ,@Column1DataType NVARCHAR(32)
   ,@Column1Nullable NVARCHAR(32)
AS

   DECLARE @SQLString NVARCHAR(MAX)
   SET @SQString = 'CREATE TABLE '[email protected] + '( '[email protected]+' '[email protected] +' '[email protected] +') ON PRIMARY '

   EXEC (@SQLString)
   GO

इस संग्रहीत कार्यविधि को इस प्रकार निष्पादित किया जा सकता है:

sproc_BuildTable 'Customers','CustomerName','VARCHAR(32)','NOT NULL'

इस प्रकार की संग्रहीत कार्यविधि में कुछ प्रमुख समस्याएं हैं।

जटिल तालिकाओं को पूरा करना मुश्किल होगा। निम्न तालिका संरचना की कल्पना करें:

CREATE TABLE [dbo].[Customers] (
    [CustomerID] [int] IDENTITY(1,1) NOT NULL,
    [CustomerName] [nvarchar](64) NOT NULL,
    [CustomerSUrname] [nvarchar](64) NOT NULL,
    [CustomerDateOfBirth] [datetime] NOT NULL,
    [CustomerApprovedDiscount] [decimal](3, 2) NOT NULL,
    [CustomerActive] [bit] NOT NULL,
    CONSTRAINT [PK_Customers] PRIMARY KEY CLUSTERED 
    (
        [CustomerID] 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

ALTER TABLE [dbo].[Customers] ADD CONSTRAINT [DF_Customers_CustomerApprovedDiscount] DEFAULT ((0.00)) FOR [CustomerApprovedDiscount]
GO 

यह तालिका पहले उदाहरण की तुलना में थोड़ी अधिक जटिल है, लेकिन बहुत अधिक नहीं है। इससे निपटने के लिए संग्रहीत प्रक्रिया बहुत अधिक जटिल होगी। इसलिए जबकि यह दृष्टिकोण छोटी तालिकाओं के लिए काम कर सकता है, यह जल्दी से अप्रबंधनीय होने वाला है।

टेबल बनाने के लिए योजना की आवश्यकता होती है। जब आप टेबल बनाते हैं तो उन्हें अलग-अलग फाइलग्रुप पर रणनीतिक रूप से रखा जाना चाहिए। यह सुनिश्चित करने के लिए है कि आप डिस्क I/O विवाद का कारण नहीं बनते हैं। यदि सब कुछ प्राथमिक फ़ाइल समूह पर बनाया गया है, तो आप मापनीयता को कैसे संबोधित करेंगे?

क्या आप स्पष्ट कर सकते हैं कि आपको गतिशील रूप से टेबल बनाने की आवश्यकता क्यों है?

अद्यतन 2:

कार्यभार के कारण विलंबित अद्यतन। मैंने प्रत्येक दुकान के लिए एक टेबल बनाने की आवश्यकता के बारे में आपकी टिप्पणी पढ़ी और मुझे लगता है कि आपको इसे उस उदाहरण की तरह करना चाहिए जो मैं आपको देने जा रहा हूं।

इस उदाहरण में मैं निम्नलिखित धारणाएँ बनाता हूँ:

1. यह एक ई-कॉमर्स साइट है जिसमें कई दुकानें हैं
2. एक दुकान में बेचने के लिए कई वस्तुएँ (वस्तुएँ) हो सकती हैं।
3. एक विशेष वस्तु (अच्छी) कई दुकानों पर बेची जा सकती है
4. एक दुकान अलग-अलग वस्तुओं (वस्तुओं) के लिए अलग-अलग कीमत वसूल करेगी
5. सभी कीमतें $ (USD) में हैं

मान लें कि यह ई-कॉमर्स साइट गेमिंग कंसोल (यानी Wii, PS3, XBOX360) बेचती है।

मेरी धारणाओं को देखते हुए मैं एक शास्त्रीय कई-से-अनेक संबंध देखता हूं। एक दुकान कई वस्तुओं (वस्तुओं) को बेच सकती है और वस्तुओं (माल) को कई दुकानों पर बेचा जा सकता है। आइए इसे तालिकाओं में विभाजित करें।

सबसे पहले मुझे दुकान के बारे में सारी जानकारी स्टोर करने के लिए एक दुकान की मेज की आवश्यकता होगी।

एक साधारण दुकान तालिका इस तरह दिख सकती है:

CREATE TABLE [dbo].[Shop](
    [ShopID] [int] IDENTITY(1,1) NOT NULL,
    [ShopName] [nvarchar](128) NOT NULL,
    CONSTRAINT [PK_Shop] PRIMARY KEY CLUSTERED 
    (
      [ShopID] 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

आइए हमारे उदाहरण के दौरान उपयोग करने के लिए डेटाबेस में तीन दुकानें डालें। निम्नलिखित कोड तीन दुकानों को सम्मिलित करेगा:

INSERT INTO Shop
SELECT 'American Games R US'
UNION
SELECT 'Europe Gaming Experience'
UNION
SELECT 'Asian Games Emporium'

यदि आप एक SELECT * FROM Shop . निष्पादित करते हैं आप शायद निम्नलिखित देखेंगे:

ShopID  ShopName
1           American Games R US
2           Asian Games Emporium
3           Europe Gaming Experience

ठीक है, तो चलिए अब आइटम्स (माल) टेबल पर चलते हैं। चूंकि आइटम/माल विभिन्न कंपनियों के उत्पाद हैं, इसलिए मैं टेबल उत्पाद को कॉल करने जा रहा हूं। एक साधारण उत्पाद तालिका बनाने के लिए आप निम्न कोड निष्पादित कर सकते हैं।

CREATE TABLE [dbo].[Product](
    [ProductID] [int] IDENTITY(1,1) NOT NULL,
    [ProductDescription] [nvarchar](128) NOT NULL,
 CONSTRAINT [PK_Product] PRIMARY KEY CLUSTERED 
 (
     [ProductID] 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

आइए कुछ उत्पादों के साथ उत्पाद तालिका को पॉप्युलेट करें। कुछ उत्पादों को सम्मिलित करने के लिए निम्न कोड निष्पादित करें:

INSERT INTO Product
SELECT 'Wii'
UNION 
SELECT 'PS3'
UNION 
SELECT 'XBOX360'

अगर आप SELECT * FROM Product execute को एक्सीक्यूट करते हैं आप शायद निम्नलिखित देखेंगे:

ProductID   ProductDescription
1           PS3
2           Wii
3           XBOX360

ठीक है, इस समय आपके पास उत्पाद और दुकान दोनों की जानकारी है। तो आप उन्हें एक साथ कैसे लाते हैं? वैसे हम जानते हैं कि हम दुकान की पहचान उसके ShopID प्राथमिक कुंजी कॉलम से कर सकते हैं और हम जानते हैं कि हम किसी उत्पाद की पहचान उसके ProductID प्राथमिक कुंजी कॉलम से कर सकते हैं। साथ ही, चूंकि प्रत्येक दुकान में प्रत्येक उत्पाद के लिए एक अलग कीमत होती है, इसलिए हमें उस उत्पाद के लिए दुकान द्वारा शुल्क की जाने वाली कीमत को स्टोर करने की आवश्यकता होती है।

तो हमारे पास एक टेबल है जो उत्पाद के लिए दुकान को मैप करती है। हम इस टेबल को ShopProduct कहेंगे। इस तालिका का एक साधारण संस्करण इस तरह दिख सकता है:

CREATE TABLE [dbo].[ShopProduct](
[ShopID] [int] NOT NULL,
[ProductID] [int] NOT NULL,
[Price] [money] NOT NULL,
CONSTRAINT [PK_ShopProduct] PRIMARY KEY CLUSTERED 
 (
     [ShopID] ASC,
      [ProductID] 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

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

यहां बताया गया है कि हम मैपिंग कैसे करने जा रहे हैं। मेरे उदाहरण में American Games R Us का ShopID मान 1 है (यह प्राथमिक कुंजी मान है) और मैं देख सकता हूं कि XBOX360 का मान 3 है और दुकान ने XBOX360 को $159.99

निम्नलिखित कोड निष्पादित करके आप मानचित्रण पूरा करेंगे:

INSERT INTO ShopProduct VALUES(1,3,159.99)

अब हम यूरोप गेमिंग एक्सपीरियंस शॉप में सभी उत्पाद जोड़ना चाहते हैं। इस उदाहरण में हम जानते हैं कि यूरोप गेमिंग एक्सपीरियंस शॉप में 3 का ShopID है और चूंकि यह सभी कंसोल बेचता है, इसलिए हमें ProductID 1, 2 और 3 को मैपिंग टेबल में डालने की आवश्यकता होगी। आइए मान लें कि यूरोप गेमिंग एक्सपीरियंस शॉप में कंसोल (उत्पादों) की कीमतें इस प्रकार हैं:1- PS3 $259.99 में बिकता है, 2- Wii $159.99 में बिकता है, 3- XBOX360 $199.99 में बिकता है।

इस मैपिंग को करने के लिए आपको निम्नलिखित कोड निष्पादित करने की आवश्यकता होगी:

INSERT INTO ShopProduct VALUES(3,2,159.99) --This will insert the WII console into the mapping table for the Europe Gaming Experience Shop with a price of 159.99
INSERT INTO ShopProduct VALUES(3,1,259.99) --This will insert the PS3 console into the mapping table for the Europe Gaming Experience Shop with a price of 259.99
INSERT INTO ShopProduct VALUES(3,3,199.99) --This will insert the XBOX360 console into the mapping table for the Europe Gaming Experience Shop with a price of 199.99

इस बिंदु पर आपने दो दुकानों और उनके उत्पादों को मानचित्रण तालिका में मैप किया है। ठीक है, तो अब मैं वेबसाइट ब्राउज़ करने वाले उपयोगकर्ता को दिखाने के लिए यह सब एक साथ कैसे लाऊं? मान लें कि आप एक वेब पेज पर एक उपयोगकर्ता को यूरोपीय गेमिंग अनुभव के लिए सभी उत्पाद दिखाना चाहते हैं - आपको निम्न क्वेरी निष्पादित करने की आवश्यकता होगी:

SELECT      Shop.*
        , ShopProduct.*
        , Product.*
FROM         Shop 
INNER JOIN  ShopProduct ON Shop.ShopID = ShopProduct.ShopID 
INNER JOIN  Product ON ShopProduct.ProductID = Product.ProductID
WHERE       Shop.ShopID=3

आप शायद निम्नलिखित परिणाम देखेंगे:

ShopID     ShopName                 ShopID  ProductID   Price   ProductID   ProductDescription
3          Europe Gaming Experience   3         1       259.99  1           PS3
3          Europe Gaming Experience   3         2       159.99  2           Wii
3          Europe Gaming Experience   3         3       199.99  3           XBOX360

अब एक आखिरी उदाहरण के लिए, मान लें कि आपकी वेबसाइट में एक ऐसी सुविधा है जो कंसोल के लिए सबसे सस्ती कीमत ढूंढती है। एक उपयोगकर्ता XBOX360 के लिए सबसे सस्ते दाम खोजने के लिए कहता है।

आप निम्न क्वेरी निष्पादित कर सकते हैं:

 SELECT     Shop.*
        , ShopProduct.*
        , Product.*
 FROM         Shop 
 INNER JOIN  ShopProduct ON Shop.ShopID = ShopProduct.ShopID 
 INNER JOIN  Product ON ShopProduct.ProductID = Product.ProductID
 WHERE      Product.ProductID =3  -- You can also use Product.ProductDescription = 'XBOX360'
 ORDER BY    Price ASC

यह क्वेरी उन सभी दुकानों की सूची लौटाएगी जो सबसे पहले सबसे सस्ती दुकान के साथ XBOX360 को बेचती हैं और इसी तरह आगे भी।

आप देखेंगे कि मैंने एशियन गेम्स की दुकान नहीं जोड़ी है। एक अभ्यास के रूप में, एशियन गेम्स शॉप को निम्नलिखित उत्पादों के साथ मैपिंग टेबल में जोड़ें:एशियन गेम्स एम्पोरियम Wii गेम कंसोल को $99.99 में और PS3 कंसोल को $159.99 में बेचता है। यदि आप इस उदाहरण के माध्यम से काम करते हैं तो अब आपको समझना चाहिए कि कई-से-अनेक संबंधों को कैसे मॉडल किया जाए।

मुझे आशा है कि यह डेटाबेस डिज़ाइन के साथ आपकी यात्रा में आपकी सहायता करेगा।