MySQL
चुनते हैं

परिचय

वाक्य - विन्यास

• चयन सूची [अभिव्यक्तियाँ] सारणी से [जहाँ शर्तें]; /// सरल चयन

• चयन DISTINCT (a), b ... चयनित DISTINCT a, b के समान है ...

• चयन करें [सभी | DISTINCT | DISTINCTROW] [HIGH_PRIORITY] [STRAIGHT_JOIN] [SQL_SMALL_SOLULT | SQL_BIG_RESULT] [SQL_BUFFER_RESULT] [SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS] अभिव्यक्तियाँ तालिकाओं से [WHERE स्थितियाँ] [भाव द्वारा समूह] [स्थिति] [अभिव्यक्ति द्वारा आदेश] ASC | DESC]] [सीमा [ऑफसेट_वायु] नंबर_रो | लिमिट नंबर_रो OFFSET ऑफसेट_वायु] [प्रक्रिया प्रक्रिया_नाम] [INTO [OUTFILE 'file_name' विकल्प | DUMPFILE 'file_name' | @ variable1, @ variable2, ... @variable_n] [UPDATE के लिए | शेयर मोड में बंद]; /// पूर्ण चयन सिंटैक्स

टिप्पणियों

कॉलम नाम से चयन करें

CREATE TABLE stack(
    id INT,
    username VARCHAR(30) NOT NULL,
    password VARCHAR(30) NOT NULL
);

INSERT INTO stack (`id`, `username`, `password`) VALUES (1, 'Foo', 'hiddenGem');
INSERT INTO stack (`id`, `username`, `password`) VALUES (2, 'Baa', 'verySecret');

सवाल

SELECT id FROM stack;

परिणाम

+------+
| id   |
+------+
|    1 |
|    2 |
+------+

सभी कॉलम चुनें (*)

सवाल

SELECT * FROM stack;

परिणाम

+------+----------+----------+
| id   | username | password |
+------+----------+----------+
|    1 | admin    | admin    |
|    2 | stack    | stack    |
+------+----------+----------+
2 rows in set (0.00 sec)

आप एक कार्य में एक तालिका से सभी कॉलम चुन सकते हैं:

SELECT stack.* FROM stack JOIN Overflow ON stack.id = Overflow.id;

सर्वश्रेष्ठ अभ्यास का उपयोग न करें * जब तक आप साहचर्य सरणियों में पंक्ति (ओं) को डिबगिंग या ला रहे हैं, अन्यथा स्कीमा परिवर्तन (ADD / DROP / रियरेंज कॉलम) बुरा अनुप्रयोग त्रुटियों को जन्म दे सकते हैं। इसके अलावा, यदि आप अपने परिणाम सेट में उन कॉलमों की सूची देते हैं, जो MySQL के क्वेरी प्लानर अक्सर क्वेरी को ऑप्टिमाइज़ कर सकते हैं।

पेशेवरों:

1. जब आप कॉलम जोड़ते / हटाते हैं, तो आपको उन परिवर्तनों को करने की ज़रूरत नहीं है जहाँ आपने SELECT * उपयोग किया था
2. यह लिखना कम है
3. आप उत्तर भी देख सकते हैं, तो क्या सेलेक्ट SELECT * -साज कभी भी उचित हो सकता है?

विपक्ष:

1. आप जरूरत से ज्यादा डाटा लौटा रहे हैं। मान लें कि आप एक VARBINARY कॉलम जोड़ते हैं जिसमें प्रति पंक्ति 200k शामिल है। आपको केवल एक ही रिकॉर्ड के लिए एक स्थान पर इस डेटा की आवश्यकता है - SELECT * का उपयोग करके आप प्रति 10 पंक्तियों में 2MB लौटा सकते हैं जिसकी आपको आवश्यकता नहीं है
2. किस डेटा का उपयोग किया जाता है, इसके बारे में स्पष्ट करें
3. स्तंभों को निर्दिष्ट करने का अर्थ है कि जब कोई स्तंभ निकाला जाता है तो आपको एक त्रुटि मिलती है
4. क्वेरी प्रोसेसर को कुछ और काम करने होते हैं - यह पता लगाना कि टेबल पर कौन से कॉलम मौजूद हैं (धन्यवाद @vinodadhikary)
5. आप पा सकते हैं जहां एक कॉलम का उपयोग अधिक आसानी से किया जाता है
6. यदि आप SELECT * का उपयोग करते हैं तो आपको सभी कॉलम मिलते हैं
7. आप सुरक्षित रूप से ऑर्डिनल संदर्भ का उपयोग नहीं कर सकते (हालांकि कॉलम के लिए ऑर्डिनल संदर्भ का उपयोग करना अपने आप में बुरा अभ्यास है)
8. TEXT फ़ील्ड के साथ जटिल प्रश्नों में, क्वेरी को कम-इष्टतम अस्थायी तालिका प्रसंस्करण द्वारा धीमा किया जा सकता है

जहां के साथ चयन करें

सवाल

SELECT * FROM stack WHERE username = "admin" AND password = "admin";

परिणाम

+------+----------+----------+
| id   | username | password |
+------+----------+----------+
|    1 | admin    | admin    |
+------+----------+----------+
1 row in set (0.00 sec) 

जहां एक खंड में एक नेस्टेड चयन के साथ क्वेरी

अधिक जटिल प्रश्न लिखने के लिए WHERE क्लॉज में कोई भी वैध SELECT विवरण हो सकता है। यह एक 'नेस्टेड' क्वेरी है

सवाल

नेस्टेड क्वेरी का उपयोग आमतौर पर तुलना के लिए प्रश्नों से एकल परमाणु मूल्यों को वापस करने के लिए किया जाता है।

SELECT title FROM books WHERE author_id = (SELECT id FROM authors WHERE last_name = 'Bar' AND first_name = 'Foo');

बिना ईमेल पते वाले सभी उपयोगकर्ता नाम का चयन करता है

SELECT * FROM stack WHERE username IN (SELECT username FROM signups WHERE email IS NULL);

डिस्क्लेमर: संपूर्ण परिणाम सेट की तुलना करते समय प्रदर्शन सुधार के लिए जॉइन का उपयोग करने पर विचार करें।

पसंद के साथ चुनें (%)

CREATE TABLE stack
(  id int AUTO_INCREMENT PRIMARY KEY,
   username VARCHAR(100) NOT NULL
);

INSERT stack(username) VALUES 
('admin'),('k admin'),('adm'),('a adm b'),('b XadmY c'), ('adm now'), ('not here'); 

"प्रशंसा" कहीं भी:

SELECT * FROM stack WHERE username LIKE "%adm%";  
+----+-----------+
| id | username  |
+----+-----------+
|  1 | admin     |
|  2 | k admin   |
|  3 | adm       |
|  4 | a adm b   |
|  5 | b XadmY c |
|  6 | adm now   |
+----+-----------+

"प्रशंसा" के साथ शुरू होता है:

SELECT * FROM stack WHERE username LIKE "adm%";
+----+----------+
| id | username |
+----+----------+
|  1 | admin    |
|  3 | adm      |
|  6 | adm now  |
+----+----------+

"प्रशंसा" के साथ समाप्त होता है:

SELECT * FROM stack WHERE username LIKE "%adm"; 
+----+----------+
| id | username |
+----+----------+
|  3 | adm      |
+----+----------+

जिस LIKE क्लॉज में % वर्ण किसी भी वर्ण से मेल खाता है, _ चरित्र केवल एक वर्ण से मेल खाता है। उदाहरण के लिए,

SELECT * FROM stack WHERE username LIKE "adm_n"; 
+----+----------+
| id | username |
+----+----------+
|  1 | admin    |
+----+----------+

प्रदर्शन नोट्स यदि username पर एक सूचकांक है, तो

• LIKE 'adm' वही करता है जो `= 'प्रशंसा'
• LIKE 'adm% एक "रेंज" है, जो BETWEEN..AND.. तरह है BETWEEN..AND.. यह कॉलम पर एक इंडेक्स का अच्छा उपयोग कर सकता है।
• LIKE '%adm' (या किसी प्रमुख वाइल्डकार्ड वाला कोई भी संस्करण) किसी भी इंडेक्स का उपयोग नहीं कर सकता है। इसलिए यह धीमी होगी। कई पंक्तियों वाली तालिकाओं पर, यह इतना धीमा होने की संभावना है कि यह बेकार है।
• RLIKE ( REGEXP ) LIKE की तुलना में धीमा है, लेकिन इसमें अधिक क्षमताएं हैं।
• जबकि MySQL कई प्रकार के टेबल और कॉलम पर FULLTEXT इंडेक्सिंग प्रदान करता है, उन FULLTEXT इंडेक्स का उपयोग LIKE का उपयोग करके प्रश्नों को पूरा करने के लिए नहीं किया जाता है।

उपनाम (एएस) के साथ चयन करें

SQL उपनाम का उपयोग अस्थायी रूप से किसी तालिका या स्तंभ का नाम बदलने के लिए किया जाता है। वे आमतौर पर पठनीयता में सुधार करने के लिए उपयोग किए जाते हैं।

सवाल

SELECT username AS val FROM stack; 
SELECT username val FROM stack;

(नोट: AS वाक्यात्मक AS से वैकल्पिक है।)

परिणाम

+-------+
| val   |
+-------+
| admin |
| stack |
+-------+
2 rows in set (0.00 sec)

एक सीमा खंड के साथ चयन करें

प्रश्न:

 SELECT *
   FROM Customers
  ORDER BY CustomerID 
  LIMIT 3;

परिणाम:

सबसे अच्छा अभ्यास हमेशा ORDER BY उपयोग करें जब LIMIT का उपयोग करें; अन्यथा आपको मिलने वाली पंक्तियाँ अप्रत्याशित होंगी।

प्रश्न:

 SELECT *
   FROM Customers
  ORDER BY CustomerID 
  LIMIT 2,1;

स्पष्टीकरण:

जब एक LIMIT क्लॉज में दो नंबर होते हैं, तो इसे LIMIT offset,count रूप में समझा जाता है। इसलिए, इस उदाहरण में क्वेरी दो रिकॉर्ड को छोड़ देती है और एक को वापस कर देती है।

परिणाम:

ध्यान दें:

LIMIT क्लॉज़ में मान स्थिरांक होना चाहिए; वे स्तंभ मान नहीं हो सकते हैं।

DISTINCT के साथ चयन करें

SELECT बाद DISTINCT क्लाज परिणाम सेट से डुप्लिकेट पंक्तियों को समाप्त करता है।

CREATE TABLE `car`
(   `car_id` INT UNSIGNED NOT NULL PRIMARY KEY, 
    `name` VARCHAR(20), 
    `price` DECIMAL(8,2)
);

INSERT INTO CAR (`car_id`, `name`, `price`) VALUES (1, 'Audi A1', '20000');
INSERT INTO CAR (`car_id`, `name`, `price`) VALUES (2, 'Audi A1', '15000');
INSERT INTO CAR (`car_id`, `name`, `price`) VALUES (3, 'Audi A2', '40000');
INSERT INTO CAR (`car_id`, `name`, `price`) VALUES (4, 'Audi A2', '40000');

SELECT DISTINCT `name`, `price` FROM CAR;
+---------+----------+
| name    | price    |
+---------+----------+
| Audi A1 | 20000.00 |
| Audi A1 | 15000.00 |
| Audi A2 | 40000.00 |
+---------+----------+

DISTINCT परिणाम देने के लिए सभी कॉलमों पर काम करता है, न कि व्यक्तिगत कॉलमों पर। उत्तरार्द्ध अक्सर नए SQL डेवलपर्स की गलत धारणा है। संक्षेप में, यह परिणाम सेट के पंक्ति-स्तर पर वह भिन्नता है जो मायने रखती है, स्तंभ-स्तर पर भिन्नता नहीं। यह कल्पना करने के लिए, उपरोक्त परिणाम सेट में "ऑडी A1" देखें।

MySQL के बाद के संस्करणों के लिए, DISTINCT ORDER BY साथ इसके उपयोग के निहितार्थ हैं। ONLY_FULL_GROUP_BY लिए सेटिंग निम्न प्रकार से MySQL मैनुअल पेज में देखी गई है, जिसके लिए ग्रुप BY का MySQL हैंडलिंग शीर्षक है।

LIKE (_) के साथ चयन करें

LIKE क्लॉज पैटर्न में एक _ कैरेक्टर एक सिंगल कैरेक्टर से मेल खाता है।

सवाल

SELECT username FROM users WHERE users LIKE 'admin_';

परिणाम

+----------+
| username |  
+----------+
| admin1   |
| admin2   |
| admin-   |
| adminA   |
+----------+

CASE या IF के साथ चयन करें

सवाल

SELECT st.name,
       st.percentage, 
       CASE WHEN st.percentage >= 35 THEN 'Pass' ELSE 'Fail' END AS `Remark` 
FROM student AS st ;

परिणाम

+--------------------------------+
|   name   | percentage | Remark |
+--------------------------------+
|   Isha   |     67     |  Pass  |
|   Rucha  |     28     |  Fail  |
|   Het    |     35     |  Pass  |
|   Ansh   |     92     |  Pass  |
+--------------------------------+

या आईएफ के साथ

SELECT st.name,
       st.percentage, 
       IF(st.percentage >= 35, 'Pass', 'Fail') AS `Remark` 
FROM student AS st ;

एनबी

IF(st.percentage >= 35, 'Pass', 'Fail')

इसका मतलब है: यदि st.percentage> = 35 TRUE है तो 'Pass' ईएलएसई रिटर्न 'Fail' लौटाएँ

BETWEEN के साथ चयन करें

आप "बराबर से अधिक और समान से कम" स्थितियों के संयोजन को बदलने के लिए BETWEEN क्लॉज का उपयोग कर सकते हैं।

डेटा

+----+-----------+
| id | username  |
+----+-----------+
|  1 | admin     |
|  2 | root      |
|  3 | toor      |
|  4 | mysql     |
|  5 | thanks    |
|  6 | java      |
+----+-----------+

ऑपरेटरों के साथ क्वेरी

SELECT * FROM stack WHERE id >= 2 and id <= 5; 

BETWEEN के साथ समान क्वेरी

SELECT * FROM stack WHERE id BETWEEN 2 and 5; 

परिणाम

+----+-----------+
| id | username  |
+----+-----------+
|  2 | root      |
|  3 | toor      |
|  4 | mysql     |
|  5 | thanks    |
+----+-----------+
4 rows in set (0.00 sec)

ध्यान दें

BETWEEN >= और <= का उपयोग करता है, न कि > और < ।

BETWEEN का उपयोग नहीं कर रहा है

यदि आप नकारात्मक का उपयोग करना चाहते हैं तो आप NOT उपयोग कर सकते हैं। उदाहरण के लिए :

SELECT * FROM stack WHERE id NOT BETWEEN 2 and 5; 

परिणाम

+----+-----------+
| id | username  |
+----+-----------+
|  1 | admin     |
|  6 | java      |
+----+-----------+
2 rows in set (0.00 sec)

ध्यान दें

NOT BETWEEN > और < और नहीं >= और <= का उपयोग करता है, अर्थात WHERE id NOT BETWEEN 2 and 5 है, वहाँ WHERE id NOT BETWEEN 2 and 5 , WHERE (id < 2 OR id > 5) ।

यदि आपके पास एक स्तंभ पर एक सूचकांक है जिसका आप एक BETWEEN खोज में उपयोग करते हैं, तो MySQL उस सूचकांक का उपयोग रेंज स्कैन के लिए कर सकता है।

तिथि सीमा के साथ चयन करें

SELECT ... WHERE dt >= '2017-02-01'
             AND dt  < '2017-02-01' + INTERVAL 1 MONTH

बेशक, इस के साथ किया जा सकता है BETWEEN और के शामिल किए जाने 23:59:59 । लेकिन, पैटर्न के यह लाभ हैं:

• आपके पास समाप्ति तिथि की पूर्व-गणना नहीं है (जो अक्सर शुरुआत से एक सटीक लंबाई है)
• आप दोनों समापन बिंदुओं को शामिल नहीं करते (जैसा कि BETWEEN करता है), और न ही '23: 59: 59 'से बचने के लिए टाइप करें।
• यह DATE , TIMESTAMP , DATETIME और यहां तक कि माइक्रोसेकंड- DATETIME(6) ।
• यह लीप दिनों, वर्ष के अंत आदि का ख्याल रखता है।
• यह इंडेक्स-फ्रेंडली है (इसलिए BETWEEN )।