MySQL Practical File Programs (Class 12 IT 802)

इन SQL practicals के बारे में

यह page Class 12 Information Technology (802) के सभी SQL practical file programs एक साथ लाता है, और हर एक को एक ही सरल Employee table पर बनाता है। एक ही table इस्तेमाल होने से आप साफ़ देख सकते हैं कि हर command — SELECT, WHERE, ORDER BY, GROUP BY, aggregate functions, UPDATE, DELETE — result को कैसे बदलता है।

शुरुआत में पहले दो practicals एक बार चलाइए (table बनाइए, फिर sample rows डालिए)। उसके बाद नीचे की कोई भी query आज़माइए। हर एक अपनी SQL और output दिखाती है, साथ में Hindi और English में छोटी आसान व्याख्या।

1. Employee table banana

Har SQL practical से पहले एक table चाहिए। यह CREATE TABLE से Employee table बनाता है जिसमें id, name, department, salary और city columns हैं।

CREATE TABLE Employee (
    emp_id     INT PRIMARY KEY,
    name       VARCHAR(40),
    department VARCHAR(30),
    salary     DECIMAL(10,2),
    city       VARCHAR(30)
);

Query OK, table 'Employee' created.

2. Employee me records daalna

Table में data INSERT INTO से आता है। यहाँ हम 5 employees के records एक साथ डाल रहे हैं।

INSERT INTO Employee VALUES
(1, 'Aarav',  'IT',      55000, 'Delhi'),
(2, 'Diya',   'HR',      42000, 'Mumbai'),
(3, 'Kabir',  'IT',      61000, 'Delhi'),
(4, 'Meera',  'Sales',   38000, 'Pune'),
(5, 'Rohan',  'HR',      47000, 'Mumbai');

Query OK, 5 rows affected.

3. Saare records dikhana

SELECT * table के सारे columns और सारी rows दिखाता है। यह सबसे basic query है।

SELECT * FROM Employee;

+--------+-------+------------+---------+--------+
| emp_id | name  | department | salary  | city   |
+--------+-------+------------+---------+--------+
|      1 | Aarav | IT         | 55000.00| Delhi  |
|      2 | Diya  | HR         | 42000.00| Mumbai |
|      3 | Kabir | IT         | 61000.00| Delhi  |
|      4 | Meera | Sales      | 38000.00| Pune   |
|      5 | Rohan | HR         | 47000.00| Mumbai |
+--------+-------+------------+---------+--------+

4. Chuninda columns dikhana

सब columns की जगह सिर्फ़ ज़रूरी columns देखने के लिए उनके नाम लिखते हैं — यहाँ सिर्फ़ name और salary।

SELECT name, salary FROM Employee;

+-------+---------+
| name  | salary  |
+-------+---------+
| Aarav | 55000.00|
| Diya  | 42000.00|
| Kabir | 61000.00|
| Meera | 38000.00|
| Rohan | 47000.00|
+-------+---------+

5. WHERE se rows chhaantna

WHERE एक शर्त लगाता है — सिर्फ़ वही rows आती हैं जो शर्त पूरी करती हैं। यहाँ सिर्फ़ IT department वाले।

SELECT name, department FROM Employee
WHERE department = 'IT';

+-------+------------+
| name  | department |
+-------+------------+
| Aarav | IT         |
| Kabir | IT         |
+-------+------------+

6. 45000 se zyada kamaane wale

WHERE के साथ तुलना operator (>) लगाकर हम salary के आधार पर rows छाँट सकते हैं।

SELECT name, salary FROM Employee
WHERE salary > 45000;

+-------+---------+
| name  | salary  |
+-------+---------+
| Aarav | 55000.00|
| Kabir | 61000.00|
| Rohan | 47000.00|
+-------+---------+

7. Salary se sort (ORDER BY)

ORDER BY result को किसी column के हिसाब से लगाता है। DESC से बड़े-से-छोटा।

SELECT name, salary FROM Employee
ORDER BY salary DESC;

+-------+---------+
| name  | salary  |
+-------+---------+
| Kabir | 61000.00|
| Aarav | 55000.00|
| Rohan | 47000.00|
| Diya  | 42000.00|
| Meera | 38000.00|
+-------+---------+

8. Har department me kitne (GROUP BY)

GROUP BY rows को group में बाँटता है और COUNT() हर group की गिनती करता है।

SELECT department, COUNT(*) AS total
FROM Employee
GROUP BY department;

+------------+-------+
| department | total |
+------------+-------+
| IT         |     2 |
| HR         |     2 |
| Sales      |     1 |
+------------+-------+

9. Kul aur औsat salary

Aggregate functions SUM() और AVG() पूरे column का जोड़ और औसत निकालते हैं।

SELECT SUM(salary) AS total_salary,
       AVG(salary) AS average_salary
FROM Employee;

+--------------+----------------+
| total_salary | average_salary |
+--------------+----------------+
|    243000.00 |    48600.000000|
+--------------+----------------+

10. Sabse zyada aur sabse kam salary

MAX() सबसे बड़ी value और MIN() सबसे छोटी value देता है।

SELECT MAX(salary) AS highest,
       MIN(salary) AS lowest
FROM Employee;

+----------+----------+
| highest  | lowest   |
+----------+----------+
| 61000.00 | 38000.00 |
+----------+----------+

11. Ek salary badalna (UPDATE)

UPDATE मौजूदा row की value बदलता है। WHERE ज़रूरी है वरना सारी rows बदल जाएँगी।

UPDATE Employee
SET salary = 50000
WHERE name = 'Diya';

Query OK, 1 row affected.

12. Ek record hatana (DELETE)

DELETE row हटा देता है। WHERE के बिना सारी rows delete हो जाएँगी — ध्यान से।

DELETE FROM Employee
WHERE name = 'Meera';

Query OK, 1 row affected.

13. LIKE se khoj

LIKE pattern से खोजता है। 'D%' का मतलब 'D' से शुरू होने वाले नाम।

SELECT name FROM Employee
WHERE name LIKE 'D%';

+------+
| name |
+------+
| Diya |
+------+

14. Chuninda cities ke employees (IN)

IN एक से ज़्यादा values में से match करता है — यहाँ Delhi या Mumbai।

SELECT name, city FROM Employee
WHERE city IN ('Delhi', 'Mumbai');

+-------+--------+
| name  | city   |
+-------+--------+
| Aarav | Delhi  |
| Diya  | Mumbai |
| Kabir | Delhi  |
| Rohan | Mumbai |
+-------+--------+

15. Department-wise औsat salary

GROUP BY और AVG() मिलकर हर department की औसत salary निकालते हैं।

SELECT department, AVG(salary) AS avg_salary
FROM Employee
GROUP BY department;

+------------+-------------+
| department | avg_salary  |
+------------+-------------+
| IT         | 58000.000000|
| HR         | 44500.000000|
| Sales      | 38000.000000|
+------------+-------------+

सारांश

• सभी 15 SQL practicals एक ही Employee table इस्तेमाल करते हैं, तो concepts एक-दूसरे पर बनते हैं।
• ये पूरा Class 12 syllabus कवर करते हैं: create, insert, select, where, order by, group by, aggregates, update, delete, like और in।
• UPDATE और DELETE के साथ हमेशा WHERE इस्तेमाल कीजिए ताकि हर row न बदले।
• Aggregate functions (COUNT, SUM, AVG, MAX, MIN) कई rows को एक value में बदल देते हैं।

और गहराई के लिए देखिए constraints in MySQL, normalization, या full outer join lesson।