शुरुआती के लिए एसक्यूएल ट्यूटोरियल

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

यह SQL ट्यूटोरियल आपको कुछ ही समय में SQL क्वेरी चलाने में मदद करेगा!

एसक्यूएल उदाहरण

यहाँ एक उदाहरण SQL कथन है:

SELECT * 
FROM Pets;

यह एक आदर्श उदाहरण है कि SQL लिखना कितना आसान हो सकता है। यह सरल SQL कथन वास्तव में बहुत कुछ करता है। यह पूरी तालिका लौटाता है। यह Pets . नामक तालिका से सभी कॉलम और सभी पंक्तियों को लौटाता है ।

तारांकन (* ) एक वाइल्डकार्ड वर्ण है, जिसका अर्थ है "सभी कॉलम"। यह सभी स्तंभों को टाइप किए बिना उन्हें प्राप्त करने का एक त्वरित और आसान तरीका है।

यह SQL के बारे में खूबसूरत चीजों में से एक है। सबसे सरल SQL क्वेरी आमतौर पर सबसे शक्तिशाली होती हैं। यदि हम कम डेटा वापस करना चाहते हैं, तो हमें वास्तव में अधिक . लिखना होगा ।

उदाहरण के लिए, यदि हम केवल लाएँ . नाम के पालतू जानवर चाहते हैं , हम एक WHERE जोड़ देंगे खंड जो उस आवश्यकता को निर्धारित करता है।

इस तरह:

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

WHERE क्लॉज हमारी क्वेरी को केवल उन पंक्तियों में फ़िल्टर करता है जहां PetName कॉलम का मान Fetch . है ।

यह क्वेरी मानती है कि PetName . नामक एक कॉलम है और Pets . नामक एक टेबल डेटाबेस में।

इस SQL ट्यूटोरियल में, मैं आपको दिखाऊंगा कि SQL का उपयोग करके ऐसा डेटाबेस कैसे बनाया जाता है।

मैं आपको यह भी दिखाऊंगा कि उस डेटाबेस में डेटा कैसे डालें, डेटा अपडेट करें, डेटा हटाएं, और इसके खिलाफ क्वेरी कैसे चलाएं।

एसक्यूएल क्या है?

एसक्यूएल संरचित क्वेरी भाषा के लिए एक संक्षिप्त शब्द है।

SQL एक मानक क्वेरी भाषा है जिसका उपयोग रिलेशनल डेटाबेस के साथ काम करने के लिए किया जाता है।

SQL का उपयोग सभी प्रमुख रिलेशनल डेटाबेस मैनेजमेंट सिस्टम (RDBMS) द्वारा किया जाता है, जिसमें शामिल हैं:

माइक्रोसॉफ्ट एक्सेस
एसक्यूएल सर्वर
ओरेकल
पोस्टग्रेएसक्यूएल
MySQL
SQLite

मैं SQL के साथ क्या कर सकता हूं?

आप SQL का उपयोग डेटाबेस के विरुद्ध क्वेरी चलाने, रिकॉर्ड डालने, रिकॉर्ड अपडेट करने और रिकॉर्ड हटाने के लिए कर सकते हैं। आप डेटाबेस और टेबल जैसे नए डेटाबेस ऑब्जेक्ट भी बना सकते हैं। आप डेटाबेस प्रशासन कार्य भी कर सकते हैं, जैसे लॉगिन बनाना, स्वचालित कार्य, डेटाबेस बैकअप, और बहुत कुछ।

यहां तक कि जब आप ग्राफिकल यूजर इंटरफेस (जीयूआई) का उपयोग करके सामान करते हैं, तब भी आपका डेटाबेस मैनेजमेंट सिस्टम (डीबीएमएस) उस कार्य को करने के लिए दृश्यों के पीछे एसक्यूएल का लगभग निश्चित रूप से उपयोग करेगा।

उदाहरण के लिए, जब आप डेटाबेस बनाएं . क्लिक करके डेटाबेस बनाते हैं और एक बार जब आप ठीक . क्लिक करते हैं, तो नए डेटाबेस के विवरण को एक संवाद बॉक्स में दर्ज करना या बनाएं या जो कुछ भी बटन पढ़ता है, आपका डेटाबेस सिस्टम SQL CREATE DATABASE . का उपयोग करेगा आगे बढ़ने और निर्दिष्ट के अनुसार डेटाबेस बनाने के लिए कथन।

अन्य कार्यों के लिए भी यही सच है, जैसे कि क्वेरी चलाना, डेटा सम्मिलित करना, आदि।

SQL आपको अधिक उन्नत क्रियाएँ करने में भी सक्षम बनाता है जैसे कि संग्रहीत कार्यविधियाँ (स्वयं निहित स्क्रिप्ट), दृश्य (पूर्व-निर्मित क्वेरी) बनाना और डेटाबेस ऑब्जेक्ट (जैसे तालिकाएँ, संग्रहीत कार्यविधियाँ और दृश्य) पर अनुमतियाँ सेट करना।

उस ने कहा, SQL के साथ आरंभ करने के लिए आपको सभी उन्नत सामग्री सीखने की आवश्यकता नहीं है। SQL के बारे में अच्छी बात यह है कि, कुछ सबसे सामान्य कार्य लिखने में सबसे आसान हैं।

एसक्यूएल मानक

SQL को 1986 में ANSI X3.135 में मानकीकृत किया गया था, और कुछ ही महीनों के भीतर, इसे ISO द्वारा ISO 9075-1987 के रूप में अपनाया गया। अंतरराष्ट्रीय मानक (अब आईएसओ/आईईसी 9075) को समय-समय पर संशोधित किया गया है, और यह वर्तमान में 9 भागों में मौजूद है।

अधिकांश प्रमुख डेटाबेस विक्रेता SQL मानक का पालन करते हैं। इसके बारे में अच्छी बात यह है कि हर बार जब आप एक नया DBMS सीखते हैं तो आपको एक नई क्वेरी भाषा नहीं सीखनी होती है।

हालांकि व्यवहार में, प्रत्येक डेटाबेस विक्रेता SQL मानक को कैसे लागू करता है, इसके बीच भिन्नताएं हैं। इसलिए, हो सकता है कि आप एक DBMS में जो कोड लिखते हैं, वह हमेशा किसी अन्य में संशोधनों की आवश्यकता के बिना काम न करे।

अच्छी खबर यह है कि सभी प्रमुख डीबीएमएस आम तौर पर एक ही तरह से सबसे आम कार्यों का समर्थन करते हैं।

एसक्यूएल उच्चारण

SQL को आमतौर पर दो तरीकों में से एक में उच्चारित किया जाता है:

“एस्स-क्यू-एल ” (अर्थात प्रत्येक अक्षर की वर्तनी)
“अगली कड़ी ” (जैसा कि मूल वर्तनी/उच्चारण में है)।

अगर आप सोच रहे हैं कि ऐसा क्यों है, तो देखें कि क्या इसका उच्चारण S-Q-L या सीक्वल है।

इस SQL ट्यूटोरियल के लिए मुझे क्या चाहिए?

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

यदि आप SQL क्वेरी चलाने जा रहे हैं, तो आपको निम्न की आवश्यकता होगी:

एक RDBMS स्थापित (जैसे SQL सर्वर, MySQL, PostgreSQL, SQLite, आदि)।
एक डेटाबेस टूल जो आपको उस RDBMS (जैसे MySQL WorkBench, Azure Data Studio (चित्रित), DBeaver, और SSMS) के विरुद्ध SQL क्वेरी चलाने की अनुमति देता है।

यदि आपके पास पहले से ही प्रत्येक में से एक स्थापित है, तो बढ़िया! आप ट्यूटोरियल के साथ जारी रख सकते हैं।

यदि आपके पास ये स्थापित नहीं हैं, तो देखें कि मुझे SQL चलाने के लिए क्या चाहिए? इस SQL ट्यूटोरियल पर लौटने से पहले, RDBMS और इसके प्रासंगिक डेटाबेस प्रबंधन उपकरण को स्थापित करने के निर्देशों के लिए।

डेटाबेस बनाएं

एक बार जब आप अपना RDBMS और उपयुक्त डेटाबेस उपकरण स्थापित कर लेते हैं, तो आप एक डेटाबेस बनाने के लिए तैयार होते हैं:

CREATE DATABASE PetHotel;

पूर्ण!

उस कथन ने वास्तव में एक डेटाबेस बनाया। एक खाली डेटाबेस, लेकिन फिर भी एक डेटाबेस।

इस डेटाबेस में इस SQL ट्यूटोरियल में उपयोग किए गए टेबल और डेटा होंगे। जब हम एक टेबल बनाते हैं या डेटा डालते हैं, तो हम इसे इस डेटाबेस के अंदर करेंगे।

मुझे यह उल्लेख करना चाहिए कि SQLite डेटाबेस बनाने के लिए एक अलग सिंटैक्स का उपयोग करता है। यदि आप SQLite का उपयोग कर रहे हैं, तो यहां SQLite में डेटाबेस बनाने का तरीका बताया गया है।

डेटाबेस से कनेक्ट करें

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

कई DBMS में (जैसे SQL सर्वर , MySQL और मारियाडीबी ), हम निर्दिष्ट डेटाबेस पर स्विच करने के लिए निम्नलिखित का उपयोग कर सकते हैं:

USE PetHotel;

यह PetHotel . बनाता है वर्तमान डेटाबेस।

SQLite . में , आप इसे बनाने के बाद शायद पहले से ही डेटाबेस में हैं। यदि नहीं, तो आप डेटाबेस संलग्न कर सकते हैं (जो इसे पहले से मौजूद नहीं होने पर भी बनाएगा):

ATTACH DATABASE 'PetHotel.db' AS Pets;

PostgreSQL . में , यदि आप psql टूल का उपयोग कर रहे हैं, तो आप निम्न का उपयोग कर सकते हैं:

\connect PetHotel

या संक्षिप्त संस्करण:

\c PetHotel

मुझे यह उल्लेख करना चाहिए कि डेटाबेस बनाने और जोड़ने की प्रक्रिया DBMS के बीच व्यापक रूप से भिन्न हो सकती है।

सौभाग्य से, अधिकांश GUI उपकरण आपको डेटाबेस पर डबल-क्लिक करके, या डेटाबेस नाम पर राइट-क्लिक करके और संदर्भ मेनू से एक नया क्वेरी टैब चुनकर डेटाबेस से कनेक्ट करने देते हैं। यदि आप स्वयं को इस चरण पर अटका हुआ पाते हैं, तो अपने DB को बनाने और/या उससे कनेक्ट करने के लिए GUI का उपयोग करें।

टेबल बनाएं

अब जब आप सही डेटाबेस से जुड़ गए हैं, तो आप आगे बढ़ सकते हैं और कुछ टेबल बना सकते हैं।

SQL में तालिका बनाने के लिए, CREATE TABLE का उपयोग करें बयान।

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

आइए एक टेबल बनाएं:

CREATE TABLE PetTypes
(
    PetTypeId   int NOT NULL PRIMARY KEY,
    PetType     varchar(60) NOT NULL
);

इस मामले में हम PetTypes . नामक एक टेबल बनाते हैं . हम जानते हैं कि, क्योंकि टेबल का नाम CREATE TABLE . के तुरंत बाद आता है अंश।

उसके बाद कोष्ठकों में संलग्न स्तंभों की एक सूची आती है।

उपरोक्त तालिका में निम्नलिखित कॉलम हैं:

PetIdId
PetType

प्रत्येक कॉलम के बाद उसका डेटा प्रकार होता है:

int इसका मतलब है कि यह कॉलम पूर्णांक स्वीकार करता है। जहां तक मेरी जानकारी है, अधिकांश प्रमुख डीबीएमएस कॉलम को int . के रूप में घोषित करने का समर्थन करते हैं . यदि आपको कोई समस्या है, तो integer . का उपयोग करके देखें ।
varchar(60) इसका मतलब है कि यह कॉलम 60 वर्णों तक के स्ट्रिंग्स को स्वीकार करता है। varchar कॉलम चर-लंबाई वाले तार हैं। एक अन्य स्ट्रिंग डेटा प्रकार है char (जो एक निश्चित लंबाई वाली स्ट्रिंग है)। यदि आपको किसी कॉलम को varchar(60) . के रूप में परिभाषित करने में समस्या हो रही है , char(60) . का उपयोग करके देखें ।

`NOT NULL` बाधाएं

इस उदाहरण में, दोनों कॉलम NOT NULL with से परिभाषित हैं प्रतिबंध। NOT NULL बाधा का अर्थ है कि यह कॉलम खाली नहीं हो सकता। जब कोई नई पंक्ति डाली जाती है, तो कोई भी NOT NULL कॉलम होना चाहिए एक मूल्य शामिल करें। यदि उन स्तंभों के लिए कोई डेटा नहीं है, तो अन्य स्तंभ खाली रह सकते हैं।

अगर NULL कॉलम में मानों की अनुमति है, आप या तो NOT NULL . को छोड़ सकते हैं भाग, या इसे NULL . के रूप में घोषित करें (मतलब, NULL इस कॉलम में मानों की अनुमति है)।

कुछ DBMS (जैसे DB2) NULL . का समर्थन नहीं करते हैं वैसे भी कीवर्ड, और इसलिए ऐसे DBMS के साथ काम करते समय आपको इसे छोड़ना होगा।

प्राथमिक कुंजियां

हमने PetTypeId . भी बनाया है प्राथमिक कुंजी को कॉलम करें। प्राथमिक कुंजी एक या अधिक स्तंभ हैं जो तालिका में प्रत्येक पंक्ति की विशिष्ट रूप से पहचान करते हैं। आप प्राथमिक कुंजी बाधा का उपयोग करके अपने चयनित कॉलम को प्राथमिक कुंजी के रूप में निर्दिष्ट करते हैं। आप इसे CREATE TABLE . में कर सकते हैं स्टेटमेंट (जैसे हमने यहां किया था), या आप एक बाद में ALTER TABLE . के साथ जोड़ सकते हैं बयान।

प्राथमिक कुंजी में अद्वितीय मान होने चाहिए। अर्थात्, उस तालिका में प्रत्येक पंक्ति के लिए, प्राथमिक कुंजी कॉलम में मान प्रत्येक पंक्ति में भिन्न होना चाहिए। यह वृद्धिशील संख्याओं (जैसे 1, 2, 3… आदि) के रूप में सरल हो सकता है या यह एक उत्पाद कोड हो सकता है (जैसे pr4650, pr2784, pr5981… आदि)।

साथ ही, प्राथमिक कुंजी में एक मान होना चाहिए। यह NULL नहीं हो सकता .

हालांकि प्राथमिक कुंजी की आवश्यकता नहीं होती है, आमतौर पर प्रत्येक तालिका पर प्राथमिक कुंजी को परिभाषित करना अच्छा अभ्यास माना जाता है।

और टेबल बनाएं

आइए दो और टेबल बनाएं:

CREATE TABLE Owners
(
    OwnerId     int NOT NULL PRIMARY KEY,
    FirstName   varchar(60) NOT NULL,
    LastName    varchar(60) NOT NULL,
    Phone       varchar(20) NOT NULL,
    Email       varchar(254)
);

CREATE TABLE Pets
(
    PetId       int NOT NULL PRIMARY KEY,
    PetTypeId   int NOT NULL REFERENCES PetTypes (PetTypeId),
    OwnerId     int NOT NULL REFERENCES Owners (OwnerId),
    PetName     varchar(60) NOT NULL,
    DOB         date NULL
);

ये दोनों तालिकाएँ पहले वाले के समान हैं, सिवाय इसके कि उनमें अधिक पंक्तियाँ हैं, और कुछ अतिरिक्त टुकड़े हैं, जिनके बारे में मैं नीचे बताऊँगा।

यदि आप रुचि रखते हैं, तो SQL में टेबल बनाने के कुछ और सरल उदाहरणों के लिए शुरुआती के लिए SQL CREATE TABLE देखें।

रिश्ते

जब हमने अपना Pets बनाया तालिका, हमने वास्तव में तीन तालिकाओं के बीच संबंध बनाया है।

उस संबंध को निम्नलिखित आरेख में दर्शाया गया है।

डेटाबेस संबंध SQL का एक महत्वपूर्ण हिस्सा हैं। संबंध हमें संबंधित डेटा के लिए कई तालिकाओं को क्वेरी करने और सटीक और सुसंगत परिणाम प्राप्त करने की अनुमति देते हैं।

हमारे मामले में, हम चाहते हैं कि हम मालिक द्वारा पालतू जानवरों की खोज करने में सक्षम हों, या पालतू जानवरों के प्रकार से पालतू जानवरों की खोज करने में सक्षम हों। और हम चाहते हैं कि हमारे परिणाम सटीक और सुसंगत हों।

इसे प्राप्त करने के लिए, हमें इस बात पर जोर देना होगा कि सभी पालतू जानवरों को उनके मालिक और पालतू जानवरों के प्रकार के साथ दर्ज किया जाए। इसलिए हमें यह सुनिश्चित करने की आवश्यकता है कि, जब भी कोई नया पालतू जानवर Pets . में जोड़ा जाए तालिका में, Owners . में पहले से ही एक संबंधित स्वामी है तालिका, और संबंधित पालतू प्रकार PetTypes . में टेबल।

मूल रूप से, हमारी आवश्यकताएं इस प्रकार हैं:

Pets.PetTypeId में कोई भी मान कॉलम PetTypes.PetTypeId . के मान से मेल खाना चाहिए कॉलम।
Pets.OwnerId में कोई भी मान कॉलम Owners.OwnerId . के मान से मेल खाना चाहिए कॉलम।

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

उपरोक्त कोड ने वास्तव में Pets . पर दो विदेशी कुंजी बाधाएं पैदा कीं टेबल।

ध्यान दें कि PetTypeId और OwnerId कॉलम में कुछ अतिरिक्त कोड होते हैं जो REFERENCES... . से शुरू होते हैं . वे भाग हैं जिन्होंने दो विदेशी कुंजियों का निर्माण किया।

जब हमने Pets बनाया तालिका, इसका PetTypeId कॉलम में थोड़ा सा होता है जो REFERENCES PetTypes (PetTypeId) जाता है . इसका मतलब है कि Pets.PetTypeId कॉलम PetTypeId . का संदर्भ देता है PetTypes . में कॉलम टेबल।

OwnerId . के लिए भी यही डील है कॉलम। यह OwnerId . का संदर्भ देता है Owners . का कॉलम टेबल।

अधिकांश DBMS में, ALTER TABLE का उपयोग करके, मौजूदा टेबल पर विदेशी कुंजियाँ भी बनाई जा सकती हैं। बयान, लेकिन हम यहां उस पर नहीं जाएंगे। इसके बारे में अधिक जानने के लिए SQL में संबंध कैसे बनाएं देखें।

वैसे भी, हमारी विदेशी चाबियां बनाई गई हैं। अब, जब भी कोई नया पालतू जानवर Pets . में सम्मिलित करता है तालिका, PetTypeId और OwnerId मानों को PetTypes . में संगत मान की आवश्यकता होगी और Owners क्रमशः टेबल। यदि उनमें से कोई भी नहीं करता है, तो डेटाबेस एक त्रुटि लौटाएगा।

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

बाधाओं की जांच करें

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

उदाहरण के लिए, आप Price . पर एक चेक बाधा बना सकते हैं कॉलम यह सुनिश्चित करने के लिए कि यह केवल उन मानों को स्वीकार करता है जो शून्य से अधिक हैं। या हम अपने Pets . पर एक चेक बाधा लागू कर सकते हैं तालिका यह सुनिश्चित करने के लिए कि DOB कॉलम भविष्य में नहीं है।

एक उदाहरण के लिए, चेक बाधा क्या है देखें?

व्हाइटस्पेस

आपने देखा होगा कि मेरे उदाहरणों में व्हॉट्सएप शामिल है। उदाहरण के लिए, मैंने कोड को कई पंक्तियों में रखा है, और मैंने डेटा प्रकारों आदि को इंडेंट करने के लिए टैब का उपयोग किया है।

यह SQL में पूरी तरह से मान्य है। आप इसे सुरक्षित रूप से कर सकते हैं, और यह परिणाम को प्रभावित नहीं करेगा। यदि आप चाहें तो SQL आपको अपने कोड को कई पंक्तियों में फैलाने की अनुमति देता है, और यह आपको पठनीयता में सुधार के लिए कई रिक्त स्थान या टैब का उपयोग करने की अनुमति देता है।

टिप्पणियां

आप अपने कोड में टिप्पणियां भी शामिल कर सकते हैं। एक बार जब आप लंबी SQL स्क्रिप्ट लिखना शुरू कर देते हैं तो टिप्पणियाँ आसान हो सकती हैं। एक बार जब कोई स्क्रिप्ट काफी लंबी हो जाती है, तो टिप्पणियों से यह पता लगाना आसान हो जाता है कि प्रत्येक भाग क्या करता है।

इनलाइन टिप्पणियां

आप अपनी टिप्पणी को दो हाइफ़न वर्णों (-- . के साथ उपसर्ग करके इनलाइन टिप्पणियां बना सकते हैं ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

इस उदाहरण में, दोनों प्रश्न बिना किसी समस्या के चलेंगे। टिप्पणियों को DBMS द्वारा अनदेखा कर दिया जाएगा।

मल्टीलाइन टिप्पणियाँ

आप टिप्पणी को /* . से घेरकर कई पंक्तियों में टिप्पणियों को फैला सकते हैं और */ :

/*
This is a longer comment so
it's spread across multiple lines
*/
SELECT * FROM Pets;

MySQL

यदि आप MySQL का उपयोग कर रहे हैं, तो आप संख्या चिह्न/हैश चिह्न का भी उपयोग कर सकते हैं (# ) सिंगल लाइन टिप्पणियों के लिए।

# This is a comment
SELECT * FROM Pets;

टिप्पणी करना कोड

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

यहां एक उदाहरण दिया गया है:

-- SELECT * FROM Pets;

SELECT * FROM Owners;

इस मामले में, पहला SELECT बयान पर टिप्पणी की गई है, और इसलिए केवल दूसरा SELECT स्टेटमेंट चलेगा।

आप इस तकनीक के लिए बहुपंक्ति टिप्पणियों का भी उपयोग कर सकते हैं।

डेटा डालें

अब जब हमने तीन टेबल बना लिए हैं और उपयुक्त विदेशी कुंजियाँ बना ली हैं, तो हम आगे बढ़ सकते हैं और डेटा जोड़ सकते हैं।

SQL में डेटा डालने का सबसे आम तरीका है INSERT बयान। यह कुछ इस प्रकार है:

INSERT INTO MyTable( Column1, Column2, Column3, ... )
VALUES( Value1, Value2, Value3, ... );

आप बस MyTable . को बदल दें उस तालिका के नाम के साथ जिसमें आप डेटा सम्मिलित कर रहे हैं। इसी तरह, आप Column1 . को प्रतिस्थापित करते हैं , आदि कॉलम नामों के साथ, और Value1 , आदि उन स्तंभों में जाने वाले मानों के साथ।

उदाहरण के लिए, हम यह कर सकते हैं:

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

प्रत्येक मान उसी क्रम में है जिस क्रम में कॉलम निर्दिष्ट किया गया है।

ध्यान दें कि कॉलम के नाम उन नामों से मेल खाते हैं जिनका हमने टेबल बनाते समय इस्तेमाल किया था।

यदि आप सभी स्तंभों में डेटा सम्मिलित कर रहे हैं, तो आप स्तंभ नामों को छोड़ सकते हैं। तो हम इस तरह दिखने के लिए उपरोक्त उदाहरण को बदल सकते हैं:

INSERT INTO Pets
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

इस ट्यूटोरियल के लिए, हम कुछ और पंक्तियाँ जोड़ेंगे, इसलिए हम और अधिक INSERT INTO जोड़ेंगे। कथन - प्रत्येक पंक्ति के लिए एक जिसे हम सम्मिलित करना चाहते हैं।

तो चलिए आगे बढ़ते हैं और अपनी टेबल्स को पॉप्युलेट करते हैं।

INSERT INTO Owners( OwnerId, FirstName, LastName, Phone, Email )
VALUES( 1, 'Homer', 'Connery', '(308) 555-0100', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone, Email)
VALUES( 2, 'Bart', 'Pitt', '(231) 465-3497', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 3, 'Nancy', 'Simpson', '(489) 591-0408' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 4, 'Boris', 'Trump', '(349) 611-8908' ); 

INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 1, 'Bird' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 2, 'Cat' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 3, 'Dog' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 4, 'Rabbit' );

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-11-20' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 2, 3, 3, 'Fetch', '2019-08-16' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 3, 2, 2, 'Scratch', '2018-10-01' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 4, 3, 3, 'Wag', '2020-03-15' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 5, 1, 1, 'Tweet', '2020-11-28' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 6, 3, 4, 'Fluffy', '2020-09-17' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 7, 3, 2, 'Bark' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 8, 2, 4, 'Meow' );

ध्यान दें कि हमने Pets . को भर दिया है अंतिम तालिका। इसका एक कारण है।

अगर हमने Pets . में डेटा डालने की कोशिश की होती अन्य दो को पॉप्युलेट करने से पहले, हमें हमारी विदेशी कुंजी बाधा के कारण एक त्रुटि मिली होगी। और अच्छे कारण के लिए। आखिरकार, हम उन विदेशी कुंजी स्तंभों में मान सम्मिलित करने का प्रयास कर रहे हैं जो अभी तक अन्य तालिकाओं के प्राथमिक कुंजी स्तंभों में मौजूद नहीं हैं। जब विदेशी कुंजी की बात आती है तो यह एक बड़ा "नहीं नहीं" होता है।

तो Owners . को पॉप्युलेट करके और PetTypes टेबल पहले, हमने यह सुनिश्चित किया कि Pets में विदेशी कुंजी कॉलम भरने से पहले ही उचित मान प्राथमिक कुंजी कॉलम में थे। टेबल।

तालिकाओं में डेटा डालने के अधिक उदाहरणों के लिए शुरुआती के लिए SQL INSERT देखें।

हमारा डेटा जांचें

ओह! अंत में हम अपने डेटाबेस के खिलाफ क्वेरी चलाना शुरू कर सकते हैं।

आइए अपने सभी तालिकाओं में डेटा की जांच करें।

SELECT * FROM Pets;
SELECT * FROM PetTypes;
SELECT * FROM Owners;

परिणाम:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)
+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
+-----------+-------------+------------+----------------+-------------------+
(4 rows affected)

बढ़िया, इसलिए ऐसा लगता है कि डेटा सफलतापूर्वक डाला गया था।

विशिष्ट कॉलम चुनें

किसी तालिका से सभी पंक्तियों और सभी स्तंभों का चयन करना आमतौर पर एक बुरा अभ्यास माना जाता है (जैसा कि हमने पिछले उदाहरण में किया था), जब तक कि आपको वास्तव में आवश्यकता न हो। ऐसा करने से आपके डेटाबेस सर्वर के प्रदर्शन पर असर पड़ सकता है, खासकर अगर टेबल में बहुत सारी पंक्तियाँ हों।

यह कोई समस्या नहीं है जब आप छोटे डेटा सेट का उपयोग कर रहे हैं जैसे कि हम यहां हैं, या यदि आप विकास के माहौल या इसी तरह के हैं। अन्यथा, आमतौर पर केवल उन स्तंभों का चयन करना बेहतर होता है जिनकी आपको आवश्यकता होती है।

इसलिए, यदि हम सभी पालतू जानवरों की पहचान, नाम और जन्मतिथि चाहते हैं, तो हम यह कर सकते हैं:

SELECT PetId, PetName, DOB 
FROM Pets;

परिणाम:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 3       | Scratch   | 2018-10-01 |
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
| 8       | Meow      | NULL       |
+---------+-----------+------------+

अगर हम फ्लफी नाम के सभी पालतू जानवरों की आईडी और जन्मतिथि चाहते हैं, तो हम इसका इस्तेमाल कर सकते हैं:

SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy';

परिणाम:

+---------+------------+
| PetId   | DOB        |
|---------+------------|
| 1       | 2020-11-20 |
| 6       | 2020-09-17 |
+---------+------------+

आप SELECT . का भी इस्तेमाल कर सकते हैं नो-टेबल डेटा वापस करने के लिए स्टेटमेंट। यही है, यह उस डेटा को वापस कर सकता है जो किसी तालिका में संग्रहीत नहीं है। एसक्यूएल देखें SELECT शुरुआती लोगों के लिए एक उदाहरण देखने के लिए वक्तव्य।

क्रमबद्ध करना

SQL ORDER BY प्रदान करता है क्लॉज जो हमें डेटा को सॉर्ट करने में सक्षम बनाता है।

हम एक ORDER BY . जोड़ सकते हैं हमारे पहले के उदाहरण का खंड ताकि पालतू जानवरों को उनके नाम से क्रमबद्ध किया जा सके:

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName ASC;

परिणाम:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 7       | Bark      | NULL       |
| 2       | Fetch     | 2019-08-16 |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 8       | Meow      | NULL       |
| 3       | Scratch   | 2018-10-01 |
| 5       | Tweet     | 2020-11-28 |
| 4       | Wag       | 2020-03-15 |
+---------+-----------+------------+

ASC भाग का अर्थ है आरोही . जब आप ORDER BY का उपयोग करते हैं खंड, यह आरोही के लिए डिफ़ॉल्ट है, इसलिए आप ASC . को छोड़ सकते हैं यदि आप चाहें तो भाग।

इसे अवरोही . में क्रमित करने के लिए ऑर्डर करें, DESC का उपयोग करें ।

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC;

परिणाम:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

आप एकाधिक कॉलम का उपयोग करके परिणामों को सॉर्ट भी कर सकते हैं। यह निर्दिष्ट पहले कॉलम के आधार पर छाँटेगा, फिर यदि उस कॉलम में कोई डुप्लीकेट हैं, तो यह उन डुप्लीकेट्स को निर्दिष्ट दूसरे कॉलम द्वारा सॉर्ट करेगा, और इसी तरह।

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC, DOB ASC;

परिणाम:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 6       | Fluffy    | 2020-09-17 |
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

देखें कि कैसे दो Fluffys ने अपनी स्थिति बदली है।

यदि आप ORDER BY . का उपयोग नहीं करते हैं खंड, इस बात की कोई गारंटी नहीं है कि आपके परिणाम किस क्रम में होंगे। हालांकि यह दिख सकता है जैसे आपका डेटाबेस किसी विशेष कॉलम द्वारा परिणामों को सॉर्ट कर रहा है, यह वास्तव में ऐसा नहीं हो सकता है। सामान्य तौर पर, बिना ORDER BY . के खंड, डेटा को उस क्रम में क्रमबद्ध किया जाएगा जिसमें इसे तालिका में लोड किया गया था। हालांकि, अगर पंक्तियों को हटा दिया गया है या अपडेट कर दिया गया है, तो ऑर्डर इस बात से प्रभावित होगा कि कैसे डीबीएमएस पुनः प्राप्त संग्रहण स्थान का पुन:उपयोग करता है।

इसलिए, परिणामों को किसी भी सार्थक क्रम में क्रमबद्ध करने के लिए DBMS पर निर्भर न रहें।

निचला रेखा:यदि आप अपने परिणामों को क्रमबद्ध करना चाहते हैं, तो ORDER BY का उपयोग करें .

SQL ORDER BY See देखें अधिक उदाहरणों के लिए शुरुआती के लिए खंड।

परिणाम सेट में पंक्तियों की गणना करें

आप COUNT() . का उपयोग कर सकते हैं क्वेरी में वापस आने वाली पंक्तियों को गिनने के लिए एग्रीगेट फ़ंक्शन।

SELECT COUNT(*) AS Count
FROM Pets;

परिणाम:

+---------+
| Count   |
|---------|
| 8       |
+---------+

यह बताता है कि तालिका में 8 पंक्तियाँ हैं। हम जानते हैं कि क्योंकि हमने सभी पंक्तियों और सभी स्तंभों का चयन किया है।

आप COUNT() . का उपयोग कर सकते हैं किसी भी प्रश्न पर, उदाहरण के लिए वे प्रश्न जो WHERE . का उपयोग करते हैं परिणामों को फ़िल्टर करने के लिए खंड।

आप गिनने के लिए एक विशेष कॉलम भी निर्दिष्ट कर सकते हैं। COUNT() फ़ंक्शन केवल गैर-NULL की गणना करता है परिणाम, इसलिए यदि आप एक कॉलम निर्दिष्ट करते हैं जिसमें NULL . है मान, उन मानों की गणना नहीं की जाएगी।

मेरा क्या मतलब है, यह दिखाने के लिए यहां एक उदाहरण दिया गया है।

SELECT COUNT(DOB) AS Count
FROM Pets;

परिणाम:

+---------+
| Count   |
|---------|
| 6       |
+---------+
Warning: Null value is eliminated by an aggregate or other SET operation.

आपको याद होगा कि Pets तालिका में दो NULL शामिल हैं DOB . में मान कॉलम (दो पालतू जानवरों ने अपनी जन्मतिथि नहीं दी है), और इसलिए COUNT(DOB) जब हमने COUNT(*) . का उपयोग किया तो 8 के बजाय 6 लौटाता है . कारण COUNT(*) सभी पंक्तियों को लौटा दिया, क्योंकि उन दो पंक्तियों ने किया अन्य कॉलम में डेटा है।

मेरे उदाहरण में, मेरे डीबीएमएस ने इस बारे में एक चेतावनी भी दी। आपके DBMS और आपके विशिष्ट कॉन्फ़िगरेशन के आधार पर आपको चेतावनी मिल भी सकती है और नहीं भी।

एसक्यूएल देखें COUNT अधिक उदाहरणों के लिए शुरुआती के लिए।

अन्य समग्र कार्यों में शामिल हैं:AVG() , SUM() , MIN() , और MAX() ।

समूह द्वारा

एक और उपयोगी क्लॉज है GROUP BY खंड। यह बहुत कुछ करता है जो इसके नाम का वादा करता है। यह आपको दिए गए कॉलम के आधार पर परिणामों को समूहबद्ध करने की अनुमति देता है।

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
ORDER BY Count DESC;

परिणाम:

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
| 1           | 1       |
+-------------+---------+

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

SQL GROUP BY देखें अधिक उदाहरणों के लिए शुरुआती के लिए खंड।

`HAVING` खंड

हम HAVING . का उपयोग कर सकते हैं GROUP BY . में परिणामों को फ़िल्टर करने के लिए क्लॉज खंड। HAVING क्लॉज उन पंक्तियों को लौटाता है जहां कुल मान निर्दिष्ट शर्तों को पूरा करते हैं।

यहाँ एक उदाहरण है।

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;

परिणाम:

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
+-------------+---------+

इस मामले में, हमने केवल उन पालतू प्रकार के लिए डेटा लौटाया है जिनके पास उस प्रकार के 2 से अधिक पालतू जानवर हैं।

SQL देखें HAVING अधिक उदाहरणों के लिए शुरुआती के लिए खंड।

जुड़ता है

SQL में, एक शामिल हों वह जगह है जहां आप एक क्वेरी चलाते हैं जो कई तालिकाओं के डेटा को जोड़ती है।

पिछले दो उदाहरण ठीक हैं, लेकिन बेहतर होगा कि वे आईडी (जैसे 1, 2, 3, आदि) के बजाय वास्तविक पालतू प्रकार (जैसे बिल्ली, कुत्ता, पक्षी, आदि) लौटाएं।

एकमात्र समस्या है, Pets तालिका में वह डेटा नहीं है। वह डेटा PetTypes . में है टेबल।

सौभाग्य से हमारे लिए, हम इन दो तालिकाओं के बीच एक जुड़ाव कर सकते हैं। यहां एक उदाहरण दिया गया है जो LEFT JOIN का उपयोग करता है :

SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType
ORDER BY Count DESC;

परिणाम:

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

यह परिणाम सेट पिछले वाले की तुलना में पढ़ने में बहुत आसान है। यह समझना आसान है कि तालिका में प्रत्येक प्रकार के कितने पालतू जानवर हैं।

सिंटैक्स जॉइन टाइप का उपयोग करता है (इस मामले में LEFT JOIN ), उसके बाद पहली (बाएं) तालिका, उसके बाद ON , उसके बाद शामिल होने की स्थिति।

आइए एक INNER JOIN का उपयोग करें सभी पालतू जानवरों के नाम उनके संबंधित पालतू जानवरों के प्रकार के साथ वापस करने के लिए।

SELECT 
    Pets.PetName,
    PetTypes.PetType
FROM Pets 
INNER JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId;

परिणाम:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

जॉइन वास्तव में हमारे विकल्पों को खोलता है, क्योंकि अब हम कई तालिकाओं से डेटा ले सकते हैं और इसे इस तरह प्रस्तुत कर सकते हैं जैसे कि यह एक एकल तालिका हो।

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

अधिक उदाहरणों और विभिन्न प्रकार के शामिल होने के स्पष्टीकरण के लिए मेरा एसक्यूएल जॉइन ट्यूटोरियल देखें।

उपनाम

हम एक कदम आगे जाकर उपनाम . असाइन कर सकते हैं प्रत्येक तालिका नाम और स्तंभ नाम के लिए।

SELECT 
    p.PetName AS Pet,
    pt.PetType AS "Pet Type"
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

परिणाम:

+---------+------------+
| Pet     | Pet Type   |
|---------+------------|
| Tweet   | Bird       |
| Fluffy  | Cat        |
| Scratch | Cat        |
| Meow    | Cat        |
| Fetch   | Dog        |
| Wag     | Dog        |
| Fluffy  | Dog        |
| Bark    | Dog        |
| NULL    | Rabbit     |
+---------+------------+

इसके परिणामस्वरूप नए कॉलम हेडर बने हैं, साथ ही कोड अधिक संक्षिप्त है।

एक उपनाम आपको SELECT . की अवधि के लिए किसी तालिका या स्तंभ को अस्थायी रूप से दूसरा नाम असाइन करने की अनुमति देता है सवाल। यह विशेष रूप से तब उपयोगी हो सकता है जब टेबल और/या कॉलम में बहुत लंबे या जटिल नाम हों।

एक उपनाम को AS . के उपयोग के माध्यम से असाइन किया गया है कीवर्ड, हालांकि यह कीवर्ड वैकल्पिक है, इसलिए आप इसे सुरक्षित रूप से छोड़ सकते हैं। ध्यान दें कि Oracle AS . का समर्थन नहीं करता है तालिका उपनामों पर कीवर्ड (लेकिन यह स्तंभ उपनामों पर करता है)।

उपरोक्त उदाहरण में, मैंने AS . शामिल किया है कॉलम उपनाम निर्दिष्ट करते समय कीवर्ड, लेकिन तालिका उपनाम निर्दिष्ट करते समय इसे छोड़ दिया।

एक उपनाम नाम कुछ भी हो सकता है, लेकिन आमतौर पर पठनीयता के उद्देश्यों के लिए इसे छोटा रखा जाता है।

हमारे मामले में, हमने दो तालिकाओं को p . में बदल दिया है और pt , और कॉलम नाम Pet और Pet Type . ध्यान दें कि मैंने Pet Type . को घेर लिया है दोहरे उद्धरण चिह्नों में। मैंने ऐसा इसलिए किया, क्योंकि नाम में जगह है। रिक्त स्थान के बिना उपनामों के लिए, आपको ऐसा करने की आवश्यकता नहीं है। SQL सर्वर में, आप वैकल्पिक रूप से वर्गाकार कोष्ठकों का उपयोग कर सकते हैं ([] ) दोहरे उद्धरण चिह्नों के बजाय (हालाँकि यह दोहरे उद्धरण चिह्नों का भी समर्थन करता है)।

स्तंभों और उपनामों में रिक्त स्थान का उपयोग करने की प्रथा को आमतौर पर हतोत्साहित किया जाता है, क्योंकि यह कुछ क्लाइंट अनुप्रयोगों के साथ सभी प्रकार की समस्याएं पैदा कर सकता है।

ध्यान दें कि जॉइन में उन्हें संदर्भित करते समय हमें अभी भी पूर्ण कॉलम नामों का उपयोग करने की आवश्यकता है (ON के बाद) कीवर्ड)।

मुझे यह बताना चाहिए कि उपनाम निर्दिष्ट करना वास्तव में स्तंभ या तालिका का नाम नहीं बदलता है।

अधिक उदाहरणों के लिए समझाया गया SQL उपनाम देखें।

डेटा अपडेट करना

आप UPDATE का उपयोग कर सकते हैं आपकी टेबल में डेटा अपडेट करने के लिए स्टेटमेंट।

मूल वाक्य रचना बहुत सरल है:

UPDATE Owners
SET LastName = 'Stallone'
WHERE OwnerId = 3;

उस उदाहरण में, हम LastName . को अपडेट करते हैं Stallone . का नया मान रखने के लिए कॉलम जहां OwnerId है 3 ।

अनेक स्तंभों को अद्यतन करने के लिए, प्रत्येक स्तंभ/मान युग्म को अलग करने के लिए अल्पविराम का उपयोग करें।

लेकिन आप जो कुछ भी करें, WHERE को न भूलें खंड (जब तक कि आप वास्तव में तालिका में प्रत्येक पंक्ति को अपडेट करने का इरादा नहीं रखते हैं एक ही मान के साथ)।

एसक्यूएल देखें UPDATE शुरुआती के लिए अधिक उदाहरणों और अधिक विस्तृत स्पष्टीकरण के लिए।

डेटा हटाना

आप DELETE . का उपयोग कर सकते हैं आपकी टेबल से डेटा मिटाने के लिए स्टेटमेंट.

मूल सिंटैक्स UPDATE . से भी अधिक सरल है कथन:

DELETE FROM Owners
WHERE OwnerId = 5;

यहां, हम Owners . से स्वामी संख्या 5 को हटा रहे हैं टेबल।

जैसा कि UPDATE के साथ है कथन, WHERE को न भूलें खंड (जब तक आप तालिका की प्रत्येक पंक्ति को हटाना नहीं चाहते )।

SQL देखें DELETE शुरुआती के लिए अधिक उदाहरण और विस्तृत विवरण के लिए।

ऑब्जेक्ट गिराना

जब हम चीजों को हटाने के विषय पर होते हैं, जब आप डेटाबेस ऑब्जेक्ट (जैसे तालिका, दृश्य, संग्रहीत प्रक्रिया, आदि) को हटाते हैं, तो यह कहा जाता है कि आप उस ऑब्जेक्ट को "ड्रॉप" करते हैं। For example, if you no longer need a table, you “drop it”.

The syntax is extremely simple, and it goes like this:

DROP TABLE Customers;

Those three words completely obliterated a table called Customers . The table and all its data is now gone.

As you can imagine, this can be a very dangerous statement, and should be used with extreme caution.

The same syntax can be used for other object types, except you would replace table with the object type (for example DROP VIEW vPets drops a view called vPets )।

If you try to drop a table that is referenced by a foreign key, you’ll probably get an error. In this case, you’ll need to either drop the foreign key (using the ALTER TABLE statement) or the child table itself.

SQL Operators

In SQL, an operator is a symbol specifying an action that is performed on one or more expressions.

Operators manipulate individual data items and return a result. The data items are called operands or arguments . In SQL, operators are represented by special characters or by keywords.

We’ve already seen some operators in action. Some of our previous example queries had a WHERE clause that included the Equals operator (= ) We also ran a query that used the Greater Than operator (> ) These are both comparison operators – they compare two expressions.

See 12 Commonly Used Operators in SQL for examples of operators that you’re likely to need when working with SQL.

You can also use this list of SQL Operators as a reference for the operators available in SQL.

SQL Views

In SQL, a view is a query that’s saved to the database as a database object (just like a table). The term can also be used to refer to the result set of a stored query. Views are often referred to as virtual tables ।

To create a view, you write a query, then save it as a view. You do this using the CREATE VIEW वाक्य रचना।

Here’s an example of creating a view:

CREATE VIEW vPetTypeCount AS
SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType;

Running that code creates the view and stores it as an object in the database.

We can now query the view, just like we’d query a table.

परिणाम:

SELECT * FROM vPetTypeCount;

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Bird      | 1       |
| Cat       | 3       |
| Dog       | 4       |
+-----------+---------+

So we get the same result as we would have got if we’d run the original query, but saving it in a view made it a lot easier to query.

This benefit would become greater, the more complex the query is.

Views and the ORDER BY Clause

One thing I should point out is that the original query had an ORDER BY clause, but I didn’t include that in the view. The SQL standard does not allow the ORDER BY clause in any view definition. Also, most RDBMSs will raise an error if you try to include an ORDER BY खंड।

This isn’t a problem though, because you can sort the results when you query the view. Therefore, we can do something like this:

SELECT * FROM vPetTypeCount
ORDER BY Count DESC;

परिणाम:

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Most RDBMSs also include a large set of system views that you can use to retrieve information about the system.

For more about views, see What is a View?

Stored Procedures

A stored procedure is a series of SQL statements compiled and saved to the database. Stored procedures are similar to views in some respects, but very different in other respects.

One of the benefits of stored procedures is that they allow you to store complex scripts on the server. Stored procedures often contain conditional programming such as IF... ELSE statements, for example. Stored procedures can also accept parameters.

Here’s an example of creating a simple stored procedure in SQL Server to get pet information from our database:

CREATE PROCEDURE uspGetPetById
    @PetId int
AS
    SET NOCOUNT ON;
    SELECT 
        p.PetName, 
        p.DOB, 
        pt.PetType,
        CONCAT(o.FirstName, ' ', o.LastName) AS OwnerName
    FROM Pets p 
    INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
    INNER JOIN Owners o 
    ON o.OwnerId = p.OwnerId
    WHERE p.PetId = @PetId;

This stored procedure accepts a parameter called @PetId . This means that when you call the procedure, you need to pass the ID of the pet that you’d like information about. The procedure then selects data from various tables and returns it.

To call the stored procedure, use the EXECUTE बयान। You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL बयान।

EXEC uspGetPetById @PetId = 3;

परिणाम:

+-----------+------------+-----------+-------------+
| PetName   | DOB        | PetType   | OwnerName   |
|-----------+------------+-----------+-------------|
| Scratch   | 2018-10-01 | Cat       | Bart Pitt   |
+-----------+------------+-----------+-------------+

In this case I was interested in pet number 3, and so that’s the info that I got.

I should mention that the syntax for creating stored procedures can differ quite significantly between DBMSs (as well as their implementations of various SQL statements and commands that you’d use inside a procedure), so I would suggest that you look at the documentation for your particular DBMS if you want to create a stored procedure.

Most RDBMSs also include a large set of system stored procedures that you can use to perform various administration tasks, and to retrieve information about the system.

For a basic overview of stored procedures, including their benefits, see What is a Stored Procedure?

Also, if you’re interested, see How to Create a Stored Procedure in SQL Server to see another example of creating a stored procedure in SQL Server. That example includes some screenshots.

SQL Triggers

A trigger is a special type of stored procedure that automatically executes when an event occurs in the database server.

Most major RDBMSs support DML triggers, which execute when a user tries to modify data through a data manipulation language (DML) event. DML events are INSERT , UPDATE , or DELETE बयान।

Some DBMSs (such as SQL Server and PostgreSQL) allow triggers to be associated with both tables and views. Others only allow triggers to be associated with tables.

SQL Server also supports DDL triggers and logon triggers.

DDL triggers execute in response to DDL events, such as CREATE , ALTER , and DROP statements, and certain system stored procedures that perform DDL-like operations.

Logon triggers are fired in response to the LOGON event that’s raised when a user’s session is being established.

Here are some articles explaining how to do various things with triggers in SQL Server:

Create a DML Trigger in SQL Server
Create a “last modified” column
Automatically send an email when someone tries to delete a record
Update a column’s value whenever another column is updated
Update a column’s value whenever certain other columns are updated

SQL Transactions

SQL transactions are an important part of transactional databases, where data consistency is paramount.

A transaction manages a sequence of SQL statements that must be executed as a single unit of work. This is to ensure that the database never contains the results of partial operations.

When a transaction makes multiple changes to the database, either all the changes succeed when the transaction is committed, or all the changes are undone when the transaction is rolled back.

Transactions help maintain data integrity by ensuring that a sequence of SQL statements execute completely or not at all.

A classic example of a transaction is to move money from one bank account to another. You wouldn’t want money to be deducted from the first bank account, but not appear in the second bank account.

Therefore, you could use a transaction which goes along the lines of this:

START TRANSACTION
Debit account 1
Credit account 2
Record transaction in transaction journal
END TRANSACTION

You could write conditional logic inside that transaction that rolls back the transaction if anything goes wrong.

The end result is that, either the transaction is completed in its entirety, or it’s not completed at all. It’s never half-done.

See my SQL Transactions Tutorial for examples of SQL transactions.

SQL Functions

A function is a routine that can take parameters, perform calculations or other actions, and return a result.

Most DBMSs provide you with the ability to create your own functions, while also providing a range of inbuilt functions.

User-Defined Functions

A user-defined function (UDF) is a function that you create for a specific purpose, and save to the database. You would create such a function for tasks that aren’t catered for by an inbuilt function.

See Introduction to User-Defined Functions in SQL Server for an overview. Although that article is written for SQL Server, most of the general concepts also apply to other DBMSs.

Inbuilt Functions

Most DBMSs have a large range of inbuilt functions that you can use in your SQL queries. For example, there are functions that return the current date and time, functions that format dates and numbers, functions that convert data from one data type to another, and more.

The range of inbuilt functions can be pretty extensive, and depend on the DBMS in use, so I won’t go over them in this SQL tutorial. But I would encourage you to try to find out what inbuilt functions your DBMS supports.

To get you started, the following articles contain some of the most commonly used functions in SQL programming.

SQL Server

SQL Server String Functions
SQL Server Mathematical Functions
SQL Server Date &Time Functions

MySQL

MySQL String Functions
MySQL Mathematical Functions

PostgreSQL

PostgreSQL Date &Time Functions
PostgreSQL Math Functions

SQLite

SQLite Aggregate Functions
SQLite Date &Time Functions

शुरुआती के लिए एसक्यूएल ट्यूटोरियल

एसक्यूएल उदाहरण

एसक्यूएल क्या है?

मैं SQL के साथ क्या कर सकता हूं?

एसक्यूएल मानक

एसक्यूएल उच्चारण

इस SQL ​​​​ट्यूटोरियल के लिए मुझे क्या चाहिए?

डेटाबेस बनाएं

डेटाबेस से कनेक्ट करें

टेबल बनाएं

NOT NULL बाधाएं

प्राथमिक कुंजियां

और टेबल बनाएं

रिश्ते

बाधाओं की जांच करें

व्हाइटस्पेस

टिप्पणियां

इनलाइन टिप्पणियां

मल्टीलाइन टिप्पणियाँ

MySQL

टिप्पणी करना कोड

डेटा डालें

हमारा डेटा जांचें

विशिष्ट कॉलम चुनें

क्रमबद्ध करना

परिणाम सेट में पंक्तियों की गणना करें

समूह द्वारा

HAVING खंड

जुड़ता है

उपनाम

डेटा अपडेट करना

डेटा हटाना

ऑब्जेक्ट गिराना

SQL Operators

SQL Views

Views and the ORDER BY Clause

Stored Procedures

SQL Triggers

SQL Transactions

SQL Functions

User-Defined Functions

Inbuilt Functions

SQL Server

MySQL

PostgreSQL

SQLite

इस SQL ट्यूटोरियल के लिए मुझे क्या चाहिए?

`NOT NULL` बाधाएं

`HAVING` खंड