ਇਸ ਪੋਸਟ ਵਿੱਚ, ਅਸੀਂ ਛੋਟੀਆਂ ਅਤੇ ਸਮਝਣ ਵਿੱਚ ਅਸਾਨ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ ਐਸਕਿQLਐਲ ਕਮਾਂਡਾਂ ਦੀਆਂ ਮੁicsਲੀਆਂ ਗੱਲਾਂ ਨੂੰ ਕਵਰ ਕਰਾਂਗੇ.
ਐਸਕਿQLਐਲ ਕਮਾਂਡਾਂ ਦੀ ਇਹ ਸੂਚੀ ਉਹ ਹੈ ਜੋ ਤੁਸੀਂ ਸ਼ਾਇਦ ਵਰਤ ਰਹੇ ਹੋਵੋ, ਇਸ ਲਈ ਉਹਨਾਂ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਣੋ.
ਹਰ ਐਸਕੁਏਲ ਕਮਾਂਡ ਵੇਰਵਾ ਅਤੇ ਇੱਕ ਉਦਾਹਰਣ ਕੋਡ ਦੇ ਸਨਿੱਪਟ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤੀ ਜਾਂਦੀ ਹੈ.
ਐਸਕਿQLਐਲ ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਵੱਖ ਵੱਖ ਸ਼੍ਰੇਣੀਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ:
ਇਸ ਪੋਸਟ ਵਿੱਚ, ਅਸੀਂ ਡੀਡੀਐਲ, ਡੀਐਮਐਲ ਅਤੇ ਡੀਸੀਐਲ ਲਈ ਕਮਾਂਡਾਂ ਨੂੰ ਕਵਰ ਕਰਾਂਗੇ.
ਐਸਕਿQLਐਲ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸਾਨੂੰ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਕੰਮ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਇੱਕ ਡੇਟਾਬੇਸ ਤਿਆਰ ਕਰਨਾ. | CREATE DATABASE
ਬਿਆਨ ਬਿਲਕੁਲ ਅਜਿਹਾ ਕਰਦਾ ਹੈ.
ਉਦਾਹਰਣ:
CREATE DATABASE testDB
| CREATE TABLE
ਸਟੇਟਮੇਂਟ ਡੇਟਾਬੇਸ ਵਿਚ ਇਕ ਨਵਾਂ ਟੇਬਲ ਬਣਾਉਂਦਾ ਹੈ.
ਉਦਾਹਰਣ:
CREATE TABLE Employees (
EmployeeID int,
FirstName varchar(255),
LastName varchar(255),
Department varchar(255) );
| INSERT INTO
ਸਟੇਟਮੈਂਟ ਟੇਬਲ ਵਿੱਚ ਡੇਟਾ ਦੀਆਂ ਨਵੀਆਂ ਕਤਾਰਾਂ ਸੰਮਿਲਿਤ ਕਰਦੀ ਹੈ
ਉਦਾਹਰਣ:
INSERT INTO Employees (FirstName, LastName, Department) VALUES ('Sam', 'Burger', 'IT');
SELECT
ਇਕ ਮੁੱਖ ਅਤੇ ਵਧੇਰੇ ਵਰਤੀ ਜਾਂਦੀ ਐਸਕਿQLਐਲ ਕਮਾਂਡ ਹੈ. ਇਹ ਇੱਕ ਡੇਟਾਬੇਸ ਤੋਂ ਡੇਟਾ ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ ਅਤੇ ਨਤੀਜਿਆਂ ਦੀ ਸਾਰਣੀ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਨਤੀਜਾ ਸੈੱਟ ਕਿਹਾ ਜਾਂਦਾ ਹੈ.
ਉਦਾਹਰਣ:
SELECT firstName, lastName FROM Employees;
| SELECT
ਕਮਾਂਡ ਜਦੋਂ ਇੱਕ ਤਾਰੇ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਵੇ *
ਓਪਰੇਟਰ, ਚੁਣਦਾ ਹੈ ਸਭ ਇੱਕ ਨਿਰਧਾਰਤ ਸਾਰਣੀ ਤੋਂ ਰਿਕਾਰਡ.
ਉਦਾਹਰਣ:
SELECT * FROM Employees
SELECT DISTINCT
ਸਿਰਫ ਉਹੀ ਡਾਟਾ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਵੱਖਰਾ ਹੁੰਦਾ ਹੈ; ਅਰਥਾਤ ਡੁਪਲਿਕੇਟ ਐਂਟਰੀਆਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ.
ਉਦਾਹਰਣ:
SELECT DISTINCT Department FROM Employees;
| SELECT INTO
ਸਟੇਟਮੈਂਟ ਇੱਕ ਟੇਬਲ ਤੋਂ ਨਿਰਧਾਰਤ ਡੇਟਾ ਦੀ ਚੋਣ ਕਰਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਿਸੇ ਹੋਰ ਟੇਬਲ ਵਿੱਚ ਕਾਪੀ ਕਰਦੀ ਹੈ.
ਉਦਾਹਰਣ:
SELECT firstName, entryGraduated INTO StudentAlumni FROM Students;
ਨਤੀਜਾ ਸੈੱਟ ਨਤੀਜਾ-ਸੈੱਟ ਵਿੱਚ ਵਾਪਸ ਆਉਣ ਲਈ ਡਾਟਾ ਐਂਟਰੀਆਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਜਾਂ ਪ੍ਰਤੀਸ਼ਤਤਾ ਦਰਸਾਉਂਦਾ ਹੈ.
SELECT TOP 50 PERCENT * FROM Customers;
| WHERE
ਧਾਰਾ ਦੀ ਵਰਤੋਂ ਇੱਕ ਨਿਸ਼ਚਤ ਸ਼ਰਤ ਦੇ ਅਧਾਰ ਤੇ ਨਤੀਜੇ ਫਿਲਟਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ.
ਉਦਾਹਰਣ:
SELECT * FROM Employees WHERE department = 'IT';
| GROUP BY
ਕਮਾਂਡ ਵੱਖੋ ਵੱਖਰੀਆਂ ਕਤਾਰਾਂ ਤੋਂ ਇਕੋ ਜਿਹੇ ਡੇਟਾ ਨੂੰ ਸਮੂਹਾਂ ਵਿਚ ਵੰਡਦੀ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਕਤਾਰਾਂ ਦਾ ਸਾਰ ਦਿੰਦੀ ਹੈ.
ਉਦਾਹਰਣ:
SELECT COUNT(Department), Department FROM Employees GROUP BY Department;
| HAVING
ਧਾਰਾ ਉਹੀ ਕੰਮ ਕਰਦੀ ਹੈ | _ _ _ _ | ਧਾਰਾ ਹੈ, ਪਰ ਫਰਕ ਇਹ ਹੈ ਕਿ WHERE
ਸਿਰਫ ਸਮੁੱਚੇ ਕਾਰਜਾਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ. ਇਸੇ ਤਰ੍ਹਾਂ, HAVING
ਧਾਰਾ ਸਮੁੱਚੇ ਕਾਰਜਾਂ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰਦੀ.
ਉਦਾਹਰਣ:
WHERE
| SELECT COUNT(Department), Department FROM Employees GROUP BY Department HAVING COUNT(Department) > 2;
ਓਪਰੇਟਰ ਨੇ WHERE ਧਾਰਾ ਵਿੱਚ ਕਈ ਮੁੱਲ ਸ਼ਾਮਲ ਕੀਤੇ ਹਨ.
ਉਦਾਹਰਣ:
IN
SELECT * FROM Employees WHERE Department IN ('IT', 'Graphics', 'Marketing');
ਓਪਰੇਟਰ ਨਤੀਜੇ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ ਅਤੇ ਸਿਰਫ ਉਹਨਾਂ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਨਿਰਧਾਰਤ ਸੀਮਾ ਵਿੱਚ ਫਿੱਟ ਹੁੰਦੇ ਹਨ.
ਉਦਾਹਰਣ:
BETWEEN
| SELECT * FROM Employees WHERE JoiningDate BETWEEN '01-01-2015' AND `01-01-2020`;
ਅਤੇ AND
ਸ਼ਰਤੀਆ ਬਿਆਨ ਹਨ. ਵਿੱਚ | _ _ _ _ |, ਸਾਰੀਆਂ ਸ਼ਰਤਾਂ ਇੱਕ ਨਿਰਧਾਰਤ ਮਾਪਦੰਡ ਨੂੰ ਪੂਰਾ ਕਰਨੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ. ਇਨ | _ _ _ _ | ਕੋਈ ਵੀ ਸ਼ਰਤਾਂ ਜਿਹੜੀਆਂ ਕਿਸੇ ਦਿੱਤੇ ਮਾਪਦੰਡ ਨੂੰ ਪੂਰਾ ਕਰਦੀਆਂ ਹਨ, ਨਤੀਜਾ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ.
ਉਦਾਹਰਣ ਅਤੇ:
OR
ਉਦਾਹਰਣ ਜਾਂ:
AND
OR
ਇੱਕ ਉਪਨਾਮ ਦੇ ਤੌਰ ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ. SELECT * FROM Employees WHERE Department = 'IT' AND JoiningDate > '01-01-2015';
ਦੇ ਨਾਲ, ਅਸੀਂ ਡਾਟਾਬੇਸ ਵਿਚ ਨਾਮ ਬਦਲੇ ਬਿਨਾਂ, ਇਕ ਹੋਰ ਕਾਲਮ ਦਾ ਅਰਥ ਬਦਲ ਕੇ ਪੁੱਛਗਿੱਛ ਵਿਚ ਕੁਝ ਹੋਰ ਅਰਥਪੂਰਨ ਜਾਂ ਛੋਟਾ ਕਰ ਸਕਦੇ ਹਾਂ.
ਉਦਾਹਰਣ:
SELECT * FROM Employees WHERE Department ='IT' OR Department = 'Graphics';
AS
ਵੱਖ-ਵੱਖ ਟੇਬਲ ਦੀਆਂ ਕਤਾਰਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ.
ਉਦਾਹਰਣ:
AS
SELECT FirstName AS fname, LastName AS lname FROM Employees;
ਖੱਬੇ ਟੇਬਲ ਤੋਂ ਰਿਕਾਰਡ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਜੋ ਸੱਜੇ ਟੇਬਲ ਵਿੱਚ ਰਿਕਾਰਡ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ.
ਉਦਾਹਰਣ:
INNER JOIN
ਖੱਬੇ ਪਾਸੇ ਸ਼ਾਮਲ ਹੋਣ ਦੇ ਵਿਰੁੱਧ, | _ _ _ _ | ਸੱਜੇ ਟੇਬਲ ਤੋਂ ਰਿਕਾਰਡ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਜੋ ਖੱਬੇ ਸਾਰਣੀ ਵਿੱਚ ਰਿਕਾਰਡ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ.
ਉਦਾਹਰਣ:
SELECT Orders.ID, Customers.Name FROM Orders INNER JOIN Customers ON Orders.ID = Customers.ID;
LEFT JOIN
ਖੱਬੇ ਜਾਂ ਸੱਜੇ ਟੇਬਲ ਵਿੱਚ ਮਿਲਦੇ ਸਾਰੇ ਰਿਕਾਰਡ ਵਾਪਸ ਕਰਦੇ ਹਨ.
ਉਦਾਹਰਣ:
SELECT Customers.CustomerName, Orders.OrderID FROM Customers LEFT JOIN Orders ON Customers.CustomerID = Orders.CustomerID ORDER BY Customers.CustomerName;
| RIGHT JOIN
ਸਟੇਟਮੈਂਟ ਕੁਝ ਖਾਸ ਕਤਾਰਾਂ ਨੂੰ ਸਾਰਣੀ ਵਿੱਚੋਂ ਹਟਾਉਂਦੀ ਹੈ ਜੋ ਕਿਸੇ ਖਾਸ ਸਥਿਤੀ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ.
ਉਦਾਹਰਣ:
SELECT Orders.OrderID, Employees.LastName FROM Orders RIGHT JOIN Employees ON Orders.EmployeeID = Employees.EmployeeID ORDER BY Orders.OrderID;
ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ FULL JOIN
ਇੱਕ ਟੇਬਲ ਤੋਂ ਕਾਲਮ ਜੋੜਨ ਜਾਂ ਹਟਾਉਣ ਲਈ.
ਉਦਾਹਰਣ:
SELECT Customers.Name, CustomerOrders.ID FROM Customers FULL OUTER JOIN Orders ON Customers.ID = CustomerOrders.customerID ORDER BY Customers.Name;
DELETE
ਇੱਕ ਡੇਟਾਬੇਸ ਵਿੱਚ ਟੇਬਲ ਤੋਂ ਡੇਟਾ ਇੰਦਰਾਜ਼ਾਂ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ, ਪਰ ਸਾਰਣੀ structureਾਂਚਾ ਰੱਖਦਾ ਹੈ.
ਉਦਾਹਰਣ:
DELETE FROM Employees WHERE FirstName = 'Sam' AND LastName = 'Burger';
ALTER TABLE
ਸਟੇਟਮੈਂਟ ਪੂਰੀ ਟੇਬਲ ਨੂੰ ਇਸਦੇ ਕਾਲਮ ਪੈਰਾਮੀਟਰਾਂ ਅਤੇ ਡੇਟਾ ਟਾਈਪ ਸੈਟਿੰਗਜ਼ ਨਾਲ ਮਿਟਾਉਂਦੀ ਹੈ.
ਉਦਾਹਰਣ:
ALTER TABLE Employees ADD JoiningDate date;
TRUNCATE TABLE
ਸਾਰੇ ਨਿਰਧਾਰਤ ਡੇਟਾਬੇਸ ਨੂੰ ਇਸਦੇ ਸਾਰੇ ਮਾਪਦੰਡਾਂ ਅਤੇ ਡੇਟਾ ਦੇ ਨਾਲ ਮਿਟਾਉਂਦਾ ਹੈ.
ਇਸ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਵਧੇਰੇ ਸਾਵਧਾਨ ਰਹੋ.
ਉਦਾਹਰਣ:
TRUNCATE TABLE temp_table
ਸੰਬੰਧਿਤ: