SQL सर्वर में, VALUES एक टेबल वैल्यू कंस्ट्रक्टर है जो एक टेबल में बनाए जाने वाले रो वैल्यू एक्सप्रेशन के सेट को निर्दिष्ट करता है।
VALUES क्लॉज का प्रयोग अक्सर INSERT . के साथ किया जाता है डेटा डालने के लिए स्टेटमेंट, लेकिन इसे USING . में से किसी एक में व्युत्पन्न तालिका के रूप में भी इस्तेमाल किया जा सकता है MERGE . का खंड कथन या FROM खंड।
सिंटैक्स
VALUES ( <row value expression list> ) [ ,...n ]
<row value expression list> ::=
{<row value expression> } [ ,...n ]
<row value expression> ::=
{ DEFAULT | NULL | expression }
ध्यान दें कि DEFAULT केवल एक INSERT . में अनुमति है बयान। DEFAULT कॉलम के लिए परिभाषित डिफ़ॉल्ट मान डालने के लिए SQL सर्वर को बाध्य करता है। यदि कॉलम के लिए कोई डिफ़ॉल्ट मौजूद नहीं है और कॉलम शून्य मानों की अनुमति देता है, NULL डाला जाता है। DEFAULT पहचान कॉलम पर इस्तेमाल नहीं किया जा सकता।
उदाहरण
यहां कुछ उदाहरण दिए गए हैं जो प्रदर्शित करते हैं कि कैसे VALUES SQL सर्वर में उपयोग किया जा सकता है।
INSERT में प्रयुक्त कथन
यहां VALUES . का उपयोग करने का एक उदाहरण दिया गया है INSERT . के भाग के रूप में क्लॉज कथन:
CREATE TABLE Idiots (
IdiotId int IDENTITY(1,1) NOT NULL,
FirstName varchar(50),
LastName varchar(50)
);
INSERT INTO Idiots VALUES
('Peter', 'Griffin'),
('Homer', 'Simpson'),
('Ned', 'Flanders');
इसने Idiots . नाम की एक टेबल बनाई और उसमें तीन पंक्तियाँ डालीं।
अब हम SELECT . का उपयोग कर सकते हैं तालिका में नए मान देखने के लिए कथन:
SELECT * FROM Idiots;परिणाम:
+-----------+-------------+------------+ | IdiotId | FirstName | LastName | |-----------+-------------+------------| | 1 | Peter | Griffin | | 2 | Homer | Simpson | | 3 | Ned | Flanders | +-----------+-------------+------------+
जब VALUES क्लॉज का प्रयोग INSERT . में किया जाता है कथन, 1000 पंक्तियों की सीमा है। इसे दूर करने का एक तरीका VALUES . का उपयोग करना है एक SELECT . में एक व्युत्पन्न तालिका बनाने के लिए कथन। यह हमें कई INSERT . का उपयोग करने से बचाता है स्टेटमेंट या बल्क इंसर्ट करना।
SELECT में उपयोग किया जाता है कथन
हम VALUES . का उपयोग कर सकते हैं FROM . में एक व्युत्पन्न तालिका बनाने के लिए खंड। यह रहा एक SELECT प्रदर्शित करने के लिए कथन:
SELECT
FirstName,
LastName
FROM
(VALUES
(1, 'Peter', 'Griffin'),
(2, 'Homer', 'Simpson'),
(3, 'Ned', 'Flanders')
) AS Idiots(IdiotId, FirstName, LastName)
WHERE IdiotId = 2;परिणाम:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Simpson | +-------------+------------+
व्युत्पन्न तालिकाओं का उपयोग डेटाबेस में मान सम्मिलित करते समय 1000 पंक्ति सीमा को पार करने के लिए किया जा सकता है।
MERGE में प्रयुक्त कथन
यहां VALUES का एक उदाहरण दिया गया है MERGE . में उपयोग किया जा रहा है कथन:
DECLARE @Changes TABLE(Change VARCHAR(20));
MERGE INTO Idiots AS Target
USING ( VALUES
(3, 'Ned', 'Okily Dokily!'),
(4, 'Lloyd','Christmas'),
(5, 'Harry', 'Dunne')
) AS Source ( IdiotId, FirstName, LastName )
ON Target.IdiotId = Source.IdiotId
AND Target.FirstName = Source.FirstName
WHEN MATCHED THEN
UPDATE SET FirstName = Source.FirstName, LastName = Source.LastName
WHEN NOT MATCHED BY TARGET THEN
INSERT (FirstName, LastName) VALUES (Source.FirstName, Source.LastName)
OUTPUT $action INTO @Changes;
SELECT Change, COUNT(*) AS Count
FROM @Changes
GROUP BY Change;परिणाम:
+----------+---------+ | Change | Count | |----------+---------| | INSERT | 2 | | UPDATE | 1 | +----------+---------+
इस मामले में, VALUES में दिए गए मानों के आधार पर, एक पंक्ति को अद्यतन किया गया और दो नई पंक्तियों को सम्मिलित किया गया खंड।
यहाँ अब परिणामी तालिका है:
SELECT * FROM Idiots;परिणाम:
+-----------+-------------+---------------+ | IdiotId | FirstName | LastName | |-----------+-------------+---------------| | 1 | Peter | Griffin | | 2 | Homer | Simpson | | 3 | Ned | Okily Dokily! | | 4 | Lloyd | Christmas | | 5 | Harry | Dunne | +-----------+-------------+---------------+
