ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ, ನಾವು SQL ಆಜ್ಞೆಗಳ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಸಣ್ಣ ಮತ್ತು ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಒಳಗೊಳ್ಳುತ್ತೇವೆ.
ಈ SQL ಆಜ್ಞೆಗಳ ಪಟ್ಟಿಯನ್ನು ನೀವು ಹೆಚ್ಚಾಗಿ ಬಳಸುತ್ತಿರುವಿರಿ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಚೆನ್ನಾಗಿ ತಿಳಿದುಕೊಳ್ಳಿ.
ಪ್ರತಿಯೊಂದು SQL ಆಜ್ಞೆಯನ್ನು ವಿವರಣೆ ಮತ್ತು ಉದಾಹರಣೆ ಕೋಡ್ ತುಣುಕನ್ನು ಒದಗಿಸಲಾಗಿದೆ.
SQL ಹೇಳಿಕೆಗಳನ್ನು ವಿವಿಧ ವಿಭಾಗಗಳಲ್ಲಿ ವರ್ಗೀಕರಿಸಬಹುದು:
ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ, ನಾವು ಡಿಡಿಎಲ್, ಡಿಎಂಎಲ್ ಮತ್ತು ಡಿಕ್ಯೂಎಲ್ ಆಜ್ಞೆಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತೇವೆ.
SQL ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಾವು ಮಾಡಬೇಕಾದ ಮೊದಲನೆಯದು ಡೇಟಾಬೇಸ್ ಅನ್ನು ರಚಿಸುವುದು. ದಿ 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
ಇದು ಮುಖ್ಯ ಮತ್ತು ಹೆಚ್ಚು ಬಳಸುವ SQL ಆಜ್ಞೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಇದು ಡೇಟಾಬೇಸ್ನಿಂದ ಡೇಟಾವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶ-ಸೆಟ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಫಲಿತಾಂಶಗಳ ಕೋಷ್ಟಕವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ:
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;
ದಿ IN
ಆಪರೇಟರ್ WHERE ಷರತ್ತಿನಲ್ಲಿ ಅನೇಕ ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಉದಾಹರಣೆ:
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
ನಾವು DELETE FROM Employees WHERE FirstName = 'Sam' AND LastName = 'Burger';
ಅನ್ನು ಬಳಸುತ್ತೇವೆ ಟೇಬಲ್ನಿಂದ ಕಾಲಮ್ಗಳನ್ನು ಸೇರಿಸಲು ಅಥವಾ ತೆಗೆದುಹಾಕಲು.
ಉದಾಹರಣೆ:
ALTER TABLE
ALTER TABLE Employees ADD JoiningDate date;
ಡೇಟಾಬೇಸ್ನಲ್ಲಿನ ಟೇಬಲ್ನಿಂದ ಡೇಟಾ ನಮೂದುಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, ಆದರೆ ಟೇಬಲ್ ರಚನೆಯನ್ನು ಇಡುತ್ತದೆ.
ಉದಾಹರಣೆ:
TRUNCATE TABLE
TRUNCATE TABLE temp_table
ಹೇಳಿಕೆಯು ಇಡೀ ಟೇಬಲ್ ಅನ್ನು ಅದರ ಕಾಲಮ್ ನಿಯತಾಂಕಗಳು ಮತ್ತು ಡೇಟಾಟೈಪ್ ಸೆಟ್ಟಿಂಗ್ಗಳೊಂದಿಗೆ ಅಳಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ:
DROP TABLE
DROP TABLE temp_table
ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಅದರ ಎಲ್ಲಾ ನಿಯತಾಂಕಗಳು ಮತ್ತು ಡೇಟಾದೊಂದಿಗೆ ಅಳಿಸುತ್ತದೆ.
ಈ ಆಜ್ಞೆಯನ್ನು ಬಳಸುವಾಗ ಹೆಚ್ಚಿನ ಜಾಗರೂಕರಾಗಿರಿ.
ಉದಾಹರಣೆ:
DROP DATABASE
ಸಂಬಂಧಿತ: